[V3] Write stub issues for new concept exercises

[SleeplessByte]

Here is a list of concepts modified from the C# one. I marked a few that I know exist already, but we should add design document to ALL our current exercises too.

How can you help?:

SEE #951 (comment) if you want something ACTIONABLE.

1. For many of these we don't have exercises or exercise ideas yet, for example chars + codepoints doesn't exist yet. These need a implement new exercise issue with all the relevant information (see current open issues).
2. Some of these concepts do have exercise ideas (and/or are being worked on), for example errors. Ignore those.
3. Some of these already have exercises, but are not mentioned in the exercise. @ErikSchierboom can you explain how you assign the concepts and how it gets turned into that automated reference readme document? Once Erik does, we need to update our files (design doc, config.json) so we can do this too.
4. We're missing quite a few things from this document. Things missing should be added here and go through the above three "steps".

Concepts

• arrays (Array.prototype)
• assignment
• basics
• bit-manipulation
• booleans (boolean)
• casting (JavaScript term: type-conversion)
• chars (JavaScript term: chars and codepoints)
• classes (JavaScript term alternative: prototypes)
• closures
• codepoints
• conditionals-ternary
• constants (const for bindings, Object.freeze for immutability)
• constructors
• datetimes (Date.prototype)
• default-value (in: parameter/argument, destructuring)
• dictionaries (Map.prototype, WeakMap.prototype, object)
• encapsulation (JavaScript term: closures)
• equality
• exception-filtering (JavaScript term: type-checking)
• exceptions
• fields (JavaScript term: properties)
• floating-point-numbers (JavaScript term: numbers)
• for-loops
• foreach-loops
• functions
• if-statements
• implicit-casting
• imports (JavaScript term: module imports)
• inheritance (JavaScript term: prototype inheritance)
• interpolation
• math-operators
• method-overloading
• mutation
• named-arguments
• modules
• module-exports
• module-imports
• module-dynamic-imports
• null-coalescing
• null-conditional
• nullability
• numbers
• objects (JavaScript term: instances, or object with prototype)
• optional-arguments (
• optional-parameters
• overflow
• parameters
• polymorphism (JavaScript term: duck-typing)
• properties
• randomness
• readonly-collections (deep immutability)
• regular-expressions (RegExp.prototype)
• return-values
• scoping
• sets (Set.prototype, WeakSet.prototype)
• state
• string-formatting
• strings
• switch-statements
• throw-expressions
• time (DateTime.prototype)
• type-conversion
• user-defined-exceptions
• variables
• while-loops

Essential Concepts

• anonymous-classes
• anonymous-functions
• async
• delegates (Proxy.prototype)
• enumerables ([Symbol.iterator])
• events
• higher-order-functions
• indexers
• recursion
• serialization (JSON.stringify, FormData)
• statics
• streams (node/web/dom API only)
• yield (generators)

Advanced Concepts

• aysnc-iterators ([Symbol.asyncIterator])
• immutability
• immutable-collections
• multi-dimensional-array

[junedev]

I had a look what we already have as issues and exercises and I noticed two things.
a) We have exercises for some advanced concepts where there are currently no exercises/concept pages for the prerequisites. So it is hard to tell whether the student actually knows all the necessary things by this point.
b) I saw some "deadlocks" in the learning curve, e.g. the current numbers exercise expects the student to do type conversion and the type-conversion exercise has numbers as prerequisite.

To mitigate those things and focus our efforts a bit I would propose to concentrate on a small set of concepts first (e.g. 20), that would provide a consistent learning experience (MVP style). Then people testing the new website etc would be able to check the unlocking mechanisms etc.

I started creating such a "focus" list. Once I have 20 exercises on the list and people think the list makes sense, I can help creating the missing "create/improve exercise" issues.

Here the current status of my list. It names the exercise, explains the concepts they include and outlines the status. The status is judged by the learning curve I am proposing here. I included proposals for fitting exercises from other tracks as well if I could find some.

