GLA Summit

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. This presentation is entirely in LabVIEW (no PowerPoint). Every screen shows demos of how LabVIEW user interfaces can be more modern, animated, intuitive, and easy to use and reuse.

We live in a connected world and with the Internet of Things (IoT), it is crucial to have our LabVIEW applications leveraging existing pieces of software and services available out there.

Did you know LabVIEW can interact with your Office 365 or Google account? Did you know LabVIEW can programmatically use Google Translate, Geolocation, Text-to-speech, Artificial Intelligence, etc.?

Any time you think something might be difficult to achieve with LabVIEW, there is probably an alternative available with a cloud services provider that you can leverage directly from your LabVIEW code.

In this presentation, we will give you all the keys, tips and tricks to have your LabVIEW application communicating with the most popular cloud services, achieving different kinds of popular authentication methods and leveraging the incredible quantity of APIs available on the web!

We will also show you how you can implement your own secured cloud services with LabVIEW Web Services and have other programmers interact with your API using any programming language they want!

Teststand is a versatile scripting environment with native reporting and cross-platform support.

It is easy to use and allows non-programmers to expand functionality on their own accord while we can focus on core functionality.

By using Teststand based actors we can provide our users with a development environment in which they can expand functionality as well as a provide compatibility to production environments.

In this presentation we explore strategies, practical implementations and version/lifetime management.

TSnax simplifies the TestStand API by splitting up the functionality found in the TestStand Engine into easier to navigate classes and putting the methods where you'd expect to find them. An example is the ability to open a Sequence File with the SequenceFile class instead of calling GetSequenceFileEx on the Engine class. It also daemonizes most references so they stick around when asynchronous VIs finish their execution.

Have you ever wished STM did connection management for you in addition to the messaging? Have you ever struggled with managing a TCP server and accepting multiple connections? Let's take a look at the Illuminated-G communication libraries available on VIPM and leave the connection management up to the libraries! There will be a small TCP specific library that serves as a more capable upgrade from STM and then a fully abstracted, event-driven with VI callbacks, streaming and messaging group of libraries that currently support TCP, Serial (VISA), and soon WebSockets.

NI's software products for electronics testing have evolved over decades, starting with LabVIEW and expanding to cover new workflows and personas with products like TestStand and InstrumentStudio. As each of those products have evolved, we've heard from our customers that they need a more connected workflow that enables them to be more productive with less low-level coding required. As we continue to evolve our software portfolio, we are adding a new component that can better bridge the gap between our core test workflow products AND set our users up to take advantage of the next generation of test and measurement software capabilities while bringing their existing IP with them.

STS Live Test Result Viewer(STS LTRV) is a tool that displays the results published by the STS Publish Data APIs from different code modules across different sites in a single view while the TestStand Sequence is running, thus enabling the live data viewing capability for NI STS test programs and makes the life of the test developers easier to debug the issues on NI STS.

Git link - https://github.com/pranay001/STS-Live-Test-Result-Viewer

adding tool roadmap and backlogs into GitHub is in progress.

We know the standard modern, silver, classic, and system controls that ship with LabVIEW appear outdated in a world where everyone is used to beautiful UI designs from their latest smartphone applications. The updated DMC GUI Suite provides a way to make sleek, modern-looking UIs in LabVIEW without having to spend hours customizing controls. Additionally, the controls and indicators operate just like native LabVIEW controls and indicators, and are fully customizable should the developers want to modify them. This presentation will highlight the features of the DMC GUI toolkit, as well as ways to maximize your LabVIEW UI prowess.

Do you ever sit back down at your desk and struggle to remember what you changed since your last commit? Do you ever feel like you've missed something out from your commit notes? Does the LVCompare tool feel like 'too much effort' to use regularly?

I'll show you how you can make graphical diffing easier than ever before, by bringing up the Git log with a QuickDrop shortcut. Now you can see what 'really' changed between two commits at the push of a button!

The signs are all there: fire-fighting mode, lots of overtime, code that requires heavy maintenance or support, overrunning budget, missed deadlines, lack of documentation and much much more. How would you like to take a vacation and not worry about getting calls from operators trying desperately to get product out the door? This can be a reality with the right team structure. Setting up the best team requires properly skilled engineers, disciplined processes and shared standards. This presentation shows how to assess your team, identify a charter and achieve the goal of becoming a all-star team. If nothing else, come and dream.

