Slashdot Mirror

I thought Gary Bernhardt's The Birth & Death of JavaScript talk was supposed to satire not a documentary! =P

You jest, but watch this video: The Birth and Death of Javascript. I dare you to decide whether that's farcical or visionary, especially considering recent discoveries of flaws in CPUs.

See the 2.nd half of this video: https://www.destroyallsoftware...

The future is coming along as planned.

> But the only language I learned to actually hate is Javascript. Talk about a steaming pile of shit.

That's because Brendan was a fucking idiot. JavaShit was designed and implemented in 10 days -- which would be impressive if he actually put some _thought_ in it. In contradistinction it was like almost every shitty thing about Basic was embraced and NOTHING about writing type safe programs from the past 40 years was used.

* Accidentally misspell a variable? That's nice -- we will just magically use it! Undefined FTW.
* Want misspelt variables to be flagged at run-time? Use the hack magic string

"use strict";

* Want to turn it off? Nope, sorry, no can do.
* Want to include files? Bwuahaha. What do you think this is? A programming language?
* Arrays and Strings are half-assed. What would you _think_ the result of

"" + [1,2] + [3,4];

should be? There are 3 possibilities:

1. [4,6] = Vector or Matrix addition
2. [1,2,3,4] = Array concatenation, aka [1,2].concat( [3,4] );
3. undefined = Exception thrown for mixing types

So what does JavaShit do? It uses an idiotic 4th choice!

4. "1,23,4" = String Concatenation WTF!?

More examples of how fucked up JavaShit is

Both JavaShit (JS) and PHucked Up (PHP) languages were designed by morons. At least other languages have _some_ sanity.

At least ES5 doesn't suck (as much).

Start with some practical code/app samples that demonstrate clear trouble. Ask them to participate -- see if they can solve the trouble. Then show how the original dev got themselves into that trouble, and the "professional" thing you would have applied to avoid it.

Bonus points for going comedic with examples that are ridiculous to the extreme.

I see you're a fan of Wat :-)

You're probably familiar with JavaShit's retarded == equality operator.

Hey retard Javascript Designer, "==" doesn't always work.
I know, let's add "===" as a kludge!
*facepalm*

When a language requires a stupid hack ..

"use strict"

... just to make it some-what type safe, you know it was designed by an moron who learnt NOTHING about programming languages from the past 30 years back in 1995.

More JavaShit broken-by-design:

if( 0 == "0" ) console.log( "equal" ); // True!? WTF!
if( 1 == "1" ) console.log( "equal" ); // True!? WTF!

for( var x in [5,6,7,8]) console.log( x + 1 );

*facepalm*

Produces 01, 11, 21, 31 instead of the expected 6,7,8,9.
Hint: for( var x in [5,6,7,8]) console.log( typeof x );

var s = '9223372036854775808', n = parseInt(s); console.log( n ); // FAYUL 9223372036854776000

> Please share some details, because I love to know about JS caveats and pitfalls and share them with others.

Math.tan( Math.PI/2 )

Returns broken 16331239353195370, instead of correct NaN

console.log( 123456789 << 5 );

Returns broken -344350048 instead of correct 3950617248

Don't even get me started on the retarded ASI (Automatic Semi-colon Insertion). As Douglas Crockford said @34:31

"Why am I betting my career on this piece of crap"

For more Javashit shennagins see Wat

That reminds me of the Birth and Death of Javascript

/Oblg. https://www.destroyallsoftware...

Maybe HotSpot / V8 type of optimizations would work well, as in running code, the actual patterns emerge. This is a great talk on the cost of virtual memory, the future of JS and more :-) https://www.destroyallsoftware...

Gary Bernhardt was ahead of the curve with his extremely amusing talk The Birth & Death of JavaScript.
https://www.destroyallsoftware...

A look back from the year 2035, he talks about the importance of having a assembly language for the web (asm.js) and tongue and cheek allowed the world to move past JavaScript where it finally becomes both a dead language and also what everything is built on.

We are slowly moving towards this nightmare ...

https://www.destroyallsoftware...

> a consistent type system

Mwuahaha. I was following you until you said that. With JS you get stupid automatic silent conversions that are the source of hidden bugs. And just to drive the point home (JS starts @ 1:22 )

* https://www.destroyallsoftware...

Javascript's == operator is fundamentally broken as this chart shows:

* http://dorey.github.io/JavaScr...

