Category: Onboarding Strategies (Page 2 of 2)

Its Purpose?
Tech huddles give people an opportunity to reflect on their learnings, and helps to shift those lessons learned from one person to the rest of the group in a time-efficient manner.

Photo taken from Water Lemon’s photostream on Flickr under the Creative Commons license

How Did We Execute It?
Thanks to the idea initially proposed by Behaviour Driven Dan North, we spent about half an hour at the end of the day almost every other day where we would talk about the following topics:

• Any learnings from the day to share with the wider group including IDE tricks, Environment tips, cool patterns, nice bits of the code, any patterns that have been particularly useful at solving something;
• Warnings that may be useful for the other developers (such as watch out for this class – it’s particularly nasty); and
• Any questions or puzzles people may have that they haven’t been had answered through out the day

Why Is It Important?
Learning is an essential part of coming on to a new project. Setting aside time to explicitly think about what people have learned gives them a bit of chance to reflect on their learnings and then by expressing it, helps reinforce those learnings. A beneficial side effect is that more knowledge is transferred within the team that would be very slow to do via other mechanisms such as just pair programming.

Tech Huddles also give a chance for people to gain more context about why something is strange, or doesn’t understand the way that something is done, or the way that something works.

Its Purpose?
Breaking down complex or larger blocks of work into very small, defined tasks helps people focus on learning one thing at a time. Each item should be as small as possible, with enough detail that the newbie either doesn’t need to ask someone how to complete it, or wouldn’t take them long to find out. Each task completed helps people celebrate small successes, and helps them make progress without being completely overwhelmed.

Photo taken from Controvento’s photostream on Flickr under the Creative Commons license

How did we execute it?
Our story cards are written on index cards, and before starting development we would discuss the requirements with our Business Analyst and Quality Assurance person. For each block of work, an experienced person would write down each task that might be needed to complete that block of work. Each tiny task would be as granular as possible and we wrote each on to a separate sticky note. We strung them together and put them on top of the story card on our wall.

A tiny task must be as simple and as clear as possible such as “New DB column to table X”, “Property to domain object”, “Modify Hibernate Mapping File” or “Refactor XXX domain object” with certain assumptions already being clear (i.e. each code task would have a test).

Tiny task lists can and will change, with our developers adding and removing more tiny tasks as they discovered more detail. Small to-do tasks found during development also ended up being written out as tiny tasks to be addressed at a later point. We would encourage developers checking in for each tiny task as much as possible although in reality this ended up being a small handful of tiny tasks (i.e. 3 or 4).

As people became more accustomed to the patterns in the system, and the things that might be needed to implement a small group of functionality, developers wrote tiny tasks less and less.

Why Is It Important?
People need successes to learn, and a safety net when they fail. Clear and easily achievable tasks help people build their confidence, either giving them a feel for how quickly they are progressing, or giving them a basis to talk over where gaps in their knowledge may be. Tiny tasks also give a certain amount of independence as some people learn certain things only by doing them themselves and either succeeding or failing.

Its Purpose?
To help people understand what parts of the system have excessive code-smells and need either refactoring or redesign.

How did we execute it?

1. Maintain a list of the technical debt – We have a list of all the technical debt in the system on our wiki. As a team, we identify parts of the system we want to address as a whole and discussed different strategies for implementing it. Some of the debt stays on there until we all agree on a common approach, although we try to remove as much of it as we can, especially if they are small things
2. Walkthrough the list with new people – We sat down and expressed our concerns by walking through the list and explaining perhaps how it came about and what effects each item on the list have.

Photo taken from Jekemp’s photostream on Flickr under the Creative Commons license

Why Is It Important?
All big projects have some part of the system that doesn’t seem particularly right. Given commercial time constraints, you never have the time to address all the issues to make every single bit of the code perfect. It’s better to keep people aware of these compromises so you address them when you have time.

From experience, I’ve also found it’s very easy for new people to projects to criticise parts of the code that obviously aren’t ideal. It’s a very healthy process having new eyes on the material to bring a different point of view and offer different approaches, although there are better ways they can express their concern without making incumbent developers feel criticised.

Providing the opportunity to openly discuss all areas of the system the team would like to collectively improve each of them has been an effective way at meeting all of these goals.

Photo taken from Radiospike’s photostream under Creative Commons.

Its Purpose?
Visible Architecture helps new team members form a common understanding about how the patterns and constructs in the system interact. It helps them to identify clearer boundaries of responsibility that should not be crossed. It may describe external or internal systems or devices the application may interact with and how they relate to the system. It may also help them understand how the application is deployed and configured.

How Did We Execute It?
We actually ran two sessions to complete this – one ended up describing the physical architecture and how it gets deployed. The other ended up describing the software architecture and focused on the patterns in the system.

