Faster progression rate through the JavaScript curriculum

Let me start by saying that I definitely appreciate the level of detail offered by the curriculum. But I feel like some of the separate steps should really be merged to improve on the rate at which one may progress through the curriculum.

For instance, once a topic has been covered several times (like variable declaration and assignment), it should be possible to make (within reasonable limits) all declarations and assignments on a single task.

I believe that it would improve the learning experience if the number of check and submit requests the user had to wait through was cut by a factor.

would you add your feedback to the issue tracker please? Maybe also mention specific steps you are thinking about

Do you have a specific example?

Generally speaking, I would say speed is not the main goal of progressing through the steps and shouldn’t be the focus. More often, steps that people are getting stuck on end up being broken out into multiple steps to make each part more clear.

Repetition is a key part of learning. It can be annoying if you feel you’ve already learned something but repetition and practice work to solidify concepts.

That said, if you have a specific example, you can make your case through a github issue, as suggested.

Famous quote:

There are only two hard things in Computer Science: cache invalidation and naming things.
– Phil Karlton

Naming things is hard

The point is that creating variables is not a trivial task and should not be rushed through. The steps should explain why a variable is being created and how it will be used further in the code. I’ve seen way too many examples in the forum in which people are just guessing as to how to use a variable because they don’t understand what that variable is actually being used for. And we probably shouldn’t create a bunch of variables up front that won’t be used until much later in the course. The variables should be introduced just prior to when they are going to be used.

But if there are places where it would make sense to concatenate steps then I’m all for it. Like the others have said, please provide specific examples so we have a better idea of what you are referring to.

2 Likes

I’m aware of the problems associated with variable naming. The variables I speak of have their names primarily based on their ids and /or purpose. An example of the issue am raising is in the Learn LocalStorage by Building a Todo App:

Here we have step 1-4 essentially being about retrieving elements by Id from the DOM. Note that as per the guidance offered in curriculum coverage, the learner is expected to have covered retrieval by Id in more than 1 project so far.

Thank you for sharing a specific example. The first 3 steps create three variables each, and the last one creates 2 . Are you suggesting that these steps be combined into one step that creates 11 variables? If so, I’m not sure that’s an improvement. That’s a lot of work to cram into 1 step and will make the instructions a lot longer. I suppose you could do three steps with 4, 4, and 3, or two steps with 6 and 5. Not sure if it is worth the change? But one step with 11 variables seems like too much to me. Just my opinion of course.

I can see a case for this.

In both cases it’s a lot of copy/pasting the assignment structure and filling in the values. I could see it collapsed into 1 or 2 steps in this case and using a table to make the instructions concise.

It’s the same amount of work really, just with less “Check your code” moments.

Begin by accessing the following elements with the getElementById() method. Save them in the corresponding variables.

ElementsVariables
`task-form``taskForm`
`confirm-close-dialog``confirmCloseDialog`
`open-task-form-btn``openTaskFormBtn`
`close-task-form-btn``closeTaskFormBtn`
`add-or-update-task-btn``cancelBtn`
`cancel-btn``openTaskFormBtn`

Something like this. Personally, I would find that easier to read than the current sentence format.

1 Like