​​​​# OpenHouse Dec'24 - CodeRefinery workshop format

Welcome

This is the notes document for the OpenHouse session on the workshop format, please use it to check in, share your ideas and take notes during disucssions. For this event, let's disregards week 1 (git and github), that seems to work well now and focus on topics currently taught in week 2.

Example workshop setup for week 2 from our last workshop, see Day 4-6: https://coderefinery.github.io/2024-09-10-workshop/#schedule
Links to lesson materials from week 2 (in order of current schedule):

Goal for today is: Collecting ideas and opinions, which will be continued via chat and potentially social media and will be taken into account when planning the next workshop.

If you want to support this discussion by working on specific tasks, please see the task list below.

Useful references for discussion

Check in

Name, affiliation, topics taught/of interest, time today; CodeRefinery connection

Name Affiliation time today topics taught/of interest CodeRefinery connection
Samantha Wittke CSC (FI) will join 10-12 CET reproducible research, documentation community manager for the project
Radovan Bast UiT (NO) 9-11 CET all project manager
Richard Darst
Diana Iusan UU (SE)

Idea and opinion collection

Workshop format

Add your ideas for the workshop format for week 2. You can also vote (add your

Image Not Showing Possible Reasons
  • The image file may be corrupted
  • The server hosting the image is unavailable
  • The image path is incorrect
  • The image format is not supported
Learn More →
) to the ideas you like, or add comments to already existing ideas

  • Keep as is (3 half days, 2 topics per day, mostly demo and discussion in notes document)
  • Bring back exercise sessions (needs adjusted timetable and/or content)
  • …
  • Different format:
    • Flipped classroom (materials, videos provided beforehand) and CodeRefinery provided support and/or discussion sessions
      • DI: this is an interesting format that we should work towards but we need to make sure that enough people who know the topic are present at the hackathon/help sessions
      • RB: I like this. The challenge will be to make the discussion session an interesting event. I don't think we would need a commercial platform to make it work. And we need quiz/puzzles a la Advent of Code.
    • Self-learning platform + support sessions
    • Hackathon (eg one topic per day, spread over multiple weeks, CodeRefinery provides introduction to topic and then support for implementing the topic for own work)
    • …
  • BYOC sessions: split it out of workshop and make it a stand-alone (monthly?) thing to reduce scheduling complexity
    Image Not Showing Possible Reasons
    • The image file may be corrupted
    • The server hosting the image is unavailable
    • The image path is incorrect
    • The image format is not supported
    Learn More →

Workshop content

Add a o (keep as is) or r (remove) or u (keep but update) to each lesson, depending on your thoughts, add additional comments (especially on o votes) under each lesson

  • Reproducible research : u
    • Make reproducible research shorter info episode, separate dependency management and workflows into separate sessions
  • Social coding : o
  • Jupyter : r
    • consider to replace with terminal/command line and/or VS Code (see discussion below)
      Image Not Showing Possible Reasons
      • The image file may be corrupted
      • The server hosting the image is unavailable
      • The image path is incorrect
      • The image format is not supported
      Learn More →
      • iPython could also be interesting
    • if we remove it, Modular Code Development is affected (typically starts in Jupyter)
  • Documentation : o
  • Modular Code Development : oo
  • Automated testing : o

