Americas CLA Summit 2015

From LabVIEW Wiki
Jump to: navigation, search


HALitosis, Quit Writing Hardware Abstraction Layers That Stink! by Norm Kirchner

The creation of HAL has been on the rise recently. Although the promise of instrument interchangeability is attractive, the implemented designs often fail and force users to code inelegant workarounds. Explore common failure points and alternative approaches that can significantly improve the flexibility and usefulness of your next abstraction architecture.

Software and Patents: Navigating A Fast-Evolving Landscape by Michael R. Henson

Long considered strange bedfellows by many an engineer, the protection of software as patentable subject matter has fundamentally changed in the past two years. Recent developments are forcing a revolution in the ways companies protect their intellectual property. The presentation will provide an overview of the current state of patent law as applied to software and will address the questions of why companies might consider obtaining a patent to protect their software innovations or explore other alternatives. We will also provide tips for identifying potential software inventions and explore strategies for defending against patent infringement allegations in this arena, particularly those relating to open-source software.

State Machine Objects with Events by Jim Kring

Presents a ballanced, "best practices" based approach for creating active objects & components in LabVIEW. Will review a component template and design pattern for quickly creating large, responsive, event-driven, readable, and maintainable software in LabVIEW that people can start using right away (open source under the BSD license). Will also discuss the decades of LabVIEW and system development that went into the design choices (pros and cons of alternatives), and some examples of the architecture in action.

Overcoming Challenges of Community Code Development by Dan Smith

Reuse is something most developers know they want but is not always easy to accomplish. This presentation discusses barriers to reuse like licensing, motivation, and collaboration, and how some of these barriers can be overcome. We focus on recent community efforts from various groups and how they have solved some challenges while revealing others.

Designing Modular RT Applications for Remote Deployment by Dave Snyder

Component-based and plug-in applications are a well-accepted way to spread work across multiple developers. Compact RIO systems present special difficulties for plug-ins. Learn what problems Innovari encountered when we built a modular application to be deployed to thousands of remote RT systems over cellular networks and the solutions, we've developed to work around them.

Bringing Agile Software Development to LabVIEW by Allen Smith

Many software integrators rely on Agile software development practices to deliver quality products in highly dynamic environments. Agile methods promote development, teamwork, collaboration, and process adaptability throughout the life cycle of a project. This flexible, lightweight approach to project management delivers a better fit to customers' needs and is more closely aligned to the way people naturally work. In this session, we will review common Agile practices and open a discussion about how to apply them to LabVIEW projects.

Running LabVIEW Everywhere by Omar Mussa

Developing reusable code for the modern LabVIEW Architect. Lessons learned developing reusable VIs and applications that are FPGA target agnostic, RT OS-agnostic, and OS agnostic.

Using Agile and Continuous Integration to Deliver the Right Working Software by Casey Lamers

Know what to work on and know when it is done. The Agile process provides methods of breaking up the work into well-defined pieces, knowing what you are working on, and knowing when it is done. Continuous Integration (CI) requires that software is tested and built frequently to catch bugs early and have working software. I will discuss the processes and tools to implement Agile and CI with LabVIEW.

Test Executive Design Patterns in LabVIEW by Craig Bedward and Tony Kuiper

Many of us with LabVIEW expertise is often called upon to write automated tests. Of course, LabVIEW can do it, but the functionality is not there out of the box, nor is there a toolkit that provides it. TestStand can be powerful, but you abandon the graphical programming that we all love. We will demonstrate a flexible HAL using TestStand and our free ALOHA framework, keeping much of the code in LabVIEW. We will also preview a new approach that we are working on -- a sort of un-executive -- which brings test executive-like functionality into LabVIEW.

Actor Programming without an Actor Framework by Dmitry Sagatelyan

Demonstrates how applying Agile Design Principles allows developing scalable actor-based applications without a dedicated actor framework (with the Actor Framework being the mainstream case) by using Dependency Injection Pattern to manage Actor lifetime and Event Aggregator Pattern for advanced Actor Topologies support. The latter decouples Actor code from specific Message Transport implementations allowing mixing of ‘traditional QDSM’ Actors with Command Pattern-based Actors in the same application. Explains significant design decisions, comparing to AF as a common baseline. Goes over the LabVIEW code of a real-life application built using the presented architecture.

