LabVIEW Wiki - User contributions [en]

LabVIEW Learning Materials

2024-09-26T20:55:46Z

Sergiovelderrain: Removed links that were broken. Added new links that Fabiola shared with me.

{{see also|category:LabVIEW fundamentals}}

This page provides a recommended set of resources for LabVIEW programmers. The links are a collection of white papers, YouTube videos and formal learning content.

=LabVIEW Programming Basics =

==Introduction to LabVIEW Environment==
* [https://www.youtube.com/watch?v=ZHNlKyYzrPE&list=PLB968815D7BB78F9C LabVIEW Overview]
* [https://www.youtube.com/watch?v=OBcwsJb01F8 Part 1: Creating your first VI]
* [https://www.youtube.com/watch?v=-8ONxoz2D3k Part 2: Introduction to Loops and Structures]
* [https://www.youtube.com/watch?v=-PFHjl5ktCo Part 3: Basic Analysis of Data]
* [https://www.youtube.com/watch?v=3hvlVtHf85Q Part 4: Basic Hardware Connectivity]

==Data Types & Structures==
* [https://www.ni.com/en-us/innovations/white-papers/06/labview-data-types.html LabVIEW Data Types Overview]
* [https://www.youtube.com/watch?v=ieC4MBxPVtM Arrays and Clusters Tutorial]
* [https://www.youtube.com/watch?v=I7FPlLzc7D0 Overview of For Loops]

==User Interface Design==
* [https://www.youtube.com/watch?v=eGlvOiqYVxg Using event structures to capture user interactions]
* [https://www.youtube.com/watch?v=jWWJKUpoois Introduction to Panes for UI Organization]
* [https://www.youtube.com/watch?v=nCvMLB_kH4Q Programmatically changing UI controls using property nodes]
* [https://www.youtube.com/watch?v=rBM_kTpUfDk Creating resizeable user interfaces]
* [https://www.youtube.com/watch?v=qvhGH0TlCqs&pp=ygUXY3VzdG9tIGNvbnRyb2xzIGxhYnZpZXc%3D Creating Custom Controls]
* [https://www.youtube.com/watch?v=0-B7p061la4 Creating Professional User Interfaces]

==Asynchronous Messaging==
* [https://www.youtube.com/watch?v=8DFf-9kcRcs Introduction to queues for sending messages between processes]
* [https://www.ni.com/en-us/innovations/white-papers/06/using-queues-and-notifiers-in-labview.html Queues, Notifiers, and Semaphores]
* [https://www.youtube.com/watch?v=MevQp9A9Xqs Queues and Notifiers in LabVIEW]
* [https://www.youtube.com/watch?v=8DFf-9kcRcs Overview of Queues]
* [https://www.youtube.com/watch?v=9og3QbfgBu0 Tutorial on Using Notifiers]

==Advanced Execution Control==
*Dynamically loading VIs
*[https://www.youtube.com/watch?v=dG8MaqO9c2A Launching clones of a VI]
*Dynamically loading classes
*[https://www.youtube.com/watch?v=tfZIJejBnXg Launching a dynamically dispatched VI programmatically]

==Object-Oriented Programming (OOP) in LabVIEW==
* [https://www.ni.com/en-us/innovations/white-papers/06/introduction-to-object-oriented-programming-in-labview.html OOP Concepts in LabVIEW]
* [https://www.youtube.com/watch?v=w0x-EBe8G7A Object-Oriented Programming in LabVIEW Tutorial]

==Debugging Tools==
* [https://www.ni.com/en-us/innovations/white-papers/06/debugging-labview-applications.html Debugging Tools in LabVIEW]
* [https://www.youtube.com/watch?v=tMtfXSqFPiY Debugging Techniques in LabVIEW]

==Build and Deployment==
* [https://www.ni.com/en-us/innovations/white-papers/06/building-executables-and-installers-in-labview.html Building Executables and Installers]
* [https://www.youtube.com/watch?v=ZFYhKDUOnus Deploying LabVIEW Applications]

=LabVIEW Software Patterns=

==State Machines==
* [https://www.ni.com/en-us/innovations/white-papers/06/state-machines.html NI White Paper on State Machines]
* [https://www.youtube.com/watch?v=NHtWZohvR7k State Machines Tutorial]

==Queued Message Handlers (QMH)==
* [https://www.youtube.com/watch?v=-xXJt7yUEis Queued State Machine Overview]
* [https://learn.ni.com/center-of-excellence/queued-message-handler Queued Message Handler Architecture Overview]
* [https://www.youtube.com/watch?v=E8onRrQjR9E QMH Video Tutorial]

==Producer/Consumer Architecture==
* [https://www.ni.com/en-us/innovations/white-papers/06/producer-consumer-architecture.html Producer/Consumer Architecture White Paper]
* [https://www.youtube.com/watch?v=X4bQDXiYs1E Producer/Consumer Architecture Tutorial]

==Event-Driven Programming==
* [https://www.ni.com/en-us/support/documentation/supplemental/06/event-driven-programming-in-labview.html Event Structures in LabVIEW]
* [https://www.youtube.com/watch?v=oZhA5qVJfb8 Event-Driven Programming Tutorial]

=Tooling and Development Processes=
==Configuration Management===
* [https://www.ni.com/en-us/support/documentation/supplemental/18/configuring-git-for-labview.html Setting up Git for LabVIEW]
* [https://www.youtube.com/watch?v=CUhBTYiUSyI Version Control in LabVIEW Tutorial]

==Static Code Analysis==
* [https://www.ni.com/en-us/support/documentation/supplemental/06/vi-analyzer-in-labview.html VI Analyzer Overview]
* [https://www.youtube.com/watch?v=WeHzr7RJJfs VI Analyzer in Action]

==Dynamic Code Analysis and Performance Benchmarking==

==Unit Testing==
* [https://www.jki.net/vi-tester JKI VI Tester for Unit Testing]
* [https://www.youtube.com/watch?v=XU9UJmHeH1U Unit Testing in LabVIEW with Caraya]

=Software Design Patterns and Best Practices=

==Modular Programming and Code Reuse==
* [https://www.ni.com/en-us/innovations/white-papers/06/reusing-code.html NI Guide to Reusing Code]
* [https://www.youtube.com/watch?v=KiS5uCrJ9D8 Modular Programming in LabVIEW]

==Error Handling==
* [https://www.ni.com/en-us/innovations/white-papers/06/error-handling-in-labview.html Best Practices for Error Handling]
* [https://www.youtube.com/watch?v=5PzbsJfzRHY Error Handling Techniques]

=Software Frameworks=

==DQMH==

* [https://dqmh.org/ Delacor’s DQMH Toolkit Overview] This is the official page for the DQMH toolkit, which includes a summary of features and download links.

* [https://documentation.dqmh.org/ DQMH User Guide] The official DQMH user guide with detailed explanations of how to use the framework.

* [https://wiki.dqmh.org/ DQMH Wiki] Your one-stop shop for everything you ever wanted to know about DQMH.

* [https://www.youtube.com/delacorllc DQMH YouTube channel]

* [https://forums.ni.com/t5/DQMH-Consortium-Toolkits/bd-p/7120 NI's DQMH Community Page]NI community hub dedicated to discussions around the DQMH framework, where developers share best practices, examples, and troubleshooting tips.

* [https://forums.ni.com/t5/Community-Documents/Introduction-to-DQMH/ta-p/4230225 Introduction to DQMH by Darren Nattinger]A quick introduction to DQMH for beginners, focusing on the key features and benefits of using this framework.

* [https://www.youtube.com/watch?v=IdqTCubXuPE How to Use the DQMH Module Template (YouTube)]A step-by-step guide for setting up and using the DQMH module template in your LabVIEW projects.

===DQMH Use Cases and Advanced Topics===

* [https://dqmh.org/simplifying-your-hardware-abstraction-layer-hal-with-lvoop-and-dqmh-part-1/ Simplifying your Hardware Abstraction Layer (HAL)]

* Advanced DQMH Techniques (YouTube) - This video explores advanced features like nested modules, scripting tools, and best practices for event handling within DQMH.

* Developing Modular Applications Using DQMH (NI YouTube Channel)A deep dive into how to build modular and scalable applications using DQMH. It covers real-world use cases and best practices.

* Integrating DQMH with Other Frameworks (YouTube) - A tutorial that shows how to integrate DQMH with other architectures like Actor Framework or Command-Response patterns.

===Community Contributions===

* DQMH Best Practices on GitHub - This repository contains best practices for using DQMH, contributed by the community. You’ll find code examples, comments, and strategies for building robust systems.

* [https://forums.ni.com/t5/DQMH-Consortium-Toolkits/bd-p/7120 NI's DQMH Community Page DQMH Forum (LabVIEW Community)]A place to ask questions, find tutorials, and get tips from experienced DQMH users.

* [https://www.youtube.com/playlist?list=PLmF-6jvwRvVOpNdPcRzskvnGbW79ug6AZ DQMH Tutorial YouTube] Presented by Tom McQuillan on his channel "Tom's LabVIEW Adventure"

==Actor Framework==
===Official Resources===

* [https://www.ni.com/en-us/support/documentation/supplemental/12/actor-framework.html NI Actor Framework Overview]A high-level introduction to the Actor Framework, its structure, and use cases.

* [https://zone.ni.com/reference/en-XX/help/371361R-01/lvframework/af_actor_framework/ NI Actor Framework Documentation]Comprehensive documentation that walks through the details of the Actor Framework in LabVIEW, including examples and best practices.

* [https://www.ni.com/en-us/innovations/white-papers/12/using-the-actor-framework-in-labview.html NI White Paper: Using Actor Framework for Modular, Scalable, and Maintainable Applications]A detailed white paper on how to use the Actor Framework to create robust and scalable LabVIEW applications.

===Video Tutorials===

* [https://www.youtube.com/watch?v=2H8T6ud9rQw Introduction to Actor Framework (YouTube)]A beginner-friendly video introducing the key concepts and structure of the Actor Framework in LabVIEW.

* [https://www.youtube.com/watch?v=YlSzBqipGY4 Actor Framework Basics (YouTube)]This video walks through the basic concepts, including actors, messages, and actors' lifetimes.

* [https://www.youtube.com/watch?v=RN-FLhmEJ2k Creating and Running Actors (YouTube)]An in-depth look at how to create and run actors using the LabVIEW Actor Framework.

* [https://www.youtube.com/watch?v=zp6npT6gqTI Advanced Actor Framework Patterns (YouTube)]A video for more experienced developers, covering advanced patterns and techniques in Actor Framework.

===Advanced Topics===

* [https://www.ni.com/en-us/innovations/white-papers/15/actor-framework-in-labview--architecture-and-benefits.html NI White Paper: Actor Framework in LabVIEW: Architecture and Benefits]A white paper exploring the architecture of the Actor Framework, with use cases and scenarios for applying it in real-world projects.

* [https://www.youtube.com/watch?v=f-WtzcZGm3A LabVIEW Actor Framework: Message Handling (YouTube)]A detailed video on how to create, send, and handle messages between actors in the Actor Framework.

* [https://www.youtube.com/watch?v=UrMe2GkOYXE NIWeek Presentation: Advanced Actor Framework Design (YouTube)]A presentation from NIWeek discussing advanced Actor Framework design patterns, modularity, and messaging techniques.

===Community Contributions and Tutorial===

* [https://zone.ni.com/reference/en-XX/help/371361R-01/lvframework/af_examples/ Actor Framework Examples in LabVIEW]A set of example projects provided by NI to help developers get hands-on experience with the Actor Framework.

* [https://github.com/LabVIEW-Tools/Actor-Framework-Best-Practices GitHub: Actor Framework Best Practices]A community-driven repository showcasing best practices, examples, and tips for building scalable applications with the Actor Framework.

* [https://forums.ni.com/t5/Actor-Framework/bd-p/actors Actor Framework Forum (LabVIEW Community)]A dedicated forum where LabVIEW developers discuss the Actor Framework, share use cases, and troubleshoot challenges.

==Workers==
==VIPER==

=Hardware and Instrumentation Connectivity=

==DAQmx Basics==
* [https://www.ni.com/en-us/support/documentation/supplemental/06/ni-daqmx-driver.html DAQmx Fundamentals Guide]
* [https://www.youtube.com/watch?v=7kWekJAM2Ag DAQmx Basics Video Tutorial]

==Instrument Control==
* [https://www.ni.com/en-us/support/documentation/supplemental/06/instrument-control.html LabVIEW Instrument Control Overview]
* [https://www.youtube.com/watch?v=kZQsb8xT6bI Communicating with Instruments in LabVIEW]

==Determinism and Real-Time Execution==
* [https://www.ni.com/en-us/innovations/white-papers/06/using-labview-real-time.html Introduction to LabVIEW Real-Time]
* [https://www.youtube.com/watch?v=OjOEwVpRrmY Real-Time Systems Tutorial]

=Community and Best Practices=

==LabVIEW Style Guidelines==
* [https://labviewwiki.org/wiki/Style_Guide LabVIEW Style Guideline]
* [https://forums.ni.com/ NI Forums]

==LabVIEW Community and User Groups==
* [https://www.ni.com/en-us/events.html LabVIEW User Groups and Community Events]
* [https://www.gcentral.org/ GCentral: Open-Source Community for LabVIEW]

=Connectivity and Report Generation=

==Database Connectivity==
* [https://www.ni.com/en-us/support/documentation/supplemental/06/labview-database-connectivity-toolkit.html Using LabVIEW with Databases]
* [https://www.youtube.com/watch?v=ARJTHbkxI-8 Database Connectivity in LabVIEW]

=Formal Training=
Formal training on LabVIEW is available from several providers. Offerings differ based on prior LabVIEW experience level and the preferred delivery method. Common delivery methods include:

* In-person instructor-led
* Remote instructor-led (usually through a web conference)
* Online self-paced (usually through a combination of pre-recorded lecture videos and exercise solution videos)
* Self-paced with a manual

National Instruments has a [http://sine.ni.com/tacs/app/fp/p/ap/ov/pg/1/sn/n8:28/ suite of courses] ranging from beginner to advanced as well as several specialty topics such as LabVIEW Real-Time and LabVIEW Connectivity. National Instruments offers all common delivery methods mentioned above except online self-paced. Other LabVIEW training providers such as [http://www.sixclear.com/ Sixclear] provide this online self-paced environment. Sixclear's same curriculum is also delivered through in-person instructor-led training. [http://www.durability.com/Divisions/Automation/Training/LabVIEW101.asp Durability] is another provider of in-person instructor-led training.

Recommended training courses for those with no knowledge of LabVIEW are the [http://sine.ni.com/tacs/app/fp/p/ap/ov/pg/1/sn/n8:28/ National Instruments Core 1 and Core 2] courses, the [http://www.sixclear.com/labviewtraining/ Sixclear LabVIEW Fundamentals I and II] courses, or the [http://www.durability.com/Divisions/Automation/Training/LabVIEW101.asp Durability LabVIEW 101 and 102] courses. All sets of courses are geared to a user with little to no LabVIEW experience and teach the proficiencies outlined by the [http://sine.ni.com/nips/cds/view/p/lang/en/nid/14438 Certified LabVIEW Associate Developer (CLAD)] exam as well as simple DAQ and instrument control.

Common arguments justifying formal training revolve around the idea that the sum cost of developers' time is greater than the cost of training because:
* the LabVIEW graphical programming paradigm is appreciably different than traditional text-based programming
* costly mistakes commonly occur when moving from simple LabVIEW applications to more complex applications, especially when developing parallel loop applications

===Alternatives to Formal Training===

National Instruments maintains a list of [http://www.ni.com/reference/books/labview.htm LabVIEW reference books] as an alternative to formal training.

Another alternative to formal training are half-day "LabVIEW Hands-On" workshops offered by National Instruments. Recommended follow-ups are the "G Programmer's reference manual" and the LabVIEW "User Manual" found in the LabVIEW documentation.

== External Links ==

Some online tutorials:

*[http://blog.sixclear.com/ VI High LabVIEW Video Tutorial Blog by Sixclear]
*[http://www.ni.com/labview/skills-guide/en/ Some NI courses, including videos] (requires an active support contract with NI)
*[http://vishots.com/category/labview-tutorials/ VI Shots LabVIEW Video Tutorials]
*NI Tutorials (including videos and exercises) - http://zone.ni.com/devzone/cda/tut/p/id/7466
*More links at NI's site - http://www.ni.com/training/labview.htm
*Software Engineering with LabVIEW (generally requires some LabVIEW knowledge) - http://zone.ni.com/devzone/cda/tut/p/id/7117
*Connexions Tutorial (written by NI) - http://cnx.org/content/col10241/latest/
*LabVIEW Tutorials - http://www.upscale.utoronto.ca/GeneralInterest/LabView.html
*Videos of NI's LabVIEW Core 3 course (8 full lessons) - http://www.youtube.com/playlist?list=PL3E1DD4C18D357331
*Tutorial videos (some are free) - http://www.fafiles.com/
*Learning LabVIEW - http://learnlabview.blogspot.com/
*LabVIEW Tutorial Basics (BEKA, German) - http://www.fu-net.de/lv/lv01/
*LabVIEW Tutorial Advanced Techniques (BEKA, German) - http://www.fu-net.de/lv/lv02/

[[Category:LabVIEW fundamentals]]
[[Category:Getting started]]
[[Category:Tutorials]]
[[Category:Introduction]]

LabVIEW Learning Materials

2024-09-25T18:04:38Z

Sergiovelderrain:

{{see also|category:LabVIEW fundamentals}}

This page provides a recommended set of resources for LabVIEW programmers. The links are a collection of white papers, YouTube videos and formal learning content.

=LabVIEW Programming Basics =

==Introduction to LabVIEW Environment==
* [https://www.youtube.com/watch?v=ZHNlKyYzrPE&list=PLB968815D7BB78F9C LabVIEW Overview]
* [https://www.youtube.com/watch?v=OBcwsJb01F8 Part 1: Creating your first VI]
* [https://www.youtube.com/watch?v=-8ONxoz2D3k Part 2: Introduction to Loops and Structures]
* [https://www.youtube.com/watch?v=-PFHjl5ktCo Part 3: Basic Analysis of Data]
* [https://www.youtube.com/watch?v=3hvlVtHf85Q Part 4: Basic Hardware Connectivity]

==Data Types & Structures==
* [https://www.ni.com/en-us/innovations/white-papers/06/labview-data-types.html LabVIEW Data Types Overview]
* [https://www.youtube.com/watch?v=ieC4MBxPVtM Arrays and Clusters Tutorial]
* [https://www.youtube.com/watch?v=I7FPlLzc7D0 Overview of For Loops]

==User Interface Design==
* [https://www.youtube.com/watch?v=eGlvOiqYVxg Using event structures to capture user interactions]
* [https://www.youtube.com/watch?v=jWWJKUpoois Introduction to Panes for UI Organization]
* [https://www.youtube.com/watch?v=nCvMLB_kH4Q Programmatically changing UI controls using property nodes]
* [https://www.youtube.com/watch?v=rBM_kTpUfDk Creating resizeable user interfaces]
* [https://www.youtube.com/watch?v=qvhGH0TlCqs&pp=ygUXY3VzdG9tIGNvbnRyb2xzIGxhYnZpZXc%3D Creating Custom Controls]
* [https://www.youtube.com/watch?v=0-B7p061la4 Creating Professional User Interfaces]

==Asynchronous Messaging==
* [https://www.youtube.com/watch?v=8DFf-9kcRcs Introduction to queues for sending messages between processes]
* [https://www.ni.com/en-us/innovations/white-papers/06/using-queues-and-notifiers-in-labview.html Queues, Notifiers, and Semaphores]
* [https://www.youtube.com/watch?v=MevQp9A9Xqs Queues and Notifiers in LabVIEW]
* [https://www.youtube.com/watch?v=8DFf-9kcRcs Overview of Queues]
* [https://www.youtube.com/watch?v=9og3QbfgBu0 Tutorial on Using Notifiers]

==Advanced Execution Control==
*Dynamically loading VIs
*[https://www.youtube.com/watch?v=dG8MaqO9c2A Launching clones of a VI]
*Dynamically loading classes
*[https://www.youtube.com/watch?v=tfZIJejBnXg Launching a dynamically dispatched VI programmatically]

==Object-Oriented Programming (OOP) in LabVIEW==
* [https://www.ni.com/en-us/innovations/white-papers/06/introduction-to-object-oriented-programming-in-labview.html OOP Concepts in LabVIEW]
* [https://www.youtube.com/watch?v=w0x-EBe8G7A Object-Oriented Programming in LabVIEW Tutorial]

==Debugging Tools==
* [https://www.ni.com/en-us/innovations/white-papers/06/debugging-labview-applications.html Debugging Tools in LabVIEW]
* [https://www.youtube.com/watch?v=tMtfXSqFPiY Debugging Techniques in LabVIEW]

==Build and Deployment==
* [https://www.ni.com/en-us/innovations/white-papers/06/building-executables-and-installers-in-labview.html Building Executables and Installers]
* [https://www.youtube.com/watch?v=ZFYhKDUOnus Deploying LabVIEW Applications]

=LabVIEW Software Patterns=

==State Machines==
* [https://www.ni.com/en-us/innovations/white-papers/06/state-machines.html NI White Paper on State Machines]
* [https://www.youtube.com/watch?v=NHtWZohvR7k State Machines Tutorial]

==Queued Message Handlers (QMH)==
* [https://www.youtube.com/watch?v=-xXJt7yUEis Queued State Machine Overview]
* [https://learn.ni.com/center-of-excellence/queued-message-handler Queued Message Handler Architecture Overview]
* [https://www.youtube.com/watch?v=E8onRrQjR9E QMH Video Tutorial]

==Producer/Consumer Architecture==
* [https://www.ni.com/en-us/innovations/white-papers/06/producer-consumer-architecture.html Producer/Consumer Architecture White Paper]
* [https://www.youtube.com/watch?v=X4bQDXiYs1E Producer/Consumer Architecture Tutorial]

==Event-Driven Programming==
* [https://www.ni.com/en-us/support/documentation/supplemental/06/event-driven-programming-in-labview.html Event Structures in LabVIEW]
* [https://www.youtube.com/watch?v=oZhA5qVJfb8 Event-Driven Programming Tutorial]

=Tooling and Development Processes=
==Configuration Management===
* [https://www.ni.com/en-us/support/documentation/supplemental/18/configuring-git-for-labview.html Setting up Git for LabVIEW]
* [https://www.youtube.com/watch?v=CUhBTYiUSyI Version Control in LabVIEW Tutorial]

==Static Code Analysis==
* [https://www.ni.com/en-us/support/documentation/supplemental/06/vi-analyzer-in-labview.html VI Analyzer Overview]
* [https://www.youtube.com/watch?v=WeHzr7RJJfs VI Analyzer in Action]

==Dynamic Code Analysis and Performance Benchmarking==

==Unit Testing==
* [https://www.jki.net/vi-tester JKI VI Tester for Unit Testing]
* [https://www.youtube.com/watch?v=XU9UJmHeH1U Unit Testing in LabVIEW with Caraya]

=Software Design Patterns and Best Practices=

==Modular Programming and Code Reuse==
* [https://www.ni.com/en-us/innovations/white-papers/06/reusing-code.html NI Guide to Reusing Code]
* [https://www.youtube.com/watch?v=KiS5uCrJ9D8 Modular Programming in LabVIEW]

==Error Handling==
* [https://www.ni.com/en-us/innovations/white-papers/06/error-handling-in-labview.html Best Practices for Error Handling]
* [https://www.youtube.com/watch?v=5PzbsJfzRHY Error Handling Techniques]

=Software Frameworks=

==DQMH==

* [https://delacor.com/dqmh/ Delacor’s DQMH Toolkit Overview]This is the official page for the DQMH toolkit, which includes a summary of features and download links.

* [https://delacor.com/dqmh-documentation/ DQMH User Guide]The official DQMH user guide with detailed explanations of how to use the framework.

* [https://forums.ni.com/t5/Delacor-Queued-Message-Handler-DQMH/ct-p/7351 NI's DQMH Community Page]NI community hub dedicated to discussions around the DQMH framework, where developers share best practices, examples, and troubleshooting tips.

* [https://www.youtube.com/watch?v=aGUkhzv4bnc Introduction to DQMH (YouTube by Delacor)]A quick introduction to DQMH for beginners, focusing on the key features and benefits of using this framework.

* [https://www.youtube.com/watch?v=NTMsFz2MC1Q How to Use the DQMH Module Template (YouTube)]A step-by-step guide for setting up and using the DQMH module template in your LabVIEW projects.

* [https://www.youtube.com/watch?v=lpXcAhoNbRU DQMH Core Concepts and Demonstration (YouTube)]In-depth coverage of core DQMH concepts like requests, broadcasting events, and using helper loops.

===DQMH Use Cases and Advanced Topics===

* [https://www.youtube.com/watch?v=_nnnP5WJQyY Advanced DQMH Techniques (YouTube)]This video explores advanced features like nested modules, scripting tools, and best practices for event handling within DQMH.

* [https://www.youtube.com/watch?v=VUXIXfoBHEM Developing Modular Applications Using DQMH (NI YouTube Channel)]A deep dive into how to build modular and scalable applications using DQMH. It covers real-world use cases and best practices.

* [https://www.youtube.com/watch?v=GKlTeDWwkgk Integrating DQMH with Other Frameworks (YouTube)]A tutorial that shows how to integrate DQMH with other architectures like Actor Framework or Command-Response patterns.

===Community Contributions===

* [https://github.com/LabVIEW-Tools/DQMH-Best-Practices DQMH Best Practices on GitHub]This repository contains best practices for using DQMH, contributed by the community. You’ll find code examples, comments, and strategies for building robust systems.

* [https://forums.ni.com/t5/Delacor-Queued-Message-Handler-DQMH/bd-p/7351 DQMH Forum (LabVIEW Community)]A place to ask questions, find tutorials, and get tips from experienced DQMH users.

==Actor Framework==
===Official Resources===

* [https://www.ni.com/en-us/support/documentation/supplemental/12/actor-framework.html NI Actor Framework Overview]A high-level introduction to the Actor Framework, its structure, and use cases.

* [https://zone.ni.com/reference/en-XX/help/371361R-01/lvframework/af_actor_framework/ NI Actor Framework Documentation]Comprehensive documentation that walks through the details of the Actor Framework in LabVIEW, including examples and best practices.

* [https://www.ni.com/en-us/innovations/white-papers/12/using-the-actor-framework-in-labview.html NI White Paper: Using Actor Framework for Modular, Scalable, and Maintainable Applications]A detailed white paper on how to use the Actor Framework to create robust and scalable LabVIEW applications.

===Video Tutorials===

* [https://www.youtube.com/watch?v=2H8T6ud9rQw Introduction to Actor Framework (YouTube)]A beginner-friendly video introducing the key concepts and structure of the Actor Framework in LabVIEW.

* [https://www.youtube.com/watch?v=YlSzBqipGY4 Actor Framework Basics (YouTube)]This video walks through the basic concepts, including actors, messages, and actors' lifetimes.

* [https://www.youtube.com/watch?v=RN-FLhmEJ2k Creating and Running Actors (YouTube)]An in-depth look at how to create and run actors using the LabVIEW Actor Framework.

* [https://www.youtube.com/watch?v=zp6npT6gqTI Advanced Actor Framework Patterns (YouTube)]A video for more experienced developers, covering advanced patterns and techniques in Actor Framework.

===Advanced Topics===

* [https://www.ni.com/en-us/innovations/white-papers/15/actor-framework-in-labview--architecture-and-benefits.html NI White Paper: Actor Framework in LabVIEW: Architecture and Benefits]A white paper exploring the architecture of the Actor Framework, with use cases and scenarios for applying it in real-world projects.

* [https://www.youtube.com/watch?v=f-WtzcZGm3A LabVIEW Actor Framework: Message Handling (YouTube)]A detailed video on how to create, send, and handle messages between actors in the Actor Framework.

* [https://www.youtube.com/watch?v=UrMe2GkOYXE NIWeek Presentation: Advanced Actor Framework Design (YouTube)]A presentation from NIWeek discussing advanced Actor Framework design patterns, modularity, and messaging techniques.

===Community Contributions and Tutorial===

* [https://zone.ni.com/reference/en-XX/help/371361R-01/lvframework/af_examples/ Actor Framework Examples in LabVIEW]A set of example projects provided by NI to help developers get hands-on experience with the Actor Framework.

* [https://github.com/LabVIEW-Tools/Actor-Framework-Best-Practices GitHub: Actor Framework Best Practices]A community-driven repository showcasing best practices, examples, and tips for building scalable applications with the Actor Framework.

* [https://forums.ni.com/t5/Actor-Framework/bd-p/actors Actor Framework Forum (LabVIEW Community)]A dedicated forum where LabVIEW developers discuss the Actor Framework, share use cases, and troubleshoot challenges.

==Workers==
==VIPER==

=Hardware and Instrumentation Connectivity=

==DAQmx Basics==
* [https://www.ni.com/en-us/support/documentation/supplemental/06/ni-daqmx-driver.html DAQmx Fundamentals Guide]
* [https://www.youtube.com/watch?v=7kWekJAM2Ag DAQmx Basics Video Tutorial]

==Instrument Control==
* [https://www.ni.com/en-us/support/documentation/supplemental/06/instrument-control.html LabVIEW Instrument Control Overview]
* [https://www.youtube.com/watch?v=kZQsb8xT6bI Communicating with Instruments in LabVIEW]

==Determinism and Real-Time Execution==
* [https://www.ni.com/en-us/innovations/white-papers/06/using-labview-real-time.html Introduction to LabVIEW Real-Time]
* [https://www.youtube.com/watch?v=OjOEwVpRrmY Real-Time Systems Tutorial]

=Community and Best Practices=

==LabVIEW Style Guidelines==
* [https://labviewwiki.org/wiki/Style_Guide LabVIEW Style Guideline]
* [https://forums.ni.com/ NI Forums]

==LabVIEW Community and User Groups==
* [https://www.ni.com/en-us/events.html LabVIEW User Groups and Community Events]
* [https://www.gcentral.org/ GCentral: Open-Source Community for LabVIEW]

=Connectivity and Report Generation=

==Database Connectivity==
* [https://www.ni.com/en-us/support/documentation/supplemental/06/labview-database-connectivity-toolkit.html Using LabVIEW with Databases]
* [https://www.youtube.com/watch?v=ARJTHbkxI-8 Database Connectivity in LabVIEW]

=Formal Training=
Formal training on LabVIEW is available from several providers. Offerings differ based on prior LabVIEW experience level and the preferred delivery method. Common delivery methods include:

* In-person instructor-led
* Remote instructor-led (usually through a web conference)
* Online self-paced (usually through a combination of pre-recorded lecture videos and exercise solution videos)
* Self-paced with a manual

National Instruments has a [http://sine.ni.com/tacs/app/fp/p/ap/ov/pg/1/sn/n8:28/ suite of courses] ranging from beginner to advanced as well as several specialty topics such as LabVIEW Real-Time and LabVIEW Connectivity. National Instruments offers all common delivery methods mentioned above except online self-paced. Other LabVIEW training providers such as [http://www.sixclear.com/ Sixclear] provide this online self-paced environment. Sixclear's same curriculum is also delivered through in-person instructor-led training. [http://www.durability.com/Divisions/Automation/Training/LabVIEW101.asp Durability] is another provider of in-person instructor-led training.

Recommended training courses for those with no knowledge of LabVIEW are the [http://sine.ni.com/tacs/app/fp/p/ap/ov/pg/1/sn/n8:28/ National Instruments Core 1 and Core 2] courses, the [http://www.sixclear.com/labviewtraining/ Sixclear LabVIEW Fundamentals I and II] courses, or the [http://www.durability.com/Divisions/Automation/Training/LabVIEW101.asp Durability LabVIEW 101 and 102] courses. All sets of courses are geared to a user with little to no LabVIEW experience and teach the proficiencies outlined by the [http://sine.ni.com/nips/cds/view/p/lang/en/nid/14438 Certified LabVIEW Associate Developer (CLAD)] exam as well as simple DAQ and instrument control.

Common arguments justifying formal training revolve around the idea that the sum cost of developers' time is greater than the cost of training because:
* the LabVIEW graphical programming paradigm is appreciably different than traditional text-based programming
* costly mistakes commonly occur when moving from simple LabVIEW applications to more complex applications, especially when developing parallel loop applications

===Alternatives to Formal Training===

National Instruments maintains a list of [http://www.ni.com/reference/books/labview.htm LabVIEW reference books] as an alternative to formal training.

Another alternative to formal training are half-day "LabVIEW Hands-On" workshops offered by National Instruments. Recommended follow-ups are the "G Programmer's reference manual" and the LabVIEW "User Manual" found in the LabVIEW documentation.

== External Links ==

Some online tutorials:

*[http://blog.sixclear.com/ VI High LabVIEW Video Tutorial Blog by Sixclear]
*[http://www.ni.com/labview/skills-guide/en/ Some NI courses, including videos] (requires an active support contract with NI)
*[http://vishots.com/category/labview-tutorials/ VI Shots LabVIEW Video Tutorials]
*NI Tutorials (including videos and exercises) - http://zone.ni.com/devzone/cda/tut/p/id/7466
*More links at NI's site - http://www.ni.com/training/labview.htm
*Software Engineering with LabVIEW (generally requires some LabVIEW knowledge) - http://zone.ni.com/devzone/cda/tut/p/id/7117
*Connexions Tutorial (written by NI) - http://cnx.org/content/col10241/latest/
*LabVIEW Tutorials - http://www.upscale.utoronto.ca/GeneralInterest/LabView.html
*Videos of NI's LabVIEW Core 3 course (8 full lessons) - http://www.youtube.com/playlist?list=PL3E1DD4C18D357331
*Tutorial videos (some are free) - http://www.fafiles.com/
*Learning LabVIEW - http://learnlabview.blogspot.com/
*LabVIEW Tutorial Basics (BEKA, German) - http://www.fu-net.de/lv/lv01/
*LabVIEW Tutorial Advanced Techniques (BEKA, German) - http://www.fu-net.de/lv/lv02/

[[Category:LabVIEW fundamentals]]
[[Category:Getting started]]
[[Category:Tutorials]]
[[Category:Introduction]]

User group

2024-08-28T23:23:25Z

Sergiovelderrain:

{{TOCright}}
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.
<ref>LabVIEW Forums: User Groups https://forums.ni.com/t5/User-Groups/ct-p/user-groups</ref>

==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:
# Share ideas and practices to improve the quality, performance, scalability and readability of LabVIEW code
# Provide a forum to solicit advice from peers regarding how best to solve technical and procedural challenges when developing LabVIEW code
# Drive standardization on stylings, code organization and tooling for the purpose of enabling greater reuse and collaboration

See the [https://forums.ni.com/t5/User-Groups/ct-p/user-groups LabVIEW Community Forum: User Group List] to find one near you.

==User Groups Roles and Responsibilities==
{| class="wikitable"
|-
! 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, [[Events|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 ([[GLA Summit 2024/Fantastic LabVIEW Hooks and Where to Find Them|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

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://github.com/elijah286/LabVIEW-vs-python 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
|[https://forums.ni.com/t5/LabVIEW-Development-Best/Object-Oriented-Design-Patterns-Technical-Manual-and-Exercises/ta-p/3507995 Presentation and Demo Materials]
[https://www.ni.com/en/shop/labview/introduction-to-oop-and-hardware-abstraction-layers.html 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
|[https://www.youtube.com/watch?v=EzhMQ0Gt_1A 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
|[https://bit.ly/dnatterrors 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
|[https://bit.ly/dnattcollections 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://www.youtube.com/watch?v=v_cdlwIWfPY 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
|[https://github.com/elijah286/lvug-team-dev 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
|[https://forums.ni.com/t5/VI-Analyzer-Enthusiasts/Improving-Your-LabVIEW-Code-with-the-VI-Analyzer/m-p/3415352 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://github.com/elijah286/Extensible-Config-Dialog 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
|[https://bit.ly/dnattdqmhintro 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
|[https://docs.workersforlabview.io 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://bit.ly/brainlesslabview 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
|[https://www.youtube.com/watch?v=R4GN_-X__GA 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
|[https://www.youtube.com/watch?v=wOntiXaIu2o 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)
|[https://www.youtube.com/watch?v=3OBV-RSQSYI 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)
|[https://www.youtube.com/watch?v=yzjiZJZCe6A&list=PL7Ul36E7e0l97vayGr_OSl5tQlLj5jHkj 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://bit.ly/labviewspeed 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
|[https://bit.ly/slowvis 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
|[https://bit.ly/dnattlvhooks 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
|[https://forums.ni.com/t5/Hidden-Gems-in-vi-lib/Hidden-Gems-in-vi-lib-pptx/td-p/3502591 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
|[https://forums.ni.com/t5/LabVIEW-Shortcut-Menu-Plug-Ins/Presentation-Augmenting-Right-Click-Menus-in-LabVIEW/ta-p/3521526 Slides, Demos, and Recording]
|
|-
|}

===UX / UI Design===

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

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|Presentation Title
!|Abstract
!|Author
!|Demo Resources
!|SME Requirements
|-
| Extensible and Modular UIs: Extend the VI Server With Object-Oriented Techniques
| Using QControls to create reusable UI modules.
| [[Quentin "Q" Alldredge (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[NIWeek 2018/UI: Extensible and Modular UIs: Extend the VI Server With Object-Oriented Techniques|Wiki Page]]
|-
| Encapsulating and Reusing your UI Code
| Using QControls to make Reusable, Encapsulated, Extensible UIs.
| [[Quentin "Q" Alldredge (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[Americas CLA Summit 2019/Encapsulating and Reusing your UI Code|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
| [https://www.youtube.com/watch?v=qpxiQ3dFDm0 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 (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[Americas CLA Summit 2019/UI/UX Considerations when there is No Keyboard or Mouse|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 (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[GLA Summit 2022/Smartphone-like User Interfaces in LabVIEW| 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)
| [[https://www.youtube.com/watch?v=zYhzQ0Mlp-I| 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://bit.ly/ludicrouslabview 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.
|}

==References==
<references />

[[Category:User Group]]

User group

2024-08-28T23:21:46Z

Sergiovelderrain:

{{TOCright}}
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.
<ref>LabVIEW Forums: User Groups https://forums.ni.com/t5/User-Groups/ct-p/user-groups</ref>

==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:
# Share ideas and practices to improve the quality, performance, scalability and readability of LabVIEW code
# Provide a forum to solicit advice from peers regarding how best to solve technical and procedural challenges when developing LabVIEW code
# Drive standardization on stylings, code organization and tooling for the purpose of enabling greater reuse and collaboration

See the [https://forums.ni.com/t5/User-Groups/ct-p/user-groups LabVIEW Community Forum: User Group List] to find one near you.

==User Groups Roles and Responsibilities==
{| class="wikitable"
|-
! 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, [[Events|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 ([[GLA Summit 2024/Fantastic LabVIEW Hooks and Where to Find Them|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

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://github.com/elijah286/LabVIEW-vs-python 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
|[https://forums.ni.com/t5/LabVIEW-Development-Best/Object-Oriented-Design-Patterns-Technical-Manual-and-Exercises/ta-p/3507995 Presentation and Demo Materials]
[https://www.ni.com/en/shop/labview/introduction-to-oop-and-hardware-abstraction-layers.html 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
|[https://www.youtube.com/watch?v=EzhMQ0Gt_1A 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
|[https://bit.ly/dnatterrors 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
|[https://bit.ly/dnattcollections 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://www.youtube.com/watch?v=v_cdlwIWfPY 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
|[https://github.com/elijah286/lvug-team-dev 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
|[https://forums.ni.com/t5/VI-Analyzer-Enthusiasts/Improving-Your-LabVIEW-Code-with-the-VI-Analyzer/m-p/3415352 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://github.com/elijah286/Extensible-Config-Dialog 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
|[https://bit.ly/dnattdqmhintro 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
|[https://docs.workersforlabview.io 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://bit.ly/brainlesslabview 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
|[https://www.youtube.com/watch?v=R4GN_-X__GA 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
|[https://www.youtube.com/watch?v=wOntiXaIu2o 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)
|[https://www.youtube.com/watch?v=3OBV-RSQSYI 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)
|[https://www.youtube.com/watch?v=yzjiZJZCe6A&list=PL7Ul36E7e0l97vayGr_OSl5tQlLj5jHkj 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://bit.ly/labviewspeed 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
|[https://bit.ly/slowvis 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
|[https://bit.ly/dnattlvhooks 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
|[https://forums.ni.com/t5/Hidden-Gems-in-vi-lib/Hidden-Gems-in-vi-lib-pptx/td-p/3502591 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
|[https://forums.ni.com/t5/LabVIEW-Shortcut-Menu-Plug-Ins/Presentation-Augmenting-Right-Click-Menus-in-LabVIEW/ta-p/3521526 Slides, Demos, and Recording]
|
|-
|}

===UX / UI Design===

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

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|Presentation Title
!|Abstract
!|Author
!|Demo Resources
!|SME Requirements
|-
| Extensible and Modular UIs: Extend the VI Server With Object-Oriented Techniques
| Using QControls to create reusable UI modules.
| [[Quentin "Q" Alldredge (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[NIWeek 2018/UI: Extensible and Modular UIs: Extend the VI Server With Object-Oriented Techniques|Wiki Page]]
|-
| Encapsulating and Reusing your UI Code
| Using QControls to make Reusable, Encapsulated, Extensible UIs.
| [[Quentin "Q" Alldredge (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[Americas CLA Summit 2019/Encapsulating and Reusing your UI Code|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
| [https://www.youtube.com/watch?v=qpxiQ3dFDm0 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 (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[Americas CLA Summit 2019/UI/UX Considerations when there is No Keyboard or Mouse|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 (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[GLA Summit 2022/Smartphone-like User Interfaces in LabVIEW| 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)
| [[https://www.youtube.com/watch?v=zYhzQ0Mlp-I| 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://bit.ly/ludicrouslabview Slides, Demos, and Recording]
|This content is very DNatt-specific, and may be difficult for others to present.
|-
|Benchmark and troubleshoot of a high throughput data acquisition system
|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.
|}

==References==
<references />

[[Category:User Group]]

User group

2024-08-28T23:20:18Z

Sergiovelderrain:

{{TOCright}}
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.
<ref>LabVIEW Forums: User Groups https://forums.ni.com/t5/User-Groups/ct-p/user-groups</ref>

==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:
# Share ideas and practices to improve the quality, performance, scalability and readability of LabVIEW code
# Provide a forum to solicit advice from peers regarding how best to solve technical and procedural challenges when developing LabVIEW code
# Drive standardization on stylings, code organization and tooling for the purpose of enabling greater reuse and collaboration

See the [https://forums.ni.com/t5/User-Groups/ct-p/user-groups LabVIEW Community Forum: User Group List] to find one near you.

==User Groups Roles and Responsibilities==
{| class="wikitable"
|-
! 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, [[Events|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 ([[GLA Summit 2024/Fantastic LabVIEW Hooks and Where to Find Them|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

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://github.com/elijah286/LabVIEW-vs-python 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
|[https://forums.ni.com/t5/LabVIEW-Development-Best/Object-Oriented-Design-Patterns-Technical-Manual-and-Exercises/ta-p/3507995 Presentation and Demo Materials]
[https://www.ni.com/en/shop/labview/introduction-to-oop-and-hardware-abstraction-layers.html 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
|[https://www.youtube.com/watch?v=EzhMQ0Gt_1A 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
|[https://bit.ly/dnatterrors 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
|[https://bit.ly/dnattcollections 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://www.youtube.com/watch?v=v_cdlwIWfPY 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
|[https://github.com/elijah286/lvug-team-dev 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
|[https://forums.ni.com/t5/VI-Analyzer-Enthusiasts/Improving-Your-LabVIEW-Code-with-the-VI-Analyzer/m-p/3415352 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://github.com/elijah286/Extensible-Config-Dialog 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
|[https://bit.ly/dnattdqmhintro 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
|[https://docs.workersforlabview.io 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://bit.ly/brainlesslabview 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
|[https://www.youtube.com/watch?v=R4GN_-X__GA 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
|[https://www.youtube.com/watch?v=wOntiXaIu2o 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)
|[https://www.youtube.com/watch?v=3OBV-RSQSYI 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)
|[https://www.youtube.com/watch?v=yzjiZJZCe6A&list=PL7Ul36E7e0l97vayGr_OSl5tQlLj5jHkj 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://bit.ly/labviewspeed 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
|[https://bit.ly/slowvis 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
|[https://bit.ly/dnattlvhooks 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
|[https://forums.ni.com/t5/Hidden-Gems-in-vi-lib/Hidden-Gems-in-vi-lib-pptx/td-p/3502591 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
|[https://forums.ni.com/t5/LabVIEW-Shortcut-Menu-Plug-Ins/Presentation-Augmenting-Right-Click-Menus-in-LabVIEW/ta-p/3521526 Slides, Demos, and Recording]
|
|-
|}

===UX / UI Design===

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

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|Presentation Title
!|Abstract
!|Author
!|Demo Resources
!|SME Requirements
|-
| Extensible and Modular UIs: Extend the VI Server With Object-Oriented Techniques
| Using QControls to create reusable UI modules.
| [[Quentin "Q" Alldredge (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[NIWeek 2018/UI: Extensible and Modular UIs: Extend the VI Server With Object-Oriented Techniques|Wiki Page]]
|-
| Encapsulating and Reusing your UI Code
| Using QControls to make Reusable, Encapsulated, Extensible UIs.
| [[Quentin "Q" Alldredge (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[Americas CLA Summit 2019/Encapsulating and Reusing your UI Code|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
| [https://www.youtube.com/watch?v=qpxiQ3dFDm0 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 (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[Americas CLA Summit 2019/UI/UX Considerations when there is No Keyboard or Mouse|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 (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[GLA Summit 2022/Smartphone-like User Interfaces in LabVIEW| 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)
| [[https://www.youtube.com/watch?v=zYhzQ0Mlp-I| 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://bit.ly/ludicrouslabview Slides, Demos, and Recording]
|This content is very DNatt-specific, and may be difficult for others to present.
|-
|Benchmark and troubleshoot of a high throughput data acquisition system
|Provides an overview of the combination of tools and methods i used when creating systems for high throughput data acquisition system. These type of systems are edge cases, and the lessons learned from this application 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.
|}

==References==
<references />

[[Category:User Group]]

User group

2024-08-28T23:16:56Z

Sergiovelderrain:

{{TOCright}}
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.
<ref>LabVIEW Forums: User Groups https://forums.ni.com/t5/User-Groups/ct-p/user-groups</ref>

==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:
# Share ideas and practices to improve the quality, performance, scalability and readability of LabVIEW code
# Provide a forum to solicit advice from peers regarding how best to solve technical and procedural challenges when developing LabVIEW code
# Drive standardization on stylings, code organization and tooling for the purpose of enabling greater reuse and collaboration

See the [https://forums.ni.com/t5/User-Groups/ct-p/user-groups LabVIEW Community Forum: User Group List] to find one near you.

==User Groups Roles and Responsibilities==
{| class="wikitable"
|-
! 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, [[Events|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 ([[GLA Summit 2024/Fantastic LabVIEW Hooks and Where to Find Them|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

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://github.com/elijah286/LabVIEW-vs-python 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
|[https://forums.ni.com/t5/LabVIEW-Development-Best/Object-Oriented-Design-Patterns-Technical-Manual-and-Exercises/ta-p/3507995 Presentation and Demo Materials]
[https://www.ni.com/en/shop/labview/introduction-to-oop-and-hardware-abstraction-layers.html 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
|[https://www.youtube.com/watch?v=EzhMQ0Gt_1A 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
|[https://bit.ly/dnatterrors 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
|[https://bit.ly/dnattcollections 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://www.youtube.com/watch?v=v_cdlwIWfPY 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
|[https://github.com/elijah286/lvug-team-dev 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
|[https://forums.ni.com/t5/VI-Analyzer-Enthusiasts/Improving-Your-LabVIEW-Code-with-the-VI-Analyzer/m-p/3415352 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://github.com/elijah286/Extensible-Config-Dialog 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
|[https://bit.ly/dnattdqmhintro 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
|[https://docs.workersforlabview.io 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://bit.ly/brainlesslabview 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
|[https://www.youtube.com/watch?v=R4GN_-X__GA 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
|[https://www.youtube.com/watch?v=wOntiXaIu2o 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)
|[https://www.youtube.com/watch?v=3OBV-RSQSYI 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)
|[https://www.youtube.com/watch?v=yzjiZJZCe6A&list=PL7Ul36E7e0l97vayGr_OSl5tQlLj5jHkj 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://bit.ly/labviewspeed 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
|[https://bit.ly/slowvis 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
|[https://bit.ly/dnattlvhooks 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
|[https://forums.ni.com/t5/Hidden-Gems-in-vi-lib/Hidden-Gems-in-vi-lib-pptx/td-p/3502591 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
|[https://forums.ni.com/t5/LabVIEW-Shortcut-Menu-Plug-Ins/Presentation-Augmenting-Right-Click-Menus-in-LabVIEW/ta-p/3521526 Slides, Demos, and Recording]
|
|-
|}

===UX / UI Design===

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

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|Presentation Title
!|Abstract
!|Author
!|Demo Resources
!|SME Requirements
|-
| Extensible and Modular UIs: Extend the VI Server With Object-Oriented Techniques
| Using QControls to create reusable UI modules.
| [[Quentin "Q" Alldredge (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[NIWeek 2018/UI: Extensible and Modular UIs: Extend the VI Server With Object-Oriented Techniques|Wiki Page]]
|-
| Encapsulating and Reusing your UI Code
| Using QControls to make Reusable, Encapsulated, Extensible UIs.
| [[Quentin "Q" Alldredge (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[Americas CLA Summit 2019/Encapsulating and Reusing your UI Code|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
| [https://www.youtube.com/watch?v=qpxiQ3dFDm0 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 (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[Americas CLA Summit 2019/UI/UX Considerations when there is No Keyboard or Mouse|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 (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[GLA Summit 2022/Smartphone-like User Interfaces in LabVIEW| 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)
| [[https://www.youtube.com/watch?v=zYhzQ0Mlp-I| 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://bit.ly/ludicrouslabview Slides, Demos, and Recording]
|This content is very DNatt-specific, and may be difficult for others to present.
|-
|Benchmark and troubleshoot of a high throughput data acquisition system
|Provides an overview of the combination of tools and methods i used when creating systems for high throughput data acquisition system.
|Sergio Velderrain
|Soon
|Yes- CLD Level proficiency, Desktop execution trace toolkit, VI Analyzer, exposure to system integration.
|}

==References==
<references />

[[Category:User Group]]

User group

2024-08-28T23:04:45Z

Sergiovelderrain:

{{TOCright}}
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.
<ref>LabVIEW Forums: User Groups https://forums.ni.com/t5/User-Groups/ct-p/user-groups</ref>

==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:
# Share ideas and practices to improve the quality, performance, scalability and readability of LabVIEW code
# Provide a forum to solicit advice from peers regarding how best to solve technical and procedural challenges when developing LabVIEW code
# Drive standardization on stylings, code organization and tooling for the purpose of enabling greater reuse and collaboration

See the [https://forums.ni.com/t5/User-Groups/ct-p/user-groups LabVIEW Community Forum: User Group List] to find one near you.

==User Groups Roles and Responsibilities==
{| class="wikitable"
|-
! 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, [[Events|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 ([[GLA Summit 2024/Fantastic LabVIEW Hooks and Where to Find Them|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

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://github.com/elijah286/LabVIEW-vs-python 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
|[https://forums.ni.com/t5/LabVIEW-Development-Best/Object-Oriented-Design-Patterns-Technical-Manual-and-Exercises/ta-p/3507995 Presentation and Demo Materials]
[https://www.ni.com/en/shop/labview/introduction-to-oop-and-hardware-abstraction-layers.html 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
|[https://www.youtube.com/watch?v=EzhMQ0Gt_1A 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
|[https://bit.ly/dnatterrors 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
|[https://bit.ly/dnattcollections 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://www.youtube.com/watch?v=v_cdlwIWfPY 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
|[https://github.com/elijah286/lvug-team-dev 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
|[https://forums.ni.com/t5/VI-Analyzer-Enthusiasts/Improving-Your-LabVIEW-Code-with-the-VI-Analyzer/m-p/3415352 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://github.com/elijah286/Extensible-Config-Dialog 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
|[https://bit.ly/dnattdqmhintro 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
|[https://docs.workersforlabview.io 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://bit.ly/brainlesslabview 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
|[https://www.youtube.com/watch?v=R4GN_-X__GA 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
|[https://www.youtube.com/watch?v=wOntiXaIu2o 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)
|[https://www.youtube.com/watch?v=3OBV-RSQSYI 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)
|[https://www.youtube.com/watch?v=yzjiZJZCe6A&list=PL7Ul36E7e0l97vayGr_OSl5tQlLj5jHkj 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://bit.ly/labviewspeed 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
|[https://bit.ly/slowvis 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
|[https://bit.ly/dnattlvhooks 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
|[https://forums.ni.com/t5/Hidden-Gems-in-vi-lib/Hidden-Gems-in-vi-lib-pptx/td-p/3502591 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
|[https://forums.ni.com/t5/LabVIEW-Shortcut-Menu-Plug-Ins/Presentation-Augmenting-Right-Click-Menus-in-LabVIEW/ta-p/3521526 Slides, Demos, and Recording]
|
|-
|}

===UX / UI Design===

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

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|Presentation Title
!|Abstract
!|Author
!|Demo Resources
!|SME Requirements
|-
| Extensible and Modular UIs: Extend the VI Server With Object-Oriented Techniques
| Using QControls to create reusable UI modules.
| [[Quentin "Q" Alldredge (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[NIWeek 2018/UI: Extensible and Modular UIs: Extend the VI Server With Object-Oriented Techniques|Wiki Page]]
|-
| Encapsulating and Reusing your UI Code
| Using QControls to make Reusable, Encapsulated, Extensible UIs.
| [[Quentin "Q" Alldredge (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[Americas CLA Summit 2019/Encapsulating and Reusing your UI Code|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
| [https://www.youtube.com/watch?v=qpxiQ3dFDm0 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 (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[Americas CLA Summit 2019/UI/UX Considerations when there is No Keyboard or Mouse|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 (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[GLA Summit 2022/Smartphone-like User Interfaces in LabVIEW| 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)
| [[https://www.youtube.com/watch?v=zYhzQ0Mlp-I| 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://bit.ly/ludicrouslabview Slides, Demos, and Recording]
|This content is very DNatt-specific, and may be difficult for others to present.
|-

|}

==References==
<references />

[[Category:User Group]]

User group

2024-08-28T22:57:14Z

Sergiovelderrain:

{{TOCright}}
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.
<ref>LabVIEW Forums: User Groups https://forums.ni.com/t5/User-Groups/ct-p/user-groups</ref>

==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:
# Share ideas and practices to improve the quality, performance, scalability and readability of LabVIEW code
# Provide a forum to solicit advice from peers regarding how best to solve technical and procedural challenges when developing LabVIEW code
# Drive standardization on stylings, code organization and tooling for the purpose of enabling greater reuse and collaboration

See the [https://forums.ni.com/t5/User-Groups/ct-p/user-groups LabVIEW Community Forum: User Group List] to find one near you.

==User Groups Roles and Responsibilities==
{| class="wikitable"
|-
! 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, [[Events|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 ([[GLA Summit 2024/Fantastic LabVIEW Hooks and Where to Find Them|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

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://github.com/elijah286/LabVIEW-vs-python 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
|[https://forums.ni.com/t5/LabVIEW-Development-Best/Object-Oriented-Design-Patterns-Technical-Manual-and-Exercises/ta-p/3507995 Presentation and Demo Materials]
[https://www.ni.com/en/shop/labview/introduction-to-oop-and-hardware-abstraction-layers.html 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
|[https://www.youtube.com/watch?v=EzhMQ0Gt_1A 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
|[https://bit.ly/dnatterrors 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
|[https://bit.ly/dnattcollections 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://www.youtube.com/watch?v=v_cdlwIWfPY 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
|[https://github.com/elijah286/lvug-team-dev 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
|[https://forums.ni.com/t5/VI-Analyzer-Enthusiasts/Improving-Your-LabVIEW-Code-with-the-VI-Analyzer/m-p/3415352 Slides, Demos, and Recording]
|-
|Architecting long life-cycle LabVIEW applications
|Presentation provides an overview on one of the many ways of developing a product using LabVIEW and showcases the was i was thought to work on a LabVIEW application that had multiple developers as well as the lessons learned from supporting multiple versions for multiple customers over the span of 2+ years.
|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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://github.com/elijah286/Extensible-Config-Dialog 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
|[https://bit.ly/dnattdqmhintro 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
|[https://docs.workersforlabview.io 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://bit.ly/brainlesslabview 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
|[https://www.youtube.com/watch?v=R4GN_-X__GA 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
|[https://www.youtube.com/watch?v=wOntiXaIu2o 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)
|[https://www.youtube.com/watch?v=3OBV-RSQSYI 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)
|[https://www.youtube.com/watch?v=yzjiZJZCe6A&list=PL7Ul36E7e0l97vayGr_OSl5tQlLj5jHkj 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://bit.ly/labviewspeed 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
|[https://bit.ly/slowvis 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
|[https://bit.ly/dnattlvhooks 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
|[https://forums.ni.com/t5/Hidden-Gems-in-vi-lib/Hidden-Gems-in-vi-lib-pptx/td-p/3502591 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
|[https://forums.ni.com/t5/LabVIEW-Shortcut-Menu-Plug-Ins/Presentation-Augmenting-Right-Click-Menus-in-LabVIEW/ta-p/3521526 Slides, Demos, and Recording]
|
|-
|}

===UX / UI Design===

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

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|Presentation Title
!|Abstract
!|Author
!|Demo Resources
!|SME Requirements
|-
| Extensible and Modular UIs: Extend the VI Server With Object-Oriented Techniques
| Using QControls to create reusable UI modules.
| [[Quentin "Q" Alldredge (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[NIWeek 2018/UI: Extensible and Modular UIs: Extend the VI Server With Object-Oriented Techniques|Wiki Page]]
|-
| Encapsulating and Reusing your UI Code
| Using QControls to make Reusable, Encapsulated, Extensible UIs.
| [[Quentin "Q" Alldredge (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[Americas CLA Summit 2019/Encapsulating and Reusing your UI Code|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
| [https://www.youtube.com/watch?v=qpxiQ3dFDm0 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 (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[Americas CLA Summit 2019/UI/UX Considerations when there is No Keyboard or Mouse|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 (LabVIEW Champion)|Quentin "Q" Alldredge]]
| [[GLA Summit 2022/Smartphone-like User Interfaces in LabVIEW| 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)
| [[https://www.youtube.com/watch?v=zYhzQ0Mlp-I| 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.

{|class="wikitable sortable static-row-numbers sticky-header col1left" border="1" cellpadding="20" cellspacing="0"
!|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
|[https://bit.ly/ludicrouslabview Slides, Demos, and Recording]
|This content is very DNatt-specific, and may be difficult for others to present.
|-

|}

==References==
<references />

[[Category:User Group]]