User group

A User Group, or LabVIEW User Group (LUG), is a local group of LabVIEW enthusiasts that come together to share common interests or goals. The user groups within the NI Community are segmented into different categories such as Local User Groups, Product User Groups, Special Interest Groups, and Partner Groups. Within each of these groups, you may collaborate with others on best practices, plan in-person meetups, or discuss any topic of your choice.

Organizing a User Group

User groups are typically created out of a shared need to seek advice and share ideas among a community of individuals that are working on similar problems OR applications. It is recommended that such a group align on goals for the organization, such as the following:

1. Share ideas and practices to improve the quality, performance, scalability and readability of LabVIEW code
2. Provide a forum to solicit advice from peers regarding how best to solve technical and procedural challenges when developing LabVIEW code
3. Drive standardization on stylings, code organization and tooling for the purpose of enabling greater reuse and collaboration

See the LabVIEW Community Forum: User Group List to find one near you.

User Groups Roles and Responsibilities

Role	Resposibility
Owner	Ultimately in charge, Get the ball rolling
Coordinator(s)	Could be the same person as the owner or a committee of people. Their job is to organize the event: Work with sponsors, Find a location, Find a Presenter, Schedule the Event, and Advertise
Sponsors	Sponsors provide financial backing for refreshments and could include using facilities for the meeting location.
Presenter	Create content, Present, and Publish Content. Ensure attendees can find your presentation and source code if you can share it. Remember to provide links to other applicable resources and your LinkedIn or company pages. (A little self-promotion is allowed for the work you put into sharing your knowledge.) A LabVIEW Wiki page can be created for your presentation as a starting point for these resources (see example).
Attendees	Attend the event. Be attentive and ask questions. Be willing to be the presenter sometimes too.

User Group Content

This is a collection of content that can be used to organize and run a LabVIEW user group.

Fundamental Programming Constructs

These materials focus on the G syntax and language-specific constructs

Presentation Title	Abstract	Author	Demo Resources	SME Requirements
Python vs. LabVIEW Technical Deep Dive	These slides are intended to explore important software considerations when developing large test and measurement software that needs to scale and the merits and considerations when using either LabVIEW. The original materials have been provided by NI but have been made open-source for the purpose of enabling the community to enhance and augment these materials with alternative view points and examples.	Elijah Kerry	GitHub Repo of Slides
Using Object-Oriented Programming LabVIEW	This session will introduce object-oriented programming as a tool that can dramatically increase the reusability and scalability of your software. Instead of going through a purely academic exploration of the concept, this session attempts to map concepts that should be familiar to any experienced LabVIEW programming towards helping explain how you can evolve your daily programming tasks without starting all over.	Elijah Kerry	Presentation and Demo Materials Video of session	Yes - experience implementing class-based software architectures
Malleable VIs Unlocked	Malleable VI's have been available for quite some years and compliments our toolbox of reusable code perfectly. Join me on a journey through techniques that have yet to be shared but are the basis of the G²CPU high performance toolkit. We'll have a look at a what its position is compared to polymorphic VI's, classes, case structures and other techniques to selectively execute code. After which we will step-by-step go from simple ground rules to never publicized techniques to elevate your reusable libraries	Natan Biesmans and Tom McQuillan	YouTube Recording
What to Expect When You're Expecting an Error	Connecting error wires across nodes on a block diagram is one of the most common, brainless tasks performed by a LabVIEW programmer. Unfortunately, this often means that VI behavior in an error condition is a second thought, if it's even thought about at all. This presentation will cover best practices in regards to the generation and propagation of errors on LabVIEW block diagrams. You should come out of this presentation with the ability to write VIs that are not only functionally correct in an error condition, but also precisely convey their exact error behavior in an error condition.	Darren Nattinger	Slides and Recording
All About Collection Data Types	Introduction to the fundamentals of Strings and Arrays, then moving into Sets and Maps, the newest data types in LabVIEW.	Darren Nattinger	Slides, Demos, and Recording

Software Engineering and Team Based Development

These presentations are intended to review best practices for code design and development processes. They are generally more advanced and benefit a presenter who has multiple years of experience with the relevant tools and technologies.

Presentation Title	Abstract	Author	Demo Resources	SME Requirements
Moving from SVN to Git with LabVIEW	Git tends to be the standard versioning system used in software development. DevOps platform like Gitlab and Github rely on it. Git could be a necessary transition to implement CI/CD. From my experience and with data collected earlier this year, it seems that SVN is still used by many people in our LabVIEW world. I want to share my journey from a former SVN user to a happy Git one and help developers to go further than just a "backup" tool. Real experience and no command-line inside.	Olivier Jourdan	YouTube Recording	Yes - familiarity with SCM, Git and SVN. Qualified presenters include: Olivier Jourdan, Fabiola De la Cueva and Emilie Kia
Team Based Development with LabVIEW	This session will provide an overview of best practices and tooling that should be used to streamline LabVIEW development by a team of developers	Elijah Kerry	GitHub Repo for slides and demo materials	Yes - CLA-level knowledge of how to manage and coordinate development activities across a team
Improving Your LabVIEW Code with the VI Analyzer	A comprehensive presentation on the features of the VI Analyzer, and how it can be used to improve code style, increase code performance, and detect bugs.	Darren Nattinger	Slides, Demos, and Recording
Architecting long life-cycle LabVIEW applications	Presentation provides an overview on one of the many ways of defining the processes to create LabVIEW code that will be used to generate multiple revisions of a product by a constantly changing team of developers.	Sergio Velderrain	Soon	Yes - CLA-level knowledge, VI Package manager, CI/CD.

