I think it is good he's learning to do the loops by hand first. It's good to have an understanding of algorithms first when learning to code.

I second this. Knowing why something is better to use is most likely learned through doing it a worse way first.

I third this. Speaking from personal experience. I sometimes try to implement the logic of some library or algorithm myself, even if I know there is well-known or canned solution for it. For the same reason as you and your parent comment said.

Interestingly, some people (typically newbies who are looking for rewards without commensurate effort. but others too) do not think that way, and even sometimes don't like it if such suggestions are made. I once made such a suggestion to a poster (an obvious newb) on comp.lang.python. He asked how to do some small task in Python. I suggested that he may learn more if he tried it on his own first. He misunderstood the intention behind the advice, and made some comment to the effect that my idea was not helpful, or something like that. Another regular pitched in and pointed out that my comment was meant in the spirit of helping him learn better, because a) if you try it yourself first and do get a solution, you just got better at something, and it will boost your confidence, and b) even if you do not get a solution, you will learn that the thing is not as easy or trivial as you thought (or why were you asking in the first place, except if wanting others to do your work for you) (which would happen if you just blindly used some library to do it). And will gain a new respect for the depth of your profession and all that it entails.

Related: How To Ask Questions The Smart Way:

http://www.catb.org/esr/faqs/smart-questions.html

It's by Eric Raymond, author of The Cathedral and the Bazaar and The Art of Unix Programming.

There are many interesting points in that article, e.g.:

http://www.catb.org/esr/faqs/smart-questions.html#noprivate

Seen people ask for private replies. IMO some of them do it because either a) they don't want to be seen as not knowing the thing if it was obvious, or b) not wanting others (likely their peers) to get the answer too. Both not good.

>...sometimes don't like it if such suggestions are made

I'll admit to occasionally being frustrated by comments like this. It's important to remember that not everyone is looking to learn. Sometimes, they just need to get something done ASAP.

It's a bit idealistic to assume that everyone has time to learn the canned solution. The real world doesn't always allow for that.

True. I did not mean it as an absolute statement. I did say above:

>I sometimes try to implement

It's each person's call, on a case-by-case basis. Had just shared my view with that newb, thinking it might help him.

Sure, but it's still a valid advice that might be helpful to others.

In fact this "you should never code FizzBuzz yourself, just use util.FizzBuzz(n) to print the first n iterations" mentality probably contributes to the surprising number of software developers who can't code.

And yet, we also have nearly-infinite number of (reinvented) wheels...

Humans are the worst

Though, keep in mind that some of this stuff (most notably the [...arr] syntax) won't work in old browsers if you make a web project (IE 11 is a big offender here). See https://caniuse.com/ for a useful source of info on what will work with what for stuff like that.

If you do web stuff (and you don't want to just say "no IE 11" - some people, and even some big companies, do that!), usually the easiest way to handle stuff like that is to use the newest syntax you're comfortable with, plus a tool like Babel that will produce a "time travel" version with older syntax that will work in all browsers.

This project explicitly says Node. But in any case, these days I generally recommend using Babel to transpile the newer JS to browser friendly JS as the productivity and readability improvements in newer versions of JS are worth the effort to me to set up the babel build step.

> This project explicitly says Node.

While that's true, future projects are a lot easier if one doesn't have to keep re-referencing "what works in Node" vs "what works on the web".

current projects are a lot easier if you can use modern syntax that will eventually be supported in future projects, and which can be transpiled in either way

Good tips if you want your code to fail randomly on older devices.

Older devices running node?

Surprisingly there are some embedded developers who use Node. I would assume those devices have a trimmed version of the Node stdlib.

I'm sure when he ports it to Espruino he can handle Babel.

Not even businesses doesn't (and shouldn't) care for older devices when it doesn't make economic sense -- even less so a fun learning project.

The code would fail to run on older devices without transpiling wnyway.