Status Color Codes
🟢 ok for now, just needs some small polishing
🟡 "improve concept exercise" issue needs to be created
🔴 "create concept exercise" issue needs to be created

🟢 Lasagna (basics)

• Concepts: basics
• Explanation: minimal explanation of variables, functions, import/export
• Prerequisites: none
• Status: 🟢 good, tiny wording mistakes

🟡 Freelancer Rates (numbers)

• Concepts: numbers, arithmetic-operators
• Explanation: should introduce only the numbers type and how to do calculations, if needed also rounding, should not include bigint (separate exercise/concept later), "about" page could mention floating point issues
• Prerequisites: basics
• Status: 🟡 needs small changes, current version includes type conversion which will be taught later, Swift numbers exercise could help as example how to change the exercise, instructions should include all syntax needed in the exercise, two separate concept pages should be created (numbers and operators), numbers "about" page should mention NaN and infitity
• <- tick off once issue was created

🟢 Annalyns Infiltration (booleans)

• Concepts: booleans
• Explanation: introduces true, false, !, && and ||, "about" page could contain lazy evaluation
• Prerequisites: basics
• Status: 🟢 main issues were already fixed

🟡 Poetry Club (strings)

• Concepts: strings
• Explanation: introduces strings, + operator and some important string methods, somewhere we should mention single vs. double quotes and immutability, "about" page should explain/link to more string methods
• Prerequisites: basics
• Status: 🟡 not all methods needed for the exercise are included in the introduction/concept, exemplar.js contains string interpolation which students don't know about at this point
• <- tick off once issue was created

🟢 Vehicle Purchase (conditionals)

• Concepts: conditionals, comparison
• Explanation: comparison introduces <, <=, >, >= and strict equal (loose equality will come later once we covered type coercion), conditionals introduced if, else if, else (ternary will be introduced later), "about" should mention one liner syntax "if(x) doSomething()"
• Prerequisites: basics, booleans, numbers, strings
• Status: 🟢 issue was already created and PR was merged

🟡 Elyses Enchantments (arrays)

• Concepts: arrays, array-methods-manipulation
• Explanation: introduces arrays, length, getting/setting value at index, splice, push, pop, shift, unshift
• Prerequisites: basics, numbers
• Status: 🟡 exercise exists but introduction/concept is nearly empty, two concept pages should be created (arrays, array manipulation methods)
• <- tick off once issue was created

🟢 Bird Watcher (for-loops)

• Concepts: for-loops, increment-decrement
• Explanation: should introduce for loops (start, end, step) and how to iterate over an array with them; should also introduce ++ and -- ;"about" page should mention label, break, continue
• Prerequisites: arrays, comparison, conditionals
• Status: 🟢 exercise does not exist, issue needs to be created, as an exercise we could use something similar to 4, 5 and 6 from C# Bird Watcher Exercise and add one more task with a different step size (e.g. every second day there was a wrong bird count, add 3 on those days and calculate total again)
• <- tick off once issue was created

🟢 Master Mixologist (while-loops and conditionals-switch)

• Concepts: conditionals-switch, while-loops
• Explanation: introduces switch, while and do-while, should point out switch fall-through issue
• Prerequisites: comparison, arrays, for-loops
• Status: 🟢 exercise does not exist, issue needs to be created, we could use Swift Master Mixologist exercise as a template (the last task could be omitted)
• <- tick off once issue was created

🟢 High Score Board (objects)

• Concepts: objects
• Explanation: should just give a very simple introduction to objects as dictionaries (container for key/value pairs), explains what is allowed as key and that values can be numbers, string etc or objects, arrays or even functions; shows how to set and delete values
• Prerequisites: basics, numbers, strings, booleans, arrays
• Status: 🟢 Exercise is now done. exercise does not exist yet, issue needs to be created, as a first part task 2,3 and 5 from Swift High Score Exercise could be used, additionally add maybe 2 more tasks, one where some parameters of different types are passed and an object is returned (to demontrate the types can different in JS) and another task where a function accepts an object like {a: 3, b: 4, fn: someFunction} and returns the result of calling someFunction(a,b)
• <- tick off once issue was created

