Check ordering of core exercises

[ErikSchierboom]

I just received some feedback from a student that he thought the sum-of-multiples exercise was way harder than the previous exercises. We should look into the current order and see if the difficulty is progressing as smoothly as possible.

[pdmoore]

Similarly, "Two Fer" comes after Bob and Raindrops. On the Java track "Two Fer" is the first exercise after Hello World. On C# track "Two Fer" is the 6th exercise and doesn't really add to what has already been covered.

[ErikSchierboom]

Thanks for the feedback! I'll come up with a new proposal soon.

[ErikSchierboom]

Some initial thoughts on this:

• two-fer should be much higher in the list, as it is actually quite easy.
• we should remove sum-of-multiples as a core exercise (see this thread).
• maybe accumulate isn't the best of core exercises, as people don't really learn much from it (except for the yield keyword).
• maybe markdown isn't a great core exercise, as it is primarily about refactoring and as such, does not teach any new skills.

[ErikSchierboom]

@jpreese @robkeim Your thoughts on this?

[ErikSchierboom]

This is the current list of core exercises and their topics:

• hello-world: strings
• leap: control_flow_if_else_statements, integers
• bob: control_flow_if_else_statements, strings
• sum-of-multiples: arrays, math, transforming
• raindrops: filtering, strings
• two-fer: optional_values, strings
• nucleotide-count: dictionaries, strings
• accumulate: extension_methods, sequences, transforming
• grade-school: lists, sorting
• kindergarten-garden: enumerations, parsing
• clock: classes, structural_equality
• binary-search: arrays, searching
• allergies: bitwise_operations, filtering
• saddle-points: arrays, matrices, tuples
• markdown: parsing, refactoring, transforming
• book-store: recursion

And these are the topics and their counts:

• strings: 5
• arrays: 3
• transforming: 3
• control_flow_if_else_statements: 2
• filtering: 2
• parsing: 2
• integers: 1
• math: 1
• optional_values: 1
• dictionaries: 1
• extension_methods: 1
• sequences: 1
• lists: 1
• sorting: 1
• enumerations: 1
• classes: 1
• structural_equality: 1
• searching: 1
• bitwise_operations: 1
• matrices: 1
• tuples: 1
• refactoring: 1
• recursion: 1

[robkeim]

Do we have data that we could use from before the release of Exercism v2 that would help us determine this order? Some values such as:

• The number of students that completed an exercise
• The number of iterations on average per exercise
• The order in which students completed the exercise

Might help give us more insight and the true "difficulty" of exercises as perceived by the students. With the release of v2 we can't trust the stats as much for the existing core exercises since we're forcing students into a specific order, but that wasn't the case in the first version.

[ErikSchierboom]

I don't think we have that data unfortunately. We'll have to rely on gut feeling, and what our experience as mentors tell us. I hope to make a proposal for a new order today.

[ErikSchierboom]

While working on the re-ordering, here are some of my thoughts on the current track's status:

• Some exercises unlock way more side exercises than others. This should be more spread out.
• We could probably add some more core exercises, to not unlock massive numbers of side exercises each time.
• We should probably add some of the more difficult exercises as core exercises.
• We could improve upon how core exercises unlock related side exercises, this is a bit random at times.

[ErikSchierboom]

This is my proposal for the new track progression:

Difficulty: easy

two-fer (core): optional_values, strings
-> reverse-string: strings
-> pangram: strings
-> isogram: filtering, strings
-> gigasecond (core): dates

space-age (core): floating point numbers
-> difference-of-squares: control_flow_loops, integers, math
-> sum-of-multiples: arrays, math, transforming
-> collatz-conjecture: algorithms, control_flow_conditionals, control_flow_loops, integers, math
-> grains: integers
-> armstrong-numbers: math

hamming (core): filtering, strings
-> error-handling: exception_handling
-> accumulate: extension_methods, sequences, transforming
-> strain: filtering, sequences
-> scrabble-score: transforming
-> protein-translation: lists, strings, transforming

nucleotide-count (core): dictionaries, strings
-> etl: dictionaries, lists, transforming
-> sieve: filtering, math
-> binary-search: arrays, searching
-> word-count: dictionaries, strings, transforming

bob (core): control_flow_if_else_statements, strings
-> raindrops: filtering, strings
-> rna-transcription: strings, transforming
-> phone-number: parsing, transforming
-> triangle: enumerations, integers

allergies (core): bitwise_operations, filtering
-> secret-handshake: arrays, bitwise_operations
-> perfect-numbers: integers, math
-> queen-attack: classes

robot-simulator (core): classes, enumerations
-> kindergarten-garden: enumerations, parsing
-> clock: classes, structural_equality
-> robot-name: classes, randomness, strings
-> grade-school: lists, sorting

