Skip to content

Reflection Day 2

We ended up ahead of schedule, covering all from SDLC to and including assert.

I am very happy with the group dynamics: learners help each other.

The biggest hurdle of that day was getting version control to work. Here I coupled self-labelled experienced users with beginners. I made it clear why I wanted that to the group: to move on with the course.

What I disliked most:

  • sessions that were short
  • the waiting in the main room
  • my weak Feedback phase
  • limits on what I can do
  • the session on design in the schedule

What I want to change next time:

  • [ ] merge short sessions (i.e. 'Intro to' and first session) into one
  • [ ] add extra optional exercises for those who are fast (and let them stay in the breakout room, yet show they are done with the actual exercises)
  • [ ] explicitly prepare Feedback questions, which helps me actually do the Feedback
  • [ ] ask extra teachers, so I can rest a bit during the week
  • [ ] the session on design is a theoretical session. I followed the SDLC over the learners here. Instead, I should better follow the learners, where I feel practice and theory are best alternated.

I these would be a great next step, now that the new course structure has been confirmed to work well.

I've taken a look at the retrospect of this same day of previous course:

  • [/] Schedule issues and kanban board after working as a team
  • [x] Go through this reflection with the learners
  • [x] Make pairs that will help get the less confident learnes thrive

In this course:

  • I did not schedule issues, nor kanban board, and I think that was a good decision.
  • I did show the learners the Retrospect results
  • I did connect expert git users with git beginners, which worked great

Retrospect

What helped us learn

  • It was good
  • The discussions we had in the break out groups. I also think the exercises made us think and reflect about the topics in an interesting way.
  • The hands-on exercises
  • The break zoom with an expert helped me to learned a lot
  • The material, exercise and discussions with partners. Peer groups was very very helpful.
  • The interactions in the small groups helped a lot.
  • Short theoretical sessions, followed by short hands-on exercises.
  • Writing code in vscode. Hands on experience. Exercise descriptions and answer examples were more explicit and concrete. Good pace.
  • The documentation, the group exercises, the questions
  • Exercise sessions
  • The course was very didactic, and the interaction in group work helped me learn a lot.
  • People helping each other out
  • the material, and when the material was flawed or unclear, the the teacher clairifed. The most helpfull was the direct supervision by Lars on how to commit and sync in VS code
  • How interactive the course is. We are encourage all the time to discuss and collaborate between us
  • Practical exercises with VCS and Git. We had problems and then we solved them in pairs or with help of the teacher. It was very good to take the time to actually solve the conflicts. Deep discussions.
  • The short theory explanations before the paired sessions
  • The discussion in paired sessions
  • Discussions
  • The coding sessions in the breakout rooms were good. I liked the assert statements session, I like how it imported os for file reading because that's something we will use in our project for the class
  • Reading and trying the code by ourselves. Testing and then reading the answers you provided.
  • The slow pace of the course
  • Peer guidance
  • Using the expert learners made everything easier.
  • Be on time was great, so that the breaks are not missed and no time is wasted.
  • Clear course material
  • course material quite compact!
  • structure of the course and peer discussions
  • Having the teachers come around in the breakout rooms was helpful
  • Meeting others

What Held us back, what stopped us from learning

  • The examples not matching up with vs code

I need to check this.

  • Could not come up with any road blocks
  • Too little hands-on coding

I agree that there were too much theoretical/introduction sessions.

  • Going well
  • Time constraint and extensive exercise.

I interpret this as a learner that was slower than the majority, which can happen due to bad luck. I am unsure which exercise was so extensive...?

  • The afternoon sessions are harder due to the timing (after lunch, already tired).

Something I cannot fix.

  • Nothing, all good.
  • Mostly usure about time slot for the exercises because of accelerated schedule. Would be good to have some type of timer, or clear time frame.

I agree that a learner-centered approach such as ours guarantees fewer clear time frames. As the literature recommends learner-centered teaching, (I hope) we will stick to it and accept to not have a clear time frame.

  • too many breaks maybe

