What makes JS a bad language in your eyes, user?

What makes JS a bad language in your eyes, user?

Attached: 1523573591875.png (265x239, 67K)

Other urls found in this thread:

destroyallsoftware.com/talks/the-birth-and-death-of-javascript
twitter.com/SFWRedditGifs

Knowing that, J is for Java.
Really fucks my eyes.

It needs to be unreadable to be high performance.

I personally like it, but the biggest issue is that there's 300 different frameworks that are all trying to be the one universal framework, and 9/10 of them all do the same damn thing.

Former js hipster here.
What I hate the most about javascript is that it's way too high level to do any "real programming", but it's also not high level enough to do basic shit fast like you can in python or ruby.

You end up downloading third party modules for everything. And when working in a team, you just need to hope everyone else is uses to the same libraries you use.

is that some Shadman?

Performance fast or getting shit programmed fast? Because it's faster than python performance wise

Think about it for 5 seconds

the only thing that this post showed is you ignorance, node is much faster than python and ruby, and even can outperform golang for heave io based apps

I'm talking about dev time, not perfomance.
If you want to talk perfomance though, pulling in 6MB dependencies for a client side web project also doesn't sound like a great idea.

Single threaded even loop callback spaghetti garbage trash

if you don't like dependencies, write your own code, in the end I don't think there is an alternative for js in client side

the jon guy who has a 1000 github repos for stuff like istrue(), isfalse() etc.

> single threaded
create as many node processes as you want in docker for example at whatever scaling level you want, this is much easier and easier for dev time than doing multi-threaded bullshit

Mostly legacy shit, like null being a data type.

The core language is not that bad anymore, after ES6, but the host language (browser JS) can be a bit too verbose.

Also, the lack of optional typing. Hopefully this one will get thru the committee.

It's not as much JS that irks me, it's mostly the ecosystem of insanity that it spawned. Basically nobody except framework and library authors write plain JS anymore, everyone's is behind multiple layers of abstraction and tooling.

>the state of JavaShit programmers

the people using it

that's why you will never be employed, because programming is simply business and business is simply about cost, time and profit

Multithreading in the browser is not a good idea at all. Yeah, sure, JS has escaped the browser and is being used in many places, but still having to manage race conditions with JS is just not the kind of thing you want to put in the hands of devs without much low-level experience.

It being functional.

both chrome and node do multithreading underneath on your behalf when you use blocking api functions through libuv, no need for explicitly exposing that for devs

>what is await-async?

The fact that dozens of js framworks exist prove a lot of people think this way, but I'm trying to argue that needing these frameworks makes js a bad scripting language to begin with.
Most of the things we have frameworks for today should actually be built into the language.

And yes, you're right that js is currently the only client side language (unless you transpile some other language which gives you a lot of overhead). That doesn't make it good though.

>your language has no loops
>what is GOTO?
t. you

you mean you want a std library for js? you can run a server using node's api without using any frameeworks, but that will be tedious for you, so you will end up writing pretty much the same expressjs or koa but untested

js at its current state ES6 or later/typescript, is one of the best around when it comes to prodcutivity/performance. And google is doing a great job improving v8 for performance

The standard node.js library feels like a thin wrapper around C API calls.
Web servers aren't really general purpose and should be external frameworks/libraries, but does the readline interface really need to be more than a single function?

Just look at this shit
const readline = require('readline');

const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});

rl.question('What do you think of Node.js? ', (answer) => {
// TODO: Log the answer in a database
console.log(`Thank you for your valuable feedback: ${answer}`);

rl.close();
});

nah, thats not a shadman nose

There's nothing wrong with it, minecraft was made with it

Then what is it?

it's a bit too inconsistent. code written in js can look like anything, from shitty pajeet spaghetti code to painfully abstracted code. in this aspect i think it's the polar opposite of go.

also writing async code is painful.
>inb4 async/await
yeah, now it's better. but a shitload of things isn't written to use it.

the behavior of `this` and variable assignment without `var` declaration

that = this

People in the industry, how is TypeScript perceived? I used it for a project and I felt it was miles better to use than JavaScript. I hardly ever saw it on job postings though.

No. It's both too gay and not gay enough

it's too easy
because it's easy the entire internet is infested with inefficient pajeetscript for things that could and should be implemented without it

js is for brainlets

The weird ad-hoc specifications. Like how iteration needs to be in insertion order, except for numbers, double-except if those numbers are outside the range of an int. Oh, and deletions of keys, including the current one, must take effect on the next iteration.

t. JS compiler engineer.

};
)
})
}])
})
});

And basic js is actually not entirely awful anymore. But try to use it and you get some dumbass CTO whining because you're not using jQuery

My dead grandmother is faster than this piece of shit.

Implicit type conversion and by extension ===

NODE was a mistake

