Solidify Courses: The Git Experience

This course is a specialized course that will be run by experienced Git practitioners.

The course is team based, meaning the participants will be divided into groups that will work together on solving objectives, guided by the trainer(s). It can be run with between 5 and 20 people. Anything above 12 people will need 2 trainers.

The course is based on creating an understanding on how git works. Understanding helps you solve new problems. The exercises are not simple step-by-step guides, but actual problems you learn to solve.

The training will be be a mixture of theory, exercises and best practices, with very open minded and experienced trainer(s). We at Solidify are using Git as a central element in our work, and are fully committed to it. We are not only trainers, we are long time users and maintainers! The training you get comes from people who are using it actively every day!

Levels and sections

The course is level based and split into sections, each section having a fixed objective (or a fixed set), and bringing the participants up to a new level. The levels can be seen in the agenda for the course.

Customizable for in-house training

If the course is run as a company in-house training, we recommend a small up front meeting to establish their current level, and the company can then choose to either 1) skip that level, 2) take it just as theory and presentation or 3) fully.

If the company has a preference on certain tools and remote storages, the course can focus on those, and leave the others.

It is also possible for a company to request special sections to replace some others, to cover special issues the company have seen in their work. One optional section is a Q/A section, where the trainers and participants engage in a discussion around issues they have, and how to best resolve those.

We also recommend companies to include the section on organizing and maintaining a git based system, including best practices for this. This is a DevOps related section, and the people in the organisation that is responisble for the git system architecture of the company should partipate in this.

How is the course run

You learn best "by doing", so each sections starts with some theory, explaining the relevant principles and practices, and then moves on the hands-on exercises. There are two types of exercises, one code based, using C# for the most, and one text based, using markdown text files. Each team can decide by themselves what they choose. There is really no prerequisite to having any deep knowledge of either C# nor markdown, as the work that will be done is not deeply related to the language per se.

The exercises will start off relatively easy, and they we will add more challenging ones as we go, dependent upon which level we are in.

The different concepts and git terms are learned as you go along. When you read the agenda you will notice that the higher numbered sections are using git terms that may be unknown to you. Rest assured you will learn them as we go. During the course you can (given company in-house training) decide there and then if you want to go further with a specific part or replace with another.

For a company based course, we are also open to using any other language as the basis, as the course can easily be customized.

Also note that we don't seperate between simple concepts and advanced concepts. Git is inherently simple, but complex with respect to the many commands that exists. Some things can be harder to learn, but if you need that knowledge we will ensure you get it!

Theory and best practices

The introductionary part of the course includes some git history - how it came about and the principles it is based on, how it relates to other source controls, how it is designed and organized, and principles for how it works. It will also cover the different remote storage possibilities that exist, and the tools you can use to work with git.

This section can be extended [for in-company training] with a DevOps related introduction bringing up typical issues and practices that is useful for maintaining a git based system.

Each theory section will also include a "best practices" part, where recommended best practices will be discussed. Since this part is about different ways of doing something, we recommend the particpants to be active with questions and discussions around issues they see. We will timelimit this, so that this does not take up too much time.

Go to the Git Experience Agenda

solidify/Course_Git

ErrorLooks like something went wrong!

About

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Contributors 2

Error
Looks like something went wrong!

Packages