Wired-in Software run a High School Year 10 1-week work experience program entitled "The Pampered Pig". This program introduces the student to LabVIEW, basic electronic circuits with a Sparkfun Redboard Arduino, Makerhub LINX drivers, SQL databases, and Grafana. The student's objective is to create an environment monitoring system for the customers and staff (ie guinea pigs) who attend The Pampered Pig - a high end luxury guinea pig beauty resort!

The need to integrate LabVIEW into hybrid software environments continues to grow and diversify. I will discuss insights, experiences, and lessons from a real application developed for an aerospace customer of NI Professional Services. The system uses FlexRIO to interface to a read out integrated circuit (ROIC) to perform high-speed data capture. The software stack starts with VHDL exported from Vivado, passes through LabVIEW FPGA for target interfacing, into LabVIEW for host processing and .NET assembly export, and finally into a C# API layer wrapping everything up for the customer's environment.

The presentation will focus on the implications of developing such a large, multi-tiered application, efficient transfer of large datasets, and using LabVIEW-built .NET assemblies. The target audience is advanced developers and system architects curious about using LabVIEW in .NET and incorporating FPGAs into large-scale applications.

Using the DQMH framework within your TestStand sequences and User Interfaces is possible !

It can be very powerfull, but with great powers come great responsabilities !

Learn how you can effectively leverage the DQMH framework forces with TestStand and understand the limitations that can appear when using it.

Deep Learning is becoming more and more popular nowadays. And GPUs are providing the computational power to make DL based application live. This presentation will introduce to DeepLTK (Deep Learning Toolkit for LabVIEW) which allows to create, train and deploy custom deep learning models, and CuLab (GPU Toolkit for LabVIEW) which has very intuitive (LabVIEW like) API and is intended for accelerating any computationally intensive LabVIEW code on GPUs.

Empathy is a technical skill. Don’t worry. You read that correctly. While empathy is often cited as a critical “soft skill,” it doesn’t stop there. Empathy is also an incredibly technical topic that is more accessible to analytical engineers and more vital to building software than you might think.

In this engaging keynote, Andrea Goulet, a noted expert on communication in the software industry, will debunk several myths around empathy. Empathy is a feeling? Nope? Technicians can’t access empathy? Nope. Empathy is just a high-level, touchy-feely fad? Nope. Andrea will demonstrate how empathy is a crucial skill for developing software and will focus on giving you practical and immediately actionable advice for making empathy a central focus of your daily development practice.

You’ll walk away with a solid understanding of what empathy is, what it isn’t, how you can build your empathy skills, and a framework for using empathy while coding. If you’ve ever thought that you’re “good with machines” but have struggled to understand people, this is a talk you won’t want to miss.

Empathy is a technical skill. Don’t worry. You read that correctly. While empathy is often cited as a critical “soft skill,” it doesn’t stop there. Empathy is also an incredibly technical topic that is more accessible to analytical engineers and more vital to building software than you might think.

In this engaging keynote, Andrea Goulet, a noted expert on communication in the software industry, will debunk several myths around empathy. Empathy is a feeling? Nope? Technicians can’t access empathy? Nope. Empathy is just a high-level, touchy-feely fad? Nope. Andrea will demonstrate how empathy is a crucial skill for developing software and will focus on giving you practical and immediately actionable advice for making empathy a central focus of your daily development practice.

You’ll walk away with a solid understanding of what empathy is, what it isn’t, how you can build your empathy skills, and a framework for using empathy while coding. If you’ve ever thought that you’re “good with machines” but have struggled to understand people, this is a talk you won’t want to miss.

A great tool becomes limited in hands of one who don’t know how to use it. From trainings to communities and code review from proficient developers provide Learning Experience cutting down the development time and effort.

At HSE, we are big believers in Inner Source (Open Source used within an organisation) and apply it to our customer projects. By opening up our code to the public and sharing it for free we make sure we stay on top of the tools and processes needed for that, and we pay back to the awesome LabVIEW community.

In this presentation, we will first introduce our open source offering and then focus on our flagship open source project: The HSE Application Template. This template is targeted at software built with and around DQMH modules. It is based on our UI framework (which builds on the HSE flavour of DQMH®) and comes with basic functionality for module loading and configuration, UI management and logging/debugging. The template serves as a starting point for our LabVIEW applications.

Finally, we will show our way of working and explain how you can contribute - because sharing is caring :-)

NI recently filled the new Developer Relations Lead position and is committed to re-engaging with our base. Our first action is to restart our support of Regional User Groups. In this session, learn how to get involved and how NI can enable and support your efforts. We will also have Q&A time so you can share your ideas for moving forward.

