Ask HN: Changing my mind about JavaScript

54 点作者 Clyd3Radcliff39 个月前

I'm a longtime developer software developer with statically typed languages, in the last few weeks i started working on a couple javascript projects and i must say that i'm changing my mind about javascript, albeit i still think that for bigger project relying on statically typed languages is a better and safer path, i think that JS deserve a chance to be "really" learned, i'm not referring following the dozens of tutorial we find online that are pure crap (using dozens on stuping npm packages or using pre-cocked solutions without really understanding it's full potential).Do you have any tip for learning js at it's fundamentals? internals, advanced patterns and everything that can relate to understand it in deep?

32 条评论

rauschma9 个月前

I have used many languages in my nearly 40 years as a programmer (Scheme, C++, Java, Python, Haskell, OCaml, Rust, etc.) and still enjoy JavaScript: It’s decent as a language and there is so much you can do with it.Tips:• If you like static typing, you’ll want to use TypeScript. It’s more work to set up, but it catches many bugs, especially subtle ones where JavaScript’s semantics are not intuitive.• I learned a lot about JavaScript (and Node.js) by writing shell scripts in Node.js.My books on JavaScript, TypeScript and Node.js shell scripting are free to read online and target people who already know how to program: <a href="https://exploringjs.com" rel="nofollow">https://exploringjs.com</a>

评论 #41200387 未加载

评论 #41263131 未加载

评论 #41200199 未加载

AshleysBrain9 个月前

I did a lot of coding with C++ and ended up moving to 100% JavaScript for our game creation tool Construct (www.construct.net).I'm now a huge fan of JavaScript - I think it's a really underrated language. People often still talk about it like it's 2010. The modern language features are amazing, the performance is incredible - including the GC performance - and it's memory safe and no need to worry about allocations. If you want static typing, use TypeScript, which is also very good and is basically a static type layer over JavaScript.My advice is look at the modern language features which now have wide cross-browser support, and be sure to use them. It can significantly change your coding style for the better. By that I mean things like modules, private class fields, nullish coalescing, optional chaining, async/await, map/set - some of which are fairly old now but are still getting new improvements worth knowing about.

rikroots9 个月前

If you have plenty of time, start a side project to build out a HTML canvas library (with no dependencies) ... just kidding! I've been building my canvas library for 11 years and there's still a shedload of JS understanding I've not yet poked.More seriously, the MDN documentation is really useful[1]. Some of the advanced topics listed on that page may be a good place for an experienced engineer to start?- Inheritance and the prototype chain - <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Inheritance_and_the_prototype_chain" rel="nofollow">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Inhe...</a>- Memory management - <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Memory_management" rel="nofollow">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Memo...</a>- The event loop - <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Event_loop" rel="nofollow">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Even...</a>[1] - <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript" rel="nofollow">https://developer.mozilla.org/en-US/docs/Web/JavaScript</a>

aswerty9 个月前

Static types are sanity when the people and years keep increasing. It isn't at all important in small one man projects since most of your defined types are in your head in any case.There is nothing wrong with JavaScript as a language beyond it's, originally questionable, foundations that have since been iterated upon (much like PHP).As a massive fan of static typed languages. There is no denying that dynamic typed languages are more fun to develop with in smaller project. It just they often hit a tipping point when they become a horror to deal with. I can still remember my first legacy Python code based where everything was thrice nested dictionaries.

评论 #41200356 未加载

评论 #41200355 未加载

评论 #41200427 未加载

flohofwoe9 个月前

