Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Curriculum change: track sequence (round 1) #590

Merged
merged 11 commits into from
Jan 25, 2019
Merged

Curriculum change: track sequence (round 1) #590

merged 11 commits into from
Jan 25, 2019

Conversation

SleeplessByte
Copy link
Member

@SleeplessByte SleeplessByte commented Jan 21, 2019

This PR is the result of work being done to structure the exercises in a track according to a predefined methodology (this work is not finished). This first step (of many rounds) attempts to remove Math and DIY exercises from the core track, and fix obvious problems with the sequence of the existing core exercises. The result is as follows:

(Taken the format from exercism/csharp#740, thanks @ErikSchierboom!)

Core (matches config.json) of this track:
- hello-world (1)
- leap (1)
- gigasecond (1)
- rna-transcription (2)
- space-age (2)
- pangram (2)
- matrix (3)
- bob (4)
- pascals-triangle (4)
- linked-list (5)
- grade-school (5)
- list-ops (6)
- robot-name (6)
- simple-cipher (6)
- wordy (7)
- secret-handshake (6)


core
----
├─ hello-world
│  └─ two-fer (1)
│
├─ leap
│  ├─ reverse-string (2)
│  ├─ triangle (3)
│  └─ collatz-conjecture (3)
│
├─ gigasecond
│  ├─ clock (5)
│  └─ meetup (7)
│
├─ rna-transcription
│  ├─ hamming (2)
│  ├─ etl (2)
│  ├─ scrabble-score (5)
│  ├─ raindrops (2)
│  ├─ allergies (6)
│  └─ nucleotide-count (4)
│
├─ space-age
│  ├─ word-count (1)
│  ├─ grains (5)
│  ├─ perfect-numbers (3)
│  ├─ luhn (4)
│  ├─ pythagorean-triplet (5)
│  ├─ difference-of-squares (3)
│  ├─ complex-numbers (4)
│  ├─ prime-factors (4)
│  └─ palindrome-products (7)
│
├─ pangram
│  ├─ isogram (2)
│  ├─ phone-number (3)
│  ├─ anagram (1)
│  ├─ acronym (2)
│  ├─ series (3)
│  ├─ largest-series-product (7)
│  ├─ bracket-push (3)
│  └─ high-scores (2)
│
├─ matrix
│  ├─ forth (8)
│  ├─ saddle-points (6)
│  ├─ ocr-numbers (5)
│  ├─ transpose (1)
│  ├─ spiral-matrix (4)
│  └─ rectangles (4)
│
├─ bob
│  ├─ beer-song (5)
│  ├─ food-chain (4)
│  ├─ pig-latin (4)
│  ├─ proverb (4)
│  ├─ house (4)
│  ├─ twelve-days (4)
│  ├─ say (6)
│  └─ isbn-verifier (4)
│
├─ pascals-triangle
│  ├─ diamond (5)
│  └─ rational-numbers (5)
│
├─ linked-list
│  ├─ sublist (4)
│  ├─ word-search (8)
│  ├─ circular-buffer (8)
│  ├─ binary-search (7)
│  ├─ binary-search-tree (6)
│  ├─ custom-set (6)
│  └─ simple-linked-list (8)
│
├─ grade-school
│  ├─ two-bucket (6)
│  ├─ bowling (8)
│  ├─ alphametics (7)
│  ├─ connect (7)
│  └─ variable-length-quantity (5)
│
├─ list-ops
│  ├─ strain (4)
│  ├─ accumulate (5)
│  └─ flatten-array (5)
│
├─ robot-name
│  ├─ sieve (5)
│  └─ nth-prime (5)
│
├─ simple-cipher
│  ├─ atbash-cipher (7)
│  ├─ crypto-square (9)
│  ├─ diffie-hellman (3)
│  └─ rotational-cipher (2)
│
├─ wordy
│  ├─ kindergarten-garden (7)
│  └─ robot-simulator (5)
│
├─ secret-handshake
│  ├─ sum-of-multiples (5)
│  └─ change (8)

bonus
----
- zipper (8)
- darts (3)
- run-length-encoding (2)
- roman-numerals (3)
- react (8)
- queen-attack (8)
- all-your-base (5)
- minesweeper (7)
- protein-translation (1)
- armstrong-numbers (2)
- trinary (4)
- octal (4)
- hexadecimal (4)
- point-mutations (0)
- binary (4)

You can generate this output running bin/print-config-tree (and make your own changes to config.json to see the effect).

The most notable changes are:

  • space-age: moved up to 5th place. The new tests / implementation requirements make it far simpler to work out.
  • gigasecond: has move up from the 7th place to the 3rd place. It's quite simple to understand and implement and as its goal is to introduce the Date type early on as a very important core data type in javascript, it makes sense to move it up.
  • list-ops: moved up from last to 12th place.
  • bob: moved down to 8th place.
  • simple-cipher: has moved down considerably from 4th to 13th 14th place. This is a change inspired by JavaScript and TypeScript track issues exercism#4577, mentoring and Non linear learning curve #564. It's a great exercise, but not this early on in the track. The implementation differences and lack of knowledge of the standard library also makes it so that mentors don't like mentoring this. Both in JS and TS, the time to wait is between 1 week and 2 months (!). Moving this down should resolve this!
  • prime-factors: no longer a core exercise. This is due to a recently added policy to exclude "mathy" exercises as core exercise.

My notes on the current core exercises are as follows and as you might be able to tell is that I'm trying to introduce a minimum number of subjects with each exercise. Bad or meh here refers to the test suite, the implementation or the exercise as a whole (in terms of teaching fluency of the language).

exercise notes post-discussion position
hello-world 1
leap bad exercise, introduction to modulo 2
gigasecond introduction to date 3
rna-transcription introduction to objects, enumeration 4
bob introduction to regex 8
pangram introduction to charAt/charCodeAt, enumeration 6
space-age date math, introduction to floating point math 5
matrix implement "string reader" and "pivot" 7
linked-list introduction to class, heavy use of "pointers" 10
grade-school introduction to sort, needs arrays, objects and class 11
robot-name introduction to rand, meh exercise 13
pascals-triangle interesting solutions with enumeration / recursive 9
simple-cipher listed as easy, is actually hard to do right 14
wordy interesting implementations (tokenizer) 15
secret-handshake bad description (incomplete), interesting solutions with bit masks / modulo 16
list-ops immutability, interesting implementations, classic exercise 12

Not all of these have mentoring notes -- that will be next up.

The current ordering is still not perfect and there is still lots to improve, but I feel it is definitely an improvement over the current situation. I'm interested in hearing your thoughts!

As part of the ongoing curriculum update, this re-orders the core exercises according to perceived difficulty. Most notably, this moves simple-cipher down -- re-orders the list loosly according to this:

hello-world, gigasecond, leap, rna-transcription, bob, pangram, space-age, matrix, linked-list, grade-school, robot-name, pascals-triangle, simple-cipher, wordy, secret-handshake, list-ops

Since it's a bit weird to introduce Date thát early, it's placed after leap --- for now.

Furthermore this moves all the core exercises to the top and all the side exercises unlocked by these below that, in order. The bonus exercises (always unlocked) are at the bottom.
Prime factors is a mathy exercise and as part of round one, mathy exercises should be demoted to side exercise.
This is an extensive exercise with four parts. Even though it's not a particularly difficult one to understand, it's actually difficult for beginners (< 4) to implement. Making this number higher makes sure it's no longer listed as easy.
This generates the output (as of this commit):

Core (matches config.json) of this track:
- hello-world (1)
- leap (1)
- gigasecond (2)
- rna-transcription (1)
- bob (2)
- pangram (2)
- space-age (3)
- matrix (4)
- linked-list (5)
- grade-school (6)
- robot-name (6)
- pascals-triangle (5)
- simple-cipher (6)
- wordy (7)
- secret-handshake (6)
- list-ops (8)

core
----
├─ hello-world
│  ├─ two-fer (1)
│
├─ leap
│  ├─ reverse-string (2)
│  ├─ triangle (3)
│  ├─ collatz-conjecture (3)
│
├─ gigasecond
│  ├─ clock (5)
│  ├─ meetup (7)
│
├─ rna-transcription
│  ├─ hamming (2)
│  ├─ etl (2)
│  ├─ scrabble-score (5)
│  ├─ raindrops (2)
│  ├─ allergies (6)
│  ├─ nucleotide-count (4)
│
├─ bob
│  ├─ beer-song (5)
│  ├─ food-chain (4)
│  ├─ pig-latin (4)
│  ├─ proverb (4)
│  ├─ house (4)
│  ├─ twelve-days (4)
│  ├─ say (6)
│  ├─ isbn-verifier (4)
│
├─ pangram
│  ├─ isogram (2)
│  ├─ phone-number (3)
│  ├─ anagram (1)
│  ├─ word-count (1)
│  ├─ acronym (2)
│  ├─ series (3)
│  ├─ largest-series-product (7)
│  ├─ bracket-push (3)
│  ├─ high-scores (2)
│
├─ space-age
│  ├─ grains (5)
│  ├─ perfect-numbers (3)
│  ├─ luhn (4)
│  ├─ pythagorean-triplet (5)
│  ├─ difference-of-squares (3)
│  ├─ complex-numbers (4)
│  ├─ prime-factors (4)
│
├─ matrix
│  ├─ forth (8)
│  ├─ saddle-points (6)
│  ├─ ocr-numbers (5)
│  ├─ transpose (1)
│  ├─ spiral-matrix (4)
│  ├─ rectangles (4)
│
├─ linked-list
│  ├─ sublist (4)
│  ├─ word-search (8)
│  ├─ circular-buffer (8)
│  ├─ binary-search (7)
│  ├─ binary-search-tree (6)
│  ├─ custom-set (6)
│  ├─ simple-linked-list (8)
│
├─ grade-school
│  ├─ two-bucket (6)
│  ├─ bowling (8)
│  ├─ alphametics (7)
│  ├─ connect (7)
│  ├─ variable-length-quantity (5)
│
├─ pascals-triangle
│  ├─ diamond (5)
│  ├─ rational-numbers (5)
│
├─ simple-cipher
│  ├─ atbash-cipher (7)
│  ├─ crypto-square (9)
│  ├─ diffie-hellman (3)
│  ├─ rotational-cipher (2)
│
├─ wordy
│  ├─ kindergarten-garden (7)
│  ├─ robot-simulator (5)
│
├─ list-ops
│  ├─ strain (4)
│  ├─ accumulate (5)
│  ├─ flatten-array (5)
│
├─ prime-factors
│  ├─ sieve (5)
│  ├─ nth-prime (5)
│  ├─ palindrome-products (7)
│  ├─ sum-of-multiples (5)
│  ├─ change (8)
│
bonus
----
- zipper (8)
- point-mutations (0)
- darts (3)
- binary (4)
- run-length-encoding (2)
- roman-numerals (3)
- react (8)
- trinary (4)
- octal (4)
- hexadecimal (4)
- queen-attack (8)
- all-your-base (5)
- minesweeper (7)
- protein-translation (1)
- armstrong-numbers (2)
@SleeplessByte SleeplessByte added the enhancement 🦄 Changing current behaviour, enhancing what's already there label Jan 21, 2019
@SleeplessByte SleeplessByte self-assigned this Jan 21, 2019
Assigning them one up, and give two exercises to "secret-handshake" which had none:

Core (matches config.json) of this track:
- hello-world (1)
- leap (1)
- gigasecond (2)
- rna-transcription (1)
- bob (2)
- pangram (2)
- space-age (3)
- matrix (4)
- linked-list (5)
- grade-school (6)
- robot-name (6)
- pascals-triangle (5)
- simple-cipher (6)
- wordy (7)
- secret-handshake (6)
- list-ops (8)

core
----
├─ hello-world
│  └─ two-fer (1)
│
├─ leap
│  ├─ reverse-string (2)
│  ├─ triangle (3)
│  └─ collatz-conjecture (3)
│
├─ gigasecond
│  ├─ clock (5)
│  └─ meetup (7)
│
├─ rna-transcription
│  ├─ hamming (2)
│  ├─ etl (2)
│  ├─ scrabble-score (5)
│  ├─ raindrops (2)
│  ├─ allergies (6)
│  └─ nucleotide-count (4)
│
├─ bob
│  ├─ beer-song (5)
│  ├─ food-chain (4)
│  ├─ pig-latin (4)
│  ├─ proverb (4)
│  ├─ house (4)
│  ├─ twelve-days (4)
│  ├─ say (6)
│  └─ isbn-verifier (4)
│
├─ pangram
│  ├─ isogram (2)
│  ├─ phone-number (3)
│  ├─ anagram (1)
│  ├─ word-count (1)
│  ├─ acronym (2)
│  ├─ series (3)
│  ├─ largest-series-product (7)
│  ├─ bracket-push (3)
│  └─ high-scores (2)
│
├─ space-age
│  ├─ grains (5)
│  ├─ perfect-numbers (3)
│  ├─ luhn (4)
│  ├─ pythagorean-triplet (5)
│  ├─ difference-of-squares (3)
│  ├─ complex-numbers (4)
│  ├─ prime-factors (4)
│  ├─ sieve (5)
│  ├─ nth-prime (5)
│  └─ palindrome-products (7)
│
├─ matrix
│  ├─ forth (8)
│  ├─ saddle-points (6)
│  ├─ ocr-numbers (5)
│  ├─ transpose (1)
│  ├─ spiral-matrix (4)
│  └─ rectangles (4)
│
├─ linked-list
│  ├─ sublist (4)
│  ├─ word-search (8)
│  ├─ circular-buffer (8)
│  ├─ binary-search (7)
│  ├─ binary-search-tree (6)
│  ├─ custom-set (6)
│  └─ simple-linked-list (8)
│
├─ grade-school
│  ├─ two-bucket (6)
│  ├─ bowling (8)
│  ├─ alphametics (7)
│  ├─ connect (7)
│  └─ variable-length-quantity (5)
│
├─ robot-name
│
├─ pascals-triangle
│  ├─ diamond (5)
│  └─ rational-numbers (5)
│
├─ simple-cipher
│  ├─ atbash-cipher (7)
│  ├─ crypto-square (9)
│  ├─ diffie-hellman (3)
│  └─ rotational-cipher (2)
│
├─ wordy
│  ├─ kindergarten-garden (7)
│  └─ robot-simulator (5)
│
├─ secret-handshake
│  ├─ sum-of-multiples (5)
│  └─ change (8)
│
├─ list-ops
│  ├─ strain (4)
│  ├─ accumulate (5)
│  └─ flatten-array (5)
│
bonus
----
- zipper (8)
- point-mutations (0)
- darts (3)
- binary (4)
- run-length-encoding (2)
- roman-numerals (3)
- react (8)
- trinary (4)
- octal (4)
- hexadecimal (4)
- queen-attack (8)
- all-your-base (5)
- minesweeper (7)
- protein-translation (1)
- armstrong-numbers (2)
printLn(`│ ├─ ${side.slug} (${side.difficulty})`)
track[slug].forEach((side, index, self) => {
junction = index === self.length - 1 ? '└─' : '├─'
printLn(`│ ${junction} ${side.slug} (${side.difficulty})`)
})

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

😍

Copy link
Member

@ErikSchierboom ErikSchierboom left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

In general, I think the new ordering is quite nice! Definitely a huge improvement over the current situation. Great work!

config.json Outdated
@@ -95,19 +52,18 @@
]
},
{
"slug": "simple-cipher",
"uuid": "62d60b42-93bc-4de9-90d1-1ca18a847812",
"slug": "bob",
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I'm wondering if bob is actually a difficulty 2 exercise. I've seen so many people struggle with it in other tracks, that I'm now moving it farther to the end of the track. But maybe it is differently in JavaScript.

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It's not. Regex is medium. We probably want more exercises in-between

config.json Outdated
"control_flow_conditionals",
"control_flow_loops",
"randomness",
"pattern_recognition",
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

We don't have a specific set of guidelines, but those are an awful lot of topics :) I would suggest perhaps only listing the "core" ones. For example, it now lists "regular_expressions" as a topic, but is that something a student necessarily has to use when doing the exercise? If not, it might be useful to drop it (the C# track is not a great example by the way, as the topics there should be cleaned-up for the exact same reason).

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yeh I want to retag them anyway because they are also wrong sometimes!

@tejasbubane
Copy link
Member

Brilliant @SleeplessByte I will have a look at this tonight.

@emcoding
Copy link

I knoooooow how tempting it is to improve All The Things. 💙
However, in upcoming Rounds there will be evaluations of each exercise. I'd recommend to focus on the reordering and removals only, in this PR.
We're aiming for small and fast PR's that cause (huge) improvements for the majority of the students and mentors.

@ErikSchierboom
Copy link
Member

@F3PiX is right of course: please focus on the re-ordering and take my comments for what they are: just hints for a future improvement :)

