Was it made intentionally bad?

Javashit won out for the same reason Unix won over the Lisp machines. Because worse is better. If two technologies are chasing the same end goal, the masses will always favor the worse one.

Why are frontenders such idiots? Always act like they are god given to this planet or something. With all current bootstrap and shit frameworks every backender can make their job done. Most if not all frontenders just copy pasting shit from other websites.

>reading severely outdated books

Attached: 1531053352958.jpg (480x480, 37K)

Same with Ethernet. It won because it was cheap and shit.

>Why are frontenders such idiots? Always act like they are god given to this planet or something

Because the front end is the whole reason the entire system exists in the first place. All code must eventually cause pixels to change on someone's screen at some point. Otherwise, it's all just pointless software masturbation.

the buttplug up your ass hurts lol

You're just looking at it from the wrong point of view.

based and redpilled

cringe and bluepilled

yikes
just yikes

Are you implying there are no good parts any longer? What happened?

It was made for small quick website the bigger websites were always ment to use java.As the web grew people started using JavaScript more it was never intend to be used as the defactor standard or the go to it was always meant to just be used for quick small shit.

This. Big boys use Java applets.

It was shit in 1995, but it's been good and getting better every year since 2015.

OBSESSED

Attached: 1537031328199.png (1000x1000, 668K)

just be glad it's not vbscript

look friendo, just because Jow Forums likes cute traps doesn't mean we support LGBT crap

Frontend has gotten stupidly complex in the last few years. I'm not saying that's a good thing. But for most business tasks the backend will be a relatively simple API, while the frontend is the highly competitive space where you win or lose users.

this.

We should have just gone with Scheme instead.

I'm implying that the book by the same name by Douglas Crockford is severely outdated and JS has only been improving since he wrote that book.

Not gonna lie vbscript in its current state I'd better than JavaScript have you seen operator handling in javascipt.

Can't be much worse than your post, mate.

That's true only if you ignore all the years it was constantly improved and all the tools modern web dev uses.

Only retards and pajeets use bootstrap. React+Redux+SASS+Webpack is pretty comfy.

>React+Redux+SASS+Webpack is pretty comfy.
Just look at all this shit needed to write a fucking hello world that executes properly in every somewhat modern browser.

Brainlet detected. You don't need all of that for hello world, it's literally 1 line of vanilla.

But if you want to rapidly create interface for some real time service with nicely organized code compiled to single file(s), normalized, deterministic state, written in modern dialect but keeping compatibility across various browsers and versions, they can come in handy.
As much as I love to use Rust or C++ for backend, I can't really imagine more comfortable and robust stack for front-end than this one.

If this is so bad and easy why is react/angular/node js so complicated while laravel django php python is like walking in the park

because the second ones were made by actual programmers

It was suppose to be Scheme for the browser but they pivoted to appeal to all the Java developers at the time. That's why you see weird things like the prototypal inheritance. I personally got no beef with the language. I think the overuse of libraries and frameworks are bad, and ES6+ is just a useless attempt to appeal to small brains (but it is working). So many things in the JavaScript realm are over-engineered and use far too much JavaScript to do the simplest of tasks.

It's really not so complicated. I've used everything you mentioned. What do you find hard to understand about the above?

Why would real programmer's choose a shitty language to build a complicated framework, dont take me wrong i hate javascript but lets be honest javascript more complicated than other languages

JavaScript is redpilled af

This kills the backend:
adventurega.me/bootstrap/

Just use Nim instead and have it compile to JS, user.

Attached: nim-lang.jpg (1080x713, 124K)

