Learning Git Live
- The Workshops
- Teaching and Writing Highlights
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.
If you are interested in having me teach Git to your team, or you are interested in having me teach Git at your conference, please get in touch via email (emma at the domain name you are currently visiting), or through LinkedIn.
2015 Public Workshops
- January 24 - /dev/winter, Cambridge, UK - Git for Teams of One or More
- February 16 - 20 - ConFoo.ca, Montreal, Canada - A Rebasing Workflow
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.
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.
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.
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.
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.
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.
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:
Part 3: Uncovering and Recovering from Mistakes
- reviewing history (log, tags, bisect, blame)
- rollbacks and resets (reset, revert, checkout, experimental branches)
- work flow optimisation (rebase, rerere)
Part 4: Emergency Procedures
- hot fixes (branching strategies, using stash)
- troubleshooting lost work (reflog)
- merging very out of sync branches (cherry-pick)
Teaching and Writing Highlights
- Dealing with Emergencies in Git. article for 24 Ways (2014)
- Running Code Reviews with Confidence. article for A List Apart (2014)
- Git for Grown-ups. article for 24 Ways (2013)
- Work Flow for Developers and Small Teams (alt title: Git Makes Me Angry Inside). conference session presented at: php|tek (Chicago, 2013), DrupalCon (Prague, 2013), CMS Expo (Chicago, 2013), TwinCities DrupalCamp (Minneapolis, 2013), DrupalCamp Toronto (Toronto, 2013), LoneStar PHP (Dallas, 2014), BADCamp (San Francisco, 2013)
- Introduction to Vagrant. video lessons. Drupalize.Me (2014)
- Mastering Git for the Drupal Developer's Work Flow. workshop at DrupalCon Prague (2013)
- Work Flow for Solo Developers and Small Teams. online workshop (2012)
- Version Control for Mere Mortals. conference session presented at: OSCON (San Jose, 2009), SCaLE (Los Angeles, 2009), Ontario Linux Fest (Toronto, 2008), Haecksen Mini-Conf (Wellington, NZ, 2010)
- Bazaar vs. Git Smackdown. conference session presented at Open Source Bridge (2009)
- Internet Management Program. Humber College. Toronto, Canada (2004-05)
A full list of public presentations and workshops Emma has given is available from her personal web site.