There is a big difference between believing something is true, and demonstrating it is true and measuring the effect. One is a vibe. The other can drive policy.

There is a big difference between believing something is true, and demonstrating it is true and measuring the effect. One is a vibe. The other can drive policy.

Comments URL: https://news.ycombinator.com/item?id=49299705

Points: 6

# Comments: 0

Escape analysis in OpenJDK will stack allocate values where it can show it is safe to do so. Project Valhalla is also reducing the memory footprint of objects.

As for thread safety, that is more of a language concern than a runtime one. Amongst JVM languages Scala is leading here AFAIK. Its "capture checking"[1] provides thread safety (e.g. [2]) and actually covers escape analysis as well. On Scala Native (the native code backend for Scala) capture checking can be used for safe stack allocation and safe arena allocation.

[1]: https://docs.scala-lang.org/scala3/reference/experimental/cc... [2]: https://softwaremill.com/understanding-capture-checking-in-s...

The proposed replacements seem to be technology that takes some of the active role away from the student. That doesn't seem to me that it would be effective, as anything I've learned well has required I do that kind of active introspection. Off-loading it to a machine feels like it would harm my learning.

Also, very typical of software people to reach for software solutions. There is a much wider space that can be explored. Maybe that would be more fruitful?

More here: https://noelwelsh.com/posts/understanding-vm-dispatch/

Technical content appeared on LinkedIn.

Not just one or two posts. Tens of posts. Every day. Technical content from the thought leaders in the industry.

Yes, there was still corporate slop.

Yes, LinkedIn still mostly serves for self-aggrandisement.

But there were nuggets of gold, for those prepared to sift for them.

Seriously: LinkedIn is still mostly garbage. The quality of discussion is not great. But it has improved a bit, and given the fractured nature of social media at the moment it's somewhat viable to use it for technical content. It very much depends on the specific area. If you want to talk about the new hotness (e.g. using LLMs to write software) there is a lot. For more niche areas I expect other venues will do better.

It's important in interpreters. Here's an example: https://blog.reverberate.org/2021/04/21/musttail-efficient-i...

  enum Expr:
    case Add(left: Expr, right: Expr)
    case Lit(val: Double)

  enum Expr:
    case Add
    case Lit(val: Double)

The transformation in the other direction is not purely syntactic as you have to know that, e.g., Add gets two parameters from the stack and add those parameters back in.

Syntax highlighting was a discrepancy between my local env and the Netlify env that deploys the site.

`loop` is what I usually call tail-recursive loops in my personal style. I think I changed that to `dispatch` for the blog post and didn't push the change all the way through.

Hope that clears it up.

Another thing that is kinda neat: there is a duality (a bidirectional transform) between the AST for a tree walking interpreter and the AST for a stack machine. To create the stack machine AST, all you do is remove any occurrence of the expression type in the tree-walking AST; these values are now found on the stack. Obvious when you think about it, but useful nonetheless. I don't think there is a simple equivalent for a register machine as, unless you have an infinite number of registers, you need to do register allocation.

(If the author reads this, my name changed from Noel to Neal at some point. I don't really mind though; my name is a bit unusual and I've been called all sorts of things.)

GADTs are well established in FP, but codata in general is not[^1]. As far as I can tell this is partly historical and partly cultural. (Codata is basically OO. Recent FP languages, like Idris, have explicit support for codata.)

More in my book: https://functionalprogrammingstrategies.com/

^[1]: The degenerate form of codata is the function, which FP languages do tend to support very well.

In 1873, French novelist Alexandre Dumas wrote that if every egg reached maturity, within three years “you could walk across the Atlantic dryshod on the backs of cod.” In 1885, the Canadian Ministry of Agriculture said it was not only impossible to exhaust the cod supply, but even to make a noticeable dent in it. “Unless the order of nature is overthrown, for centuries to come our fisheries will continue to be fertile,” the ministry declared.

Humans find a way: https://en.wikipedia.org/wiki/Collapse_of_the_Atlantic_north...

[1]: https://docs.scala-lang.org/scala3/reference/experimental/cc...

In my experience, the more constrained the LLM is, either by existing patterns in the code base or by prior art in general, the better the LLM is. When I've asked it do architectural or design work, it has been much less successful. That's one dimension on which LLM capabilities vary. There are certainly more!