Thread

1. mccoyb · 1789695417 · focus · HN ↗

   My read on this, after ingesting a good amount of content on the history, is:

   - this Bend is not really related to the old Bend (only in name)

   - this Bend doesn't really have anything to do with interaction combinators

   - this Bend is a QTT, with a change to affinity which enforces a good performance property for GPUs

   - the "higher order at comptime" is neat, reminds me of Andras Kovacs' work on 2ltt and staging in dependently typed languages.

   - this Bend is likely to be good at "balanced recursive computations on ADT", and can parallelize them ... but won't be as good as CUDA or e.g. Futhark on dense rectangular array computations

   - performance needs improvement in the scheduler, to possibly help with balanced work (looking at the n queens and symbolic regression numbers)?

   How are you going to handle search or synthesis over irregular structures (SupaGen)?

   1. sigbottle · 1789696351 · focus · HN ↗

      aww man. I remember following victor in college. I mean pivots gotta pivot, and this is probably a better one for business, but always thought the interaction combinator framework was cool
   2. snthpy · 1789721514 · focus · HN ↗

      What?

      Thanks for pointing this out. I'm only reading these comments because i liked the interaction combinator Bend language.

      Pivots are cool but why reuse the name and cause confusion? What is the old Bend called now?

      1. [deleted] · 1789727825 · focus · HN ↗

         [deleted]

      2. mabini · 1789741437 · focus · HN ↗

         [dead]

   3. killerstorm · 1789721895 · focus · HN ↗

      Here's what Victor wrote about inets in Bend2 (on X):

      > interaction combinators still parallelize better than anything else, but the graph overhead prevents us from compiling to maximally efficient assembly. bend2 is basically inets without the overhead. in a way, inets live in it architecturally, but they don't exist at runtime

      From what I understand, the main difference between lambda calculus and inets is that in LC you can refer to a binding multiple times for free, i.e. call same closure multiple times, etc. In inets, you can't - they are more like physical wires where each reference costs. You can definitely see inets in Bend design here (from the guide):

      > A closure is affine: it can be called at most once, even when everything it captures is Data. Only top-level definitions can be called freely.

      So programming in it might be very different from the normal functional programming. Seems like a big limitations. But I guess that's what lets it run without GC, on GPUs, etc.

      1. mccoyb · 1789734921 · focus · HN ↗

         Thanks for clarifying. I would like to see a more clear exposition on the relationship here.

Unofficial Hacker News client; not affiliated with Y Combinator.