It was initially designed in 10 days thanks to Netscape (I think) wanting a demo of interactive stuff in a browser for some conference.

Destroy All Software has a great talk on JS and all of it's pros and cons:
destroyallsoftware.com/talks/the-birth-and-death-of-javascript

Regardless of the merits or drawbacks of the language itself, the thing that its most often used for - running active content on web pages in a browser - is a bad thing that ought not to be done at all in any language.

Arbitrarity.

Minecraft was made with Java you dim shit runescape was made with japascript

Runescape was made with PHP you dumb fuck

not a decent standard like PEP8 or Google's Java Style.

It's technically a "no man's land" language.

no, Shadman is more like Java, people hate him but he is mainstream

what about dart?

disk i/o is the bottleneck, not the language.

holy shit senpai

cant wait for webassembly to be adopted, lots of potential there that is not yet used

Bullshit. The reason it's made unreadable is because bad devs can't dev without frameworks so they try to reduce bandwidth. And then there's that guy who can't get over the fact that people could read his sources.

> cant wait for webassembly to be adopted, lots of potential there that is not yet used

like what? only high performance apps like web vr, gaming, simulation, I doubt that webassembly will be ever used in general purpose, most code that's deployed in client side is just event handling to user actions which doesn't have to reach c-tier performance

There is no modularization system; there are no classes, interfaces, or even namespaces. These elements are in other languages to help organize large codebases.

The inheritance system -- prototype inheritance -- is both weak and poorly understood. It is by no means obvious how to correctly build prototypes for deep hierarchies (a captain is a kind of pirate, a pirate is a kind of person, a person is a kind of thing...) in out-of-the-box JavaScript.

There is no encapsulation whatsoever; every property of every object is yielded up to the for-in construct, and is modifiable at will by any part of the program.

There is no way to annotate any restriction on storage; any variable may hold any value. For this reason alone, dynamically typed languages in general make it harder to maintain a large codebase, because the work that is done by the compiler "for free" is now work that you must do in the form of writing test suites.

JavaScript's error management system is designed with the assumption that the script is running on a web page, that failure is likely, that the cost of failure is low, and that the user who sees the failure is the person least able to fix it: the browser user, not the code's author. Therefore as many errors as possible fail silently and the program keeps trying to muddle on through. This is a reasonable characteristic given the goals of the language, but it surely makes programming in the large harder because it increases the difficulty of writing test cases. If nothing ever fails it is harder to write tests that detect failure!

Attached: MFUHZhVTYFs9wGlqY5oo_hSrD942Qhih4W8a5DelawM.jpg (640x477, 105K)

This, and beacuse it encourages you to write fucking terribile inline functions that make the whole thing unreadable.

Also, making some function calls asyncronous by default is just bad

It doesn't provide abstractions at all. I can implement streams, use CPS, write monadic code, and the like but it's on the level of lisp without macros if we ignore the type conversion which happens out of the blue.

My other complaint revolves around safety... there's none at all. Must test all code going through as something might be converted / some libraries return different types based on the arguments given which is a real pain.

The fact that some faggots think it's the right language to do anything.
This is why we have shit software, because web hipsters want to make programs with the only thing they know.

> There is no modularization system; there are no classes

There is classes, I know they are treated as functions internally but you can do OOP in js

> interfaces
use typescript
> namespaces
not needed, use ES modules


> prototype inheritance -- is both weak and poorly understood
valid point, probably a very few who can understand the prototype inheritance or when to add properties to constructors or to prototypes, it's very confusing

> There is no way to annotate any restriction on storage; any variable may hold any value
use typescript

> JavaScript's error management system is designed with the assumption that the script is running on a web page, that failure is likely
use typescript, most errors of js are due to type errors, typescript will help you find that while you're programming

Unit tests don't cover enough cases.

ES6 does not fix ES5, it does bring in a lot of new features, but what is mainly bad about ES5 is C-style for/while loops, the ForEach loop in ES6 is just shitty the way it takes an anonymous function as its only argument in order to stay backwards compatible with ES5

we need to start over, start fresh with an entirely new language, I think Dart or Coffeescript would work. Coffeescript is just not a transpiler add-on, it is its own language and its very well designed

Who even does anything other then web design and database queries using JS and company?

...

Duck typing.

npm install typescript

npm

But my shitty javascript codebase are too large now, converting it to typescript or making a typescript wrapper around it is time consuming desu.
Maybe for the next project.

Libraries.

No, we need a lisp on the browser.

The fact that JS hipsters genuinely believe modern Javascript invented async io.

It's like Erlang didn't just celebrate 20 years of open source, with a better async story.

Holy shit.

"read a line of input in your language" will be a new daily thread.

It's slow, it's terribly designed (what do you expect of a weekend project turning industry standard), has no benefit over other languages.