Software Architectures and Code Design Patterns

These presentations are intended to review best practices for code design and development processes. They are generally more advanced and benefit a presenter who has multiple years of experience with the relevant tools and technologies.

Presentation Title	Abstract	Author	Demo Resources	SME Requirements
Using Plugin Frameworks for Extensibility	This session will show how to improve the reusability and extensibility of LabVIEW code through the use of dynamically loaded plugins	Elijah Kerry	Example source code	Yes - CLD-level knowledge of how to dynamically load and communicate with sub processes
Introduction to DQMH	DQMH is the world’s most popular 3rd-party framework for LabVIEW, and was designed to facilitate the robust implementation of complex LabVIEW applications, while still being accessible to CLAD/CLD-level LabVIEW programmers.	Darren Nattinger	Slides, Demos, and Recording
Workers for LabVIEW	Efficiently develop asynchronous applications using Workers for LabVIEW, a framework that provides simple LVOOP QMHs along with a comprehensive set of development tools to streamline application development. This framework is suitable for developing both small and large multi-process LabVIEW applications in a scalable, modular and extensible way.	Peter Scarfe	User Guide, Introduction Video, Tutorial Videos	LabVIEW Core 3 or CLD level knowledge

Best Practices

These materials cover best practices for various aspects of LabVIEW development.

Presentation Title	Abstract	Author	Demo Resources	SME Requirements
An End to Brainless LabVIEW Programming	There are lots of supposed "best practices" we do in LabVIEW without thinking. If we actually think about them, it turns out they may not be best practices at all.	Darren Nattinger	Slides and Recording
Industrial Communications in LabVIEW	Don’t underestimate the complexity of industrial communications protocols, nor the completeness of LabVIEW toolkits for supporting these. This presentation collates crowd-sourced data on the woes and wahays of integrating National Instruments systems into an industrial network, providing any developer with an up to date and pragmatically authored review of the state of current capabilities and maybe a brief look into the future. Dr. Richard Thomas, a founding member of GDevCon and the ALA, LabVIEW Champion, CLA and CLED, has worked with LabVIEW and NI systems for nearly 25 years, in various roles from Academia, Consultancy to Production Engineering, with experience in several industry sectors.	Dr. Richard Thomas	Recording
Communicating intent through the VI Icon - Jesper Kjær Sørensen (GPower)	This presentation is one you don't want to miss. We will embark on a quest through the massive Icon Dungeon in the land of LabVIEW. The goal is to slay the dreaded default icon Dragon, which has brought much pain and suffering to LabVIEW developers. We will wander through the multi-level halls of VI icons to search for traps and recover the ancient knowledge of visual grouping. We will be spelunking into the Casm of Class icons. Finally, we will enter the Vault of Glyphs to fill our bags with loot and make a quick getaway through the dimension of Automation. My name is Jesper Kjær Sørensen. I am a level 5 Systems Engineer aboard the fantastic vessel GPower, hailing from Denmark. I have replaced my character sheet three times over the past 14 years since I graduated from the University of Aalborg. Throughout the years, I have honed my skills in LabVIEW and TestStand and dabbled in the dark arts of Python programming. I have several side quests involving photography, dairy cows, my family, and my love for Dungeons and Dragons.	Jesper Kjær Sørensen	Recording
Building the LabVIEW IDE and Tooling That You Always Wanted	This presentation will give an insight into how you can build the LabVIEW features and tools you wish it had out of the box to make it even more productive. Emerson/NI have provided many hooks into the environment so let's use them to make LabVIEW better.	Chris Roebuck (Konrad Technologies)	Recording
VI Analyzer: The unsung hero of software quality	In this presentation we explore the features of VI Analyzer and show how you can easily incorporate it into your daily workflow. We showcase how to implement your own tests using the in-built templates.	Chris Roebuck (Konrad Technologies)	Recording

Tips and Tricks

These materials cover suggestions and insight from developers aimed at streamlining interaction with the development environment for the sake of increased productivity.