@SleeplessByte
Copy link
Member Author

SleeplessByte commented Jan 22, 2019

@ErikSchierboom and @F3PiX haha don't worry. This is why I didn't include #591 with this as I know it's part of the next rounds!

I want to spend some time with @tejasbubane too to make sure we both agree on the tags etc and that won't be part of this PR. Speaking of him, @tejasbubane how do you feel about bob? I just looked at the provided solutions and people don't necessarily know RegExp is an easy way to go (but they build complicated state machines or memory maps that are actually mimicking RegExp).

Moving it further down will probably solve that partially.

EDIT: perhaps bob below space-age and before matrix ?

@kytrinyx
Copy link
Member

@tejasbubane Did you have a chance to look at this yesterday? I'd like to get this merged tomorrow if possible so that we can move on to the next step. (As always, we can change things further later as new information surfaces!)

@tejasbubane
Copy link
Member

tejasbubane commented Jan 24, 2019

@SleeplessByte @kytrinyx Sorry I missed out on it yesterday. I just had a look at this - a few comments:

  • I don't think list-ops has a difficulty of 8. There are quite a few operations to be implemented, but still 8 is pretty high.

  • Do we need to keep both list-ops and linked-list in core? I know both are different (linked-list is doubly-linked list), but still they are related, so maybe linked-list unlocks list-ops?

  • bob is slightly complex with the nested conditionals and regex (although regex is not strictly required but lot of students go that way). Maybe move it down a bit or remove it from core and replace with one from the list it unlocks (beer-song maybe?)

