Allow me to start with a preemptive response from a random user:
Globals are evil!
They are the worst thing ever to have been created. They will make your hair fall out and do bad things (TM) to you!
Many people feel this way because globals are dangerous. It is very easy to use them, but they don't have the protection needed for the parallel nature of LabVIEW and so they can easily cause bugs.
They also prevent proper seperation of code modules.
They do have their advantages, though, and now that warning is out of the way I want to present a use case for which globals are currently relatively appropriate.
Text based languages usually have the concept of logical constants. These are similar to variables, except you only set their value once when you write the code.
A common example is declaring Const PI=3.14 and then using the text PI instead of 3.14 throughout the rest of the code. That way, the code is much easier to read and if you wanted to have more accuracy, you would just need to change the value in a single place.
LabVIEW already has a PI constant, but this could apply to any other constant you need.
Another example would be declaring Const Delimiter = ";" in a system where you have to generate delimited strings. If the delimiter changes (for example, if you have to merge your code with an already existing program which uses another value), you simply change the value of the constant once.
Other examples include using constants for display strings and localized strings.
LabVIEW does not currently have constants, but you can do this by creating a global variable and never writing to it.
The process for doing this is:
- Create a global VI. Make sure it has a properly identifying name and icon (for example, MyProject_Constants_Display Strings.vi). Preferably, it should be used only to hold constants.
Also, be sure to create as many of these as necessary, so that you can copy and move your code around later, if needed (since global VIs are part of the hierarchy).
- In the global VI, create a control of the type you need. You can append or prepend "CONST" to its label, to avoid mistakingly writing to it.
- Set its value and then right click it and select Make Current Value Default. This part is critical because that sets the value of your constant. I place a prominent free text in the FP of the global VI alerting me to remember this step when I modify values.
- Save the global VI.
- You can now simply use the global variable and only read from it without ever writing to it.
To be honest, this is far from an optimal solution. The 3 main disadvantages are that
- a global can still be written to,
- you have to remember to set the default value (those two can cause bugs) and
- adding CONST to the label makes the constant name unnecessarily long.
If your code needs to be secure, then this would be a security hole and not usable at all.
Personally, I think that these could all be solved with the addition of a Global Constant VI to LabVIEW which will be similar to a global VI, except it would have a different icon in the terminal, it would accept the value changes without needing to set the values to default and it would be read only.
Also, not that it usually matters that much, but LV should be able to constant-fold it.
Another optional implementation - allow the VI to have a block diagram and make sure it executes first (although that would make it much more complicated and is probably unnecessary).
That's my wishlist item for this thread.
P.S.
There are other ways to create constants today, but they are more cumbersome. For example, you can create a VI for each constant or you can create a single VI with an enum or a string which will select the constant you like, but they all require a lot of overhead.
For a list of past nuggets, see
here.
If you want to write a nugget yourself, see
here.
___________________
Try to take over the world!
