πŸ§‘πŸΎβ€πŸ€β€πŸ§‘πŸΎ day-plan

✍🏽 Register

🎑 Morning orientation

Learning Objectives

Planning during the week

🧭 During the week, create a post on Slack and get some people to take on the roles of facilitator and timekeeper. Nominate new people each time.

πŸ‘£ Steps

If you haven’t done so already, choose someone (volunteer or trainee) to be the facilitator for this morning orientation block. Choose another to be the timekeeper.

πŸŽ™οΈ The Facilitator will:

  1. Assemble the entire group (all volunteers & all trainees) in a circle
  2. Briefly welcome everyone with an announcement, like this:

    πŸ’¬ “Morning everyone, Welcome to CYF {REGION}, this week we are working on {MODULE} {SPRINT} and we’re currently working on {SUMMARISE THE TOPICS OF THE WEEK}”

  3. Ask any newcomers to introduce themselves to the group, and welcome them.
  4. Now check: is it the start of a new module? Is it sprint 1? If so, read out the success criteria for the new module.
  5. Next go through the morning day plan only (typically on the curriculum website) - and check the following things:

Facilitator Checklist

  • Check the number of volunteers you have for the morning
  • Check someone is leading each session
  • Describe how any new activities works for the group
  • Decide how best to allocate trainees and volunteers for a given block - most blocks will make this clear

⏰ The Timekeeper will:

  • Announce the start of an activity and how long it will take (check everyone is listening)
  • Manage any whole class timers that are used in an activity
  • Give people a 10-minute wrap-up warning before the end of an activity
  • Announce the end of an activity and what happens next

πŸ”— Breaking down features workshop

Breaking down the quote generator

You should have already followed the prep to design, write, and deploy a quote generator.

We already broke down this project into steps. We’re going to talk about the techniques that helped us to do this breaking down. This will help you to break down projects yourself in the future.

Get into groups of about 5, with at least one volunteer per group.

Axes to break down by (20 minutes)

There are different ways we can break down a project. For instance:

  • We could write the whole frontend, then the whole backend (or the whole backend then the whole frontend).
  • We could build one entire feature in the frontend and backend, then another feature in the frontend and backend.
  • We could write down the whole API between the backend and frontend, and then build one, then the other.

There are other ways we could break down the project too.

Spend 3 minutes thinking of different ways you could break down a project.

Spend 10 minutes discussing all of your ideas (including the suggestions above) in your group. What advantages does each approach have? What disadvantages does each have?

Are the answers different depending on the number of people working on the project?

Are the answers different depending on whether you have specialists (e.g. one person who is specialised in frontend and one specialised in backend) vs generalists (people who can do a bit of everything)?

Can you think of ways to combine approaches, to get the advantages of different approaches?

Hints for volunteers

We’re generally trying to get towards:

  • Breaking down by feature is useful (proves out end-to-end design, provides incremental value, …).
  • Thinking about data / APIs can help us to develop components in parallel.
  • We can often interact with components in isolation for testing, e.g. curl testing against a backend, dummy backends for testing frontends, etc.

User journey mapping

Collecting features (5 minutes)

We often first break down projects by feature. We try to build entire end-to-end journeys for one thing a user can do at a time.

One example of a feature our quote generator has is “Add a quote”.

Spend 2 minutes thinking of as many features as you can for our quote generator. These don’t have to be things we have implemented, they can also be things we haven’t implemented yet. For instance, I can imagine after adding a quote, a user may want to share a link to that quote with someone - our server doesn’t support this right now (it only shows random quotes). But this is still a feature we can imagine.

In your group, make a list of all of the features you have thought of.

Some examples if you're really stuck
  • Displaying a quote on first load.
  • Displaying new quotes on demand.
  • Adding new quotes.
  • Seeing the quote you just added actually got added.
  • Sharing a link to a specific quote.
  • Displaying a new quote that is guaranteed not to have been show before.
  • Showing statistics about how often a quote has been displayed.
  • Up/down-voting quotes.
  • Finding quotes on similar themes.
  • Listing all of the quotes by a particular person.
  • Auto-grouping similar quote authors (e.g. “FDR” and “Franklin Roosevelt” are the same person).

Mapping features (20 minutes)

Pick three features and create user journey maps for them. Use the user journey mapping intro you read to help you - who wants to use each feature? What do they want to achieve? What steps would they need to achieve their goals? What would they experience on the way?

Making a plan

Unlocking parallelism and feedback (10 minutes)

When developing, we want to get feedback as quickly as we can. We don’t want to have to build a whole backend and a whole frontend and a whole database in order to see whether any one piece works.

It can be helpful to think about the interfaces between these components before building them. Asking questions like:

  • For each operation, what data will we need to pass from the frontend to the backend?
  • For each operation, what data will we need to pass from the backend to the frontend?

In our quote generator, this may mean asking questions like:

  • What information does the frontend need from the backend in order to display a quote? (The answer here may be: An object containing two fields - the quote as a string, and the author as a string).
  • What information does the frontend need to give the backend to save a quote?
  • What information does the frontend need to give the backend in order to get a specific quote? (This question may suggest we need some kind of ID for each quote, which we can put in a URL, but don’t show to the user in the page).
  • What information does the frontend need to give the backend if it wants to guarantee the next quote it shows hasn’t been shown to this user before?

For each of the three features your have mapped, write down what information needs to be sent between which components in order to perform an action. Be specific. Include names and types of each field.

Agreeing on data formats and APIs

Now that we know what data we need to pass where, we can come up with the APIs we need to build. This can happen at multiple levels, e.g. you can decide:

  • The backend APIs your frontend will call (and what the requests and responses will look like).
  • The function one part of your frontend will call to to generate a component for some data.
  • The frontend URLs that a user can visit to interact with the application, and what they will do.
  • And more.

