Using Git Effectively Course

Git is powerful, but it’s also intimidating. Whether you’re coming from SVN, starting fresh, or already using Git but still feeling unsure, this course removes the confusion. We clearly explain what Git is (and what it isn’t), how it differs from GitHub and GitLab, and why Git works the way it does. You’ll move beyond memorizing commands to truly understanding how Git thinks so when something goes wrong, you know how to fix it instead of making it worse with random copy-and-paste solutions from the internet.

This course is hands-on and practical. You’ll get set up correctly from the beginning, learn the essential terminology and commands, and practice real workflows that mirror everyday development. Special attention is given to the unique challenges of LabVIEW development and how to use Git effectively in that environment. You’ll learn proven collaboration patterns, how to manage multiple versions safely, and how to recover lost work—even when you’re sure it’s gone. Advanced tools and techniques for data recovery and bug hunting are introduced so you can confidently diagnose problems in any version of your codebase.

By the end of this course, you will be able to:

  • Develop a deep, practical understanding of Git and its best practices

  • Confidently track down bugs in current and past versions of your code

  • Collaborate smoothly without stepping on your colleague’s work

  • Manage multiple versions and maintain older releases with ease

  • Recover lost or misplaced code and reduce the risk of damaging changes

  • Spend less time debugging Git issues and more time building features

With lifetime access, this course becomes a long-term reference you can return to whenever Git feels overwhelming. Instead of fearing mistakes, you’ll know how to recover from them calmly, quickly, and confidently.

Purchase Course

FAQs

What is this course?

1

This hands-on course explains what Git really is, how to recover mistakes, manage versions, collaborate safely, and handle LabVIEW’s unique challenges so you spend less time fixing Git and more time building.

Who is it for?

2

Literally every LabVIEW engineer. You should be using source code control!

What will you learn?

3

Installing Git, Git As A Time Machine, Git As A Collaboration Tool

Prerequisites?

4

None

Syllabus

    1. About this course

    2. Quick Intro Survey

    3. Why Source Code Control?

    4. What Are The Basic Moving Parts?

    5. Introducing The Commit Graph

    6. Git vs SVN

    7. Quiz: Intro Review

    1. Intro

    2. Installation Options

    3. Installing Git For Windows

    4. Installing SourceTree

    5. Setting Up LVCompare and LVMerge

    6. Configuring Git

    7. Installation Survey

    8. Zombies!

    1. Intro

    2. Note of Caution

    3. CLI Intro

    4. Exercise: Creating Aliases

    5. Solution: Creating Aliases

    6. CLI Intro Part 2

    7. Exercise: Explore CLI

    8. Hints for Exploring the CLI Exercise

    9. SourceTree Intro

    10. SourceTree Intro Part 2

    11. Exercise: Exploring SourceTree

    12. GitLab Intro

    13. GitLab SourceTree Integration

    14. Exercise: Creating new Gitlab repos

    15. Push, Fetch, and Pull

    16. Exercise: Push and Pull changes

    17. Separate Compiled Code

    18. Quiz: Getting Started

    1. Intro

    2. Referencing Commits

    3. Quiz: Referencing Commits

    4. Diffing

    5. Undoing Working Copy Changes

    6. Exercise: Working Copy Changes and Diffs

    7. Using Checkout and Switch

    8. Exercise: Checkout

    9. Retrieving Previous Versions of Files

    10. Undoing Commits with the Reset Command

    11. Reflog and Garbage Collection

    12. Exercise: Reset Command

    13. Advanced Undoing Changes - Revert and Cherry-Pick

    14. Exercise: Reverting Merges

    15. Rewriting History with Rebase --interactive

    16. Exercise: Playing with Interactive Rebase

    17. Exercise: Scavenger Hunt

    18. Scavenger Hunt Hints

    19. Bisect

    20. Exercise: Bisect

    21. Quiz: Time Machine

    1. Intro

    2. Branches

    3. Merge

    4. Auto-merge and Conflicts

    5. Exercise: Auto Merge Fail

    6. Exercise: Merge Conflicts

    7. Rebase

    8. Exercise: Rebase Conflicts

    9. Merge Versus Rebase

    10. Remotes

    11. Rewriting Shared History

    12. Pull or Merge Requests

    13. Git Flow

    14. Exercise Gitflow

    15. Continuous Integration

    16. Forking Workflow

    17. Exercise: Forking

    18. WorkFlow Patterns Overview

    1. Intro

    2. Book Recommendations

    3. Online Resources

Your Instructor

Purchase Course

Sam Taggart

I am passionate about helping LabVIEW developers grow so they can confidently take on bigger and better challenges. I have been doing LabVIEW for over a dozen years. Over that time I have learned a ton. I learned a lot of it the hard way. I wish I would have had some more guidance along the way. That is why I created these courses to point junior developers in the right direction and help them to avoid stubbing their toes so much.

Questions?

Questions about the content in this course? Would you like more information on the next offering of this workshop? Interested in custom classes? Drop us a line.