Elixir track difficulty curve of early exercises.

[Billiam]

I'm currently making my way through the elixir track slowly, but some of the exercises (so far, as a newcomer) seem to occur later or earlier than I would expect.

A couple of examples:

Exercise 5: The list-ops exercise, using core language features to re-implement reduce, append, filter, count, concat, and map occurs before:
Exercise 12: Accumulate (Given a list and a function, apply the function to each list item and replace it with the function's return value.)

Exercise 10: Nucleotide-count (Counting occurrences of a character in a character list, raising exceptions based on invalid arguments, creating histogram of preset characters), occurs before
Exercise 11: rna-transcription (simple letter substitution).

I didn't see any open (or closed) issues about this, so thought I'd throw this out there for discussion. Thanks!

[kytrinyx]

I think we always end up with things in the wrong places for a number of reasons. First, it's never quite clear when we're making new exercises how difficult they actually will be compared to others. Second, we're always implementing exercises spread out across time, so we don't always remember everything about the existing exercises when we add new ones. Third, sometimes it just takes time and feedback to really understand which exercises are harder when you're new to the language (some exercises aren't conceptually difficult, but might introduce several new language features at once).

This is how it was tackled in the Rust track: exercism/rust#127

[jedschneider]

I also noted the discrepancy here.

[devonestes]

Ok, I've gone through and done a brief analysis of all the exercises in the track so far and made notes about them. Here's that initial analysis:

Exercise	Concepts
hello-world	basics
bob	control flow w/ cond, String processing (should be lower)
word-count	maps, lists, reduce
acronym	String processing, map
run-length-encoding	String processing, map_join
list-ops	compound, pattern matching, recursion, lists
sublist	pattern matching, recursion, lists
anagram	filter, String processing
bracket-push	control flow w/ cond, String processing
nucleotide-count	maps, String processing (should be very early, very simple)
rna-transcription	map
accumulate	reduce, recursion (should be before list ops)
hamming	String processing, tuples
phone-number	String processing, Regex, pattern matching
beer-song	Ranges, default values, pattern matching, edge cases
grade-school	state, maps, lists, tuples
leap	algorithms, conditionals
etl	maps, algorithms
meetup	dates, algorithms
space-age	pattern matching/conditionals, basic math (should be much further forward!)
grains	bitwise operators (should be towards the end)
change	reduce, algorithms, pattern matching, maps
luhn	algorithms, complex logic
gigasecond	dates
queen-attack	state, advanced string manipulation, UI
pascals-triangle	algorithms, recursion
saddle-points	algorithms, state, string parsing
triangle	pattern matching, algorithms (should be much further forward!)
hexadecimal	algorithms, recursion
scrabble-score	String processing (should be much further forward!)
crypto-square	String processing, complex logic, algorithms
diamond	algorithms, UI, recursion
roman-numerals	algorithms, map (common, should be much higher)
binary	algorithms, String processing (could probably be higher)
binary-search	algorithms, recursion, control flow
prime-factors	algorithms, recursion, control flow
sieve	algorithms, recursion
raindrops	String processing, recursion (common, should be much higher)
allergies	algorithms, bitwise operators (should be towards the end)
wordy	regex, pattern matching
atbash-cipher	algorithms, String processing, encoding/decoding
bank-account	GenServer, state, OTP
sum-of-multiples	reduce (should be much higher)
largest-series-product	algorithms, map, reduce
pythagorean-triplet	compound, algorithms, reduce
palindrome-products	maps, reduce
parallel-letter-frequency	OTP, String processing
rail-fence-cipher	algorithms, encoding/decoding, String processing
zipper	structs, state, algorithms, compound, complicated
minesweeper	UI, complicated
connect	UI, complicated
difference-of-squares	reduce, compound
bowling	String processing, state, edge cases
dot-dsl	structs, complicated, UI
custom-set	behaviours, compound
nth-prime	recursion, algorithms (should be much higher)
forth	complicated, compound, state

There are definitely some easier ones that should be moved forward, and I'll do that in a coming PR.

The other question I wanted to raise is one of grouping. It seems like there are several recurring "types" of exercises. For example, the "algorithms" ones (like binary-search, pascals-triangle, pythagorean-triplet, etc.) that rely on knowledge of algorithms, and then there are many that are basically "encoing/decoding" (like rail-fence-cypher, luhn, rna-transcription). I wonder if we should attempt to group these together, or try and keep them separated so there aren't too many of the same type of exercise in a row. I can see a benefit to both, but I figured I'd toss it out to see if anyone had any other ideas (or if there is an exercism-wide idea bout this).

[kytrinyx]

This is fantastic, @devonestes!

I wonder if we should attempt to group these together, or try and keep them separated so there aren't too many of the same type of exercise in a row.

I lean towards keeping them separated to avoid the type of fatigue that comes with doing the same type of thing over and over.

[devonestes]

Ok, cool. I'll put together a PR for my proposal for the re-ordering of exercises later on today and try and keep the similar ones spaced out. This should be a fun puzzle!

[devonestes]

This should be solved now with #211 - or at least hopefully it's better!