Alternative schedule proposal

[gvwilson]

Along with a lot of exercises (thanks!), the modified version of this lesson at https://biologyguy.github.io/python-novice-gapminder/ puts episodes in a new order - it takes longer to get to the data analysis payoff, but makes more sense from a building-blocks point of view. What do you think?

[andreww]

I can see that the modified order makes more sense, but I suspect it is more important to get to the "payoff" early. I'm also not convinced by separating "Libraries" from the first use of Pandas.

I like to do is split the python material over two days (e.g. afternoon of day 1, and morning of day 2). It would be interesting to know what happens to no-shows on day 2 if this is done and the two orderings are tried for a couple of workshops.

Having said that, I've not actually tried giving this lesson yet (it looks like I will in January) so you may want to take my views with a pinch of salt. Finally, I think this kind of modification for particular workshops is something we should be happy with. Especially if it is in response to something we know about the needs, background or expectation of the attendees at a particular workshop.

[pvanheus]

I see Steve (@biologyguy) added an extra hour to the schedule. That's wise, if you can do it. I taught the gapminder lesson at PyConZA recently and ran out of time. If you are going to run out of time, the order that Steve proposes means that you might miss out programming style and you might miss out conditionals even but you'll have covered functions, lists, dataframes and the basics.

This 'building-blocks' perspective does, however, largely feel like 'bottom up' teaching which is not traditionally what Software Carpentry has done. Not sure if that is an issue? The inflammation lesson starts with the 'payoff' and then goes bottom-up from there - I've sometimes felt that is a strange gear-shift though.

[bsmith89]

I see three ways of organizing the material with respect to this discussion:

1. Motivating example (e.g. plotting) first (this is what swcarpentry/python-novice-inflammation does)
2. Motivating example early (by the end of the first half-day) (swcarpentry/python-novice-gapminder)
3. Motivating example once learners have all the building blocks (biologyguy/python-novice-gapminder)

I believe that the best approach of these three will depend on how motivated the learners are. If everyone's there to learn shell and they've never heard of Python, take approach (1). If they already know they want to learn Python, (3) avoids confusing/intimidating them early-on.

There's both inter- and intra-workshop heterogeneity in the audience, so I doubt there is one, universally best approach.

[lo5an]

What if we add a README notebook to python-novice-gapminder-data.zip that contains an introduction to the GapMinder data, along with some code cells and a plot or two?

We could use that notebook as part of the Running and Quitting episode when we show people the features of Jupyter, and then open up a new blank notebook and build back up to plotting using @biologyguy's alternative ordering.

In addition to a motivating example of Python code, that might also make the initial intro to Jupyter more meaningful, and would give us a chance to model good practices for documenting a dataset for distribution.

[djinnome]

An alternative order that would compromise between the current early payoff approach and @biologyguy building-blocks is to keep the current schedule of reading tabular data and introducing DataFrames, but push plotting until lists, loops and conditionals have been introduced. From a building blocks perspective, it also makes more sense to introduce conditionals before function definition. In summary:

1. Running and Quitting
2. Variables and Assignment
3. Data Types and Type Conversion
4. Built-in Functions and Help
5. Libraries
6. Reading Tabular Data into DataFrames
7. Pandas DataFrames
8. Lists
9. For loops
10. Conditionals
11. Plotting
12. Writing Functions
13. Variable Scope
14. Programming style

If you are teaching two half-day courses, you can probably get through 6 and 7 by the end of the first day and get to plotting by the middle of the second. The argument for this approach is that reading tabular data is a pretty big win for spreadsheet users, and understanding how to index, slice and dice pandas DataFrames uses the same logic as string slicing using iloc. (And we can compare and contrast slicing with loc instead).

However, both lists, conditionals and the accumulator pattern are used in the plotting section, so it really doesn't make sense to throw a bunch of code that they haven't seen when just a few episodes later, they would have all the info necessary to understand the code.

[djinnome]

Plus, by ending the lesson with function definitions and programming style, you really leave with a (perhaps overinflated) sense of the power at your fingertips when you can design your own functions.

[charlesbmi]

Reviving this thread: I just taught this lesson (online) with a class of mostly beginners. My initial impression is to move to the building-blocks order (https://github.com/biologyguy/python-novice-gapminder) for next time, because our learners were confused by the many new concepts that are bundled inherently with DataFrames. I'm not sure they felt empowered by the data analysis payoff, because they were caught up with reading in data, methods, Boolean values/NaN, and 2-D indexing, without much experience from the earlier sections. More experience from other sections with lists/functions/booleans would help smooth over that experience.

After reading through everyone's comments, I wonder whether we could keep a simpler initial motivating example (plotting Gapminder data that is just hard-coded) at the end of day 1, then move DataFrames and a more exciting plotting example to the end of day 2 (such as [Gapminder's World Health Plot](https://www.gapminder.org/fw/world-health-chart/, utilizing for-loops instead of true interactivity)