GLA Summit

Presenting my collection of open source reusables that I have created over the years with my team - SLL Toolkit, which includes:

1. Write/Read Spreadsheet File - Supports multiline texts and commas within cells, like Excel

2. Variant Pop Up - Allows showing any data type (like a cluster) as a message pop up.

3. Alpha Numeric Sort 1D Array - Alpha Numeric Sorting of 1D String Array so that strings are ordered like File 1, File 2..File 10 instead of the usual sorting like File 1, File 10, File 2..

4. Class DVR API Generator - Generates DVR based APIs for LabVIEW Class Methods.

5. Project Save As - Make a copy of the project and rename some of the components of the project including their relinking.

6. Compare VI Folders - Compare two folders containing VIs to identify modified VIs ignoring cosmetic changes.

https://github.com/solitontech/SLL-Toolkit

In the presentation I'll tell you all the hooks that exist in the LabVIEW IDE and how to create and automate your development. I'll even show you some that you should use at your own risk.

A quiz about LabVIEW!

A quiz about TestStand! Guest-hosted by Michał Bieńkowski.

In this case study, I will show tools for automating software deployment on the NI Linux RT system. The discussed scenario assumes the deployment of a custom software package with a specific configuration on an offline PXI with the NILRT system (without access to the remote NI package repository). I will discuss the tools necessary to accomplish such a task. Finally, I will present conclusions about the advantages and disadvantages/drawbacks of the implemented solution.

LabVIEW has a rich ecosystem of toolkits and frameworks designed for reuse across multiple programs and hardware setups.

Together we will investigate the usage of GPU computing with a wide range of environments like DQMH, Unit tests, build servers and more. We will also have a look at effective use of different hardware solutions with personal and industrial computers as well as PXI's.

All based on the free community edition of G²CPU.

Continuing my trend of "Why do that in LabVIEW?" I'll be showing off some demos of how I'm aiming to make Summer of LabVIEW challenges more engaging and fun that can also be used to elevate GUIs for LabVIEW applications and the adventurous. See how to integrate web builds from the Godot game engine (and other web exports) with a LabVIEW application. This also opens to door for more tightly integrating web UIs into LabVIEW applications.

A brief introduction to the GLA Summit and the conference platform.

Code optimization for large data set for memory and to get good execution speed. write optimized code with large array, to get good TT and less memory footprint, to avoid memory leak

Documentation is critical in so many applications ranging from documenting code, to document project plans, to generating reports. But keeping documentation organized, accurate, and relevant often fails the ROI test because of the manual effort required.

Atlassian’s Confluence product is an environment that enables anyone to capture, organize, evolve, and distribute knowledge.

In this session l'll walk through my free, open source API that automates interactions with Confluence (both cloud and server). Then I’ll show some of the applications of the API.

If your company has access to Confluence, the presentation is for you!

In this session, we'll learn how to improve the LabVIEW project development cycle using Continuous Integration (CI) with Azure DevOps (AzDO). We'll explain what CI is, why it's useful for LabVIEW, and show you an implementation example. You'll see how to automate tasks like building, testing, and deploying LabVIEW applications, making your development process smoother and more efficient. Whether you're new to CI or want to make LabVIEW development easier, this session will help you to get started.

Agenda:

1. Introduction to Continuous Integration

2. Overview of CI/CD Pipelines in Azure DevOps

3. Setting Up a LabVIEW Project for Continuous Integration

4. Demo on

o Perform Static Analysis using a VI analyzer

o Execute Unit tests using the Caraya Unit Test Framework

o Building an Executable out of LV Project

From business decisions to relationship conflicts, your thoughts and mindset have a huge impact on your life. But what influences those thoughts? Hint: It's the emotions you are experiencing.

Emotions are the foundation of decision making for most people and dictate how you experience life. They are the difference between feeling inspired when you have an idea, and feeling exhausted and quitting when a challenge arises.

In this talk Sumedha will share about the science behind emotions, ways to practice emotional awareness, how mindfulness helps you create inside out and live more intentionally.

