---
# System prepended metadata

title: Focus CoE instructor training days 1 and 2

---

# Focus CoE instructor training days 1 and 2

Notes from days 1 and 2 below:

### Welcome session

https://coderefinery.github.io/instructor-training/

What do we want to get out of this workshop?

- Be more familiar with pedagogical skills and topics (no formal training prior to this workshop)
- What to use from CR/Carpentry and what not?
- Get an idea how the software engineering training course should be organised in general 
- I'd like to build a collaborative community around training in the HPC context, and relearn some instruction skills
- How to determine what level of skill one should pitch a workshop at and tailor the material to that level.
- Overview (or recap) of practical pedagogy and experience in technical teaching. Tips for teaching online.
- Good practices for the teaching I need to do as part of other work
- Do's and dont's in training users and in training instructors
- Networking; Learning from each other on how to teach better; more diverse and accessible HPC training material

What does HPC mean to you?
- High performance computing
- some task that it is not possible to do on my own computer.
- Computing (e.g. software development) where performance matters. 
- Everything that's not AI
- High performance computing for various software applications
- Large multi-node monolythic computing workflows that are optimised for short durattion FLOPS
- Remote computing that uses more resources than my laptop
- Something many life science researchers are afraid of
- Using any purpose built system for computation (and not other computer usage like watching videos)

## Welcome and introduction
https://coderefinery.github.io/instructor-training/welcome/

- Is this how I ask questions?
  - reply like this
  - ok, got it... thanks
- Do you always do this course online?
  - We have had it online twice, in person once.  We are still working out the optimal mechanics.
  - Ok thanks. It would be good to hear about your different opinions on this.

## Teaching philosophies
https://coderefinery.github.io/instructor-training/02-teaching-philosophies/
Exercise: ice breaker in the top
15 minutes, ends at xx:40.

(add things here)

- Share your approach to teaching and your teaching philosophy with your group.
- Please share your tricks and solutions in the live document for others.


### Room 1

- lectures in academic context
- Get to know the background of your learners, to make sure we do not demotivate
- Hands-on workshops, very interactive, learners come with their own use case
- Now moved online since covid-19; reduce switching between hands-on and lectures; demos and then separate hands-on
- face 2 face lectures
- New to online training, will show tools for performance analysis. Try to interact with learners, take into account the culture/background of participants (some do not ask questions, etc.).
- important to set a common language
- mainly teaching face to face but started online, a bit hard when explaining theoritical concepts, no particular problems with language (same country)
- Teaching online may not be too challenging if you are used to work virtually
- Learn of each other mistakes
- Be careful with jargon
- Define what you mean by students, participants, learners, listeners
- Explain that you expect participation
- Get prior information (before the workshop such pre-survey workshop, when participant registers) about the participants
- Break down the barrier between experts and participants
- Online: harder to keep the connection, feedback, difficult to network. Less personal interaction. Learn to use the chat.


### Room 2

- speaking with a single individual, walking through questions, solving a problem (30 minutes 1-1 sessions)
- not only giving answers, but also "teach them how to fish"
- hands-on and breakout rooms and 1-1 tutoring appreciated also in online environment
- prepared material in advance is important for students
- students are happy when the environment is working and set up
- managing background knowledge can be tricky (some students have computing background but no application background)
- hands-on demonstration (e.g. numerical methods using Jupyter notebooks)
- create small exercise groups if possible, even in larger courses
- "backwards design": working backwards from learning goals and learner personas
- picking good/convincing/relatable/relevant examples can be difficult, especially for training across disciplines
- bring your own data/code/visualization
- consider letting participants choose between a set of examples
- workshops plan for group sessions with tutors


### Room 3
- Teaching (theoretical) vs training (much more practical)
- A course to me is like I am showing someone how to do something at my desk, but at a larger scale.  So very interactive
- A lot of questions abotu scalability
  - How to deal with things like language? Easier to ignore than address
