Hacker News Reader

Comment by simongray | Hacker News Reader

It's probably because the author keeps getting comments from other developers about his choice of language and he's tired of explaining why.

There was a HN submission yesterday about another project of his (also in Clojure) and many of the comments were "Why is this made in Clojure?".

Unfortunately, a large segment of developers think there is no value in venturing beyond C-style languages.

Another dimension in recent years is the static type checking cult, whose adherents must warn everyone else in the cult whenever they spot any kind of dynamically typed programming language, e.g. causing a separate thread about the lack of static type checking in any comment section about a Clojure project.

View on HN

I came from C#/Java to JavaScript and it was extremely painful. I didn't care that much about typing until I experienced a dozen types of error that should have been impossible. (Shouldn't even compile, let alone silently poison your data at runtime...)

For years I thought it was a dynamic/static issue. Then I used Python (without type hints), and almost all the JS errors were impossible in Python too! Turns out it's about weak/strong typing instead.

Put simply: when given something that is an obvious error, throw an error. This sounds obvious, but given an obvious error, in many cases JavaScript remains silent and passes garbage data to the rest of the program.

I think if JS added a "use strong", it would remove 80-90% of the need for TypeScript.

Javascript does have 'use strict' https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

Yes! Exactly. However:

    "use strict";

    let undef;
    let str1 = "hello";
    let str2 = str1 + undef;
    console.log(str2); // -> "helloundefined"

Whereas I propose:

    "use sane";

    let undef;
    let str1 = "hello";
    let str2 = str1 + undef; // -> Uncaught TypeError: Cannot append string and undefined
    console.log(str2); // (code never reaches this point)

(I would also settle for "Uncaught ReferenceError: Attempted use of `undef` before initialization.")

Yeah, JavaScript has a pile of terrible type coercions, implicit conversions and misuse/reuse of operators. It was a bad 90s/00s trend to do this kind of thing; re-use + for string append, or coerce things into strings for convenience. Python and Ruby have their own gotchas, though not as bad.

You might enjoy this classic comedy routine: https://www.destroyallsoftware.com/talks/wat

With VSCode, you can use "// @ts-check", which essentially turns on a linter that assumes JS is strongly typed and respects any provided TS definitions and jsdoc comments. It's not the same as actual strong typing (like Python/Clojure), as it obviously doesn't affect the runtime, but it really helps.

> Another dimension in recent years is the static type checking cult, whose adherents must warn everyone else in the cult whenever they spot any kind of dynamically typed programming language

Shun the nonbeliever!

The blog post does mentioned the lack of a static type system as a drawback. Although it sounds that what he really wants (cause of his prototyping remarks) is gradual typing similar to typescript.

Clojure has a gradual type system--core.typed--that I've used extensively. It's... it's very cool, but for my uses it seems to be more trouble than it's worth. I keep coming back to it every few years, though.

> There was a HN submission yesterday about another project of his (also in Clojure) and many of the comments were "Why is this made in Clojure?".

https://news.ycombinator.com/item?id=38525968

Reply on news.ycombinator.com