🟢 Amusement Park (null and undefined)

• Concepts: null-undefined
• Explanation: introduces null and undefined, explains the difference, how to check for null and undefined, should include accessing a key that does not exist on an object
• Prerequisites: objects
• Status: 🟢 all fixed for null there is already some work done here but the current exemplar file does not fit the knowledge the student has at this point, for undefined there is nothing yet; the exercise could be creating a function that accepts an object and a string (name of a key) and returns a different string depending on whether the value is undefined, null or has some actual value; then some other task could require writing a function that sets some value to null etc, as inspiration for the background story see Ruby Amusement Park
• <- tick off once issue was created

🟢Lasagna Master (functions)

• Concepts: functions
• Explanation: should explain that all arguments are optional, what to do if you want to return multiple values, and that functions are objects that can be assigned, passed around etc., explain pass by reference vs. pass by value, optional: incl. default params; this concept/exercise is meant as preparation for callbacks, out of scope for now: rest parameters
• Prerequisites: objects, null-undefined
• Status: 🟢 Exercise was created. About.md not complete yet, a follow up issue was created. exercise does not exist yet, issue needs to be created, this concept is very special to JS so there is probably no fitting exercise in other tracks to use as a template
• <- tick off once issue was created

🟢 Lucky Numbers (type-conversion)

• Concepts: type-conversion
• Explanation: should introduce explicit and implicit type conversion, truthy/falsy when using values in if statements etc., "about" page: loose equality, unary + for conversion to integer
• Prerequisites: objects, arrays, conditionals
• Status: 🟢 exercise was fixed there is already a good exercise, introduction of split is missing in concept, currently it does not include truthy/falsy so we could add that to the introduction and add one more small task like "return x if the array is empty without using ===" solution currently uses reverse which the student does not know about at this point, hint points it out though
• <- tick off once issue was created

🔴 Custom Signs (string-formatting (template-strings) and ternary)

• Concepts: template-strings, conditionals-ternary
• Explanation: introduces template strings, should mention that this is also called "string interpolation"
• Prerequisites: strings, conditionals, type-coercion
• Status: 🔴 exercise does not exist yet, issue needs to be created; Swift Custom Signs Exercise could serve as inspiration for the story, needs to be changed a bit (no characters, adapt last task to include the calculation in the template string, include ternary operator)
• <- tick off once issue was created

🟡 Fruit Picker (callbacks)

• Concepts: callbacks, arrow-functions
• Explanation: introduces callbacks so we have them when teaching the array methods like map etc., can optionally also introduce basic arrow functions without the details on "this"
• Prerequisites: functions
• Status: 🟢/🟡 there is already a good exercise, it should be modified to work without ternary, errors and closures (which are mentioned as prerequisite atm) so it fits the learning curve; arrow functions might need a bit more detail in the introduction (e.g. when can return be dropped); example in the introduction is a bit hard to understand; for arrow-functions there is already an issue which might need to be closed when we include the concept here
• <- tick off once issue was created

🔴 Elons Toys (classes)

• Concepts: prototypes, classes, this
• Explanation: should first introduce prototype syntax since this is how JS works (tbd), then introduce classes as syntactic sugar, should introduce the constructor and methods, "about" should mention "this" pitfall with nested functions and arrow functions or "that" as mitigation, out of scope: inheritance
• Prerequisites: objects, functions
• Status: 🔴 exercise does not exist yet, but there is an existing issue which might need to be updated to fit the learning curve; C# Elons Toys Exercise could serve as template for the exercise
• <- tick off once issue was reviewed/updated

🟢/🟡 Quality Management (errors)