Contributing to a LabVIEW open-source project is not as easy as we think.

In this presentation, Olivier Jourdan, a project maintainer, and Paul Morris, a contributor, present how they effectively and successfully worked together to improve a feature of this project significantly.

You'll learn how discussions lead to contribution and the minimum git configuration you need to know to allow the final merging of the code modification into the project.

We hope this will help the LabVIEW community to contribute more than ever to open-source projects.

The documentation process is often a pain.

You and your manager know that having valuable and up-to-date documentation is essential. Still, you also know that you don't like using MS Word, and your manager considers it a low-priority task.

Using a real project example, we will see a way to make the documentation process a part of your development workflow and how we can mix automated and manual content creation to obtain better documents.

The uFramework is an open and extensible framework that allows for payload-agnostic messaging with a lowered barrier of entry for users of different backgrounds and skill levels. It improves code reusability by abstracting communication, and allows for seamless transition from direct inter-process messaging to pub/sub messaging patterns. The framework natively supports synchronous or asynchronous communication with or without delivery acknowledgements and/or sync/async replies. It is tailored for pluggability but could be optimized for high-speed streaming applications.

The goal of the presentation is to how one can set up CI on JetBrains Team City using tooling developed by Steve Ball called composed-ci.

An example will contain:

- Fetching Code from Source code control (git / bitbucket)

- Compiling of the LabVIEW application (including using of LV Submodules)

- Running unit tests using JKI VI Tester

- Building of the Application as an (executable or other build spec like NI Package)

- Runing Static Analysis using VI analyzer.

This presentation will introduce the main new features introduced into Workers 4.0, such as the new Workers Debug Server and the development of Workers applications on NI real-time targets such as a cRIO. A case study will also be given of how to create a Workers API that can be called from TestStand.

TestStand made some improvements to its Python adapter in 2022 (releases 2021 SP1 and 2022 Q4). As part of this presentation, I will showcase how the end user can step into a Python code module from a Python step and also how TestStand will reload Python modules that are modified during the execution of a TestStand sequence.

"It's LabVIEW, you don't have to worry about memory management!"

This is true, until you need to squeeze more performance out of your application. This session will cover an understanding of memory performance in a modern PC and how that translates into LabVIEW.

Nowadays, we are coming across a lot of use cases and environments, where multiple programming technologies are used together to leverage the advantage of each technology. This also depends on various personal or group choices as well. This is leading to the need for software developers, especially those who are developing software frameworks to build scalable software that can support multiple programming technologies.

One type of scalability that we can provide is allowing the software plugins to be developed with any other technology and developing the framework in such a way that it can work with those plugins. To do this kind of architecture, gRPC technology that is getting traction recently can be used. GRPC is like a communication interface that allows communication between different software pieces irrespective of the technology/language being used.

We will be discussing how to leverage gRPC to build a software framework that can work with many programming languages with some examples.

An early preview of SLL Drona - an open source LabVIEW UI Testing Framework. The presentation will cover SLL Drona APIs and will walkthrough on how to write UI tests for a sample LabVIEW application.

Introduction to the fundamentals of Strings and Arrays, then moving into Sets and Maps, the newest data types in LabVIEW

Giving a presentation is hard. Giving a good presentation is really hard. Giving a good LabVIEW presentation is really easy... for Darren and Norm. Come learn some tips and techniques for putting together and delivering an engaging, informative, memorable LabVIEW presentation. Darren and Norm happen to have very different presentation styles, yet are often told by LabVIEW audiences that their presentations are good. So learn from the masters on both sides of the Good LabVIEW Presentation spectrum!

In my time as a Principal TSE at NI, I have seen a lot of compiler errors, app builder failures, crashes… and most of the time, users will settle for any hack, kludge, or workaround just to get usable code. In this presentation I’m going to share a number of the ridiculous ways I’ve managed to get broken code running.

History of FlexTest 1.0 with problem statements and challenges faced during feature development. Motivation for FlexTest 2.0 by adding features to the existing software by using Actor framework for effective solution. Using multilayer architecture for design processes with low level driver and framework development.

I want to present a demo of Panther Dashboard and show what's new to date.

These are some of the topics I want to talk about:

Drag and drop capability

Right Click Menus

Find DQMH Module Callers

Find DQMH Module Subscribers

Open Antidoc Output

