Check ordering of core exercises

[ErikSchierboom]

This is the current list of core exercises:

• hello-world: strings
• leap: control_flow_if_else_statements, integers
• bob: control_flow_if_else_statements, strings
• sum-of-multiples: lists, math, transforming
• two-fer: optional_values, strings
• space-age: discriminated_unions, floating_point_numbers
• raindrops: filtering, text_formatting
• accumulate: recursion, transforming
• grade-school: maps, sorting
• beer-song: algorithms, text_formatting
• queen-attack: tuples
• kindergarten-garden: enumerations, parsing
• clock: structural_equality, time
• robot-simulator: records, tuples
• allergies: bitwise_operations, enumerations, filtering
• ocr-numbers: parsing, pattern_recognition
• tree-building: refactoring, trees
• pig-latin: strings, transforming

And these are the topics, sorted by count:

• strings: 4
• transforming: 3
• control_flow_if_else_statements: 2
• filtering: 2
• text_formatting: 2
• tuples: 2
• enumerations: 2
• parsing: 2
• integers: 1
• lists: 1
• math: 1
• optional_values: 1
• discriminated_unions: 1
• floating_point_numbers: 1
• recursion: 1
• maps: 1
• sorting: 1
• algorithms: 1
• structural_equality: 1
• time: 1
• records: 1
• bitwise_operations: 1
• pattern_recognition: 1
• refactoring: 1
• trees: 1

[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 tree-building isn't a great core exercise, as it is primarily about refactoring and as such, does not teach any new skills.

[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

accumulate (core): recursion, transforming
-> error-handling: exception_handling
-> strain: filtering, strings
-> hamming: filtering, sequences
-> scrabble-score: transforming
-> protein-translation: lists, 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
-> clock: classes, structural_equality
-> kindergarten-garden: enumerations, parsing
-> robot-name: classes, randomness, strings
-> grade-school: lists, sorting

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

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

bracket-push (core): parsing, strings
-> scale-generator: algorithms, parsing
-> spiral-matrix: algorithms, matrices
-> 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

list-ops (core): lists, recursion
-> all-your-base: integers, math, transforming
-> book-store: 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. accumulate: filtering, recursion
4. bob: control_flow_if_else_statements, strings
5. allergies: bitwise_operations, filtering
6. robot-simulator: classes, enumerations
7. etl: dictionaries, lists, transforming
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. bracket-push: parsing, strings
15. rotational-cipher: algorithms, strings, transforming
16. run-length-encoding: algorithms, transforming
17. list-ops: lists, 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).

Note: the track progression is very similar to the proposed C# ordering, with some changes to better suit F#.

[MiyamotoAkira]

Ok, some comments. As a note, I have barely done any side exercise, so I will be commenting mostly on the ones that have been moved/removed.

For the ones moved, in general I agree with them being a lower level. And most of the removed ones I am fine with (I really dislike tree-building as an exercise).

I want to attract attention to queen-attack, as is the exercise that introduces tuples, and the fact that you can do de-structuring on the signature of the function. To me that should be within the easy group, rather than being optional under allergies, with which I don't see at the moment relation.

floating point numbers is the least interesting thing about space-age in my view, introduction of discrimated_unions and pattern matching seem to me the most important concepts.

On robot-simulator you have added the tag classes and removes the tag records. I think there should be an exercise that has classes as the best possible option for grouping function/methods. Not sure if robot-simulator is.

A bit more talk about tags, they seem to be copied straight from C#. Is that a conscience effort to normalize tags for the exercises? To me introducing concepts of the language should be the point of the exercises.

[ErikSchierboom]

These are all very valid comments! Would you be willing to submit a PR that updates the topics to more sensible values?

A bit more talk about tags, they seem to be copied straight from C#. Is that a conscience effort to normalize tags for the exercises?

Nope, this is likely just laziness to easily have some set of concepts for the F# exercises. It's great that you're looking into them in more detail.

I really dislike tree-building as an exercise.

Just to be clear. Do you dislike it from a student viewpoint and/or a mentor viewpoint?

I think there should be an exercise that has classes as the best possible option for grouping function/methods.

Agreed here too. This is something we'll have to think about. If you have any good ideas on what would a good exercise to teach about classes, let us know!

[MiyamotoAkira]

These are all very valid comments! Would you be willing to submit a PR that updates the topics to more sensible values?

Sure can look into that.

A bit more talk about tags, they seem to be copied straight from C#. Is that a conscience effort to normalize tags for the exercises?

Nope, this is likely just laziness to easily have some set of concepts for the F# exercises. It's great that you're looking into them in more detail.

I really dislike tree-building as an exercise.

Just to be clear. Do you dislike it from a student viewpoint and/or a mentor viewpoint?

Mostly mentor, though it left me puzzled when I did it as student. With the other exercises I can zero on some specific themes of the exercise, because I can help with adding new concepts. While on this one, I find that there is no specific goal other than looks good.

I think there should be an exercise that has classes as the best possible option for grouping function/methods.

Agreed here too. This is something we'll have to think about. If you have any good ideas on what would a good exercise to teach about classes, let us know!

Haven't thought about it yet. But will put some mental effort :-)