I am not aware of the further rounds you have in mind. These are just the points that I can think of looking at the list. We can choose to discuss/implement these in later steps.

@SleeplessByte
Copy link
Member Author

SleeplessByte commented Jan 24, 2019 via email

@SleeplessByte
Copy link
Member Author

I've made some additional changes to reflect everyone's commentary here (cc @tejasbubane).
Moved list-ops bob and because of #598 space-age.

I don't think the side unlocks are great right now, but I think that's part of a future round. This should do for now! Thanks everyone :)

@SleeplessByte
Copy link
Member Author

@tejasbubane if you can give a final LGTM (new ordering), I'm happy to finish round 1 according to Coda :)

@tejasbubane
Copy link
Member

This is the current core order:

Core (matches config.json) of this track:
- hello-world (1)
- leap (1)
- gigasecond (1)
- rna-transcription (2)
- space-age (2)
- pangram (2)
- matrix (3)
- bob (4)
- pascals-triangle (4)
- linked-list (5)
- grade-school (5)
- list-ops (6)
- robot-name (6)
- simple-cipher (6)
- wordy (7)
- secret-handshake (6)

Looks good to me 👍

@tejasbubane
Copy link
Member

Can we merge this?

@SleeplessByte SleeplessByte merged commit a220fb4 into exercism:master Jan 25, 2019
@SleeplessByte SleeplessByte deleted the chore/round-1-curriculum branch January 25, 2019 13:45
sshine added a commit to exercism/haskell that referenced this pull request Mar 8, 2019
As part of [The Track Anatomy Project][1], the Haskell core track is
restructured in #798 using @F3PiX'es multi-stage framework referred to
as "The Track Tool".