- CodeRefinery has strategies to scale: HackMD, breakout rooms, 
- Transitioning to online learning
- Picking up content from other providers
- Helpers
  - Register people as a group, get helpers from the group (like the guy in the group who knows Git)
- Code vs slides
- 

### Follow-up discussion

(copied question from voice to notes:)

Should HPC (resources, training material) be for "everybody"?


## Break
Until xx:02


## Group work: Top issues new instructors face
until xx:25


 Discussion/group work: Top issues new instructors face (Sabry)
(e.g. Focus on pitfalls, tools, assessment)


### Room 1
 - 
 - never leave a new instructor on its own. New instructors should always be "buddied" and "coached" by experienced instructors
 - do not dedicate enough time for teaching: time spend to learn the content of the training and learn to deliver is limited; and then it can be difficult to answer to a question
 - The course does not clearly state what you will learn and what the course will not learn
 - check the level of the future participants and clarify prerequisites
 - How to choose the tools to teach online and also how to use the tools
 - Show a terminal (live coding) so participants can see command lines but forgot to show the concept 
 - problems to manage expectations
 - new instructors may be expert but not know how to engage with participants, adapt the pace, manage your time
 - internet connections
 - Environment: have a proper chair, proper light, etc.


### Room 2
- give instructions and not following them myself
- showing too much, running out of time
- too specific examples in a specific expertise, not relevant to learners
- material not readable
- too many things/channels to follow
- we need to carefully choose tools to use in online teaching
- as a participant it can be scary or unusual to ask questions so doubts/questions are never addressed; a good instructor should create a safe space to encourage students to ask questions (also creating more homogeneous group can help)
- at the subscription step one should ask the level and figure out how familiar they are, not only with codes but more specifically about exercises and levels
- new instructor may not anticipate problems (time management)
- when reusing existing material it can be difficult to decide between reusing/contributing/rewriting when bringing in own ideas and views
- what tools are others using for participatory sketch tools for online teaching?
  - https://sketchboard.io/
  - an actual white-board video-taped
  - S.R.'s amazing plexiglass board
- having a very different OS/terminal environment compared to learners
  - how to solve this?


### Room 3
- pacing and expert blind spot, instructor rushes ahead and everyone is left behind
- Can you space out online training courses to give them more time to do things?
- You can reach more people when you go online, but other challenges
- When you don't see or hear any feedback, it is difficult.  When normally learning teaching, you are taught things like body language, etc.
- Would be good to have some tricks to get people to interact in an online workshop.
- Differences in software environment, or even having to install software yourself.  How can you give the environment to the students?
- Access to infrastructure is hard
  - Need access to one machine but you have site policies that make this hard
  - Prerequisite skills needed (things like ssh-keys)
- Takes a very long time to get started with your very first "hello world" example since there are so many different things that can go wrong.
    - provide the students with a working starting point, and course is then modifying it
- Do people even still learn basics like C and fortran in undergraduate courses? These languages appear frequently in examples.


## Interactive teaching style
https://coderefinery.github.io/instructor-training/03-teaching-style/

- What happens when learners don't have the prerequisites?
  - We have found it useful to schedule a semi-mandatory preparation session few days before the workshop where learners need to briefly demonstrate that the prerequistes are installed and working.
  - Alternative is to reserve a breakout room and send the learner with a helper into the room to debug/install. But the risk here is to disconnect the learner from the rest of the workshop for few minutes. So sometimes we recommend to follow-along and watch it as demo and debug during break or after the session.
    - Practical advice (which we sometimes forget): when you schedule a training event, schedule (and place in your calendar) also the onboarding session
  - The helper can also help the learner catch up
  - Every email emphasises the software installation!  Plus we have some links to videos/shell crash course.  But that can only help a certain kind of thing...
  - Be clear at the beginning of the workshop. To respect all the participants, you sometimes need to clearly state that you will not accept if some prerequisites are not met.
  - 
  - 
- This "start with what you expect the learner to be able to do at the end" seems obvious, but was quite a useful development for me - made things much faster to develop lessons, and them higher quality.
  - also less bias and more relevance; more about this later today
  - Definitely agree. This also makes it easier to align exercises with the content and learner outcomes.


