Learning Git Live

Philosophy

Too many workshops are designed to teach hands-on commands in a way that isn't
directly applied to on-the-job tasks, leaving learners stuck on how to apply
the workshop. Instead of using a command-heavy, Git-based approach, my sessions
are designed to help learners to identify the kinds of problems they will
encounter. I emphasize critical thinking skills, and teach people how to create
maps which describe their own work flow. From these learner-created assets, I
show people how to map commands onto their own problem space. The skills people
learn in my sessions go far beyond what they could have learned from reading a
manual.

With a longer workshop, I then use the learner-driven approach to show people
which command gets applied at what stage of the process. I then extend the
examples the students have created to add lessons for edge case scenarios which
they have not yet anticipated.

The techniques people learn in my workshops extend well beyond Git. They can be
used to improve team communication, creating efficiencies in process; create
better documentation for smoother on-boarding of new team members; and develop
the confidence to tackle other software packages which previously seemed too
daunting to use.

I am not currently available to teach private workshops, but I am sometimes available for conference presentations. Please do get in touch via email (emma at the domain name you are currently visiting).

The Workshops

2015 Public Workshops

Available Workshops

Conference organisers: Approximate times are listed for each session and workshop. All one-hour
sessions can be adapted easily to fit into a 30-45 minute slot.

Git for Grown-Ups

Git For Grown-Ups has been delivered at several conferences including
DrupalCon Prague, and OSCON. It has also been converted to an article on 24
Ways. This session also sometimes goes by
the title Git Makes Me Angry Inside. It is a one-hour session.

Session Description

You are a clever and talented person. You have architected a system that even
my cat could use; your spreadsheet-fu is legendary. Your peers adore you. Your
clients love you. But, until now, you haven't &^#^! been able to make Git
work. It makes you angry inside that you have to ask for help, again, to figure
out that &^#^! command to upload your work.

It's not you. It's Git. Promise.

We'll kick off this session with an explanation of why Git is so freaking hard
to learn. Then we'll flip the tables and make YOU (not Git) the centre of
attention. You'll learn how to define, and sketch out how version control
works, using terms and scenarios that make sense to you. Yup, sketch. On paper.
(Tablets and other electronic devices will be allowed, as long as you promise
not to get distracted choosing the perfect shade for rage.) To this diagram
you'll layer on the common Git commands that are used regularly by efficient
Git-using teams. It'll be the ultimate cheat sheet, and specific to your job.
If you think this sounds complicated, it's not! Your fearless leader, Emma
Jane, has been successfully teaching people how-to-tech for over a decade. She
is well known for her non-technical metaphors which ease learners into complex,
work-related topics that previously felt inaccessible.

Yes, this is an introductory session. No, you don't have to have Git installed
to attend. You don't even need to know where the command line is on your
computer. Yes, you should attend if you've been embarrassed to ask team-mates
what Git command you used three weeks ago to upload your work...just in case
you're supposed to remember.

If you're a super-human Git fanatic who is frustrated by people who don't just
"git it", this session is also for you. You’ll learn new ways to effectively
communicate your ever-loving Git, and you may develop a deeper understanding of
why your previous attempts to explain Git have failed.

The Three Rs of Git: Rebase, Revert, and Reset

The Three Rs of Git is based on the very popular flow chart I made in 2014.
It includes an overview of where problematic code lands in the repository, and
how to get it "undone". This session can be delivered as a one-hour session; or
as a three-hour (half day) workshop with hands-on activities.

Session Description

You understand how to use Git, at least in principle. You can make commits, you
can share branches, it's all fine as long as nothing goes wrong. In this
session you will learn how to undo the most common mistakes with rebase, reset,
and revert so you can roll your repository forward to a working state. With
recovery methods out of the way, you'll then learn how to adjust your workflow
so that it's easier to back out of future mistakes....all without losing your
HEAD.

A Rebasing Workflow

In 2013 I wrote a very long rant about how much I hated Git. (Keep reading! It
gets better. I promise!) In the rant I decided the only way out of the
situation was to make it my personal mission to improve the experience others
have. And I LOVE this outcome from that rant. One of the biggest things I've
encountered is a fear of using the command rebase. I don't like rebase, but I
understand how and why to use it, and I think it's a great tool when applied in
the correct context. A Rebasing Workflow demystifies the command rebase, and
explains why and how it should be used. This session has been accepted to
ConFoo.ca in 2015. It can be delivered as a one-hour session; or as a 90 minute
tutorial.

Session Description

You've decided to level up your Git skills and have heard that rebasing is
where it's at. In this session we'll talk about: WHY rebasing can make it
easier to untangle your project's history; WHEN you should use rebase; WHAT
rebasing actually does to your repository; and HOW it actually looks when
things go right (and how to recover when things go wrong).

Git for Teams

Git for Teams of One or More is a half-day workshop which works well for
public workshops, and in-house teams. It has been taught popular open source
conferences including OSCON, and php|tek.

Workshop Description

You’ve dabbled a little in version control using Git. You know about commits
and pulls and branches. You may have even tried Git to rebase something once
(and remember getting kinda freaked out by the headless thing). You can follow
along with the various tutorials you’ve found online. But now you’ve been asked
to implement a work flow strategy for your company’s next project and you’re
not really sure how (or where) to start.

In this session you will work closely with long-time version control lover Emma
Jane Westby to create the perfect work flow strategy for each of your projects.
This is a process workshop designed to help you sort through the pros and cons
of different types of work flows. It is not just a tutorial on how to run Git
from the command line—it’s a workflow overhaul. Promise.

TUTORIAL REQUIREMENTS AND INSTRUCTIONS FOR ATTENDEES

People with a very limited knowledge of Git will do better in this
workshop.

Technical project managers, developers transitioning to management
positions, and developers looking to accept community
contributions for their projects will get the most out of this
session.

To get the most out of this session you should bring your favorite
diagramming tools (pencil and paper are perfect!).

If you want to test out the commands, you should also bring a
computer with Internet capabilities, and access to a remote
repository, such as GitHub or BitBucket.

Full-Day Workshop

This workshop is an extension of the public half-day workshop. For a one-day
workshop of up to 10 people, and assuming some comfort with technical topics, I
recommend the following hands-on lab work.

Agenda

Part 1: Getting Started

task analysis (list common tasks; people on teams; infrastructure)

local repository editing (setup, init, add, commit)

work flow intro (branch, checkout, merge)

examining work (log, gitk, diff)

working with remotes (local, origin, upstream)

Part 2: Collaboration

intro to work flow (sketch team work flow)

deployment strategies (tag, branching strategies)

collaboration intro (clone, pull, push)

integrating teamwork (merge)

resolving merge conflicts (mergetools)

If you have time / budget, I recommend extending the workshop as
follows: