Ordering the katas

[adamatan]

Thanks!

First, thanks a lot for this very useful repo. I refer to it a lot when I deliver git sessions on stage as a great learning and practicing resource.

The Problem

Newcomers to the katas, who just want to get more professional with git, don't have a clear starting point and progress path. Some katas clearly require prior knowledge, and taking a random kata might be frustrating.

Current (ad-hoc) solution

I have built a github repo with a reasonable starting point and path.

Suggested solution

I would like to add an order prefix to the katas, with leaps of 10 to allow future insertions. For example, basic-commits ➜ 0010-basic-commits, basic-staging ➜ 0020-basic-staging and so on, by the following order:

1. basic-commits
2. basic-staging
3. basic-branching
4. reset
5. squashing
6. detached-head
7. ff-merge
8. merge-conflict
9. 3-way-merge
10. rebase-branch
11. advanced-rebase-interactive

The first numbering should include what we consider basic knowledge for any senior developer.

Advanced material (e.g. Investigation, submodules, ...) can be numbered with a different prefix (e.g. 1010-Investigation, 1020-submodules) to denote that they are not part of the basic path every user should know.

Next steps

I'm opening this to discussion here. If we reach a consensus, I'll PR with a numbering schema.

[RandomSort]

I like your suggestion. We have also been touching on this in #56 and #130 :)
We can also add a "next" command to the exercises to jump to the proper exercise - but that is probably the next step.

We should also drop the basic prefix.

My suggestion would be:
Staging
Commits
basic branching -> branching
ff-merge
3-way-merge
merge-mergesort (better than merge-conflict)
reset
detached-head
squashing
rebase-branch
advanced-rebase-interactive

[RandomSort]

My thoughts at the moment is that perhaps the 0 prefix should be for getting up and running, with perhaps now only the configure git thing. That could also contain some very basic shell katas or some actual katas in configuring.

I tend to talk about ignoring quite early in the setting, so I'd like to move that to the current 0 track.

I can do the reordering, what are your thoughts?

Pulling in some Praqma trainers @JKrag @praqma-thi @sofusalbertsen

[adamatan]

Makes perfect sense. I'll try to set the numbers and suggest a new ordering during the weekend (please let me know if you already did it).

[adamatan]

• Moved configuration and ignore to 0xxx
• Increased other prefixes accordingly (basics are 1xxx, commits 2xxx and so on)

aa690f7

Todo, after we agree on numbers:

• Rewrite Overview.md
• Change README.md - state the starting point
• Squash WIP commits

[JKrag]

While I get the intention, I don't think this is the right way to create a learning path. Partly I think it is hard to agree on a good "order" for learning even the basics, and partly I fear that having a numeric fixed order as part of the file names will also lead us to making too many assumptions within the individual katas as to what the user already knows. Yes, this could be a good thing, as it could make exercises more concise, but only if we all use the exercises in the suggested order, which we don't.

I think we should consider other options for creating learning paths. I suddenly have a half backed idea that i might try to explain in a new issue.

With regards to renaming the actual exercises (not numbering), I also want to mention the thoughts in #156.

[JKrag]

Just for reference and input, here is the order I currently run the exercises in during my 2-day git class:

• git-katas/basic-commits
• git-katas/basic-staging
• git-katas/investigation
• git-katas/basic-branching
• git-katas/ff-merge
• git-katas/3-way-merge
• git-katas/merge-mergesort
• git-katas/rebase-branch
• git-katas/basic-revert
• git-katas/reset
• git-katas/basic-cleaning
• git-katas/amend
• git-katas/reorder-the-history
• git-katas/advanced-rebase-interactive (Typically just live demo)
• git-katas/basic-stashing

But quite a few changes in order have occurred from time to time.

[adamatan]

@JKrag Thanks for your response!

I would like to argue that having a default numbered order might be a good idea because it would help instructors safely assume some prior knowledge when fixing a kata or creating a new one. For example, @RandomSort teaches staging before commits, and you're doing it the other way around. If they are to be ordered, adding steps to the katas would be much easier.

We can also add a "prior knowledge" section at the beginning of each kata, to let the student know what should they practice in order to do the current kata effectively.

I'll follow the issues here - please mention me when you post your new idea about learning paths.

[RandomSort]

Partly I think it is hard to agree on a good "order" for learning even the basics

I think this is a valid point - but I would argue that any sane suggested order is better than none. It will make the repository infinitely more valuable for non-praqma people - I assume this is why we opensourced it :)
I think we should run with the way you are going through the exercises - If we internally are doing it in very different ways we should look at why :)

I fear that having a numeric fixed order as part of the file names will also lead us to making too many assumptions within the individual katas as to what the user already knows.

This is a very good point! Glad I pulled you in the discussion :)
This might be the deal breaker. I see two options. We go for a default ordering - signified by numbers - to be very explicit about what would be the order we expect a newcomer to the repository to go through things. This exercise will also help us figure out how we actually want to teach Git :)
This requires us to add the assumed prior knowledge to all katas - but we probably should do that anyway.

Or we can number only the core exercises and leave the supplementary material unorder - I am not a lot for this.

Alternatively we can just document the suggested learning path through the repository in Markdown file. With optional next.sh scripts in each kata - but that is for later :)
How does this approach feel to you @adamatan ? Also look at #156 as @JKrag mentioned.

I think we should consider other options for creating learning paths. I suddenly have a half backed idea that i might try to explain in a new issue.

I will look into that when the issue has been created ;)

I have another week of vacation, but I will follow up no later than the week I get back

[JKrag]

@RandomSort "The issue" has now been created :-) #188

[praqma-thi]

Hopping in a bit late, but I'm a big fan of ordering core katas. Having a clear starting point and a path forward would really help accessibility. However, doing that but leaving the rest as is wouldn't be ideal, as they'd just be lying around without any indication of the knowledge required to do them. (Hopping from 040-basic-branching to optional-filter-branch would cause a newbie much grief. 😅)

I wonder if we can order core katas, while making it easy to identify when optional katas would be a good idea to do. Perhaps something like:

• split all the katas into "difficulty" levels
• number the core katas throughout those levels
• suggest optional exercises throughout the core katas

Difficulties could be basic (daily git), intermediate (problem solving), advanced (wacky problem solving, messing with internals, etc.) Mostly arbitrary categories though, so I'm not sure I feel about the whole thing.

[adamatan]

Hi everybody!

@RandomSort Hope you had a terrific vacation!
@JKrag Thanks for #188 (commented there).

@praqma-thi :
I do agree that numbering is an all-or-nothing move, and a mix would be confusing. However, I think that defining the level of difficulty is problematic. Is interactive rebase a daily action? What about merging conflicts, or amending?

Therefore, I think that the solution should be twofold: ordered and numbered learning path on the first hand, and a clear prior knowledge list at each kata on the second hand. A linear learner can move forward without wondering what's the next move, and a learner that wants to understand any advanced topic can easily see what prior knowledge is required without running through the entire learning path.

I would refrain from a next.sh script. It's another file to maintain, and the user can lose orientation if some magic script took them elsewhere. A cd to the next number would be easier to grasp.

Suggested Solution (#186)

# Configuration and environment
0010---configure-git
0020---ignore

# Daily / Basic
1010---staging
1020---commits
1030---branching
1040---ff-merge
1050---3-way-merge
1060---merge-mergesort
1070---reset
1080---detached-head
1090---squashing
1100---rebase-branch
1110---interactive-rebase

# Advanced (Commits)
2010---amend
2020---bad-commit
2030---commit-on-wrong-branch
2040---commit-on-wrong-branch-2
2050---revert
2060---reverted-merge
2070---cleaning
2080---stashing
2090---save-my-commit

# Advanced (References and Objects)
3010---merge-conflict
3020---merge-driver
3030---rebase-exec
3040---reorder-the-history
3050---bisect
3060---objects
3070---investigation
4010---pre-push
4020---submodules

[RandomSort]

My part conclusion here is:

• We would like a learning path
• Automating it is not in this step
• Learning path should be seperated from a posisble renaming of exercises

We will order the exercises according to the suggested order that @JKrag posted in this thread.
Beside that will be a group of ad-hoc or optional exercises. They will also be grouped.

To move it forward and get a first we'll go with one of the two suggested solutions:

• ordering by numbering of file names
• Learning Path as part of the README.md

Vote by reacting to this comment with 🚀 for numbering and 👀 for README.md. I will close the voting friday at noon.
I would like to see votes from: @meekrosoft @Neppord @JKrag @praqma-thi @RandomSort, If I have forgotten any please mention them here.

Thank you for your participation, you all rock!

[JKrag]

😕 = really on the fence on this one. I might come up with a more clear 🚀 or 👀 vote in a few days....

[RandomSort]

Understandable Jan, but then we know that the Agile way tells us to do a first increment, and iterate from there :)

[JKrag]

@RandomSort ....., you got me there!

So maybe the first increment is to number the basic exercises for now and leave the advanced topics for now or have them grouped by some naming convention?

[RandomSort]

The first increment is to either number or add learning path to the readme :)

…

On Mon, Jul 29, 2019 at 1:43 PM Jan Krag ***@***.***> wrote: @RandomSort <https://github.com/RandomSort> ....., you got me there! So maybe the first increment is to number the basic exercises for now and leave the advanced topics for now or have them grouped by some naming convention? — You are receiving this because you were mentioned. Reply to this email directly, view it on GitHub <#185>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AAEOHKZF6SGF2TQGKTF5YZLQB3JUHANCNFSM4H5XWBEA> .

[RandomSort]

As no one has made any votes I will be happy to add a Learning path to the read me. It gives me a chance to brush up that anyway :D
I will add @JKrag's suggested order to the readme, and reject your pull request @adamatan Thank you for sparking this discussion and making us move.
The README solution is also the least invasive solution :)