Do you think writing clean code is a bit difficult in javascript compared to other languages ?

I think the main reason why it is so difficult about writing clean code is us, developer.

I often heard people saying that being lazy is not good, unless you are a developer. And most of the people out there have learned to adopt this moto without good reasons. There is nothing good at being lazy in our field of work. But instead of being lazy we should be smart.

Because lazy would mean writing a library that takes the least amount of work to be done. I see many libraries brag about being the fastest, about being the easiest to use. That's great really I don't mind that. But if that comes at the cost of the maintenance and the bugs that are created, leaving us a night of debugging because there has been a lack of runtime type checking in a chain of library calls, I would rather prefer a code that is 10x slower and that is reliable to use than that.

And most of the time this is what we saw:

function add(first, second) {
    return first + second;
}

Instead of this:

/**
 * Add two numbers together.
 *
 * @param {number} first The first number to add.
 * @param {number} second The second number to add.
 *
 * @throws {Error} If the function gets called with not exactly two arguments.
 * @throws {TypeError} If the first parameters is not a number.
 * @throws {TypeError} If the second parameters is not a number.
 *
 * @return {number} The addition of the first and second number.
 *
 * @example
 * add(1, 2);   // 3
 * add(-1, 2);  // -1
 */
function add(first, second) {
    if (arguments.length !== 2) {
        throw new Error("Expected two arguments.");
    }

    if (typeof first !== "number") {
        throw new TypeError("Expected first argument to be a number.");
    }

    if (typeof second !== "number") {
        throw new TypeError("Expected second argument to be a number.");
    }

    return first + second;
}

And that saddens me a lot. Because JavaScript itself has nothing wrong. No languages are perfect. Unfortunately, the path that JavaScript has taken (being an overly accessible and easy language for beginners to pick) has probably made it one of the most misused languages of all time.

Plus the fact that it tries to be both an object-oriented (but it is not since it is prototype-based) and a functional (but it is not, or at least not entirely) makes it even more difficult for newcomers to chose between the two to write good APIs. Also, the language itself does merely nothing to help us make the smallest amount of mistakes since it does not have type system baked into the language to do type checking, compared to TypeScript or Elm for instance.

So yeah, maybe JavaScript has gained its popularity because it is very easy to learn the basics of the language compared to TypeScript or Elm again, and it has contributed to the popularity of the Web ecosystem lately, but I think that now that its popularity is no more to justify, it should thrive for robustness and reliability.

But this is only my opinion, and I didn't have this opinion when I was a complete beginner since it was an opportunity for me that the language was so easy to learn and be productive with. Anyway, there is no very good answer to that question, we can only see that through the prism of our own experience and tell our own vision of what a language should be.

No, I don't think...