I was thinking about a general experience of working with null/nil. Clojure has nil punning which makes sense in the context of the language (lisp variant) and can be nice to work with.
The null is a high price to pay because eventually someone will make some type assertion somewhere in the TS codebase that will end up biting you. Sure, you can be diligent, but will every contributor during the lifetime of a project be?
Not sure about Scala, but I did see NullPointerException every so often, and what is the practical advice to handle them in Scala? It’s to use Option[T]
I agree that this can be nice when done right (Clojure), but null is a high price to pay for this convenience.
I must admit I’ve never had this problem in application development. In fact, I do want to change my callers because strengthening the contract is an opportunity to simplify the callsites - they no longer have to handle the optionality. The change might carry some semantic meaning too, why are you getting x instead of Maybe x all of the sudden? Are there some other things you should reconsider in the callers? I can see how it could be useful in library development, but there are also patterns to account for this that are idiomatic to Haskell.
This is not necessarily the case for every programming language. Plenty of them are first-class citizens in Emacs and only decent in VS Code, languages like Clojure and Haskell come to mind, and I'm guessing pretty much every LISP.
VS Code is probably a pragmatic choice if you want to start coding right away and don't care about any customization, but if someone is interested in productivity and efficiency, Emacs should be considered (along with other high-performing tools).
You never start completely new, you always carry your previous experiences and knowledge you gained. This will be valuable to your progress even if it doesn't seem relevant right now.
Speaking from experience, switching career at 28 was the best decision of my life.
This is correct, but there are some guarantees such as the result will be an array of the same length, mapping function will be called for each element, function itself can be more easily tested in isolation and there are no imperative constructs (creating accumulator array outside of the scope, tracking the index, pushing to the accumulator array)
This lends itself very nicely to functional programming (especially with typescript IMHO)
Can you really make glass window that much more complex? It's still the same molecular structure with maybe a more complicated shape, but how it interacts with the outside world is still pretty much the same
You can try contemplating about why there ought to be any meaning in the first place. Once you come to terms that the universe isn't obligated to provide anything to you, I think you'll possibly appreciate life more, at least that's how I see it.
If you already have some experience with React, Node is probably the best choice. It's in high demand, and it's always nice to have one language on both backend and frontend.
Angular is also very popular and it's often used in combination with Node or .NET
Because when you start learning, you learn what is popular - in my case that was OOP principles in python and javascript. Only later on I learned about functional programming through Clojure. It's really hard to do that mental shift, and it takes time. A lot of people don't want to invest into learning a different paradigm
> students are oblivious to what actually happens in real world.
Is Node not happening in the real world?
Most job ads I see look for node, far more than python or php, so it makes perfect sense for bootcamps to teach that, not to mention keeping everything in one language.
At least with vim/emacs you have certain stability and proven record that they'll be around in 5 years and all the time you invest in it will pay out.
For vscode, who knows what the next most popular editor will be in 2-3 years? But then again, these editors are easy to pick up.
I think if vim or emacs intrigues you, you should go for it and try it out for at least a week or so.
I don't think this is a very productive pathway, and it will take a long time. Rust and Assembly is also probably a poor choice for somebody who is starting to learn web dev, and an especially poor choice to learn before flexbox.
I would say: 1. HTML 2. CSS 3. Flexbox & Bootstrap 4. Javascript 5. React
The null is a high price to pay because eventually someone will make some type assertion somewhere in the TS codebase that will end up biting you. Sure, you can be diligent, but will every contributor during the lifetime of a project be?
Not sure about Scala, but I did see NullPointerException every so often, and what is the practical advice to handle them in Scala? It’s to use Option[T]