When even Douglass Crockford, who wrote the excellent "Javascript: The good parts" says @34:31 "Why am I betting my life on this piece of crap" in this video "Javascript: The Better Parts"

* https://www.youtube.com/watch?...

You know there is something horribly broken with JS.

Eventually the METAL Linux kernel module (C -> JS + asm.js) will boost overall processing speeds by ~4%.

/Oblg.

The birth and death of Javascript
https://www.destroyallsoftware...

I could go into a dozen technical reasons why javascript is a terrible, horrible, outrageously bad language here but this post would be TL;DR; for most people. Lets just settle for goggling "javascript terrible" and reading the first couple links.

Or for some silly (not not really deal killing) things watch https://www.destroyallsoftware...

The fact that there are actually people who think using in on the server is a good idea, proves there are insane or completely incompetent developers out there. If someone actually approaches me with this idea, I immediately think they are an idiot.

See, on the browser we basically have to deal with javascript because there aren't any real alternatives. But things that are just "issues" or "irritations" in the browser quickly blossom into product killing problems when used on the server.

Oh, and yes, I've written my fair share of javascript (and other languages), so don't think i'm talking out of my ass here.

/Oblg. The Birth and Death of Javascript

* https://www.destroyallsoftware...

Any language that requires a "use strict"; hack as the first line to turn on better error checking is fucking retarded.

> I've never understood the hate for VB.

Because shit designed languages, like PHP, Basic, and Javascript teach and encourage all sorts of bad, sloppy, programming habits, and inhibit the programming from using _good_ design / architecture. i.e. Visual Basic didn't get inheritance _until_ VB.NET long after everyone suffered with VB6.

For professionals we want compile-time type checking to catch stupid mistakes of

- mis-spelt variables
- using a variable with a mis-matched type.

Sure, for one-off's and throw away code VB6 was fine, but when you change the case of a variable, and the IDE changes ALL copies of it, or worse, lets you use a variable without declaring it earlier, you are shooting yourself in the foot with dumb mistakes that will waste your time tracking down subtle bugs.

> The verbose syntax of VB makes it easier for a broader range of abilities to be introduced to programming without all the symbology of C like languages getting in the way.

Nothing says a noob language like verbosity.

Why?

Verbosity is "noise" cluttering up the "signal" all in the name of a mythical "readability." Consider the enum in VB6:

Public Enum Flavor
    flVanilla = 2
    flChocolate = 4
    flCoffee = 8
    flStrawberry = 16
End Enum

C's enum gets rid off all the crap we don't need:

struct Flavor
{
    FLAVOR_VANILLA = (1 << 1),
    FLAVOR_CHOCOLATE = (1 << 2),
    FLAVOR_COFFEE = (1 << 3),
    FLAVOR_STRAWBERRY = (1 << 4)
};

Note: The '=' equal sign is multi-column aligned, but /.'s formatting is retarded and strips contiguous whitespace.

In Mathematics we don't go:

result_integer = integer_2 integer_add integer_2

We get rid of the superfluous crap and use symbols.

result = 2 + 2;

Verbosity is one of the reasons Pascal was a complete failure. It wasn't pragmatic and/or practical for SERIOUS coding.

/Oblg. The birth and death of JavaScript

https://www.destroyallsoftware...

I'm surprised no one has posted wat yet. Even though it's a video, I really found it interesting and funny.

https://www.destroyallsoftware...

^ This.

A WAT HOUR

Wat

I sense something here... is it possibly sarcasm?

About metaprogramming...

https://www.destroyallsoftware.com/talks/wat

Wat?

Once you realize that all languages have essentially the same structures, you start to say things like "languages are just syntax. Learn to program in one language and you can pick up any other language very easily."

The more enlightened say: "languages are just syntax. We don't need a hundred different syntaxes to express the same concepts. Let's stop reinventing the wheel."
Letters are just syntax. Yet nobody reinvents new ones an a daily basis.

Ok, so technically learning to program doesn't have the same set of requirements as production programming. Back in the day you were likely to get BASIC and then moved on to Pascal, C, Fortran or (god help you) COBOL. Once you realize that all languages have essentially the same structures, you start to say things like "languages are just syntax. Learn to program in one language and you can pick up any other language very easily." This is not actually completely true, but I'll get to that in a moment. They also didn't tell you much about the environment beyond giving you the "vi cheat sheet" and instructions on how to invoke the compiler. Near as I can tell they don't do a much better job of it today.