A day in the life of a LabVIEW FPGA Developer by Aaron Ryan

This presentation highlights experiences that I have learned first-hand in my 7 years of LabVIEW FPGA application development. Through my experiences as a former National Instruments employee and now as a National Instrument Alliance Partner, I hope to aid new and existing programmers to improve their FPGA coding through examples of resource conservation, application error/debugging, and past stories.

Treating Vis as Text: An Alternative to VI Analyzer for FilePath-Rules-Check by Elaine Ramundo and Scott Crook

While VI Analyzer is the de facto tool for automated style checking, it can be slow to launch and parse large directories worth of files. This can make it challenging to meet the ‘rapid response time’ needed for an on-the-fly style checker in a team development tool. Reading *.vi as raw text is possible, and can be used to quickly extract path and dependency information from code without having to launch LV or attach to an existing instance. Our team assembled a Jenkins rule based on this trick in order to give developers across our company “<5 min” feedback times on each SCC check-in for key projects to alert them to common mistakes. We will share our string parsing ‘trick’, and discuss the pros and cons of our approach vs a more conventional VI Analyzer-based rule-check.

Case Study of a Modular Dynamic FPGA & Host Library: The Engine Simulation Toolkit by Stephen Barrett

I needed to write a library of FPGA code LabVIEW users could build bit files with, but hand these bitfiles over to different end-users that don’t even know or care what is in the bitfile. This introduced complexities of bitfile parsing, versioning, and dynamics that standard LabVIEW EPGA doesn't solve. See how this was solved in the Engine Simulation Toolkit using the LabVIEW FPGA Advanced Session Resources combined with careful design.

Profile Buffer Allocations (PBA) tool by Rob Dye

Memory usage is a primary design concern for users developing large LabVIEW applications as LabVIEW sometimes runs out of 32-bit address space. In order to understand LabVIEW’s memory usage, we extensively analyzed some large signal processing applications. We found that a very small number of allocations accounted for a major part of the memory usage. Therefore, significant memory (and speed) improvements could be obtained by targeted optimization of a small amount of code responsible for these large allocations. In order to enable users to identify large allocations in their applications and the G code that causes them, we've added the Profile Buffer Allocations (PBA) tool to LV 2014 SP1. In this talk, we will demo the PBA tool and show how it enables you to find the parts of your code you should optimize. We will also describe some common coding patterns we found during our analysis and how we went about optimizing these.

Breaking through the language barrier - Leveraging inter-process communication in LabVIEW by John Kokott

Interacting with other programming languages and software engineers can be a minefield. Leveraging standardized serialization in multilingual (i.e. C/C++, C#, and more) environments has never been easier in LabVIEW. Break through the language barrier and streamline your development team to do what LabVIEW does best. Points of emphasis include TCP sockets using JSON, Binary vs Human readability, standardizing interfaces between languages, and interacting with the command line beyond system exec.

Organizational Proficiency by Brian Powell

Brian wants to talk about the idea of "organizational proficiency" and building strong teams of developers. He's seen projects flounder not because they had terrible architecture, but because they failed to build the right team to build a good architecture. This isn't tied to any particular development environment, but the examples he uses are based on typical LabVIEW/TestStand architectures and how to construct a team around them.

Scalable cRIO Command Interface with JSON-RPC Web Service by Matt Pollock

Use a single, scalable, reusable web service to handle all of your command interface needs. Why build your own remote procedure call protocol for your LabVIEW target when you can leverage an open-source format with wide client support, full cross-platform compatibility, and the ability to run operations in parallel? Why build a different web service method for every command for every project when you can reuse a single one?

Five Tips to Modularize, Reuse, Organize and Bring Order to your Development Chaos by Fabiola De la Cueva

Fabiola will talk about combining reuse library management and source code control tools to manage your released code and facilitate working in multi-developer teams. She will discuss ways to add formal release steps for reused code. Learn useful tips and tricks to influence the way you architect your applications.

Aligning Software Engineering with Business Processes - Effective Issue Tracking by John Giannangeli

This presentation is part of a series entitled “Aligning Software Engineering with Business Processes’. This section focuses on Issue Tracking. Presents techniques for project management, feature and defect tracking, requirements management, time tracking for billing, software versions and releases, and integration with revision control systems.