## Break
:::danger
until xx:10
:::

I am sharing this to demonstrate what we normally do during our major workshops - you always need to present important stuff like this multiple ways.

HPC certification 
https://www.hpc-certification.org/


## Online teaching strategies
https://coderefinery.github.io/instructor-training/teaching-strategies/

- S1
  - good
      - good only if learners have two screens
      - Can force the learner to not see any other material (or make impractical)
  - bad:
    - some learners may not have a wide screen to follow what's going on
    - Learners see everything instructor sees, no room for extra material
- S2
  - good: 
     - allows participants to use the other half of their screen for tabs/terminal
  - bad:
    - too small font when viewed in zoom without resizing zoom window
    - unsure how great the recording looks on youtube
    - too vertical, commands will disappear quickly
- S3
  - good: 
    - Similar to learners window
  - bad:
      - sidebar should perhaps be minimised to focus on the notebook
    - a lot of screen real estate lost on non-relevant stuff 
- S4
  - good: good for the history of the commands, but learners can be distracted by the outcome of the instructor
  - bad: way too much real estate on command line wasted by irrelevant junk
- Student layouts:
  - ...
- Instructor layouts:
  - ...


- Team teaching
  - One person talking, one person writing in the terminal
  - Good for making things interesting (have a dialogue going)
    - indeed! it can be nicer to listen to different voices and also different opinions 
  - May work well in an online environment

- History-sharing tools
  - https://shellshare.net exports the entire shell


### Teaching feedback: git bisect