Rolling objects into the mix really doesn't change that much. You still need to know structural programming because you're going to need to write your methods and you don't want to write them as spaghetti. You have a whole other set of concepts to master for OOP. You can show people objects, but until they're ready for them, they're not going to understand them. I don't know how many people remember learning to program, but when you're looking at it for the first time, even basic language structure like function parameters (and functions) and variable initialization are confusing.

So yeah, Ruby and Javascript might make OK learning languages, inconsistencies and all. Of all the ones I looked at when I was a wee programmer (And I looked at them ALL,) Logo and Pascal seemed like the most sensible. We did Pascal in my high school (in the '80's) in a programming environment on Apple II machines. They environment was mildly quirky, but didn't take long to pick up. That let us concentrate on the language. Logo offered the most immediate feedback about how your changes affected the behavior of the program. At least for me, immediate feedback was very helpful to the learning process. You can definitely get that with the interpreted languages. The same things that make them reasonable languages to learn programming also make them not-so-great for production projects, at least not without a lot of unit testing that no one ever bothers to write.

Of course, the more you work with different computer languages, the more you start to realize that the statement that "all languages are the same" is not really true. You discover things like the ones mentioned in the presentation I linked to at the beginning of this post, and find yourself having to work around deficiencies in the language. At a basic level all languages are the same and once you learn the control structures you can write simple code in any language very quickly. To actually learn the quirks of a specific language and truly master it, that could take years. I'd go so far as to say that most programmers will go their entire career never having truly mastered a single language. What they give you in school are the tools to achieve that mastery, and I don't feel that anyone even does a good job of doing that.

There are a number of reasons. Admittedly, the language has a lot of quirks (this shows a few). But so so other languages. I think the bad rap js gets comes down to three things.

1) It's a prototype based language but people expect it to behave like a class based language.
2) The DOM. (which isn't the language's fault).
3) traditionally, a lot of JS code is often copy pasted from various sources and hacked together to mostly work by people that have no business being a programmer.

Speaking of tradition, the old days of browser incompatibility during the IE vs Netscape wars didn't help it's reputation much.

My oppinion is that Javascript is not bad as a scripting language, but we are abusing it and twisting it beyond its original purpose.

I disagree with that sentiment. Like PHP it gets used a lot and for that reason plenty people think it must be good for something, right?

Well, uhm, no. Wide availability and popularity do not a good language make. You have a point about the stretching but I disagree that it was any good to start with. Merely really, really widely available. And apparently well-suited for the kind of non-thinking that abounds in its niche. Which makes it enterprise-y, in a sense.

https://www.destroyallsoftware.com/talks/wat - Give that a watch - it's short and amusing, not some huge rant or dissection (begins on Ruby, moves to JS). Done watching? JS is full of that kind of horrific design that makes code do stuff you don't expect, and it lacks features that everyone needs. It just makes development harder, and that's the reverse of what you want a language to do.

But, hey, lots of people like them, so they must be good, right? https://www.destroyallsoftware.com/talks/wat

Wat? Do you download your software over UDP without any error checking or means of correction? Do your dll's and exe's not verify their size and signature? I tend to verify my packets, files, and packages.

If you don't like dynamic languages, fine, but implying that folks who choose to embrace FP and dynamic languages are "hobbyists" serves no purpose other than to expose your lack of depth as a developer.

Read this and take a long hard look at yourself.

I inject a little (apparently very well targeted) teasing into a thread full of uninformed anti-Java ragefacing, and you're judging *me*?

My implication served my purpose just fine (hi there!), and may or may not reflect my actual feelings on dynamic languages.

It's that some of us have put up with statically typed languages for 15 years, and have had enough of that crap.

I've had enough of this crap.

Let's be friends! Nay, will you be my pair programming partner? Imagine the insights and perspectives we could share! Imagine the paradigms we could shift, the behavior-driven mocking we could exchange while rebasing our git trees and eating Mongos. Yes, Mongos!

WILL YOU ACCEPT MY PULL REQUEST?

So hot.

Javascript is broken in a number of ways. Just watch this video: WAT.

The fact that commutativity does not hold for "[] + {}" is just wrong! I understand the need for "pretty graphics" and "instant gratification", but a different language would have been appreciated. Heck... a background in python would at least set them up for a lifetime of scientific computing.