Presentation Title	Abstract	Author	Demo Resources	SME Requirements
I Find Your Lack of LabVIEW Programming Speed Disturbing	In just an hour of LabVIEW programming, you interact with the LabVIEW IDE hundreds, perhaps thousands, of times. Chances are, you could be executing many editor gestures more efficiently. Explore how to change your workflow to perform the most common LabVIEW programming tasks as quickly as possible.	Darren Nattinger	Slides, Demos, and Recording
Quick! Drop Your VI Execution Time!	Simple tips and techniques for speeding up your VIs. This includes general purpose programming techniques, as well as the most efficient way to use profiling tools in LabVIEW.	Darren Nattinger	Slides, Demos, and Recording
Don't Wait for LabVIEW R&D... Implement Your Own LabVIEW Features!	You can choose from many hooks to add your own G-based features to the LabVIEW IDE (no text programming required). This session reveals every single one of those hooks (No, really!) along with some LabVIEW Scripting tips and best practices for implementing those LabVIEW features you always wanted.	Darren Nattinger	Slides and Recording
Hidden Gems in vi.lib	A walkthrough of several useful VIs and APIs that ship with LabVIEW, but are not officially supported by NI.	Darren Nattinger	Slides and Recording
Augmenting Right-Click Menus in LabVIEW	All the details of the right-click plugins feature in LabVIEW, that allows you to extend the right-click menus in the LabVIEW editor purely with G code.	Darren Nattinger	Slides, Demos, and Recording

UX / UI Design

These materials provide insights on how to design user-interfaces in LabVIEW

Presentation Title	Abstract	Author	Demo Resources	SME Requirements
Tell a Story with Your Interface by Hunter Smith		Hunter Smith	YouTube link
Extensible and Modular UIs: Extend the VI Server With Object-Oriented Techniques	Using QControls to create reusable UI modules.	Quentin "Q" Alldredge	Wiki Page
Encapsulating and Reusing your UI Code	Using QControls to make Reusable, Encapsulated, Extensible UIs.	Quentin "Q" Alldredge	Wiki Page
The LabVIEW UI of Your Dreams	Often, the LabVIEW front panels we use day after day are far from a “dream UI,” and we’ve all seen some nightmare UIs. In this session, we’ll use a high‐minded design philosophy combined with practical developer checklists that you can apply to make your interfaces more functional, consistent, professional, and dreamy.	Hunter Smith	YouTube Recording
UI/UX Considerations when there is No Keyboard or Mouse	This presentation provides an overview of best practices and lessons learned when developing software interfaces that will rely on a touch screen, especially given the number of UI components that are not well suited for a touch interface.	Quentin "Q" Alldredge	Wiki Page
Smartphone-like User Interfaces in LabVIEW	Do you want more advanced User Interfaces than you can normally get from LabVIEW? Maybe the user experience needs to be for a touch screen similar to common smartphone interfaces. I’ll show tricks to using the QControl Toolkit to create swipe, scroll, and selection via a touchscreen.	Quentin "Q" Alldredge	Wiki Page
How to successfully scale UIs in LabVIEW	All started with a tough requirement: “The application needs more than 50 Synoptics” . With such a breath taking number, you need to think in a way of programming User Interfaces that is easily scalable, flexible and maintainable. As a programmer, the last thing you want is to have the need to implement a new feature and have to repeat the same piece of code in 50 different places. This presentation navigates through the process of getting a successful approach, from the idea to the implementation.	Iker Segovia Revilla(ULMA)	[Video]
Thin Client TestStand	Using LabVIEW WebUI hosted on and communicating with SystemLink to remotely control, monitor, and deploy Test software and equipment using a TestStand Server; all from a thin client or phone/tablet.	Nathan Lutz (Konrad Technologies)

Debugging/Troubleshooting

These materials cover suggestions and insight from developers aimed at debugging and troubleshooting LabVIEW applications.

Presentation Title	Abstract	Author	Demo Resources	SME Requirements
Ludicrous Ways to Fix Broken LabVIEW Code	When LabVIEW programmers encounter compiler errors, app builder failures, and crashes, they will usually settle for any hack, kludge, or workaround just to get usable code. This presentation demonstrates a number of ridiculous ways to get broken code running.	Darren Nattinger	Slides, Demos, and Recording	This content is very DNatt-specific, and may be difficult for others to present.
Benchmark and troubleshoot of a mission critical LabVIEW application	Provides an overview of the combination of tools and methods i used when creating systems for high throughput data acquisition. These type of systems are considered edge cases, but the lessons learned from this presentation can be applied to any other LabVIEW application to ensure an efficient troubleshooting.	Sergio Velderrain	Soon	Yes- CLD Level proficiency, Desktop execution trace toolkit, VI Analyzer, exposure to system integration.

Additional Resources

These are additional sites that have links to technical content pertaining to LabVIEW that may be appropriate for a user group presentation.

Site	Description
StudioBods Presentation Materials	A collection of presentation materials and recordings given by Matthias Baudot, CLA and founder of StudioBods
Example	Example
Example	Example

See also

• List of LabVIEW user groups

External links

• User Groups (NI Community)