You are currently browsing the archive for the JKI Labs category.
Greg Sands has just released a very cool plug-in for the JKI Right-Click Framework (RCF) called “Open Typedef Wire.” It allows you to right-click on a wire and open its Type Definition control (if the wire is a typedef).
The screenshot below shows how it works.
Needless to say, this is very cool! Nice work, Greg!
We’ve just released VI Tester 1.1.1 on the VI Package Network. This release contains a fix for a minor bug that caused the VI Tester toolbar to not show up in the LabVIEW 2009 Project Explorer window.
You can download & install this package using VI Package Manager. Just press the “Check the Network for Available Packages” button to refresh your package list, then install the jki_labs_tool_vi_tester-1.1.1.137-1 package.
JKI is pleased to announce the recent release of the JKI Right-Click Framework, from the JKI Labs, which allows you to install new features into LabVIEW right-click menu. And, we’re excited to show you some of the new LabVIEW features (right-click plugins) that the community has already created.
Community Contributed RCF Plugins
Hands-on Demo of the RCF at NIWeek 2009
If you’re coming to NIWeek 2009, make sure you check out JKI’s NIWeek 2009 Schedule and stop by the JKI Booth (#335) for a hands-on demo of the RCF and other JKI Software technology in action. See you there!
Download and More Info
For more information about the JKI RCF including download, getting started, a how-to articles, please visit the JKI RCF Homepage.
JKI is excited to announce the upcoming release of the JKI Right-Click Framework for LabVIEW in the JKI Labs. This amazing tool allows you to create new features in LabVIEW and use new features created by other developers. It does this using the power of LabVIEW Scripting (using LabVIEW to programmatically edit LabVIEW code).
How it Works
The JKI RCF manages plug-ins (we call these “right-click plug-ins”). Each plug-in adds right-click menu options for different types of Block Diagram and Front Panel objects (functions, structures, controls, etc) in LabVIEW. When the user chooses one of the right-click menu options, the JKI RCF passes the LabVIEW object references into the plug-in associated with the context menu, and the plug-in performs its operations on those objects.
How to Use It
To use the JKI RCF, simply:
1) Select one or more LabVIEW functions, structures, controls, etc., on the Front Panel or Block Diagram of a VI.
2) Activate the JKI Right-Click Framework by pressing the configurable ”hot key.”
3) Right-click on the selected objects and choose the operation you want to execute. The JKI RCF knows what type of object(s) you have selected, and automatically shows you the plugins that can operate on the current selection.
This video shows the JKI RCF in action:
How to Extend It
The JKI RCF will come with several useful plug-ins pre-installed. But its open architecture will also allow you to create your own plug-ins that can be shared with other users.
How to Get It
We’re working hard to get the JKI Right-Click Framework ready for release. Stay tuned, because it’s coming soon to the VI Package Network. That means that when it arrives, you’ll be able to install it in just a few clicks, using VI Package Manager!
History of the JKI Right-Click Framework
For years, JKI has been using LabVIEW’s under-the-hood Scripting capabilities to create software engineering and development tools for the LabVIEW environment. One of the challenges that our team faced was making our tools easily accessible to the developer, at the time they were needed. The solution was the right-click menu and, circa LabVIEW 8.0, the JKI Right-Click Framework was born. Since then, it has remained an internal tool at JKI, due to the uncertainty about whether public use of LabVIEW’s scripting features would ever be officially condoned by NI.
In December 2008, we noticed a post on Darren Nattinger’s blog, describing exactly what we’d already built. So we showed the JKI RCF to Darren (who is on the LabVIEW R&D team) and then to others at NI. The consensus was that the JKI Right-Click Framework should be released to the public, along with LabVIEW Scripting and other LabVIEW APIs, so that LabVIEW developers could work together to create new features that make LabVIEW better and help people solve common programming challenges.
We’re very proud that the JKI Right-Click Framework has played a role in demonstrating to NI the enormous potential of LabVIEW Scripting in the LabVIEW Community, and we’re thankful that NI has worked hard to bring LabVIEW Scripting support to the public in the NI Labs. We think the JKI Right-Click framework and LabVIEW Scripting make up a powerful combination that will allow LabVIEW users to create and share all kinds of innovative features and tools in LabVIEW.
Have you ever set a reentrant VI to non-reentrant in order to facilitate debugging, only to forget to set the VI back to reentrant when you’re done? This mistake can be very tough to debug, as the difference in behavior (between reentrancy and non-reentrancy) can be very subtle. The same is true for other VI Settings (e.g. the subroutine Execution Priority setting). The point is, during development you may change some VI Properties in ways that make sense for debugging, but will cause bugs in your application if left that way. Forgetting to reset them to their correct values can cause huge headaches when your software is delivered (or worse, long after it’s delivered).
How can you ensure that important VI Settings are correct for specific VIs, prior to deployment?
That’s easy, just create a unit test (using VI Tester) that validates the required setting, as shown below:
Unit Test for Required Reentrancy
The VI that performs the reentrancy check, passIfReentrant.vi (shown below), is one that you probably haven’t seen before, since it’s not delivered as part of VI Tester.
passIfReentrant.vi
If we look at the block diagram, shown below, we’ll see that it’s not very complicated:
passIfReentrant.vi Block Diagram
This VI simply checks the reentrancy and outputs a descriptive test failure message explaining the details of the failure. When we run our unit tests, prior to building and deploying our application, VI Tester catches the problem and shows us exactly where to look.
VI Tester showing failure
If you’d like to add reentrancy tests to your LabVIEW application’s unit test suite, you can download passIfReentrant.vi here:
If you have ideas for other common, reusable VI Settings (or other) tests, please share your ideas by leaving us a comment below.
How to get VI Tester
VI Tester is available on the VI Package Network. If you’re already a VI Package Manager user, just click the “Check the VI Package Network for Available Packages” button in the VIPM window. VIPM will notify you that VI Tester is available, and you can simply tell VIPM to download & install it for you.
Check the VI Package Network for Available Packages
If you’re not already a VI Package Manager user, what are you waiting for? VI Package Manager lets you take control of your reusable VIs, and is also the best way to put all the great tools from JKI Labs, OpenG.org, and the whole VI Package Network into your palettes!
For more information about VI Tester, visit jkisoft.com/vi-tester.
JKI is pleased to announce the release of VI Tester 1.1. This release fixes several issues reported by the community, and also adds some significant new features:
VI Tester's Programmatic API
VI Tester's Project Toolbar
We’re excited by the community’s response to VI Tester. We hope you find the new features in VI Tester 1.1 as useful as we do!
How to get VI Tester
VI Tester is available on the VI Package Network. If you’re already a VI Package Manager user, just click the “Check the VI Package Network for Available Packages” button in the VIPM window. VIPM will notify you that VI Tester is available, and you can simply tell VIPM to download & install it for you.
Check the VI Package Network for Available Packages
If you’re not already a VI Package Manager user, what are you waiting for? VI Package Manager lets you take control of your reusable VIs, and is also the best way to put all the great tools from JKI Labs, OpenG.org, and the whole VI Package Network into your palettes!
For more information about VI Tester, visit jkisoft.com/vi-tester.
NI’s New Year’s resolution to provide better support for third-party LabVIEW addons is already bearing fruit in some big ways inside JKI.
Very soon, you’ll be able to access VI Tester directly from the LabVIEW project toolbar.
By clicking on toolbar buttons you’ll be able to run all your project’s unit tests, as well as add new Test Cases and Test Suites without leaving the project window.
Here’s a short video showing a development version of the VI Tester’s LabVIEW Project Explorer toolbar in action:
All this is made possible by NI’s growing openness to providing LabVIEW developers with ways to plug into and extend LabVIEW. We are very excited about this trend and are learning more every day about new ways to plug into LabVIEW. Expect to see better integration with LabVIEW for more JKI tools, such as VIPM, in the near future.
If you’re going to be in the San Francisco Bay Area next Wednesday evening (February 18th, 2009 at at 6pm), then be sure to come to the LabVIEW User Group Meeting at the NI Mountain View office.
Jim Kring and Omar Mussa will be giving a demo of JKI’s new VI Tester and talking about ways to improve your software quality via unit testing.
For more details, see the meeting agenda page.
We hope to see you there!
Last week, JKI released VI Tester. To some, this might seem like an overnight development, but it is really the result of several years of internal development and eating our own dog food. This is something that’s very important to us, and we do it with all our JKI Software products. In fact, the path to “productization” is a natural outgrowth of our normal development process at JKI. Generally, the process is:
During this process, we continuously evaluate whether the tool is a candidate for a commercial product or whether it would be more appropriate for a community release (e.g. on JKI Labs).
Now, let’s look more closely at how VI Tester evolved…
Identification:
A few years ago, we identified the need to unit test our code — primarily as a tool for ensuring quality for our JKI Software products like VIPM and EasyXML. Our customers depend on these products to perform reliably, and they’re too complicated for us to test by hand. We also wanted to use an xUnit framework because this software testing architecture has proven to be a powerful tool in the software engineering world. Additionally, xUnit test frameworks have spawned Agile and Test-driven development processes that our company strives to replicate in LabVIEW. Since xUnit frameworks are object-oriented unit test frameworks, with the release of LVOOP we saw an opportunity to create a powerful tool to make our own lives easier, and our software more robust.
Creation:
We started by reading a lot of unit testing books and articles. We studied the xUnit architecture and some reference implementations (like PyUnit). We thought about how the xUnit architecture would best be implemented using LabVIEW’s by-value object-oriented paradigm. We built a prototype in LVOOP, added a basic GUI, and started using it in projects.
Sharing:
With the basic test designs in place, we had VI Tester working essentially as you see it today. However, sharing a tool requires hammering it into a form that makes it easy for other developers to use. We know that there is no better tool than VI Package Manager for LabVIEW tool distribution – so we built VI Tester into a package! This allowed our whole team to easily use VI Tester on several versions of LabVIEW and across multiple projects. In fact, we’re even using VI Tester to run unit tests on VI Tester itself, to make sure it works the way we expect it to! (did we mention the dog food yet?)
Improvement:
Improving VI Tester means incorporating feedback from users to make the tool even better. As long as a tool remains internal, that feedback is limited to a handful of users. This has the positive effect of not overwhelming the development team when the product is immature. However, we really want all of JKI’s tools to make an impact on the entire LabVIEW Ecosystem, so we are constantly looking for ways to help users help us. In the case of VI Tester, JKI Labs is the best way to let users benefit from VI Tester, and participate in making it better.
Repeating the process:
And now, we arrive at the present day. In reality, VI Tester has already been through many cycles of sharing / feedback / improvement thanks to our internal team and our private beta testers. But now, by releasing VI Tester on JKI Labs, we’re making a statement: we think VI Tester is ready to help you improve the robustness of your software; and if it’s not, we want to know how we need to improve it to make it useful to you. And in doing this, we want to facilitate the ongoing process of bringing high-quality software engineering practices to the world of LabVIEW development. Try out VI Tester, join the discussion on our forums, and stay tuned for more exciting blogs posts, examples, templates, and videos that will help you get the most out of VI Tester, and out of LabVIEW.
Tags: unit testing
JKI is excited to announce the JKI Labs release of VI Tester, a software test framework for LabVIEW that allows programmers to test their VIs (code) during the development process.
Software testing is a critical component of agile development and test driven development software engineering processes — it is also critical for validating software functionality. VI Tester is based on the industry standard xUnit software test architecture that is used in many other programming languages — this architecture is very flexible and powerful, but also very easy for beginners to learn.
For more information about VI Tester, visit jkisoft.com/vi-tester
Tags: agile, software engineering, unit testing
