Decoupling in Practice: How Good Software Engineering Can Save Your Sanity

Does it take a week to load your project? Are your builds interminable, and prone to obscure failures? Does LabVIEW load a bunch of files before it lets you probe a wire? These and other IDE pain points are often symptoms of excessive coupling between our libraries and classes. Drawing on real-world examples, this session will explore the role of module dependency in our software designs. We will show excessive coupling complicates engineering tasks like unit testing and overly burdens the LabVIEW IDE. Then we’ll demonstrate the techniques that solve the problem, and apply them to common coupling scenarios. The result will be cleaner code, a more efficient IDE experience, and happier developers.

Fail Fast Vs Fail Smart - Lessons Learnt

The term "experience" signifies all the failures and sacrifices of an individual in personal and professional world. Failure is an essential part of the puzzle.

Technologies has played a big role to minimize losses due to failures. Eg. simulations help to test systems virtually that allow to catch some failures if not all.

Approaches like Fail Fast and Fail Smart give an avenue for acceptance of failure as a building block for success.

In this session, I will try to explain these approaches based on my "experiences".

Modularity As It Applies to Everything

Modularity is good, right? Low coupling. High cohesion. But I'm not just talking about software.

We're at an inflection point with LabVIEW and NI/Emerson--entering a new era of focus and accountability. NI has to change, and so too must our community. I'll take you on a journey that starts with the value of modularity in software and leads us to apply the ideas to the organizational structure of our LabVIEW community.

Le Roi est mort, vive le Roi!

Lessons learned installing NI targets on the edge

Over the past few years, several customers have asked us to install targets (sbRIO, cRIO, PXI systems) on the edge. From energy management to security, we'll go through a series of discoveries and tools we've built to simplify and secure access to NI targets through exposed networks. We will discuss VPN, firewall, DynDNS, data exchange and power management for IIoT NI-target-based systems.

Your LabVIEW Code Is a Work of Art... But I Can't Read It

We often talk about LabVIEW programming style: rules to follow to make VIs "look good". We assume LabVIEW code that follows style guidelines is well-written and easy to read. I propose there is a palpable gap between style and readability, and I'm going to prove it by creating and reviewing several beautiful VIs... that are unreadable. Then I'm going to introduce simple programming techniques you can follow to maximize the readability of your LabVIEW code.

The LabVIEW Experiment Live!

The LabVIEW Experiment podcast is coming to you with another live episode at GDevCon N.A. Stay tuned for details about our topic and panelists!

J-Crawler - Automating and Enforcing Code Quality

JKI's J-Crawler is a powerful static analysis and automation tool for LabVIEW that can run in the dev environment or as part of CI/CD. We'll show how we use this highly extensible tool to audit AND fix code so we can automate and enforce high quality LabVIEW according to each project or developers needs.

DQMH Generic Networking

Introduction, code review and discussion of an attempt to implement a generic networking endpoint for DQMH: The HSE Generic Networking Modules - or short: GenNet.

We've been using GenNet in our customer projects, and some others have also found them useful. The challenge that remains to be solved is: How can we make GenNet simple enough for a broader audience?

LabVIEW on my Mind

Using low-cost, open-source biosensing hardware such as OpenBCI, I will read EEG/EMG data from my brain and/or muscles into LabVIEW. Then I will do cool things with it such as control hardware based on certain brainwave activity, or link brainwaves to LabVIEW scripting or quickdrop shortcuts.

Using LabVIEW and LoRa for Long-Distance Status and Control

LoRa is a technique for long-range, low-power communication sometimes used in the Internet of Things. Let's explore what it would take to leverage this for use in LabVIEW and see some of the trade-offs involved with this fun technology.

Boost Your Innate Human Creativity and Make AI Your Bit**

Building on Nancy's previous sessions on Engineering Creativity on Demand, we will dive into the details on neuroscience and how our human creative process works. We will also delve into AI Deep Learning, the algorithms and the appearance to human learning. You will walk away with actionable practices for enhancing your ability to generate great ideas, practical AI tools to use in your business as you streamline processes, and constructive practices to remain "human" in this evolving AI world as you leverage your "human creativity" to make AI your Bit**

Optimizing Your Code for Speed: Creating a Run-Time Spellchecker to Present Word Replacement Options

In LabVIEW there are many ways to accomplish the same algorithms. Some take less code, some take more. Some execute slower, some faster. In this presentation I'll show some ways I optimized the LabVIEW code in a run-time spellchecking algorithm to provide the user with replacement word options. I show different ways of executing parts of the algorithm and benchmark each one to find which executes the fastest and why.

