Stuck on an issue?

Lightrun Answers was designed to reduce the constant googling that comes with debugging 3rd party libraries. It collects links to all the places you might be looking at while hunting down a tough bug.

And, if you’re still stuck at the end, we’re happy to hop on a call to see how we can help out.

[V3] Roadmap to Launch

See original GitHub issue

This issue is to track the JavaScript v3 roadmap. If you intend to help with this track, please read this entire document, and find the section about “How can you help”.

I have been working on the JavaScript v3 track by compiling a list of JavaScript specific concepts, transition documents from various languages and starting writing exercises. The concepts can be found here. Important things are to consistently realise, mention and reiterate that JavaScript types do not include “types” such as Array and Date. Prototype-based programming is different than class-based programming.

Folder structure

Specifics for javascript concepts can be found in the /info folder. There are other special folders such as /keywords, which take the keyword, and explain what they do, as they are language-specific (mostly), and the /objects folder which would be /types in many other languages: it lists the global objects available.

Concept exercises

The concept exercises in the JavaScript track are a work-in-progress and can be found in /exercises/concept. Important types of concepts to target are things that only exist in object-oriented programming (for people coming from non-oop languages), functions as a first class citizen (for people coming from non-functional languages), and javascript specifics:

prototype based inheritance
event loop
sameness
destructuring
duck typing

It is important to understand we never explain a specific type or syntax as a concept, but teach the more “abstract” concept around it, using the type(s) or syntax(is).

A list of exercises that we must have is compiled below, and is not at all a complete list:

/numbers: "numbers", "type-conversion"
/strings: "string"
/promises: "promises"
"arrays", "array-analysis", "array-transformations", "array-destructuring"
"booleans"
"nullability"
"errors"
"callbacks", "closures"
"recursion"

⚠ Note ⚠: The idea here is to use a concept name for the folder, but perhaps use some sort of “progression”, so they will naturally become a sort of path to traverse. In this example, the numbers exercise only teaches basic number usage, and doesn’t look into more advanced subjects. I would expect to see

numbers-advanced for mathy usage that is non-basic,
numbers-irrational showing how to do irrational / complex / whatever numbers,
numbers-precision which would explore binary representation and floating points,
numbers-arbitrary-precision which would explore bigints and/or how to do that with decimals.

It’s only important that it’s reasonably easy to find the exercise. It’s okay if the name isn’t perfect. We will iterate on this.

Concept interpretation

Here is how I’ve interpreted the following concept-keywords. This should be synced across tracks.

concept	interpretation
`numbers`	Know of the existence of the `number` type and (for this language) see that it’s whole numbers, and floating points. Know of basic operators such as multiplication. Know where it’s documented, or at least how to search for it.
`strings`	Know of the existence of the `string` type. Know of some basic functions (like looking up a character at a position, or slicing the string). Know where it’s documented, or at least how to search for it.
`promises`	Know of the `Promise` construct (`future` type in some other languages), chain-ability, and `.then`. Know where it’s documented/how to search.
`arrays`	Know of the `Array` construct (`array` type in some other languages). Know of some basic functions.
`errors`	Know how to create an error, how throw it and how to catch it
`callbacks`	Know how to use a function as a first-class citizen, that is, pass it into a function as a value, and call it somewhere inside that function. Know that you can pass in values and retrieve out return values.
`recursion`	Know how to call a function from itself
`type-conversion`	Know that there exist functions that can convert between “types” (objects of a prototype) and types (primitives).

This also indicates that for example basic-strings does not include knowing that JavaScript strings aren’t strings in the compsci sense as in, they are made up of UTF-16 codepoints, and therefore there are a lot of catches with this. basic-numbers does not talk about the % operator and how it’s remainder and not modulo, or the fact that binary operations on negative numbers are … weird.

How can you help?

This track

There are files in the /info, /keywords and /objects folders which are either empty or stubs. They need to be written. You can use the already filled-in ones to see what we’re looking for.

Globally

There are concepts missing.

Exercises

We need two types of exercises. The concept ones, as explained above – you can chose to pick one from the list above or suggest, in this issue, one that’s not listed. The other ones are the practise ones, which are like the v2 exercises.