For the physical architecture diagram, we drew on sheets of flip chart paper a box for each machine in one colour, then each executing application in another colour on the machines. We also drew circles around the boxes grouping them and gave them a physical name since the servers are grouped together but each group is distributed around the world. Each unique executable was given a code to which we drew a legend on the side to give them a name. We ended up with nine unique executables (it’s the most minimal set for our application requirements), though with many instances of these based on the redundancy needs and distributed nature of this application.

For the software architecture one we first drew onion ring layers of the systems, added labels to each of them and talked about which how the parts should interact and their dependencies. We applied this to the testing layers as well to demonstrate their dependencies on the onion rings that we just drew and their own set of onion rings. We also talked about the patterns in the system and in which layers you would find them.

Techniques Found Useful For Running It

• Flip chart or whiteboard – It was useful to be able to draw relationships between individual executables to show what parts really communicate with each other, and other ones that communicate or depend on a database.
• Colour codes – Given how busy our diagram got in the end, the colours helped people to easily identify what was what.
• Executable code names –Writing each executable name on every box would have taken a long time and made the diagram more confusing. It was more useful to give them a shorthand code such as XX01 or XX02 and to describe it on the side.
• Onion ring layers – Helped people solidify the boundaries to the system in their own heads.

Why Is It Important?
Architecture diagrams are popular for a big reason in many systems as they help people visualise the larger parts of the system. It forces people to take a broader look at the system and provides a better context for the smaller programming tasks. It helps them raise suspicions when one part of the system starts getting too tightly coupled to another as they can understand where the responsibilities lie.

I’ve found that ad-hoc and lo-fidelity diagrams are much more useful than using one built specifically in a single tool as anyone can adapt them there and then in front of everyone and it helps someone show questions they may not be able to ask.

Next Time I Might Try:

• Team Participation First – Getting team members to first draw up what they see as the patterns might help demonstrate where misunderstandings or gaps in knowledge lie and to have better idea of where to focus the discussions.

Photo taken from Sean Stayte’s photostream under Creative Commons.

Its Purpose?
Big Vision Business Problem helps team members form a common understanding of the problem they are trying to solve. It introduces them to a number of high level domain concepts and puts the work they will do into an overall context. The Big Vision Business Problem must be driven by a real Business Need.

How Did We Execute It?
The entire team sat down at the start of the project, and using a whiteboard, we started drawing people (represented as stick figures), systems (as boxes) and talked through a number of workflows. We incorporated both technical and non technical systems as we talked about the needs of the users, how the system satisfies or doesn’t satisfy those needs and how they interact. We kept mainly to the main “happy flow” or the “common walkflow” through the system because it is such a big system.

Techniques Found Useful For Running It

• Personas – We leverage personas a great deal during requirements gathering, and found this same technique helps new people grasp with the system for many of the same reasons. Giving a name to a person playing a role in the overall business problem is much easier to understand than simply labelling them with that role.
• Physical Diagrams – Talking over a set of boxes at a high level and seeing the users interact with each box helps give context to what is really going on.
• Whiteboard – Nice big diagrams are great, but simple lo-fi diagrams that you can edit in response to people’s questions and around discussions is much easier

Why Is It Important?
Putting people’s work into context is important for me, and by talking over the business problem as a team, helps people understand what it is they are contributing to. Technical solutions may seem strange and may appear clearer if people understand the business constraints. It also allows people to offer alternative solutions that might be more practical and less costly. I can imagine that if you are having difficulty expressing the business problem, perhaps there is no problem, or it needs to be simplified or clarified as people focus their energies on work that may not contribute to solving the same overall problem.

Next Time I Might Try:

• Taking and Showing Photos – Could be quite useful for showing people using the system
• Drawing a Timeline – Doing a simple walkthrough over a well spaced out timeline to discuss stages of an older system, and what the business would like to achieve in the future.

In the last month and a bit, I’ve been heads down starting with a new team on another release of an old project I worked on last year. Onboarding new members to a team or to a project is important to me – namely because I’ve been in positions where if it’s not done right makes people a less effective team member. Tight schedules and the overall lack of domain knowledge in new team members meant that successful or unsuccessful onboarding a huge influence on overall project success.

Perhaps it’s my emphasis on coaching, learning and sharing that means that my interest naturally gravitates towards onboarding activities. Just like well-run company inductions help new employees in their overall position, I feel project onboarding is important for setting the scene, establishing the role and efforts of new members. The last thing I wanted was for a bunch of really enthusiastic people to be pulling in separate directions. After talking with some people at the pub, I realised that the techniques I applied aren’t naturally that apparent to people, so I thought I’d write up about them, how we used them, how unsuccessful or unsuccessful they were and then what I’d change about them. In a way, these patterns are a combination of learning/teaching patterns that might be useful to someone (if so, I’d really like to know and please leave a comment!)

I’ll continue to categorise/tag each of these as “Onboarding Strategy” so it’s easy to find. Read on for the first one here.