Humans need this amount of breaks. We will keep assuming we are human.

  • Some concepts were difficult at first because I am still getting familiar with Git and programming workflows.

Welcome to the course :-)

  • Waiting in the main room for others to finish

I agree and already made a TODO on this.

  • Too slow pace.

We follow the learners, which means the faster learners will suffer.

  • And too much discussion of what the students are guessing about the topic, while the correct answer was not discussed as much.

The Prior is known to be useful. I agree my Feedback is weak.

  • Nothing.
  • The main issues was the short time to go through all the exercises.

We follow the learners, which means the slower learners will suffer.

  • My own preparation

We are aware of this and we already have an idea.

  • I had to spend quite a long time to help another student who hadn't done the preparations before the course. It was ok to do but it took away a lot of time from my own learning.

I agree that it is a problem when a learner does not prepare. We are aware of this and we already have an idea.

  • Tiredness in the afternoon
  • The less structured nature of the afternoon hindered a bit.

I agree, this was more improvised.

  • Weird git errors in VSCode

I agree they pop up.

What can we do to improve, how can learning be improved

  • Maybe some more initial steps can be done in preparation for people who have not used git before

No. This is a prerequisite.

  • Not sure
  • Some exercises did not include answers

I agree. They should have.

  • A bit more lecture

I will consider this.

  • Maybe not so many exercise for the assert section. It was very re-iterating and good but maybe can be used for one's own pace instead of in the class.

The repetition was the point in the exercise: the first time, the learners have it wrong, so I ask them to do the (very similar) exercise 2. Still, I consider making more diverse exercises.

  • The afternoon session could be more structured.

I agree: it was last-minute created.

  • Some people might a bit shy with questions. I guess having a place where they can post anonymous questions, might be good for them. And then address those questions during the lessons or afterwards.

I agree that some people may be a bit shy with questions. I am unsure if we should accomodate for people that do not dare to ask questions in a as-safe-as-possible environment as this.

  • More specific information about time given/needed for exercises. Mark the most important part of the sections to be able faster move toward the exercises.

Hard to specify time for exercises when it is learner-centered. The first exercises are always the most important. The optional exercises are used for the faster learners to go deeper and the slower ones to catch up.

  • maybe explain polymorphism

I agree that this could be a topic in the course. As we did not even reach object oriented programming, I think it is the right thing to not have discussed polymorphism.

  • Learning could be improved with more guided practice time for Git, GitHub, and VS Code workflows

Hmmm, this was exactly the purpose of these exercises ...?

  • Probably the content of today could be learnt using much less than a whole day by having access to the material and using AI to help explain what I didn't, and then doing exercises together afterwards

Unsure. I am happy this learner found a way that works for him/her :-)

  • Maybe for the exercises of today's session the break room could have been with four-five students instead of pairs. There were more theoretical questions and more people could create a better discussion

Maybe. I will consider this.

  • Write some code in pairs and then swap so other people can read and compare.

This would help the Feedback phase. I will consider it.

  • Maybe, have 5-10 minutes to go through the exercise answers with the instructors would be a good idea to improve understanding.

I agree my Feedback is weakest.

  • perhaps some fore focus on merge conflicts and different ways of dealing with them. (perhaps it is outside of this course's scope though).

Show the many different ways on dealing with a merge conflict.

  • A longer lunch break

Hmmm. No.

  • More specific instructions when writing code (do it through vs code etc.)

This should have been part of IDE. Let's remind myself.

TODOs from retrospect

  • [ ] The examples must match with VS Code
  • [ ] Consider a bit more lecture
  • [ ] Consider making the assert exercises more diverse
  • [ ] Consider bigger group sizes for discussion questions
  • [ ] Consider to let the learners write some code in pairs and then swap so other people can read and compare
  • [ ] Show the many different ways on dealing with a merge conflict
  • [ ] add more specific instructions when writing code through VS Code in IDE session

Conclusion

  • The last-minute improvisation resulted in weaker course material
  • Learners struggle with learner-centered schedules
  • I need to improve my Feedback phase