I would recommend using Typescript and a strict linter if possible. TS is essentially modern Javascript plus static typing (so by learning TS, you also learn JS as a side effect), and strict linting rules will reject outdated Javascript features and nudge you towards the 'good parts'.With those two things (a static type system layer, and strict linting) JS is actually a quite decent language nowawadays, especially in VSCode (e.g. see: <a href="https://code.visualstudio.com/docs/languages/typescript" rel="nofollow">https://code.visualstudio.com/docs/languages/typescript</a>).

评论 #41200298 未加载

评论 #41201572 未加载

aristofun9 个月前

JavaScript is flexible and simple in a good sense of the word.There not much advanced to learn.Thanks to single threaded design you basically just write whatever you intend to do and it works.With a proper mix of oop and fp there is no place for “advanced patterns” and other over-engineering diseases in a lean js world.The most terrible and ungly js code ive seen are from former .net and java developers.I suggest you unlearn all the “patterns” and keep it as simple ad possible.

rom1v9 个月前

> Do you have any tip for learning js at it's fundamentals?I would recommend:- <a href="https://eloquentjavascript.net/" rel="nofollow">https://eloquentjavascript.net/</a>- <a href="https://javascript.info/" rel="nofollow">https://javascript.info/</a>

评论 #41201443 未加载

评论 #41200285 未加载

bubblebeard9 个月前

I have been using JS for more than 20 years, and I do not like it. There are parts of it I find useful, but I avoid using it as much as I can in any project.The biggest reason for this being that the execution of JS code it down to the browser rendering the page where it’s deployed. As such it’s practically impossible to get any code to run consistently. This is of course only relevant in my day to day work as a web dev.That aside, JS has some funny behavior. If you wish toninderstand JS better you could read up on how null and undefined works.You could also read up on how functions work, they are objects actually.

评论 #41200259 未加载

emil0r9 个月前

There is a functional core in js, and as such it might be an idea to take a look at common OOP design patterns and how they translate to an FP approach.This is Clojure based, but there is a lot of similarity to js once you get past the syntax: <a href="https://mishadoff.com/blog/clojure-design-patterns/" rel="nofollow">https://mishadoff.com/blog/clojure-design-patterns/</a>

mo_429 个月前

There's JavaScript The Good Parts by Douglas Crockford.I've read the book and watched a similar series on YouTube.

评论 #41200274 未加载

评论 #41200421 未加载

评论 #41205618 未加载

ryandvm9 个月前

Been coding for 30+ years. In the last 5 years I have come around to not hating JavaScript (TypeScript really), but let's be honest, it took 15 years of hearing the JS community tell us "sure JavaScript used to be awful, but now it's finally good" for it to actually be true.I remember clearly the days of callback hell. You didn't change your mind about JavaScript, JavaScript changed it's mind about being a real language.I will give it credit, I don't know of another programming language that has changed so drastically and so much for the better.

评论 #41203581 未加载

jokethrowaway9 个月前

I've been doing JS for 18 years. I don't think it particularly deserves to be learned but I think in general you should know a scripting language and JS is very popular (and can be embedded with v8 isolates fairly easily). If you know python or lua I wouldn't bother. Lua would probably be my first choice.Scripting languages are faster for prototyping but they are a nightmare for maintenance. TypeScript might look like a good middle ground but the many escape hatches really allow you a single bad coder to wreck havoc in your codebase. You can't trust a codebase you don't know in TypeScript the same way you would trust a Rust codebase.JS is good for job security because the node.js hype cycle brought a lot of JS in enterprise places - it's been used for massive codebases and now there are plenty of microservices nobody wants to touch or know how to debug. The rise of horrible, enterprisey frameworks (eg. NestJS) helped this. JS could be the COBOL of the next generation, if it weren't for the web, which will likely keep JS alive for a long time.If you really want to learn JS, focus on the good parts.Avoid classes and `this`, avoid prototypal inheritance.Postpone the frontend as much as you can as that changes every 5 minutes.Start with bun (if you have no dependencies on node, it's not really compatible), so you'll have no issues with imports / require and all the tooling / transpiling (which rightly give JS a bad name)

MatthiasPortzel9 个月前

JavaScript is one of my favorite languages. It has the nearly unique design constraints of having multiple implementations and being unwilling to break backwards compatibility, which gives it a lot of warts that are easy to ridicule. But I think the language on the whole is very flexible, very simple, and very usable.I would recommend getting your head around closures. It’s possible to statically determine what variables exist in which scope, and so if you can nail down those rules it makes analyzing code much easier.<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Closures" rel="nofollow">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Clos...</a>I would recommend a light linter. I see too much new JavaScript code using `var` written by non-JS devs in 2024.But I don’t think you need TypeScript if you’re first learning the language. Instead, revel in the dynamically-typed flexibility, and learn the error messages JS gives. There are only really 4 or 5 things that will cause JS to error, which can make debugging difficult initially, but once you learn those error messages, it makes debugging comparatively easy.