Discussions

  • one thing that was tricky Sep 2024 was to reach out to local groups for somebody who maybe did not have prior context with them
  • key in flipped classroom will be to provide interactivity during events and also in-between events. events could be advertized as having direct access to knowledge/instructors.
  • we could "flip" also only one lesson and see how it works and if it works, we convert more of the workshop so that we don't take a too huge tasks that might not work.
  • should we replace Jupyter with terminal? Paradoxically we might need the terminal more. We particularly need it to activate environment and install dependencies.
    • Also file structure. Many learners don't know where they are on their computer.
    • This is needed but terminal and file structure lesson should be a separate lesson/doc outside of the CodeRefinery workshop?
    • This could be the flipped classroom lesson/event that we could try before deciding about converting the rest
  • Conda installation becomes part of the workshop (beginning of week 2?)
    • it's not enough to ask learners to install before workshop and come to help sessions
    • for many learners it's a completely new thing, especially Miniforge
    • organize them by operating system
    • 1h warm-up before stream starts or the day before could be dedicated to installing/activating/navigating on file system
    • if one day before, we need to advertize it as part of the workshop. If it's advertized as "bonus", then many won't be there who might need it. It could happen the day before, 1 h on stream and later we go to Zoom to help out, not recorded.
  • If somebody struggles with navigating the file system, will they benefit from the workshop?
    • might still benefit (example: someone working inside R Studio or Jupyter)
    • analogy of file system on phones and why a hierarchy of files can be useful
  • VS code can also manage environments, run Jupyter, with Git (see DI's comments below)
  • Maybe VS code could simplify the number of terminal that we require to install and navigate (could we not require Git Bash?)
  • Consider advertising VSCodium (truly open source) instead of VS Code (Microsoft, telemetry)
    • it seems we would not lose access to extensions
  • For data support staff (who would like to attend workshops) the workshops start too technically so we will need to bring people up to speed
    • data support staff (who might not program themselves) second week is too much and they need an overview session at the beginning of week 2 (big picture session)
    • this session could be pre-recorded
    • this might also help ambassadors who want to get an overview or communicate an overview
    • "what can CR workshop help you with?"
  • Let's try to schedule also the autumn workshop at the same time? Maybe this simplifies scheduling.
  • Maybe helpful: "what changes would simplify scheduling?"
    • e.g.: week 1 and 2 separate events? BYOC session separate event series? installation is part of the event
    • we schedule for 2 weeks but in reality it's 4-5 weeks currently
  • Getting/updating recordings on how we work with Conda and terminal to improve pre-requisites
  • In-person class rooms: many registrations but only very few people show up so it might not be best use of resources. On the other hand, CSC might offer an in-person classroom next time.
  • Stream but no recordings or unprocessed recordings could also simplify things
  • Manuals could be the place to start simplifying
  • Use existing channels/networks to reach out, eg CSC scicomp ambassadors
  • UNITE alliance (Aalto is part with KTH, Montpellier, Torino etc)
    • Online MOOC request, CodeRefinery planned to be promoted there
  • ECTS provision discussion
    • fast track (people submit early and get credits fast)
    • slow track
    • not a human resource bottleneck atm; Aalto knows how to do it, Mira in addition to Enrico can do
    • repository generating certificates (private repo): https://github.com/coderefinery/generate-certificates
    • at Aalto: via student numbers they get credits directly
    • others: get certificate and need to talk to supervisor to get credits
    • Amsterdam: own homework with own check and direct credits
    • CodeRefinery: info on what is behind credits more visible (currently on workshop page), also info for other universities on how to do their own
    • Idea: Advent-of-code-ify the tasks
      • towards self learning
      • could also be used for prerequisites
        • remember: capture flag thingy by Marijn
        • in future could also suggest which sessions to attend
      • making it fun and lightweight is important
      • its work, but we have people who enjoy working on such stuff :)
  • back to Jupyter/VSCode/CommandLine:
    • interaction with CL: skill, needs to be practiced
    • feedback from advanced git: many don't comfortable in CL, can short session help?
  • people also do not necessarily know about filesystem etc anymore; not a skill but info
    • having seen it may increase confidence
  • we need to find out what is it that people need and present it in a way suitable for every level
  • gamification nice idea to get people work with the command line after crash course
  • discoverability of skills
  • Softwarecarpentry should be the entry point, after that should be a phase where they practice before coming to CodeRefinery
    • unknown how much these exist in Nordics, some use materials from there
  • pedagogically it would be cool to teach CR without command line, but researchers may have good use for it, should be somehwat included to also show what it can be useful for

Propoasal based on discussions

  • Bring your own code sessions separate from workshop with own registration
    • Give support people something to plan
    • Give learners possibility to ask before meeting
    • Give us possibility to remind the target audience
  • Pre-workshop shell crash course
    • have part of the workshop somehow, "join if needed", also have self-learning ready
    • Monday before workshop or week before
  • Jan/Feb event for (data)- support people
    • CodeRefinery in an hour targeted at people who don't necessarily need to use the tools themselves but work in some advisory role
    • Lecture and discussion
  • Keep the usual 2 week (6 half day) workshop format
    • Gamified prerequisite quiz
    • Replace Jupyter with VSCode
    • Add shell crash course in beginning
    • Have installation session as part of Conda lesson
    • Other lesson updates up to co-instructors