This presentation will cover the basics of a 3D engine written completely in LabVIEW. The basics including cameras, transform and projection, lighting, rasterising and presentation will be discussed. Although 3D can be maths heavy, the focus of this presentation will be placed on obtaining intuition rather than a deep dive into the maths.

We will also review optimisation techniques that can be applied in LabVIEW to get the highest possible performance out of the renderer.

This is a talk about what modern applications, based on asynchronous messaging between components, can learn from older techniques that use synchronous subVI calls. As an example, it looks at weaknesses in the Continuous Measurement and Logging Project Template.

Note: this was given previously at the 2017 eCLA Summit.

One of the things that keeps the software community alive is the sharing and reuse of code. However, the LabVIEW community has relatively few examples of open-source projects with multiple contributors - instead featuring projects built in many cases by small teams or individuals.

The benefits of open source have been widely promoted within the LabVIEW community - including in presentations at this summit such as G Idea Exchange: Empowering Your Open-Source LabVIEW Ideas and A real-life example of contribution to a LabVIEW open-source project.

For this panel, we therefore want to discuss a different aspect:

Why does this not work as well for LabVIEW as for text-based languages?

Where are the main barriers?

What can we do to overcome them?

We will present a short introduction to the TestStand gRPC API that is in Technology Preview. You will get a chance to understand what has been built and what the plans are for ongoing development.

We will showcase the example that is available today on GitHub and show users how to access the proto files and more.

You will have a chance to join the Technology Preview.

This presentation introduces an custom project template based on the ATM Sample Exam for CLA test. From this example, I created this Template to be a starting point for our projects.

NI Keynote - more information coming soon.

NI Keynote - more information coming soon.

Often times R&D will throw a prototype over the wall at production. It becomes their job to write automated tests, most of the time reproducing what R&D has done. What if you could rapidly develop tests for design verification and then reuse most of that code during production? This presentation shows one approach to making this a reality. A modular architecture that builds much like a lego system is the answer. This has been proven with many companies and across multiple industries. Come find out how you can take advantage of such an architecture.

Reusing properly engineered code saves time and money. Applying SOLID Design Principles results in creating highly reusable code units. Actors are the typical building blocks of Distributed Applications. Actors interact with each other by sending and receiving Messages.

Actors developed with the knowledge of location (within the Distributed Application) and/or runtime environment of other Actors are not truly reusable. In such systems, moving an Actor into a different location or different Development Environment (i.e., Programming Language) takes time and effort not only for updating code of the Actor being moved, but also code of the Actors it communicates with.

This presentation shows how to design and implement context-agnostic Actors interacting via a LabVIEW-based Distributed Message Broker.

improving the power of LabVIEW with merging with DLL files has many advantages in addition to some warning we need to consider .

The LabVIEW community has more automated testing capabilities than ever before with increased adoption of unit testing, VI analyser and continuous integration. In this presentation, we'll take this a step further and look at how you can use industry-standard software testing tools to automate testing of your built LabVIEW applications. This can significantly reduce manual test time and increase quality through fewer regression defects.

The architecture of an actor system has three components:  what the actors do, what messages they send, and what routes exist between them.

However, in Actor Framework, the messages in a system are intimately coupled to the recipients, not the senders, which tends to overemphasize the individual actors.  Interfaces, new in LabVIEW 2020, break this coupling, and elevate messages to first class citizens.  This presentation will discuss how interfaces let us view the message network as a distinct design entity, and explore some ways we can use that insight to strengthen our designs.

Collections – maps and sets - were added, without much fanfare, in LabVIEW 2019. These highly useful constructs are still new to many LabVIEW users. In this presentation, we will explore what maps and sets are and how you can use them to solve routine data management challenges. As a practical example, we will use maps, sets, and some additional LabVIEW features together to identify groups of objects that share common search tags.

LabVIEW front panels often overwhelm users with a torrent of raw data that takes time and brainpower to make sense of. We'll discuss strategies to add context, and impact to your data so users can immediately understand the story your system is telling. Build clean, intuitive, and functional interfaces that reduce pain for developers and operators alike.

Submit your best (and worst) LabVIEW UI screenshots to Hunter@jki.net for an interactive discussion of best practices for making sense of complex systems with great interfaces.

Do you have the next great idea for an open-source toolkit in LabVIEW but need help implementing it? Would you like to help new upcoming toolkits get funded and get initialized? Is your company looking for an open-source project to invest in?

The G Idea Exchange is a sub-committee under the non-profit GCentral. It promotes and supports new open-source toolkits and ideas for improving LabVIEW, helping open-source ideas get off the ground.

