Birbla

Join the discussion

Write your take first — we'll ask for email only when you're ready to publish.

Sign in
  • Hacker News
  • It's only 2 months old. Clearly vibe coded. Still, kind of crazy what you can vibe code now.

    Also the actual language design seems quite nice. I'd love something like this that was embeddable (and not vibe coded). There are basically no good easily embeddable languages. Everyone used Lua but it sucks.

    by IshKebab
  • Gossamer has a cycle collector and eager reference counting. Good luck dropping the last reference to a 10,000-node graph, especially if cyclic. That means it doesn't have "pause free" memory. If you want pause freedom, go use ZGC or another modern GC on a modern VM.

    I just can't take seriously this spate of languages that ignore the past 30 years of research into automatic memory management. We have multiple open-source pauseless miracles GCs right there before our eyes, yet it's the trendy thing in language design to foist memory management on users.

    You don't even have to use a big VM if you want good GC. Go use MPS. Lots of options out there, even if you want to implement your own VM.

    by quotemstr
  • This post reminded me of Swift– a modern high-performance language that uses automatic reference counting. Its got a REPL and compiles via LLVM. It does trade goroutines for something with a little more safety built in.
    by sdicker
  • There was once a time when I'd see a page like this and think "wow, must be a great project with such a polished website".

    Now, it's just a neutral or perhaps even very slightly negative signal (especially the em-dash in the very first line of the page).

    Anyone able to tell me if this is a project actually worth paying attention to, or just another raindrop in the current monsoon of slop?

    by throwrioawfo
  • I'm fairly sure the code snippets aren't equal in the last python example:

    ```python names = sorted({name.lower() for name in users if name}) ```

    vs.

    ```gossamer let names = users |> iter::filter(|n: String| n.len() > 0) |> iter::map(|n: String| n.to_lower()) |> iter::sort_by_key(|n: String| n.len()) ```

    Python is sorting a set (unique values only), but I'm not seeing a unique or set approach for gossamer.

    by pantsforbirds
  • I can't figure out the point of having both go and spawn. `spawn` seems to be an ordinary thread spawning mechanism, generating a handle that you can join with (but not cancel? can't find that for certain, it's not actually in the tour but is in the SPEC.md). `go` inherits all the problems of go routines. You can't join with it, you can't cancel it, you have to build other infrastructure on top of it to achieve those effects. As neat as golang was 17 years ago when it came out, this was and still is a major weakness of the language which has resulted in the community developing conventions (now standardized in the go standard library and particular usage patterns) around how to deal with it. I don't get why you'd half fix it (by introducing spawn) but then leave it in anyways. Just let the handle from spawn be ignored and you remove that particular footgun (it becomes a choice to ignore it, which still causes problems but at least the programmer chose to shoot towards their own foot).
    by Jtsummers
  • If you are interested in Gossamer, you may also be interested in Lis, which is Rust flavored and compiles to go: https://github.com/ivov/lisette

    From their readme:

      Safe and expressive:

    - Hindley-Milner type system
    - Algebraic data types, pattern matching
    - Expression-oriented, immutable by default
    - Rust-like syntax plus |> operator and try blocks
    - Go-style interfaces, channels, goroutines

  Quietly practical:

    - Interop with Go ecosystem (WIP)
    - Linter, formatter, 250+ diagnostics
    - Fast incremental compiler, readable Go
    - LSP for VSCode, Neovim, Zed, Helix, GoLand
    by rsyring
  • Three things stick out to me on https://gossamer-lang.org/docs/migration/rust/

    * No user macros at all. Six fixed format! / println!-family macros expand at parse time. - Meta programming is incredibly important in rust.

    * (unsafe is) Forbidden at the language level. No unsafe keyword in Gossamer source. std is safe-Rust too. - No low level programming then.

    * No move semantics. Non-trivial values are heap-allocated, reference-counted, and shared by reference; primitives are copied the same as Rust. - Again, no low level programming.

    Calling this rust flavored (or even a systems programming language) seems a bit bold.

    by reocha

Explore Birbla archives