LV_Chalk is a versatile terminal styling and coloring library designed to enhance the presentation of command line output. This abstract explores the utility and functionality of LV_Chalk in customizing response messages with vibrant colors, thereby improving readability and facilitating efficient error detection. By enabling users to personalize their output with distinct color schemes, LV_Chalk offers a user-friendly solution for developers seeking to elevate the visual appeal and clarity of their command line interfaces.

A live presentation of the new features of DQMH 7: Helper Loops, Private/Local Events, Custom Request Timeout, and many more small improvements. We will also talk about what's going on at the DQMH headquarters these days, and which other tools and products you can expect in the near future.

-----

Comments: This presentation is on behalf of the DQMH Consortium; the new features of DQMH 7 are listed at (https://documentation.dqmh.org/dqmh/7.0/WhatisNewInDQMH.html)

This presentation will cover:

- The basics of object-oriented design, its purpose and advantages

- The effectiveness of graphical means in the project planning phase

- How UML diagrams are useful for visualizing code architecture

- NI-GDS - why it exists, its relevance today, and useful tools included

- Designing UML diagrams from scratch, and reverse engineering from existing code

There are several methods to schedule code execution at regular intervals in a LabVIEW program.

On desktop operating systems, I find it helpful to create a "Helper loop" using a while loop and an event structure.

In this 15-minute presentation, I will demonstrate the correct way to implement this method to ensure a consistent execution period.

(A replay of the NI Keynote.)

In this keynote, we'll discuss strategies for improving user relationships and share our vision for the road ahead. Additionally, I'll outline our initiatives to streamline software integration, making your workflows smoother.

I have over a decade of experience building successful relationships and communities, and I’m excited about the opportunity to work closer with all of you. This keynote is the official start of my “listening tour” so I encourage you all to bring your community-building ideas to this keynote so we can discuss them together.

Let's work together to build a stronger LabVIEW community where your feedback helps shape our future direction.

In this keynote, we'll discuss strategies for improving user relationships and share our vision for the road ahead. Additionally, I'll outline our initiatives to streamline software integration, making your workflows smoother.

I have over a decade of experience building successful relationships and communities, and I’m excited about the opportunity to work closer with all of you. This keynote is the official start of my “listening tour” so I encourage you all to bring your community-building ideas to this keynote so we can discuss them together.

Let's work together to build a stronger LabVIEW community where your feedback helps shape our future direction.

Tom's take on working with controlled technologies, navigating compliance in the US, placing insurance, perspective on Small Business Innovation Research Grants and bootstrapping high-tech hardware companies, blue economy engineering opportunities, and keeping things fun when the tech is pretty darn serious.

Also don't forget - launching rockets from Downeast Maine!

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

LabVIEW is missing an open-source image acquisition and processing toolkit until now.

Learn about the features of the G Augmented Reality Toolkit and how you can get involved to support the development.

This session is about how to establish a enterprise level deployment of TestStand using Keyword Driven framework,

Adapting all skills to be part of the framework, collaborate & work together at organization level for test automation.

Enabling utilization of TestStand's multi adapter support.

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 quickly and precisely convey their exact error behavior in an error condition.

A friendly reminder of a bunch of the the great things about LabVIEW that brought us here, and kept us here.

HIL systems are widely used for testing and validation of complex control algorithms in various industries. Leveraging DVRs in LabVIEW, engineers can efficiently manage data communication between real-time controllers and simulation models, enhancing system performance and flexibility. Also highlights the benefits and implementation strategies of DVRs in HIL setups, emphasizing improved data handling, reduced latency, and simplified code maintenance.

This work presents a Master's Research about LabVIEW Analysis and Refactoring Code . In this Scientific Research, we introduce the theme and the main research problem. Then we pass by the most important papers about the subject that were published. At the end, we propose a tool to analyze code and make some refactoring when some code smell is found.

Have you ever heard something along the lines of ‘LabVIEW is so convenient for executing code in parallel’ probably you have and depending on your LabVIEW experience you may already know by this point that this person meant concurrent but not parallel. But do not worry if you do not know what I mean by concurrent, jump in with me and let me show you the differences between parallelism and concurrency and how they apply to LabVIEW.

As engineers, we deal with complex issues. But are we making things more complex than necessary? Let's explore the concept of simplicity, how it makes engineering easier, and apply it to our lives.

Ever wonder what it would take to push your TestStand data to Excel or TDMS? This presentation shows how to create a custom report plugin for TestStand. A simple step by step guide with tips and tricks.

Sam Roundy is the most kudoed author on the TestStand forums. He has taught hundreds of users how to use TestStand. This presentation is a culmination of things he has witnessed over the 20+ years of his career that you should, or shouldn't, do in TestStand to make it a pleasant experience. No! There will not be a burning bush or stone tablets.... just wisdom.

Presenting the newest features added to the 2024 release of the Workers framework for LabVIEW, this presentation will introduce the new scripting tools that allow you to create Public APIs and HALs (that can be used by TestStand) using Worker QMHs. The presentation will also introduce the new API messaging types (Requests, Responses, etc.) as well as the improvements made to the new Workers 5.0 Debug Server application.

Code comparison and review play pivotal roles in ensuring the quality, reliability, and maintainability of software. While Git facilitates these processes through its robust versioning capabilities, LabVIEW's graphical nature poses unique challenges for integration with Git services like GitHub or Azure DevOps etc. LabVIEW developers typically resort to manual code comparisons or rely on the LabVIEW compare utility, often leading to cumbersome workflows and increased review times. To address these challenges, my "LabVIEW Code Comparison Tool for Git" offers a streamlined solution.

This LabVIEW VI empowers users to effortlessly compare code between Git branches or commits directly within the LabVIEW environment, eliminating the need for external tools or complex configurations. With features like current branch status indication, selective comparison controls, and intuitive interface, the tool enhances efficiency and productivity in LabVIEW code review processes. Its versatility caters to various use cases, including general code comparison between revisions and facilitating pull request reviews by identifying changes across branches or commits. By bridging the gaps between LabVIEW development and Git version control, the tool facilitates smoother collaboration and improves the overall software development lifecycle.

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.

You might carry the next big thing that would help the LabVIEW community. Having an idea is not enough! Bringing the ideas to life and finally releasing it to the world is much more valuable.

At GCentral, we provide the G-Idea Exchange Forum, making sharing easier, and discuss ideas within the LabVIEW. Over the past couple of years, we have tried different formats and have now settled on what we think will be the best solution.

We are presenting the state of the current ideas to give examples.

Additionally the we support posts for ideas that you would like to find other developers to solve or take over.

We're excited to announce some major transformations at GCentral! Today, we are thrilled to share several new and exciting initiatives.

This presentation will delve into all the website transformations we've implemented, making GCentral a more user-friendly and engaging platform. Get ready to discover a website that's simpler to navigate and packed with valuable content.

LabVIEW Actor Framework by itself is a very robust framework for a variety of reasons like Encapsulation, Modularity, Scalability & so on. In this presentation, we would be driving in on Scalability aspect & how it can help in building a robust applications.

Unit testing and test driven development are invaluable disciplines for developing high quality code. However, dealing with calls to external code and verifying interaction with IO can be challenging. These challenges are not unique to graphical programming and the industry standard way for tackling these is to use test doubles, such as mocks, to emulate the environment and verify interactions.

This presentation will introduce and explain the concept of mocks and show how they can be used to improve testing. The mocking framework LMock is introduced and it is shown how this may be used to reduce the amount of boilerplate code and reduce development time. We will further discuss some of the design implications of using mocks and test driven development as design tools.

I just want to point out a set of GCLI tools that I created and a website with a bunch of useful CI/CD getting-started information. It'll mostly just be a few minutes of me pointing out the website and the various tools available.

I will go through the Gilded Rose Kata using Approval Tests. I'll show how to use combination testing to make sure you hit all code paths and I'll also show off a few refactoring techniques.

The Community Training Initiative (CTI) is a collection of open-source projects designed to enable hosted training events to be run anywhere in the world.

These projects can be found at https://github.com/LabVIEWCommunityTraining and include guides, drivers for inexpensive hardware, and hardware simulators for a software-only setup.

Join Steve Watts for an introduction to the Community Training Initiative and to learn how to get started or contribute yourself!

This year I'm focused on building a template for embedded systems. The LattePanda boards seem to fit our requirements and come with an on-board Arduino... Let's play!