Tasks

  • Simplify and update install instructions (to Miniforge)

    • define python version

  • Shell crash course: prepare (record or material & live)

    • registration to send reminder
    • Monday before workshop (same week or week before?)

  • CodeRefinery in an hour before the workshop for data support?

    • In February/January, doodle for data networks
    • Ask for bringing cases, what would they like to get from it

  • Collect relevant points from workshop notes documents (findable per past workshop > Q&A > Bottom of each days document)

  • Collect relevant points for discussion from participant feedback (https://coderefinery.org/blog/2024/08/10/post-workshop-survey/)

Long idea collection

Feel free to add your thoughts also in free form to below collection, can also be non thought through ideas:

EG's proposal of restructuring:
Just a wild idea for now, details need to be figured out (i.e. how much the usual week 2 can be fully independent from git lessons)

  • Week 1 (old week 2):
    • day 1: reproducible research + social coding
      • motivational lesson to get started
    • day 2: linux terminal (replaces jupyter) + github pages 1 (replaces and extends documentation)
      • full hands on with the terminal including creating conda environments and running simple python scripts in the terminal
      • full hands on generating sphinx book/website/documentation on own computer
    • day 3 automated testing + modular code
      • With hands on terminal-based exercises
  • Week 2 (old week 1):
    • git as the old week 1 but having one new session that pushes local website to github pages

RB:

  • Devil's advocate question not to doubt/question but to create good arguments and motivation: Will github pages and automated testing (week 1) not require git/github knowledge (week 2)? But many of week 2 lessons currently could be taught without Git so I find this an interesting idea.
  • My main recommendation for the 2025 workshop is to simplify and subtract (workshop complexity, not content). Over the years we have been adding complexity and copying from 6 months ago and adding more without considering that we might not have the resources for it. Example: when we schedule it we look for 2 weeks but right now, in reality it is a 4-5 week committment and every edition we are then surprised that we have difficulty finding people who can be at e.g. bring-your-own-code session or similar.
  • Since lesson development is so important for these topics (since they change so rapidly) and since we never have time for lesson development and since continuous work "over the next months" is unrealistic since our work weeks are so fragmented into meetings, can we think about making lesson development somehow part of the event? Or will monthly open house events solve this? How can we restructure the workshop and solve the last minute stress at the same time?

DI:

  • I am unsure about the linux terminal lesson. Some may need it, no doubt, but I would not have it as part of the worksop. Possibly as a link to reading material. Also, many of the lessons do not need the command line, IMO. But it would be nice to have an intermediate-advanced lesson on linux added to our portofolio.
  • Instead of Jupyter we could have VSCode. One can integrate it with Git, and use with diff. programming languages. Surely, Jupyter can too, VSCode is just an alternative.
  • I am not sure of we should keep the Bring Your Own Code under the tools workshop or have it separate. I am more inclined to have it separate so that one can register for it, and thus have an idea for how many will show up and coordinate the mentors. At the same time, this adds an additional barrier and maybe people would not be inclined to join. But a plus for having it separate is that we can advertise it separatly via the usual channels.

SW: Thinking out "loud" -> "written down":

  • Bring your own classroom currently does not work for Week 2, some are sad about that
  • I like week 1 as it is and would not touch it other than maybe add an optional first day for linux/computers for non-computer people
  • We previously got a lot of feedback that time is too short for having discussions and support with all new tools in week 2
  • Its already long "half days", i don't think we should do longer days
  • Some topics are more beginner friendly than others just based on what they are for, some have just too many tools for being beginner friendly (reproducible research)
  • Testing once had a full workhsop/hackathon on its own, which seemed to work well
  • Snakemake/Nextflow too
  • There is many courses/videos/tutorials out there teaching Jupyter; do we have something they do not have?
  • I wonder if we could do two week 2, advanced and beginners, instead of having twice a year same workshop
    • Beginners could be documentation, Dependencies, Workflows and Containers (but each of the latter 3 get their own lesson + one shorter lesson on intro to reproducible research and why care), social coding and modular code development. Maybe one of the lessons per day with exercises (make a bit longer) and the other as demo (make a bit shorter)
    • Advanced could be more in depth and for example testing instead of modular code development
  • Or it could be spring: Only the current morning topics and Autum: Only the current afternoon topics
  • In any case I think it would be great if we could give more time to the reproducible research topics that are currently all in one lesson. Not sure what is a good way to do it.
  • I also like the idea of really rethinking week 2 and trying something more along the lines of flipped classroom. We prepare materials to read/videos to watch this coudl be done using MOOC platform, but so far I havent seen one that I would enjoy using personally. No matter the platform, we would then invite people for exercise sessions. The sessions could start with a demo of the exercise and then open for questions .
  • About Bring your own code: Agree with Diana that it would be good to separate in some way that makes it possible for us to plan and advertize and for participants to be as easy as possible to join. Maybe "garage times" in some way?
Select a repo