beer-song (core): string building
-> proverb: string building
-> house: string building
-> twelve-days: string building
-> food-chain: string building

Difficulty: medium

grep (core): files, searching, strings
-> anagram: filtering, strings
-> series: arrays, strings, transforming
-> isbn-verifier: conditionals, loops, pattern_matching, strings
-> markdown: parsing, refactoring, transforming

yacht (core): games, parsing, sorting
-> poker: games, parsing, sorting
-> bowling: algorithms, control_flow_loops
-> dominoes: arrays, tuples
-> tournament: parsing, strings

simple-linked-list (core): classes, lists
-> linked-list: classes, lists
-> circular-buffer: classes, queues
-> custom-set: sets
-> sublist: lists
-> binary-search-tree: overloading, searching, trees
-> tree-building: refactoring, trees

meetup (core): dates
-> bank-account: classes, concurrency
-> saddle-points: arrays, matrices, tuples
-> complex-numbers: math, tuples
-> rational-numbers: math
-> prime-factors: integers, math

roman-numerals (core): control_flow_loops, transforming
-> wordy: parsing, strings, transforming
-> say: strings, transforming
-> acronym: strings, transforming
-> largest-series-product: integers, math, strings, transforming
-> ledger: globalization, refactoring, strings
-> pig-latin: strings, transforming

spiral-matrix (core): algorithms, matrices
-> scale-generator: algorithms, parsing
-> bracket-push: parsing, strings
-> ocr-numbers: parsing, pattern_recognition
-> matrix: matrices, parsing
-> minesweeper: parsing, transforming

rotational-cipher (core): algorithms, strings, transforming
-> simple-cipher: algorithms, strings, transforming
-> atbash-cipher: algorithms, strings, transforming
-> crypto-square: algorithms, strings, transforming
-> rail-fence-cipher: algorithms, strings, transforming

run-length-encoding (core): algorithms, transforming
-> nth-prime: math
-> diffie-hellman: algorithms, integers, math, transforming
-> luhn: algorithms, strings, transforming
-> parallel-letter-frequency: dictionaries, parallellism, transforming
-> pythagorean-triplet: integers, math, overloading
-> transpose: strings, transforming

book-store (core): recursion
-> all-your-base: integers, math, transforming
-> list-ops: lists, recursion
-> flatten-array: lists, recursion
-> pascals-triangle: arrays, control_flow_loops, math
-> dot-dsl: classes, domain_specific_languages, equality

Difficulty: hard

diamond (core): algorithms, strings
-> sgf-parsing: parsing, strings
-> connect: algorithms, strings
-> go-counting: algorithms, strings
-> rectangles: parsing, transforming
-> word-search: searching, tuples

zebra-puzzle (core): logic, laziness
-> two-bucket: logic
-> hangman: reactive programming
-> react: events

forth (core): stacks
-> alphametics: algorithms
-> change: arrays, integers

zipper (core): trees
-> pov: trees

The core progression path would become:

1. two-fer: optional_values, strings
2. space-age: floating point numbers
3. hamming: filtering, strings
4. nucleotide-count: dictionaries, strings
5. bob: control_flow_if_else_statements, strings
6. allergies: bitwise_operations, filtering
7. robot-simulator: classes, enumerations
8. beer-song: string building
9. grep: files, searching, strings
10. yacht: games, parsing, sorting
11. simple-linked-list: classes, lists
12. meetup: dates
13. roman-numerals: control_flow_loops, transforming
14. spiral-matrix: algorithms, matrices
15. rotational-cipher: algorithms, strings, transforming
16. run-length-encoding: algorithms, transforming
17. book-store: recursion
18. diamond: algorithms, strings
19. zebra-puzzle: logic, laziness
20. forth: stacks
21. zipper: trees

Here is my rationale for this progression:

• I've tried to select those exercises as core exercises that are easier than the ones they unlock. This gives students the ability to "dig deeper," if they want to.
• I've tried to select core exercises that will probably have solutions that are interesting to mentor/receive feedback on.
• The core exercises unlock similar side exercises, such that they are better related to the core. This will allow students to further hone their skills on a particular subject through the use of side exercises.
• I've added some more core exercises, to allow a smoother progression where each core exercise unlocks a small set of side exercises, to not overwhelm the user with side exercises.
• The core exercises are quite diverse in their topics, with little overlap.
• Move core exercises that often don't have an interesting solution (such as leap and accumulate) to side exercises.
• Ensure that all math-y exercises are side exercises (see this issue).

[ErikSchierboom]

@robkeim @pdmoore @jpreese The comment above contains my suggestion for an updated core exercise path. Any thoughts?