8fingerlouie9 个月前

I have a long history developing stuff in strongly typed languages, C, C++, C#, Go, Rust, Java and Kotlin but have always done the "quick and dirty" in Perl, Ruby or more recently Python or Kotlin.I still much prefer strongly typed languages for anything that needs to be maintained, and i've always hated JS with a passion.What finally convinced me that JavaScript might have it's merits was working on an application written in TypeScript. In my opinion (and not everybody elses) TypeScript fixes a lot of "flaws" not only JavaScript but any duck typed language.I've long used type hints in Python, but they rely on the editor/tooling to find stuff that doesn't match, where TypeScript finds it compile time. Sure, it's all javaScript in the end, but considering that JavaScript can compare Apple and Orages and decide they're all tomatoes, having compile time type checking is a god sent.

pjmlp9 个月前

I have started with a dynamic language with optional typing (BASIC), back in 1986, went through several static and dynamic typing throughout the years.While I lean on the static languages front, I am a big fan of dynamic languages as well, like Smalltalk and anything Lisp.In regards to JavaScript, it isn't the Scheme/SELF we wanted, it is what we got and already quite powerful.Some advanced stuff, how prototype inheritance works, how the new class model is actually mostly syntax sugar on top of prototype inheritance and not really Java like even if it looks similar, how decorators work (not yet fully there but will come), JIT and GC across the various runtimes, if care about server code how to write native extensions for the various runtimes.

JoeCortopassi9 个月前

I think the best way to understand/appreciate javascript as a language is to A) separate it from the DOM, and B) take a functional programming focusToo many times, when people complain about javascript, what they are really complaining about is the hectic nature of web development. You have three trillion dollar companies (Google/Chrome, Microsoft/Edge, Apple/Safari) actively fighting over agreed upon standards for how the dom is rendered and manipulated. Try and learn any language in that environment, and you'll have a very frustrating timeWhy functional programming? Javascript was one of the earlier mainstream languages to support passing around functions as first class citizens, and it's often an aspect of the language that gets downplayed. By and large, javascript sits at the sweet spot of allowing you to do cool functional programming concepts, without all the strictness and verbosity of a language like Haskell. Is that a good thing? It depends, obviously. But for the sake of "Change my mind", this is where I bet you'll start looking at it in a different lightI'm not saying it's the best/one-true language. It's just another cool tool to have on your tool belt

dabber9 个月前

I'm surprised that Kyle Simpson's, _You Don't Know JS_ hasn't been mentioned in this thread.<a href="https://github.com/getify/You-Dont-Know-JS">https://github.com/getify/You-Dont-Know-JS</a>When I was beginning to develop a deeper understanding of JS a few years ago, that book, Kyle's talks, and conference presentations by Chrome's V8 team were very helpful for me. It looks like Kyle has expanded the content considerably since then too.

spion9 个月前

There is honestly not much to learn, and that might be part of the appeal. At its core, JS is a relatively simple dynamic language with a clean syntax. Despite the clean syntax there are quite a few quirks in how some of the internals work (sorting and pervasive string comparison and casting, equality operator, etc). The most interesting thing about it is probably the programming model of free-form objects and closures: rather than using classes, you could write functions that return free-form records containing functions (and getters) that close over the lexical scope of the function. This gives a kind of dynamic object construction flexibility without the additional boilerplate.For the base language I recommend Dr. Axel Rauschmayer's books (<a href="https://exploringjs.com/" rel="nofollow">https://exploringjs.com/</a>) as they're kept very much up to date.Where things get really interesting is TypeScript, which takes all of this dynamism and manages to model it with a type system that doesn't feel all that constraining. It also ameliorates most of the core language papercuts. I don't really have good recommendations for TypeScript for now, other than browsing typescript issues and pull requests for examples written by Anders HejlsbergYou have to be very careful with the library and tooling ecosystem, however. There are a billion ways to do things, many of them incompatible with each other, and things break all the time. This includes major, popular libraries and frameworks with good looking documentation websites, so it can be difficult to pick something solid and stable. This is where most of the pain of using JS comes from.

