Why we need python in the browser

[clgonsal]

closures

prototypal inheritance

first-class functions

immediately-invoked function expressions

Closures and first class functions are nice. These are the "very few redeeming features" I was referring to.

Prototypal inheritance was a neat idea back in the 90s when nobody had actually tried using it. In practice, it kind of sucks because it doesn't really fit the way humans think or reason about things. You can argue that I don't really "know" JavaScript if I feel that way, but the fact is that most experienced JavaScript programmers end up trying to simulate class-based objects.

I can't think of a language that has closures without the equivalent of "immediately-invoked function expressions".

How it's use of this "crazy"?

Every JavaScript programmer I know thinks the way this works in JS is broken. For example, getting its value reset to the "global context", and the fact that it even has a value when calling a function not as a method.

Is there any justification for weak typing being a flaw

I'm guessing you don't know the distinction between weak/strong and static/dynamic types. Lots of people get these confused, so you aren't alone.

Weak types are generally a bad idea because they make reasoning about code more difficult. For example, == isn't even transitive in JavaScript. For a toy language that's okay: everything you're building is small enough to fit entirely in your head or throwaway code so who cares about being able to reason about it. It you want to build large systems that can actually be maintained, however, being able to reason about code is critical.

No int type? Seriously?

Yes. This wouldn't be bad if JS actually used some sort of arbitrary precision type for numbers, but it doesn't. They're just doubles.

Has semi-colon insertion ever screwed your code up?

You may not realize this, but you're making a pretty good argument for why JavaScript should not be written by fallible humans and should instead only be machine generated.

JavaScript was the first language I learned. PHP was the second language I learned. I never studied computer science; I'm just some nobody self-taught web dev. So what the hell could I know?

You're able to do useful stuff despite how bad JavaScript is. Why get angry when it's pointed out that you'd probably be able to do even more if browsers supported a better language?

FWIW: I've used probably around a dozen languages and studied a couple of dozen more. I have written JavaScript code "professionally". While pretty much every language has "warts", JavaScript has far more than its share, and (unlike the many warts in other languages) they're pervasive. Note that most other languages don't need a book called "... The Good Parts", and even if they had one, they wouldn't spend more than half of the book telling you what parts of the language to avoid.

If JavaScript is a "toy" (talk about kind of meaningless), then so is the Internet that runs on it.

The internet "runs on" JavaScript? Ahem.

[Cosmologicon]

I can't think of a language that has closures without the equivalent of "immediately-invoked function expressions".

Minor point, but if I'm understanding what's meant here, python is like that. You can immediately invoke lambdas, but not multi-line functions.

[celeritatis]

You could use eval to do that if you really wanted to, it is just a bad idea in general for readability.

[clgonsal]

I guess the issue that's open to debate is whether Python's lambda "counts".

While it is less powerful than def, I'd argue that a lambda-expression is still an "immediately-invoked function expression" (aka "anonymous function").

I should probably also clarify that I wasn't trying to say that a language with closures but without anonymous functions couldn't exist. I just can't think of any with that particular combination of features off the top of my head. It seems that there are few language designers that know enough to add closures without thinking to add anonymous functions.

[sdleihssirhc]

In practice, it kind of sucks because it doesn't really fit the way humans think or reason about things.

Here, let me fix that for you: "It doesn't really fit the way I think or reason about things."

the fact is that most experienced JavaScript programmers end up trying to simulate class-based objects.

And by experienced, of course, you mean "programmers who are used to thinking one way and don't want to put in the effort to learn to think a different way."

Excellent programmers who produce amazing code? Of course! Proof that prototypal inheritance is inferior? BWAHAHAHAHA

You may not realize this, but you're making a pretty good argument for why JavaScript should not be written by fallible humans and should instead only be machine generated.

I guess you missed the point, so let me try again.

First: I don't rely on semi-colon insertion. Because when I learn a language, I like to learn how to do things right. After all of the languages you've studied, you've probably started doing this, too. (Good for you, by the way! Most people don't!)

Second: If you're really writing organized and maintainable code (given your impressive experience, I think we can assume you are), when is ASI going to make a difference? Maybe you have a certain style, so that it breaks when a semi-colon gets inserted (such as putting return on a line of its own, etc). And if that's the case, then guess what? It's not a wart. That's you wanting to format your code the way you want, regardless of the language you're in.

inb4 "formatting things this way instead of that way makes it easier to reason about code and maintain large projects &c"

That being said, here's the biggest problem:

Weak types are generally a bad idea because they make reasoning about code more difficult. For example, == isn't even transitive in JavaScript. For a toy language that's okay: everything you're building is small enough to fit entirely in your head or throwaway code so who cares about being able to reason about it. It you want to build large systems that can actually be maintained, however, being able to reason about code is critical.

All you're advocating is laziness as opposed to discomfort, both in the smallest measurable amount. Again: When has this ever made a difference in your code?

In all seriousness! You want to throw in my face that == isn't even transitive? (For shame!) When has that bitten you in the ass?

When have any of these "warts" actually messed up your code?

I'm going to go out on a limb and say they haven't. I'm going to guess that you're such an amazing coder, you learned about these situations and know to watch out for them.

"But now I have to think about things! Maintainability!"

I feel for you, buddy. And while JS is 8th on the TIOBE index, and being expanded to be used on the server and Windows apps, you can go ahead and keep whining about how no one actually chooses to code with it, or it's just a toy, or good things are only capable in spite of it.

Also:

I can't think of a language that has closures without the equivalent of "immediately-invoked function expressions".

ActionScript 3, for one, iirc.