As programmers, we work with sequence diagrams, flow charts, and class diagrams often. At times it might be time-consuming to create, edit and maintain these. Plantuml provides an online and offline tool to create these and many more diagrams from simple text instructions. These instructions can be easily maintained in any Source Control Management. These diagrams can then be exported as PNG, SVG, or ASCII art.

In this presentation, we will see how to use plantuml to create sequence diagrams and flow charts

LabVIEW Quiz Session

TestStand Quiz Session

The seemingly simple edge cases often bedevil us the most, bringing complexity, race conditions, and that unsavory sensation we might dub "designer's remorse." I submit that even the most elegant application needs to share *some* data between asynchronous processes and that this predicament is a main driver of complexity in otherwise well-designed software. As LabVIEW developers or architects, we know what NOT to use (globals, yuck!) and often reach right into our standard toolkit of complexity-shifting design patterns. Having spent an unhealthy amount of time pondering and tinkering with this problem, I propose an alternative: share and mutate these special data safely, free of race conditions, using graphical syntax that looks exactly like the deterministic, readable, dataflow that all professional LabVIEW developers know and love. In this presentation I will provide the solution and some rationale that helped me get there. The concepts come (almost) straight from Clojure, a first-class functional programming language; they just required some thought and a good deal of elbow grease to bring to LabVIEW. Introducing: the LabVIEW Atom!

This presentation will discuss how to extend the functionality of the LabVIEW application by accessing the other Windows applications using Active X and .NET

Test Driven Development (TDD) is a software engineering discipline where the design process is guided through the use of automated tests. This discipline has many advantages and a strong impact on the design emerging through the process.

During this presentation I will walk through the process of solving a Certified LabVIEW Developer (CLD) exam using TDD. I’ll analyze the solution, explore the challenges, and share some conclusions.

This should give a nice introduction to the concepts involved in TDD and some motivation to why it might be worth the effort.

In recent years, LabVIEW has gained better and better support for interoperability with some text-based languages, such as Python and MATLAB. At the same time, there has been public discussion around moving either chunks of functionality, or entire applications, into languages like Python.

This panel will feature discussion of both LabVIEW and text-based languages or tools, particularly Python, and:

How to determine the best tool for the job

How LabVIEW can work with other languages

Things “LabVIEW developers” should be aware of when using Python

The experience of moving code from LabVIEW to Python

You may have heard the term CI/CD. It's all the rage lately. In the LabVIEW Community there's been a lot of focus on the Continuous Integration or CI part, but very little talk about the Continuous Delivery or CD part. We'll talk a little about CD and what it is supposed to accomplish and why. Then Casey and I will both show the tools we each use.

This presentation provides an introduction to the "New VI From Template" IDE extension. "New VI From Template" is a free, open source right-click menu (a.k.a. shortcut menu) plugin that helps create new VIs and CTLs based on templates, and helps insert them quickly into a LabVIEW project, LabVIEW library (lvlib) or LabVIEW class (lvclass). The tool helps improve standardisation (reuse of templates), and saves a few seconds and clicks each time a new VI or CTL is needed. The tool is available on VIPM. The source code is available on GitHub.

LabVIEW's collection types (sets and maps) has had me curious ever since it was introduced in 2019. This presentation demonstrates the approach we took for a recent project when using sets and maps for longer lived data such as configuration and measurements. This is not an introduction to sets and maps, but more of a demonstration of their versatility.

Unsuccessful test deployment is not a single massive failure. It is the result of several cascading failures. Was it ever possible to prevent this last-minute challenge? Attend this presentation for a high-level view of lessons learned over years of working with users of TestStand on ATE for inspiration on you can reflect on how you prepare a project for deployment. These lessons will be amplified from my unique perspective of the semiconductor test industry.

Among the researchers in the field of quantum information with different backgrounds such as physicists, computer scientists, and engineers, the "quantum circuit" (QC) model is widely used for its visual representation of quantum algorithms. Various online and local drag-and-drop programs allow the designing and simulation of QC with parallel “quantum wires” and interconnected “quantum gates” at the front-end level. However, by replacing these wires and gates with wires and subVIs in the block diagram, it would be possible for "quantum programming" at the back-end level and unlock the true visual programming for quantum computers with LabVIEW. In this presentation, I will go through the already published toolkit on VIPM; "QuVI - Quantum Circuit" and discuss its challenges and obtained immediate benefits and also future improvements.