Nx24x7: Challenges and Considerations When Designing a Life Cycle Tester

In developing a product, it is critical to have an accurate understanding of the life expectancy, reliability and durability of the product or its subcomponents. In many industries (e.g., automotive, aerospace) there may even be quality standards that must be met before the product can be integrated into another system. One tool for gathering this information is a Life Cycle Tester.

A Life Cycle Tester is a system designed to repetitively exercise (physically or electrically) a product for days, weeks, or months – often to failure. The tester may be used to verify product life predictions or measure the reaction of the product to stressors (e.g., extreme temperatures, vibration). Data gathered by the test system may be analyzed to determine values like mean time to failure or early life failure rate. These results may then be used to qualify the product for production. In the event of a design or component change, the tester and its measurements can be used to determine the impact of the changes.

Due to the expected extended test times and large lot sizes often required, most Life Cycle Testers are designed to run multiple devices at the same time – often asynchronously.

With LabVIEW’s inherent parallelism, it is a great fit for the controlling of these systems.

This talk will cover two of the biggest challenges in designing a Life Cycle Tester: 24-7 continuous operation and multiple asynchronous device testing. It will cover high-level design considerations and include some practical tips, tricks and trip-ups when designing this type of system.

Using LabVIEW To Do Totally Legal Things Online (Legally!)

Suitable for all Have simple web tasks you'd like to automate? Does your instrument lack an API, but have a web based interface? Well, LabVIEW can help with that! Inspired by an NI Forums post about automating online banking actions and the need to create an API for an instrument over the web, see how you can use the NI Advanced HTTPS toolkit to interact with websites through LabVIEW. No web development experience required.

In this presentation, I'll spend a few minutes introducing my specific use case, which was writing a LabVIEW API for instrumentation that lacked a vendor provided API. I'll then spend the majority of the time talking about what it means to Get and Post HTML data, how to use the NI Advanced HTTPS toolkit to accomplish this, and how you can use a 3rd party tool to identify the necessary HTML and Java code if, like me, you have no idea where to start interpreting that code. We'll also talk about strategies to manage this data safely.

Everything we'll do is totally, 100% legal.

Innovate, Validate, Elevate: LabVIEW Quality Paradigm

Are you ready to revolutionize your LabVIEW code development? Dive into a transformative approach to elevate your code to new heights. How can coding guidelines and National Instruments' Center of Excellence principles set the stage for innovation and excellence in LabVIEW development?

Innovating higher quality processes involves fostering a collaborative environment where developers actively engage in iterative feedback loops. By encouraging open communication and embracing diverse perspectives during code reviews, we elevate the overall code quality. Integrating tools like VI Analyzer, VIA+ Scripting and GitLab pipelines for continuous integration, and adherence to guidelines accelerates the development cycle without compromising code integrity. This holistic approach not only expedites software delivery but also establishes a culture of continuous improvement, where innovation and collaboration intersect for fast and effective higher quality code.

Explore the validation phase, where a solid test approach drives decisions in your test approach before you write unit tests. Have you considered the power of automated testing and continuous integration to ensure a robust and error-resistant codebase?

Discover the elevation strategies through a variety of code reviews – from collaborative peer code reviews to in-depth functional and quality code criteria and tools. How can these reviews foster a culture of excellence and refinement within your development team?

Embark on a journey to transform your LabVIEW coding practices. You too can innovate fearlessly, easily validate, and elevate your code to new standards of excellence. Are you ready to revolutionize your LabVIEW development approach?

Stop Wasting Your Time Straightening Wires

We waste so much time in LabVIEW focussing on the wrong things. We focus on all kinds of cosmetic things, like wire bends and terminal sizes, etc. What if you could redirect all that energy into solving the customers problems?

Python has an autoformatter called Black. If set up correctly, you never have to worry about formatting when you write Python code. How do you format a dictionary that spans multiple lines? I don't know and I don't care because Black handles it for me.

In LabVIEW we have the Nattify QD shortcut that many devs run instinctively before saving. What if that just ran automatically? And cleaned up a few other things as well.

Introducing "Blue - It's like Black but for LabVIEW"

Decomposing Object Data into a Tree Structure using JSON and SQLite.

Have your data objects become so complex that you can't see the forest for the trees?

This presentation will demonstrate how to decompose your objects and display the data in a user-friendly, clear manner.

We explore the innovative use of existing libraries to visualize complex object data in a tree structure.

The session highlights how JSON and SQLite can be utilized for streamlined data management and enhanced clarity.

Discover how to transform complex datasets into visually clear, easily filterable representations.

As a bonus, the presentation will also briefly show the reverse process: creating a new LabVIEW control from any JSON data.