LabVIEW Refactoring Course

Maintaining and evolving existing code can feel risky and overwhelming, especially when you didn’t write it. Maybe you’ve inherited a system you’re afraid to touch, need to add features the architecture doesn’t support, or must adapt to new hardware and changing assumptions. Every change seems to break something, the code is hard to understand, and even small improvements take far longer than they should. You know big changes are needed, but rewriting everything feels too dangerous and expensive.

This course is designed for developers facing exactly these challenges. Instead of risky rewrites or endless hesitation, you’ll learn a methodical, low-risk approach to changing code safely and confidently. The focus is on taking small, incremental steps that keep systems working while steadily improving them. You’ll learn how to break large, intimidating problems into manageable pieces and how to make progress even when the design isn’t ideal.

Testing plays a central role in lowering risk. You’ll learn how to use tests to protect existing behavior, how to test code that seems hard or impossible to test, and when it’s reasonable to refactor without tests. The course ties common code smells to specific refactoring techniques, helping you recognize improvement opportunities and move toward better designs over time. You’ll also learn how to leverage existing IDE tools and apply these techniques to class-based, object-oriented code.

By the end of this course, you will:

  • Feel confident making changes to existing code

  • Reduce the risk of breaking systems during development

  • Move faster without needing perfect designs up front

  • Better handle uncertainty and changing requirements

  • Develop transferable refactoring and design skills

  • Deliver new features more quickly and safely

With plenty of hands-on practice, this course helps you regain momentum and take control of slowing, fragile systems one safe step at a time.

Purchase Course

FAQs

What is this course?

1

This course teaches low-risk, step-by-step techniques using testing and refactoring to safely improve existing systems, handle change, and deliver features faster without rewrites or fear.

Who is it for?

2

All engineers will come across legacy code at some point in their career. It’s imperative that you approach it safely.

What will you learn?

3

VIPC Install, Simple Safe Refactorings, Split and Combine Loop, Dealing with Nesting Code Smells, IDE Tools, Class Refactorings, Changing Connector Panes, Legacy Code First Aid Kit

Prerequisites?

4

None

Syllabus

    1. Welcome

    2. VIPC Install

    1. Self Assessment

    2. Definition

    3. Black Box

    4. Kent Beck

    5. Resources

    6. Homework

    1. More than straight wires

    2. Move Fast

    3. The Process

    4. Importance of Feedback

    5. Small Steps

    6. Target - Good Design

    7. Code Smells

    8. Balancing Act

    1. Basics = Advanced

    2. Blue Demo

    3. Safe Renaming

    4. A few words about testing

    5. Problem Statement

    6. Create SubVI Demo

    7. Exercise: Simple Serial

    8. Debrief Exercise

    1. Problem Statement

    2. Testing Note

    3. Simple Split Loop Demo

    4. Exercise - Simple Split Loop

    5. Split Loop with Cluster Demo

    6. Exercise - Split Loop using Cluster

    7. Demo - Combine Loop Refactoring in LabVIEW

    8. Exercise - Combine Loop

    9. Debrief Exercise

    1. Intro

    2. Self Assessment

    3. Discuss Simple Serial Example

    4. Quick Intro To Unit Tests

    5. Write some tests for Simple Serial

    6. Approval Testing

    7. Learning How to Set Up Approval Tests

    8. Test Coverage

    1. Notes for Katas

    2. Problem Statement

    3. Case versus select

    4. Gilded Rose Description

    5. Gilded Rose Demo

    6. Gilded Rose Video Debrief

    7. Exercise: Gilded Rose

    8. Gilded Rose Exercise Debrief

    9. Extra Credit

    1. Smells and Solutions

    2. Tennis Notes

    3. Tennis Kata Code Smells Exercise

    4. What did you find?

    5. Tennis Kata

    1. Introduction

    2. Finding stuff in the project

    3. Class Refactoring Tools

    4. Additional Tools

    1. Case Structures + Dynamic Dispatch

    2. Why might Dynamic Dispatch be better?

    3. Replace Case with Dynamic Dispatch Refactoring LabVIEW

    4. Exercise: Parrot Kata

    5. After

    6. Move Method Down and Move Field Down

    7. Exercise: Parrot Kata 2

    1. Introduction

    2. Conn Pane Changes

    3. TDD Discussion

    4. Making a new API with LabVIEW

    5. Yatzy Kata

    6. Debrief Exercise

    1. Legacy Code First Aid Kit

    2. Sprout/Keystone

    3. Mikado Method

    4. SuperMarket Kata Demo

    5. SuperMarket Kata

    1. Real Life Example

    2. Real Life Exercise

    1. Reflection

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.