5 ms·

As someone who works with this every day, I'd say this is pretty solid advice. The "use a more functional approach" and "take advantage of ES6" are by far the

As someone who works with this every day, I'd say this is pretty solid advice. The "use a more functional approach" and "take advantage of ES6" are by far the biggest for me. ES6 added so much good stuff, I wouldn't consider it optional. It's better than incremental upgrades, feels almost like a different language to me. Every language has its quirks, and while I'll keep on hating Javascript's, I'll never lose sight of the fact that if you're holding out for the perfect language, you're not going to be doing much coding.

noir_lord 9y ago
TypeScript does to me (and technically I suppose it is a different language), where it gets interesting is that TS made me a better JS programmer since I could express stuff the way I wanted to and then look at the output. The only transpiler I've seen that gets close in terms of quality of output is BuckleScript, that thing is damn near magic but TS has the momentum and adoption. TypeScript has been so good and caused me so few problems that I actually look at ways of moving more bits to the frontend, it makes it pleasant to work and I think (personally) the highest praise you can give a language is that it's pleasant.
- slackingoff2017 9y ago
  Typescript with TsLint is a godsend on larger codebases. It makes JavaScript into a pretty solid language for big projects. Without it you frequently run into objects passed to you after going through 10k lines of code and it becomes a wicked game to figure out which properties the object actually has at that point. JavaScript, even ES6, is IMO crap for large codebases. Does this object have the property I'm looking for? Did somebody overwrite it with the wrong type 5000 lines ago? Why is the prototype chain broken? Where's my damn inline documentation. My company has abandoned JavaScript wholesale with great relief. If it was a physical object we would have tossed it off the balcony.
  - tisdy 9y ago
    Typescript is essential for large codebases / many devs. > My company has abandoned JavaScript wholesale with great relief. If it was a physical object we would have tossed it off the balcony. I would like to do the same with our gigantic SPA-ghetti.
    - WorldMaker 9y ago
      There's no time like the present to start! Typescript's allowJS compiler option and comment-based approach lets you start with the spaghetti you have and slowly transition to Typescript. (Though I'm still fan of the "rip off the Band-Aid" approach I used in a few projects back in the day: rename every .js to .ts and then fix compiler errors until things compile. allowJS is a great option now.)
  - Guthur 9y ago
    The true source of your problems there are mutation, which in my opinion is the primary source of issues. Immutable data structures being the most benefit. I also believe dynamic language tooling has regressed.
    - mercer 9y ago
      > I also believe dynamic language tooling has regressed. I'd truthfully love to hear more about that. Care to elaborate?
      - Guthur 9y ago
        I've worked with common lisp, clojure, python and javascript, and common lisp debuggers are just hands down better in everyway. Check this series for what should be a basic debugging experience by now http://malisper.me/debugging-lisp-part-1-recompilation/ http://malisper.me/debugging-lisp-part-1-recompilation/
erikpukinskis 9y ago
What do you like about ES6? It just looks like syntactic sugar to me, but I'm always interested in re-evaluating. Writing [1,2,3].map(function(x) { return x+10 }) really doesn't bother me. I don't see what the benefit is of an arrow function. Are there other things that you like? As the OP mentions, the inheritance stuff is just likely to cause architecture headaches. I like JavaScript's concurrency model (single threaded with callbacks) so I don't see any benefit to the async stuff. It just seems like people added a ton of complexity to give up a few keystrokes. Transpiling and shimming and adding more control structures make your application more complicated, so there is a real cost. And keystrokes are not generally a big problem when I'm programming. I'm not in a race.
- k__ 9y ago
  sure, if I would write code like that it wouldn't bother me too. const add = x => y => x +y; ... [1,2,3,4].map(add(1)); now we are talking ;)
- geoelectric 9y ago
  The big deal of an arrow function, brevity aside, is that it inherits the value of 'this' from the scope that creates it. Regular functions do not, so to use them as first-class functions you often have to bind before passing, pass around thisObjs for rebinding, do a 'that = this' type trick, etc. Same goes for 'arguments', though that comes up less. Basically, they're much more representative of a simple lambda than a classical function.
  - erikpukinskis 9y ago
    What's wrong with explicitly binding the scope? I really like that in JavaScript you have to be explicit about that kind of thing.
    - haimez 9y ago
      I think the problem with "this" is that you are trying to recreate classes instead of passing it as a parameter, or using currying. Arrow functions might be slightly more intuitive to intention, but the problem is still there. The implicit nature of "this" in JS is always worse than any explicitly controlled alternative.

noir_lord 9y ago

TypeScript does to me (and technically I suppose it is a different language), where it gets interesting is that TS made me a better JS programmer since I could express stuff the way I wanted to and then look at the output. The only transpiler I've seen that gets close in terms of quality of output is BuckleScript, that thing is damn near magic but TS has the momentum and adoption. TypeScript has been so good and caused me so few problems that I actually look at ways of moving more bits to the frontend, it makes it pleasant to work and I think (personally) the highest praise you can give a language is that it's pleasant.

slackingoff2017 9y ago
Typescript with TsLint is a godsend on larger codebases. It makes JavaScript into a pretty solid language for big projects. Without it you frequently run into objects passed to you after going through 10k lines of code and it becomes a wicked game to figure out which properties the object actually has at that point. JavaScript, even ES6, is IMO crap for large codebases. Does this object have the property I'm looking for? Did somebody overwrite it with the wrong type 5000 lines ago? Why is the prototype chain broken? Where's my damn inline documentation. My company has abandoned JavaScript wholesale with great relief. If it was a physical object we would have tossed it off the balcony.
- tisdy 9y ago
  Typescript is essential for large codebases / many devs. > My company has abandoned JavaScript wholesale with great relief. If it was a physical object we would have tossed it off the balcony. I would like to do the same with our gigantic SPA-ghetti.
  - WorldMaker 9y ago
    There's no time like the present to start! Typescript's allowJS compiler option and comment-based approach lets you start with the spaghetti you have and slowly transition to Typescript. (Though I'm still fan of the "rip off the Band-Aid" approach I used in a few projects back in the day: rename every .js to .ts and then fix compiler errors until things compile. allowJS is a great option now.)
- Guthur 9y ago
  The true source of your problems there are mutation, which in my opinion is the primary source of issues. Immutable data structures being the most benefit. I also believe dynamic language tooling has regressed.
  - mercer 9y ago
    > I also believe dynamic language tooling has regressed. I'd truthfully love to hear more about that. Care to elaborate?
    - Guthur 9y ago
      I've worked with common lisp, clojure, python and javascript, and common lisp debuggers are just hands down better in everyway. Check this series for what should be a basic debugging experience by now http://malisper.me/debugging-lisp-part-1-recompilation/ http://malisper.me/debugging-lisp-part-1-recompilation/

erikpukinskis 9y ago

What do you like about ES6? It just looks like syntactic sugar to me, but I'm always interested in re-evaluating. Writing [1,2,3].map(function(x) { return x+10 }) really doesn't bother me. I don't see what the benefit is of an arrow function. Are there other things that you like? As the OP mentions, the inheritance stuff is just likely to cause architecture headaches. I like JavaScript's concurrency model (single threaded with callbacks) so I don't see any benefit to the async stuff. It just seems like people added a ton of complexity to give up a few keystrokes. Transpiling and shimming and adding more control structures make your application more complicated, so there is a real cost. And keystrokes are not generally a big problem when I'm programming. I'm not in a race.

k__ 9y ago
sure, if I would write code like that it wouldn't bother me too. const add = x => y => x +y; ... [1,2,3,4].map(add(1)); now we are talking ;)
geoelectric 9y ago
The big deal of an arrow function, brevity aside, is that it inherits the value of 'this' from the scope that creates it. Regular functions do not, so to use them as first-class functions you often have to bind before passing, pass around thisObjs for rebinding, do a 'that = this' type trick, etc. Same goes for 'arguments', though that comes up less. Basically, they're much more representative of a simple lambda than a classical function.
- erikpukinskis 9y ago
  What's wrong with explicitly binding the scope? I really like that in JavaScript you have to be explicit about that kind of thing.
  - haimez 9y ago
    I think the problem with "this" is that you are trying to recreate classes instead of passing it as a parameter, or using currying. Arrow functions might be slightly more intuitive to intention, but the problem is still there. The implicit nature of "this" in JS is always worse than any explicitly controlled alternative.