Give each other constructive verbal feedback on the teaching demos, for example using this [demo rubric](https://carpentries.github.io/instructor-training/demos_rubric/).

- Content
    - good:
      - Explain the goal and give the context of the demo
      - purpose of example code that we are bisecting is relatively simple
      - understood what it did at the end!
      - good amount for 5 mins
   - bad:
      - "bisection algorithm" may be unfamiliar
      - Bisect good and bad not explained
      - it may show too many stuff on the screen

- Presentation
    - good:
      - apologise for unexpected problem that you cannot control
      - pace is good
      - good meta-talk
      - Show the exercise as a demo (before participants try it out)
      - good summary at the end
    - bad:
      - history tab was behind zoom controls
      - font is a little hard to read (I have an HD screen)
      - make sure your cat (or anything else!) does not disturb you!
      - using a shortcut (`cr:`) when git cloning, if learners try this, it will not work
      - prompt is super long (and has info a normal user wouldn't have)
      - 
      - Cat interupted the lesson
      - shortcuts and aliases

### Exercise session
https://coderefinery.github.io/instructor-training/teaching-strategies/#shell-sharing
Set up your screen share for tomorrow and get feedback on it.
- Set up screen share and terminal layout.  Get feedback from others
- Getting a shell history working may be more than you have time for.  See what you can do!


## Break
Until xx:10



## Lesson design
https://coderefinery.github.io/instructor-training/lesson-design/

How do you (re)design lessons?
- not quite backwards design, but by always starting with "what should my audience be able to do at the end?" - and build to that.
    - I also use 3 as the magic number: what are three things that a learner should be able to do / remember.  
- ask colleagues/collaborators to help me to find the learning objectives
- +1 for revealing biases in existing lessons...

Exercise until xx:50 (we will check how it is going and perhaps give 5 mins more)


### Room 1
status: do you need more time than xx:50?

1. Introduction to high-performance computing
2. Audience: 
    - someone who has low level of understanding of HPC, but they have some knowledge
    - Understand why they would need to use HPC but have no experience yet
--> people ending their Master and/or during their PhD and in need of using HPC
--> can be someone working in a startup/SMEs
--> data scientist with data challenges (SMEs)
3. Learner personas:
    - Data analyst from SME: Sarah has a commercial code, she needs to perform certain actions with HPC, e.g. accessing data, accessing software (compilers, how to get installed their software, how to run (batch system), how to use the HPC environment (bash shell))

4. Learning outcomes:
    - Understand how to login
    - Understand how to transfer data in and out 

### Room 2
status: we are ok closing xx:50
1. Topic: plotting with matplotlib (half-day course; or any Python library)
2. Audience
  - starting researchers
  - students
  - undergraduate intern students
3. Learning outcomes
  - know what matplotlib is
  - be able to install python/jupyter and matplotlib
  - be able to read in data in a suitable way for data visualization
  - know about file formats
  - be able to create different type of graph, eg. pie chart, bar chart and etc.
  - be familiar with different visualization approaches, be able to find examples in galleries, and apply them to own data
  - understand figure objects and axes objects and know how to change them
  - know how to export/save/show the figures objects
  - know where to look up possible customizations
5. Exercises
  - create a basic plot with default settings
  - Add axis labels to it
  - Label the data
  - Plot cosine, sine
  - Multiple data in single plot


### Room 3
status: do you need more time than xx:50?
1. Shell crash course for new users of HPC.
2. Audience
   -  New users on the system
       -  Choose to be there
   -  They may have some familiarity with the terminal, since they had to apply to get access.
   -  Someone who has used Windows but not Linux
   -  PhD who has been told to use the resources of their supervisor
3. Learner personas
   - Researcher who has started to use ML for analysis but they don't have access to a recent GPU. They've heard that there are lot's of GPUs on their national resource so they want to go off and use those. All their experience is using Jupyter notebooks.
   - New PhD students in biosciences, mostly Windows/Mac users with no command line experience.
   - X is a postdoc in management science who has been using Jupyter extensively on their own computer.  They are pretty good at doing computations interactively, so they know Python and R well, but the idea of making a batch script and waiting for the answer is completely new.  They would rather not have to deal with this shell stuff, but realize they need to eventually.  They use a Mac computer, so have at least seen a terminal before but haven't used it much.

4. Learning outcomes 
    - Understand basic operation system concepts, and using command lines for various functions.
    - Understand difference beteween HPC and his/her laptop, local/remote resources
    - Understand basic HPC architecture, nodes, cores, clusters.
    - ssh logins
    - how to access an editor and use it
    - Write a Slurm script and submit it
    - 

### discussion
- Here, we have "learning objectives" but manuals call that step "summative assessments".  What is current best practice/name?
    - Also, I tend to get mixed up between summative and formative assessments.  I know the theory of why they are different, but 


## Feedback

- one thing you like:
    - perfectly on time with each single session, inclusivity and kindness
    - thinking about how to lay out the screen for online lectures
    - promoting practical exercises, hands-on is very good to keep people engaged
- one thing to improve:
    - Try to make sure (as much as possible), that all participants in the breakout rooms are given the space to contribute
      - thank you, we need tomorrow to better level this. I also had this impression. 
    - You might want to take a look at gender balance in the courses
      - thank you. this is really something we need to improve. we are trying but we need to try better. 





## Collaborative lesson development
https://coderefinery.github.io/instructor-training/lesson-development/


### Discussion: collaboration:

- What advantages do you see in developing lessons collaboratively and sharing lessons (making material accessible)?
    - .
    - .
    - .
- What difficulties are there?
    - .
    - .
    - .

What are your best practices in lesson development?


- How I built Jekyll page locally on my computer, using Docker:
  - `$ docker run -it --rm -v "$PWD":/usr/src/app -p "4000:4000" starefossen/github-pages`

- Hi. I am not totally sure about what the goal of this part of the course. Is it to observe how we can modify the text, in a collaborative document? 
    - We promote a Github based workflow for developing lessons.  GitHub provides a collaboration workflow, which can work well.  This is very brief demo of the process.
    - 

- What is SORSE?: https://sorse.github.io/faq/about/what-is-sorse

## Teaching demo

- Content
    - good
        - starts with big picture diagram
        - Takes learners background into account
        - showed an error
        - 
    - suggestions to improve
        - used his username but did not warn that we should adapt this to our username
        - are there other ways to do this?
        - highlight how the prompt has changed
- Presentation
    - good
        - arranged windows for readability
        - explaining every typed command
    - suggestions to improve
        - making fun of windows users
        - Resized the text in the terminal to be a bit small
        - discuss a bit all the text we see after login
        - conclude by saying when you would use this (but yes, time was up)

## Break

Break until xx:02


- How to manage expectations? Balancing material that is not too difficult for novices but not too boring/obvious for those more advanced in this topic?
    - Some learners may also underestimate themselves. If somebody "knows everything" and seems bored, one can offer optional exercises or involve them as helper to help others.
    - Advanced material, clearly labeled "optional"
    - Spending a lot of time thinking about learner personas, and writing them down.  This worked for one of our courses.

- The DOI seems to be for the sources used to build a lesson intended for other instructors, and not an actual lesson itself in a form that a learner would wish to refer to.
    - when using github+zenodo in combination with jekyll (like HPC carpentry does), indeed this would refer to the sources. but I think it's still usable. Just to have something to refer to.
    - Alternatively one could generate pdf (or some other form) from the sources and upload the pdf and get a DOI for that.
    - But I think the key is to have something to refer to which can be measured for metrics (number of citations)

## Teaching demos

### Copyable rubric
- Content
    - Good
        - 
    - suggestions to improve
        - 
- Presentation
    - Good
        - 
    - suggestions to improve
        - 

### Room 1

- Example 1:
- Content
    - Good
        - Explained the context at the beginning
        - the program had good window use, didn't flip between windows a lot
        - Seems matched to the audience
    - suggestions to improve
        - I missed a part about when it would be used
        - I had to infer to how 
- Presentation
    - Good
        - 
        - He asked if the participants were comfortable with the screen size
        - He explained what we were seeing on the screen
        - mouse pointer highlight app
    - suggestions to improve
        - Maybe a bit slower, so participants have time to ask about something before we move to another thing
        - 

- Example 2:
- Content
    - Good
        - clearly said what topic was
        - explained the key points of the diagram
        - 
    - suggestions to improve
        - 
- Presentation
    - Good
        - pasting link to chat
        - 
    - suggestions to improve
        - what's blast?  perhaps repeat in case someone forgot
        - clicking back button quickly, could verbalize that

- Example 3:
- Content
    - Good
        - explained what the prupose was at the stop
        - showed examples about what things you can check in a dataset
    - suggestions to improve
        - what does this syntax mean?  Though, probabyl covered in previous lessons
- Presentation
    - Good
        - shows mistake and how to fix it
        - The blue color for previously-entered commands is great
    - suggestions to improve
        - 



### Room 2

- Example 1: Running LAMMPS job on an HPC systems
  - https://shellshare.net/r/JC5jL0m35m2pZfTxRi
- Prereqs:
  - Already had an intro course on HPC but might be fresh knowledge
  - Learners know how to use LAMMPS
- Content
    - Good
      - set the context
      - very well connected to previous lessons
    - suggestions to improve
      - 
- Presentation
    - Good
      - started with checking readability
      - shellshare so that we can follow commands
      - shellshare is awesome!
      - speed
    - suggestions to improve
      - not sure whether we should watch or follow along (but perhaps it was mentioned)
      - avoid words "just"
      - few pixels on the sides of terminal were cut off
      - not sure: text is not syntax-highlighted, however I am not sure whether to change that since this would be different from learner environment

- Example 2: setting up cluster on laptop
- prereqs: installed libraries and linux term 
- Content
    - Good
      - motivation for why we look at this
    - suggestions to improve
      - what's root?
      - htop is nice but learners might not have it installed
      - processes (and why they are printed "nested") and daemons may be new to many
      - I am not sure what /bin/sleep does
        - why full path
- Presentation
    - Good
      - good readability
      - good speed
      - meta-talk
      - very "easy to listen to" style
    - suggestions to improve
      - Python shell is b/w, might be easier to follow with code highlighting in IPython shell or Jupyter
      - switching from python shell back to terminal was very fast
      - switching between the tabs can be difficult to know where we are and what is going on
      - watch out for jargon
      - making a mistake might be informative
      - show history of commands


### Room 3

Example 1: Thougths for master students on VMD
- Prereqs:
  - Some experience with terminal
  - VMD installed and able to open
- Outcomes
  - Open data from PDB
  - Visualize the data 
- Content
    - Good
      - Showing the actual site for finding the data
    - suggestions to improve
      - Start by telling what you will do and why (also when people already know the basics)
- Presentation
    - Good
      - Talking clearly through while demonstratin
      - Good pace, not too fast
    - suggestions to improve
      - A lot of things on the site at once (but how to improve)
      - VMD display window covers the commands


Example 2: Gnuplot on an HPC system
- Prereqs: 
  - Knowing what is Gnuplot
  - a bit of shell
  - submitting jobs
- Outcomes: 
  - able to visualize data without copying files
- Content
  - Good
    - Showed why first and explained what will happen
  - suggestions to improve
    - Not clear how compiling code is related to the outcomes
    - More developed examples of gnuplot (Ran out of time)
- Presentation
  - Good
    - clear explanation of outputs
    - Pleasent, clear tone and good speed
  - suggestions to improve
    - Would be good to tell us what each command does and why you are typing it
    - Could have output files ready 


Example 3: Intro to HPC: module
- Prereqs: 
  - logged in to cluster
  - some shell
- Outcomes: 
  - know how to use module
- Content
  - Good
    - Clear explanation of what the lesson will be about
    - Clear description of the modules
  - suggestions to improve
    - Is it possible to explain the list of modules more quickly, in less detail
    - The suggested history of the used commands can be really useful in this case
    - Can be possible to say a bit more about the module-related commands (i.e.: how to search for one modules, how to search `half-nameed` modules,...)
- Presentation
  - Good
    - Good pace
    - Easy to concentrate since only one window is important
    - Not too many commands
  - suggestions to improve
    - Is the browser window necessary to show?
    - Connection problems. Recommend connecting with ethernet cable if normally using wifi.
    - 

## Break

Until xx:10


## Teaching exercise phase 2



### Room 1
Example 1
- Content
    - Good
        - clearly related to the previous material
        - said the audience expectations at the start
    - suggestions to improve
        - 
- Presentation
    - Good
        - shellshare, also explaining what it means
        - nice, large terminal
    - suggestions to improve
        - sounds became less audible partway through
Example 2
- Content
    - Good
        - easy to grasp
    - suggestions to improve
        - environment variables in the echo made things seem harder than they are
        - give an example of how to use the environment variables
- Presentation
    - Good
        - nice pace
    - suggestions to improve
        - highlighting the terminal made it hard to read
Example 3
- Content
    - Good
        - Different plotting was good
        - useful tools
    - suggestions to improve
        - 
- Presentation
    - Good
        - command line colour is different from rest of the text
    - suggestions to improve
        - bit more discussion of the commands
        - the shell window was a bit narrow, making it hard to read (fixed)
        - The font may be too small for some screens
        - a long command without any spaces is hard to read

### Room 2

Example 1:
- Prereqs: Master student, computational biophys, able to use different OSs, VMD installed
- Outcomes: be able to download protein data and visualize the protein in differt ways, quick render
- Content:
  - good:
    - motivation and context
    - connecting to prerequisites 
    - really nice to have a visual presentation and see the visual result
    - timing
  - to improve
    -    
- Presentation:
  - good
    - presentation speed
    - readability
  - to improve
    - should we watch the demo or follow along?
    - how to find the search in VMD, was a bit quick if we follow along
    - if we follow along, good to add few pauses when clicking
    - before you click an option, pause there
    - font on GUI a bit small (but this may be difficult to change)

Example 2: Tool for application profiles
- Context: toy example, demo (normally follow-along)
- Content:
  - good
    - context and motivation
  - to improve
    - 
- Presentation:
  - good
    - redability
    - also nice to see where the mouse/focus is
    - visual
    - timing
  - to improve
    - how do I see/find the interesting portions in the middle panel?
    - at times got a bit quick so perhaps few moments so that we can also visually verify the sums
    - maybe point out how a metric would look if it is good or bad
    - topological view: maybe walk us through what we are looking at


### Room 3

Example 1: Gnuplot on an HPC system
- Prereqs: 
  - Knowing what is Gnuplot
  - a bit of shell
  - submitting jobs
- Outcomes: 
  - able to visualize data without copying files
- Thing to improve:
  - More gnuplot related content, using preprepared data 
- Content
  - Good
    - demonstrating nice looking plots
    - scripting is good, improves reproducibility
    - describing potential problems is valuable
  - suggestions to improve
    - prepare by checking if the data you expect to show is there
      - although demonstrating workflow is also nice
    - What do each of the gnuplot commands mean?
- Presentation
  - Good
    - Good pace again. Clear explanation of each step
    - Reminder that things are remote may be slow to get
  - suggestions to improve
    - the bottom of the terminal is off the bottom of the screen if the zoom bar is visible
    - give little bit of explaination of abbreviation of the commands


- Example 2: setting up cluster on laptop
- prereqs: installed libraries and linux term 
- improvements: reduce jumping between tabs and spend more time after commands
- Content
    - Good
      - Point out that syntax does not always make sense
        - Makes it lighter, you don't need to understand every little detail 
      - demon is fantastic
      - Showing ps and top was very useful 
    - suggestions to improve
      - Comment about breaking a cluster might be a bit personal for someone
      - Mention goal in beginning. What is this useful for.
      - it may help if you give details of ps, top commands in prereqs
- Presentation
    - Good
      - Large fonts, easy to read
      - pleasant presentation style
    - suggestions to improve
      - Cannot see the tabs, would be easier to follow if I did


Example 3: Intro to HPC: module
- Prereqs: 
  - logged in to cluster
  - some shell
- Outcomes: 
  - know how to use module
- Improvements:
  - Less detail on libraries, more module commands
- Content
  - Good
    - Tie in to previous session, great!
    - Good quick description of why we are doing this
    - Warning messages are useful
  - suggestions to improve
    - Maybe also show module help
    - Did you show module load? Also show how it affect module list.
- Presentation
  - Good
    - Very good pacing and explaining things as they come up on the screen
    - Good that you pointed out the warning, these can be scary to new users
  - suggestions to improve
    - A lot of detail, some might not be important for most learners


## Break

Until xx:10

## Online workshops
https://coderefinery.github.io/instructor-training/workshops-online/


In-person:
- It is easier to get people to interact in person.
- More personal interaction, more "trust" built with participants
- Easier to ses how it is going (whether participants are happy or unhappy, typing along or not)
- Straightforward to arrange group work
- one can move around while teaching

Online:
- cheaper in terms of travel
- easier to involve participants from different countries
- more environmentally friendly
- Can scale to larger groups
- need more staff, not only for instruction but also to prepare and help out
- screen fatigue

## Questions
- Was it a useful format and useful content? Please give us feedback.
    - .
    - .
    - .
- Should we collaborate on HPC Carpentry workshops?
    - .
    - .
    - .
- Who will end up teaching HPC Carpentry? What do you need from us/somebody as support?
    - Someone hired to support users of a local scale cluster
    - .
    - .


Next CR workshop: https://coderefinery.github.io/2020-11-17-online/



## Feedback for day 2

One thing that was good
- Getting feedback on the short practice session
- It was good to have several instructors to help and solve any possible issues fast
- I liked the summary of experience running online training events

One thing we should change/improve
- Would like some training on how to set up one of these workshop static pages from scratch: which software is needed, where to put the page, etc
- The lecture this morning looked a bit unprepared, like if it was not clear what we were going to do there
  - thanks. indeed we changed the plans 10 minutes before start and in hindsight I think we should not have done that.
- As someone who doesn't 'git', that section was not for me (or put me off)