By agreeing on these things, we can start building them in parallel - one person can be working on one side of the API (like the backend endpoint, or a function) while another works on the code that will call it.

Using dummy data

We can even use fake versions of these APIs with dummy data.

One of our user journeys is “When I load the page, a quote is displayed”. Some ways we can develop this without having a whole backend:

  • We can write the frontend code to display a quote with one hard-coded quote.
  • We can write a fetchQuote function in the frontend which doesn’t call a backend but instead always returns one quote in the data format we’ve agreed.
  • We can fetch a quote, but write a small backend where the “get quote” endpoint always returns one quote (while someone makes the backend do something more complicated like choose a random quote).

These are all ways we can develop and test our frontend before completing the whole system. Agreeing on a data format, and APIs, makes it easier for us to do this.

Making a plan (30 minutes)

For each of the three user journey maps you’ve created, make a plan for how you could break these down and implement them.

You should work out the data formats, work out the APIs, and work out how different people could be working on different parts of the implementation at the same time.

Write down tickets for each task that contain enough information that someone could pick up the ticket and work on it. Make sure to identify which tickets depend on which other tickets (i.e. which ones need to be done before each other).

πŸ«– Morning Break

A quick break of fifteen minutes so we can all concentrate on the next piece of work.

πŸ›— Study Group

Learning Objectives

What are we doing now?

You’re going to use this time to work through coursework. Your cohort will collectively self-organise to work through the coursework together in your own way. Sort yourselves into groups that work for you.

Use this time wisely

You will have study time in almost every class day. Don’t waste it. Use it to:

  • work through the coursework
  • ask questions and get unblocked
  • give and receive code review
  • work on your portfolio
  • develop your own projects

🎲 Games, rules, logic, and strategy

We have some favourite games you can play if you are stuck.

  1. Traffic Jam: re-order the cars to unblock yourself
  2. Telephone: draw the words and write the pictures
  3. Set: a game of visual perception
  4. Mastermind: a game of deduction
  5. Sudoku: a game of logic
  6. Mancala: a game of strategy

🍽️ Community Lunch

Every Saturday we cook and eat together. We share our food and our stories. We learn about each other and the world. We build community.

This is everyone’s responsibility, so help with what is needed to make this happen, for example, organising the food, setting up the table, washing up, tidying up, etc. You can do something different every week. You don’t need to be constantly responsible for the same task.

🎀 Demo

At CYF we expect you to demo your work to the class. You must have many opportunities to practice how to clearly and simply explain your work to others. This is really important both for interviews and for getting promoted later on.

⏰ Timekeeper

The timekeeper will keep the groups on track.

Split randomly into groups of no more than 5 people. Each person will have 2 minutes to demo their work to the group. After the demo, the group will give feedback for 5 minutes. Then the next person will demo their work.

πŸ§‘πŸΌβ€πŸŽ“ Trainees

1. Demo

You will demo your work to the group. You will have 2 minutes to explain what you did and why. It’s ok to show broken code or code that doesn’t work yet. Just make sure your demo is interesting.

2. Feedback

After the demo, the group will give you feedback for up to 5 minutes. It’s smart to suggest what kind of feedback you want by asking some “generative” questions. For example:

  • I wasn’t sure if it makes sense to try X. What do you think?
  • I liked the way I did X, but I know there are other approaches, what did you do?
  • I found X really confusing, did anyone else have the same problem?
  • I wasn’t sure if I explained what an X was very clearly, how could I have explained it better?

πŸ’‘ Tips:

  • Practice your demo before class.
  • Keep it simple. Don’t try to show everything you did. Just show one interesting thing.
  • Keep it short. Two minutes is enough.
  • Explain what you did and why.
  • Show your code.
  • Ask for feedback.

πŸ›— Study Group

Learning Objectives

What are we doing now?

You’re going to use this time to work through coursework. Your cohort will collectively self-organise to work through the coursework together in your own way. Sort yourselves into groups that work for you.

Use this time wisely

You will have study time in almost every class day. Don’t waste it. Use it to:

  • work through the coursework
  • ask questions and get unblocked
  • give and receive code review
  • work on your portfolio
  • develop your own projects

πŸ›ŽοΈ 0 PRs available. Open some pull requests! πŸ”—

πŸ«– Afternoon Break

Please feel comfortable and welcome to pray at this time if this is part of your religion.

If you are breastfeeding and would like a private space, please let us know.

πŸ›— Study Group

Learning Objectives

What are we doing now?

You’re going to use this time to work through coursework. Your cohort will collectively self-organise to work through the coursework together in your own way. Sort yourselves into groups that work for you.

Use this time wisely

You will have study time in almost every class day. Don’t waste it. Use it to:

  • work through the coursework
  • ask questions and get unblocked
  • give and receive code review
  • work on your portfolio
  • develop your own projects

πŸ”„ Retro: Start / Stop / Continue

πŸ•ΉοΈRetro (20 minutes)

A retro is a chance to reflect. You can do this on RetroTool (create a free anonymous retro and share the link with the class) or on sticky notes on a wall.

  1. Set a timer for 5 minutes. There’s one on the RetroTool too.
  2. Write down as many things as you can think of that you’d like to start, stop, and continue doing next sprint.
  3. Write one point per note and keep it short.
  4. When the timer goes off, one person should set a timer for 1 minute and group the notes into themes.
  5. Next, set a timer for 2 minutes and all vote on the most important themes by adding a dot or a +1 to the note.
  6. Finally, set a timer for 8 minutes and all discuss the top three themes.