Recent submissions

Comment · 10 days ago
Agreed. This feels like an abandon ship situation. I’m working on switching right now. That’s too bad, but this is not acceptable unfortunately
Comment · 11 days ago
Why use Drupal at all if the agent can just build things?
Comment · 3 months ago
There is no source because it's not true
Comment · 5 months ago
Hmm they all seem to be working for me
Comment · 8 months ago
I’ve been really unhappy with pretty much every Google product I’ve used except their consumer productivity tools — Gmail, Calendar, and Meet. Diving into Google Cloud has been extremely unsatisfactory
Comment · 1 year ago
The two feel very different. Elixir is introducing gradual set-theoretic typing (https://hexdocs.pm/elixir/1.18.4/gradual-set-theoretic-types...) while Gleam has a static Hindley-Milner style type system.

To me, Gleam feels like if Elm’s type system met Rust’s syntax. I really like it. But I also really liked Elixir too, I just can’t live without Gleam’s type system anymore.

Comment · 1 year ago
It’s a good lesson. We found PMF with a shared google sheet and a bit of data processing behind the scenes. The level of polish I’d come to expect as an engineer at an enterprise company was astronomically higher than what was actually needed for our customers to give us their dollars.
Comment · 2 years ago
This is a really gross comment and should be removed.
Comment · 2 years ago
That reminds me, there’s a really great survival game called The Long Dark in which you survive a plane crash in something like the arctic circle and must survive. If anyone is into survival games, definitely check this one out!
Comment · 2 years ago
Comment · 2 years ago
Erika wrote “Using use in Gleam” in part because I didn’t understand how to use `use`, so I feel at least a little bit qualified to answer this.

I find that `use` is quite effective when needed. This is the part referenced in her article where I find `use` particularly helpful. Something like:

    fn outer() -> Result(success, failure) {
      result.map(parse_id(), fn(id) {
        ... // More code that uses the id
      })
    }
Becomes:

    fn outer() -> Result(success, failure) {
      use id <- result.map(parse_id())
      ... // More code that uses the id
    }
In more concrete terms, I’m building an application with Gleam and Wisp that uses Wisp’s `require_form`. The type signature for `require_form` is:

    pub fn require_form(
      request: Request(Connection),
      next: fn(FormData) -> Response(Body),
    ) -> Response(Body)
But I get to use it like this:

    use form <- wisp.require_form(req)
I’m not sure if I have the appropriate nomenclature here, and I consider myself a beginner of writing strongly typed functional languages, but when I use `use`, I get to invoke the callback with the value on the left side of the arrow.

As Erika so thoughtfully put it:

> The key is to use `use` when it allows you to highlight the happy path of your code … A use expression is syntax sugar, and it’s always possible to write Gleam code without it, though maybe not as clearly.

You can see more here [1] if you want, but note that there are a lot of structural changes in this codebase while I learn and figure out how to best use Gleam and Wisp :)

1. https://github.com/usepriceflow/app/blob/main/src/app/web/ad...

Comment · 2 years ago
Awesome video, and definitely captures some of the super powers of targeting the BEAM! Thanks for sharing
Comment · 2 years ago
Congrats to the community, Gleam is a really awesome language! This is such exciting news!
Comment · 2 years ago
Hands up if you’ve still got ColdFusion powering critical apps in production to this day
Comment · 2 years ago
It doesn’t really matter what can be done natively versus in a browser. For many folks, apps are the internet. This take is very developer-centric but it doesn’t account for the real world. Many people prefer using apps, especially middle-age to older demographics. That’s what our analytics say at least.

Live from the official Hacker News API

A modern reader for Hacker News · SvelteKit + Skeleton