JonChesterfield9 个月前

I love writing javascript. It behaves like a lisp which really likes hashtables and runs on some of the best compiler tech anyone has shipped. Typescript is an interesting layer I haven't used enough.Most stuff written in javascript makes me nauseous. The entire NPM ecosystem is a parody of software development. But you can ignore essentially all of the libraries and still get work done.

chkry9 个月前

I love JavaScript, been programming for more than 16 years now. Built websites, apps, banking portals, chat bots and customer experience software using Js, React, Redux and TypeScript. Also used Java and currently work on Go lang. Even after using every language I still prefer JS to be my everyday work love language. Its better now and improving too.

ativzzz9 个月前

> Do you have any tip for learning js at it's fundamentals?Build something you think is fun. Take a static index.html page without any build tooling (just open the file with a browser), link a JS & CSS file to it, and make a cool thing with animations or interactivity. Maybe try to remake some cool interactive thing you saw somewhere

vhcr9 个月前

Once you understand the fundamentals, knowing about the newer stuff would be a good step forwards:<a href="https://github.com/tc39/proposals/blob/main/finished-proposals.md">https://github.com/tc39/proposals/blob/main/finished-proposa...</a>

can16358p9 个月前

I strongly suggest TypeScript, which is (as you probably already know) JavaScript with static typing: in other words exactly what you want.TypeScript adoption over plain JS is HUGE in the recent years, I wouldn't be surprised if it becomes the native default in browsers some time in the future.

jacobp1009 个月前

The industry uses TypeScript these days. If you’re inheriting a project, write the new stuff in TS, and gradually migrate. If you’re using the modern syntax, I’d say JS behaves mostly like every other language, with the exception being the tooling landscape is massive

izolate9 个月前

I started my career with JavaScript and Node.js, but over time I've grown to dislike its design flaws and dynamic nature. If JavaScript had Dart's strengths, I might still be using it; instead, I've moved on to languages I find more respectable.

7275647970697069 个月前

My (unpopular?) take is that JavaScript should suffice.Once I feel the need for TypeScript, I've done something wrong. For example, built my whole frontend with JavaScript or built my backend in JavaScript.JavaScript's use case for me is sprinkling it where needed in browser. Anything extra and it feels wrong tool for the job.Frankly, I believe whole existence of TypeScript is a mistake – we should've never used JavaScript at a scale where static typing becomes necessary.Having said all that, I'd love to be able to write gradually typed JavaScript (i.e. TypeScript) in the browser. Gradual typing is still greatly beneficial, even in my sprinkles.

评论 #41200332 未加载

ivanjermakov9 个月前

The power of JS is the amount of effort put into its optimization, because of its importance for the web.JS is no longer as slow as people say, especially when developers are cautious about memory allocations and time complexity.

contrarian12349 个月前

I don't write JS, but the Wat talk makes me want to stay as far away as possible<a href="https://www.destroyallsoftware.com/talks/wat" rel="nofollow">https://www.destroyallsoftware.com/talks/wat</a>C has lots of uglyness and quirks but it has the excuse of being ancient - when people knew less. Zig/Hare are attempts to revisit the space with cleaner designsSomehow several decades later something even more gross was created. No thanks. And the "well just stick to the good parts" stinks of C++Thankfully there's Clojurescript if I ever need to touch the browser

chpatrick9 个月前

I think TypeScript is a legitimately fantastic language and I've used everything from C++ to Haskell.

d139 个月前

Cristian Salcescu‘s books on JavaScript are absolutely marvellous and must-reads.

Gettingolderev9 个月前

JS is broken and TypeScript is a way of fixing it but at the end of the day, you use Frameworks anyway like Anguular.If you just want to hack around it, hey just use it as any other scripting language

评论 #41200458 未加载

IshKebab9 个月前

I mean why not use Typescript and have both?Projects don't have to become very large at all before static types are better & more productive than dynamic types. Especially for multi-person projects, or ones that last for a while so you forget stuff.

评论 #41200261 未加载