Virtual DOM is one of the greater things that we've seen in recent JavaScript libraries (although most are far too heavy, not the vdom's fault, I've made very tiny vdom implementations). Thrashing the browser on every value/state update is absurdly slow. But once again the browser wasn't created for application development (but that's what we do with it now!).

Javascript is proof functional programming failed.

whoops, I meant to say "just use Elm"

Sorry, I think you mean to say "Javascript is the only successful functional programming language"

Javascript transpilers are absolute cancer

It was made to make Java applets look good and powerful in comparison.
So yeah.

Elaborate please? Eich's decision to model the language after Scheme was arguably the best decision he ever made.

Oh, you must be one of those oop faggots. Nevermind, I shouldn't be wasting keystrokes on you.

Attached: 02850234862346.jpg (866x1300, 168K)

Just use ReasonML
Just use ScalaJS
Just use ClojureScript

even baybl?

Every Jow Forums Javascript thread ever:
>muh made in x days
>muh 0.1 + 0.2 doesn't equal 0.3
>muh dynamic typing
>muh pic related

Backendfags are so predictable.

Attached: 2093053235802.jpg (3264x1836, 792K)

Because the former lets you do everything latter can, but not the other way around.
Similarly how Java is easier than C++.

>Because the former lets you do everything latter can
AT WHAT COST BOSS AT WHAT COSSST??

>I'll point out the common criticisms and not address them
>heh what now backendfags

>>muh made in x days
Yes, the very first prototype was devised and shipped in 10 days. The language has been continuously improved since by the standards committee.
>>muh 0.1 + 0.2 doesn't equal 0.3
People somehow forget that this happens in 90% of the programming languages that implement IEEE 754 64bit double precision floating point numbers.
>>muh dynamic typing
TypeScript is also available for people who can't take a single step without types holding their hands.
>>muh pic related
Two very very outdated books. Refer to my first point.

ES6 syntax is great, what do you mean? Arguably the only bad thing was the new class syntax.

Attached: 3458304683046.png (569x170, 51K)

The inability to detect sarcasm is a symptom of autism.

Depends on what you want to do.
If you just want simple website with some dynamic content and comments section or something, you mostly likely don't need to write a server. PHP might be fine here.
But if you want to create some more advanced service and/or web application in it, it's probably not a good idea.

I was just explaining those points, not necessarily replying to you in any way.
Are you per chance autistic?

Sure, it's good. But everything you can do in ES6 you can do perfectly fine in ES3 (outside a few things, proxies come to mind). It's unnecessary. JavaScript has been a very easy to understand and simple language for a long time and after TC39 has their way with it it's going to end up like C++, developers will only know a small subset of the language ("React developers" come to mind).

ES3 with E4X, Proxies, and async/await is all the web needs for feature packed "applications."

My beef is with developer that immediately jump to new features like `fetch` before even having a cancelable API. XMLHttpRequest is still perfectly fine. Or even worse the developers that immediately jump to Axios, Moment, ... I see a lot of people in web development sacrificing UX for DX and it's absurd.

>cringe
>based as fuck.

If you use React with ES6 you know how comfy it is. JavaScript previously was admittedly trash.

The mindset still applies, you might need to work with legacy ES once in a while, and he had a talk about (then upcoming) ES6 called "The better parts". I'd say his book is one of the greatest books about CS, and people should read it no matter if they will ever touch ECMAScript, because it's about how to approach a programming language. I don't know why this book isn't memed as hard as SICP and K&R2 are around here.
infoq.com/presentations/efficient-programming-language-es6

It's really not that bad unless you subject yourself to horrible frameworks and use them as an example as to how to write code.

These are the small brains I am talking about. If they don't have docs to follow along with and 100s of kbs to send to clients they are lost.

It was designed in 10 days. It was never intended for the purposes we see today. Neither was HTML. Modern web is an utter mess.

React seems pretty cool, can I implement it with Flask?

>100s of kbs
you know it’s not the 90s anymore right gramps?

Attached: 0CD0A8FB-0F47-4AE1-ABC0-E89B7C0D8400.png (325x325, 126K)

How much does webshit earn you vs. backend dev?

It's not bad, though. It's just not great.

Why not? It's just front end code that compiles into plain js.
However it might come at a cost. If you decide to do everything in React, your page might require JS and bots(google) won't see anything. Node+React can do server side rendering by design.

About the same

It's pretty much the same.

its just a prank bro

>Junior Full Stack Developer
>Have a few server and db related tasks
>most of my day is fixing frontend and routing shit in angularjs in a 120000 line app that mainly uses it in ways it was never intended to

I would much rather do pure backend, tyvm.

The funny thing is that it was going to be a scheme but SUN wanted the syntax to look more like Java.
The interesting thing is that SGML and XML are essentially just s-expressions with a lot of extra fluff and exclusively for representing data. Unless you combine them with the earlier markup language processor languages, DSSSL and XSLT, which are both technically schemes.
Mozilla only decided to create a new language for the front-end because the earlier two were considered overkill.

It turns out that if SUN had kept their fingers off lisp would rule the world.

ye that's why I brought it up.

I don't particularly like JS, but I can't imagine using any other language for frontend. I always use a different language for backend, but a well-tested set of JS libraries/frameworks makes using it a dream for frontend

I personally write in common lisp and compile it into JavaScript using parenscript.
Lots of concepts translate direcrly from one to another because of the relationship mentioned a couple posts up. You can then use the same functions for shared things on both ends, like with NodeJS.

Haven't used lisp in years, but it sounds interesting. I can't imagine using it for web dev, but looking at examples on parenscript now

There is no legacy ES. There has not been a single breaking chang in the language that would warrant a "legacy" label.
Vanilla JS written in any year will never become legacy because it always comforms to the latest spec.

Based and redpilled

JS gets so much hate, but ES6 and up is ridiculously well-featured, and only gets the hate that it does, because brainlets don't take the time to learn it, properly.

Even the little quirks it does have are easily avoidable. Something that can't be said for most interpreted languages

>There is no legacy ES.
No sane person wants to write code like
var that = this;
so I consider it to be a legacy thing, as it feels like playing russian roulette. There is existing code using dinosaur libraries like jQuery written with ridiculously old browsers in mind without using tools like babel.
The fact that there are no breaking changes just shows that even with initial releases screwed up so badly, a language can be turned into something decent without breaking old code that nobody would want to write.

>mfw I unironically read that big book at least 2 times.
>mfw I still don't know everything in it

Attached: 1533513584542.jpg (251x242, 15K)

That is not legacy. If you spent 2 minutes and read the documentation for functions carefully then you'd know that they get their own `this` in the function body.

It is a severe design mistake (picking OOP was a retarded idea in the first place) that was mitigated with how fat arrow lambdas behave.
Anyone who worked on something more involved than fizzbuzz will learn this, hard way or not. I actually have a job as an ECMAScript developer, and I know the language. Pretty much everyone hates ES because of how much of a footgun older versions were, and that first impression sticks around.

ES6+ is fine. Jow Forums hates on javascript because they're ignorant.

pretty sure Jow Forums hates on javascript because javascript is responsible for the absolute state of the modern web

So are C/C++ compilers following your logic.

It's not Javascript's fault so many people suck at web design. If anything, blame PHP and WordPress

>react/angular/node js so complicated while laravel django php python is like walking in the park

Comparing apples to oranges. I therefore don't doubt why anything is complicated to you.

>node so complicated
>django walking in the park

Bullshit
Node.js Code with Express
const app = require('express')()

app.get('/hello', (req, res) => {
res.send('Hello World!')
})

app.listen(3000)

Now show me that in your Django.

>no semicolons
kys

What makes you think that, OP?
No excuse. Unless, of course, Eich was never confronted with making a programming language before.
>No, it was a language designed to make animated ad banners
My theory as well.
>That's true only if you ignore all the years it was constantly improved and all the tools modern web dev uses.
Well, in that case standardizing it with this extended scope in mind was the mistake. You hardly can fix the wrong core assumption. Same is true of the C standardization.

No, it's not Javascript's fault. It's the business' fault. Javascript just happened to rise at the same time.

>You hardly can fix the wrong core assumption.

Core Javascript's horrible array loop:
for (var index in myArray) { // don't actually do this
console.log(myArray[index]);
}

ES6's awesome loop function:
for (let value of myArray) {
console.log(value);
}

Wow, that was impossible to fix.

>syntactic sugar
Doesn't fix the compilation model & type model, parsing assumptions and the overall bad idea that untrusted code runs over your potentially vulnerable data.

>8 ways to define a function
>js style guide expects you to use them all

nothing wrong here folks

As opposed to "hey download this bash script and run it trust it it's totally safe even though it has access to your hard drive it won't do anything bad"

it's not a race to the bottom, user

They must've failed because it's becoming the most successful language in the world.