• Concepts: errors, inheritance
• Explanation: introduce new Error, custom errors via inheritance, try/catch, throw, instanceof
• Prerequisites: classes
• Status: 🟢/🟡 there is already a good PR, the concept pages need to be adjusted to fit the two concepts taught here, the introduction should include a bit more info on inheritance
• <- tick off once PR feedback was given

🟡 Elyses Destructured Enchantments (array-destructuring)

• Concepts: array-destructering, rest-and-spread
• Explanation: introduces array destructering and the rest and spread operators in the context of arrays, should also introduce rest parameters to implement variadic functions
• Prerequisites: arrays, functions
• Status: 🟡 ~~exercise exists but introduction/concept is nearly empty, two concept pages should be created, tasks should be adjusted to include rest parameters
• <- tick off once issue was created

🟢 Elyses Looping Enchantments (array-loops)

• Concepts: array-loops
• Explanation: introduces foreach and const x of array
• Prerequisites: arrays, callbacks, arrow-functions,for-loops, increment-decrement
• Status: 🟢 exercise was fixed
• <- tick off once issue was created

🟡 Elyses Analytic Enchantments (array-analysis)

• Concepts: array-analysis
• Explanation: teaches methods to analyse arrays, indexOf, includes, every, some, find, findIndex, "about" could mention more methods
• Prerequisites: arrays, callbacks, arrow-functions
• Status: 🟡 exercise exists but introduction/concept is nearly empty, introduction needs to include all methods needed to solve the exercise
• <- tick off once issue was created

🟡 Elyses Transformative Enchantments (array-transformations)

• Concepts: array-transformations
• Explanation: teaches reduce, slice, splice, filter, sort, fill
• Prerequisites: arrays, callbacks, arrow-functions, array-methods-manipulation
• Status: 🟡 exercise exists but introduction/concept is nearly empty, introduction needs to include all methods needed to solve the exercise; tasks can be reduced/simplified a bit, they can but do not need to inlcude map, push, pop, shift, unshift as those were already tought before
• <- tick off once issue was created

[SleeplessByte]

[..] where there are currently no exercises/concept pages for the prerequisites. So it is hard to tell whether the student actually knows all the necessary things by this point.

Yes, it was up to "future authors" to make sure the prerequisite chain included at least what was needed in those exercises, OR that they update those exercise prereqs.

To mitigate those things and focus our efforts a bit I would propose to concentrate on a small set of concepts first (e.g. 20), that would provide a consistent learning experience (MVP style). Then people testing the new website etc would be able to check the unlocking mechanisms etc.

I wholeheartedly agree. This is exactly the goal for April 1st! 100%.

Elyses Enchantments (arrays)
Concepts: arrays, array-manipulation

This is actually 5 exercises (including array-loops) and thus teaches all those concepts. I think all of them have the exact same issue as you mentioned here.

Bird Watcher (for-loops)

Agree. This is required for array-loops.

---

I think this is actually a great list to start with. I like this way of conveying the information. For the yellow ones, I'd expect "improvement" issues. For the red ones I'd expect "new concept exercise" issues. I actually think your suggestions of other exercises is great and will gladly see those ported to JS.

[junedev]

Thanks for the positive feedback. Added the explanation for the colors and exercise 9 to 15.

[ErikSchierboom]

Some of these already have exercises, but are not mentioned in the exercise. @ErikSchierboom can you explain how you assign the concepts and how it gets turned into that automated reference readme document? Once Erik does, we need to update our files (design doc, config.json) so we can do this too.

Which specific document are you referring to? This document? If so, that document was generated by a GitHub Actions workflow using some C# code: https://github.com/exercism/v3/tree/main/.github/bin/csharp-exercise-report

[junedev]

Finished the proposal for the first 20 concept exercises. Will start to create issues for the missing exercises first (status 🔴), will follow the template that was used for the issues so far.

Once we got the 20 exercises sorted, I will try to come back here and create a somewhat more complete list of concepts.

[SleeplessByte]

Amazing. This is really helpful @junedev, 💯% appreciated