undefined | Better HN

0 pointsfbonetti8y ago0 comments

Elm's primary selling point is "no runtime exceptions". The subheader on Elm's homepage even says this[1]:

    Generate JavaScript with great performance and no runtime exceptions.

Type safety doesn't come for free. If you want to build an application that doesn't have runtime exceptions, you have to specify what external data should look like, how to translate that data into a native datatype, and what to do if that expectation fails. With this in mind, you can't just write `JSON.parse(data)` and expect everything to work. What if your data has a different shape? What if it's missing fields? What if field "foo" is a String instead of an Int?

Here's a short example in Typescript:

    import fetch from "node-fetch"

    interface Post {
      user_id: number,
      id: number,
      title: string,
      body: string
    }

    const postUrl = 'https://jsonplaceholder.typicode.com/posts/1'

    const show = function(post: Post) {
      console.log(post.user_id)
      console.log(post.id)
      console.log(post.title)
      console.log(post.body)
    }

    function getJSON(): Promise<Post> {
      return fetch(postUrl).then(x => x.json())
    }

    getJSON().then(show)

Do you see the bug? `user_id` is supposed to be `userId`, yet this example will compile without an issue. When you run it, `post.user_id` will be undefined, even though our interface clearly states that a Post most have a `user_id` field of type `number`. The compiler won't catch this even with `--strictNullChecks` enabled.

Everything in programming is about tradeoffs. If you don't care about strong type correctness, use something like Typescript. If you do care, Elm is a great choice.

[1]: http://elm-lang.org/

0 comments

hudon8y ago

Elm's type system will not catch this bug at compile time, it will still be a runtime exception, unless you're saying Elm's compiler does an HTTP call to that endpoint to verify that the interface matches the response object??

The only difference in your example probably is that Elm will force you to handle the case where your interface doesn't match the response object (missing field, in this case). But nothing in Elm forces you to handle it well, so if the programmer forgot to handle it well in TypeScript, they will do the same in Elm, and the end result will be the exact same: a runtime failure.

Skinney8y ago

> ... it will still be a runtime exception ...

No.

> The only difference in your example probably is that Elm will force you to handle the case where your interface doesn't match the response object

Which means that no exception have been thrown. You've handled it, however poorly, and so you've made a conscious decision about how to deal with it.

In TypeScript, this is much easier to forget, because you don't have a compiler that forces you to deal with it. If you're lucky, this causes a runtime exception at the place the error occurs. More likely, however, no exception is raised, and you get an error down the line which is hard to notice and hard to debug.

Like, there's nothing in TypeScript that forces the developer to use the correct types. A lazy developer could just use "any" everywhere. So if the programmer doesn't handle this well in JavaScript, they will do the same in TypeScript, and the end result will be the exact same: a runtime failure. This, however, doesn't mean that TypeScript isn't a great tool that helps developers avoid runtime errors, it just means that this particular programmer doesn't take advantage of the tools at his/her disposal.

hudon8y ago

I agree that Elm is more strict at compile-time than TypeScript, there is no argument there.

What I have a problem with is using an example where the programmer is lazy in TypeScript, then assuming the programmer is NOT lazy when coding in Elm.

If you just print an empty error string and your app continues running assuming it decoded successfully, you can be in as bad a place as the app that crashed. Actually, in some mission critical cases, failing hard is safer than continuing with corrupt data.

In both cases, TypeScript AND Elm, you must do work to handle the failure to decode gracefully, it will actually be less work in TypeScript because you have less to specify. The only difference is that in Elm, you are reminded more often to do that work.

1 more reply

fbonettiOP8y ago

> Elm's type system will not catch this bug at compile time

This is completely false. Elm's type system will force you to handle the decoding failure at compile time. The `decodeString` function has the following type:

    decodeString : Decoder a -> String -> Result String a

Which means that when you call `decodeString`, it will return a Result containing either the decoded value or a String describing the error.

This is not a "runtime failure". This is the compiler forcing you to explicitly spell out what you want to happen the case of a decoding problem. The difference between Typescript and Elm is that Typescript's compiler will happily let your program crash when this type of issue occurs, whereas Elm's compiler won't.

hudon8y ago

You're just rewording what I said. The coder can simply ignore that string or make it empty, which can lead to a runtime failure if another module depends on a value being returned (think a runtime failure from a non-exhaustive pattern match). If they were a lazy coder in TypeScript, they'll be lazy in Elm (:

So, no, what I said is not "completely false"

1 more reply

j / k navigate · click thread line to collapse

0 pointsfbonetti8y ago0 comments

Elm's primary selling point is "no runtime exceptions". The subheader on Elm's homepage even says this[1]:

    Generate JavaScript with great performance and no runtime exceptions.

Here's a short example in Typescript:

    import fetch from "node-fetch"

    interface Post {
      user_id: number,
      id: number,
      title: string,
      body: string
    }

    const postUrl = 'https://jsonplaceholder.typicode.com/posts/1'

    const show = function(post: Post) {
      console.log(post.user_id)
      console.log(post.id)
      console.log(post.title)
      console.log(post.body)
    }

    function getJSON(): Promise<Post> {
      return fetch(postUrl).then(x => x.json())
    }

    getJSON().then(show)

Everything in programming is about tradeoffs. If you don't care about strong type correctness, use something like Typescript. If you do care, Elm is a great choice.

[1]: http://elm-lang.org/

0 comments

hudon8y ago

Skinney8y ago

> ... it will still be a runtime exception ...

No.

> The only difference in your example probably is that Elm will force you to handle the case where your interface doesn't match the response object

Which means that no exception have been thrown. You've handled it, however poorly, and so you've made a conscious decision about how to deal with it.

hudon8y ago

I agree that Elm is more strict at compile-time than TypeScript, there is no argument there.

What I have a problem with is using an example where the programmer is lazy in TypeScript, then assuming the programmer is NOT lazy when coding in Elm.

1 more reply

fbonettiOP8y ago

> Elm's type system will not catch this bug at compile time

This is completely false. Elm's type system will force you to handle the decoding failure at compile time. The `decodeString` function has the following type:

    decodeString : Decoder a -> String -> Result String a

Which means that when you call `decodeString`, it will return a Result containing either the decoded value or a String describing the error.

hudon8y ago

So, no, what I said is not "completely false"

1 more reply

j / k navigate · click thread line to collapse