Since The Track Tool is still under development, it isn't documented
yet. But the execution of the first step can be viewed for other
languages, e.g. exercism/javascript#590.

---

Proposal:

 - Switch "Bob" and "Pangram".

   They're both about handling textual data.

   Pangram has fewer gotchas, is quicker done, has more variations among
   its alternative solutions, and doesn't lend itself as well to `Data.Text`.
   (See #795.) Bob often involves more refactoring, has more learning
   objectives and has the extra "You could do it with Data.Text, too!" part.

   This way people don't try to solve Pangram with Data.Text which is possible
   but not ideal without mono-traversable, and they get an exercise more under
   their belt before being thrown into a lot of refactoring.

 - Switch "Nucleotide Count" and "Sum of Multiples".

   Eventually I think we should delete "Sum of Multiples" and "Grains" (see #761).

   But since The Track Tool does not address removal yet, I want to make
   "Nucleotide Count" come immediately after "RNA Transcription", since
   they're both thematically related and Nucleotide Count uses Either
   while RNA Transcription uses Maybe for monadic error handling, so they
   practice the same thing in progressive difficulty.

The proposed track reordering looks like:

1. hello-world
2. leap
3. space-age
4. **pangram**
5. **bob**
6. collatz-conjecture
7. rna-transcription
8. **nucleotide-count**
9. sum-of-multiples
10. grains

[1]: https://exercism.io/blog/track-anatomy-project
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
enhancement 🦄 Changing current behaviour, enhancing what's already there
Projects
None yet
Development

Successfully merging this pull request may close these issues.

5 participants