Poll: What LV operators do you use most frequently?

[Ben]

After sharing my idea of a Quick-Drop Tutor I thought;

I may make for an interesting form of competition if we had a common set of short-cuts and could compete virtually to see who could QD the fastest.

But then the question came up "Do we use my short-cuts or who's?

So to feed this idea I would like others to reply with their favorite operators in order of preferences. We may be ale to find a common-set of operators that we all use. This could be the basis of some freindly gaming but also may serve as the standrads that ship with future LV versions.

So please post your favorites.

If you like someone elses list, give them a Kudos and we can factor that in as a multiplier for those lists.

Thank you for the help!

Ben

[JÞB]

* denotes non-default values

Crtl+H (Help)

Crtl+Shift+H (Help for this vi)*

Crtl+Shift+V(View VI Heirarchy)*

Crtl+Shift+!(View Errors)*

Crtl+*/Crtl+Shift+*(Save/Save All)*  (it made more sense than S to me since the dirty dot is *)

[Darin.K]

My shortcuts are now graphical, and are equal to the icons themselves.

To answer your question I used my code to analyze how frequently I use LV functions (What?  You mean everyone doesn't do this?)  I have this list based on my code posted to the LV example challenges.

1. Property Node (scripting heavy list)

2. Case Structure

3. NamedUnbundler (Unbundle by Name for you non-scripters)

4. Invoke Node

5. For Loop

6. Bundler

7. Build Array ("Built Array" for altenbach )

8. Format Into String

9. Comparisons (did not hone in)

10. Index Array

As to Favorites:

1. Get/Set Variant Attribute

2. Match Regular Expression

3. Search and Replace String

4. Compound Arithmetic

5. Feedback Node (hates Variants , wasted a lot of time with that one)

6. Type Cast

7. Property/Invoke Node

8. Matrix Size

9. PNG Data to LV Image.vi

10. Stacked Sequence Structure

[F._Schubert]

Being stuck with good old 7.1, my own plugin for Ctrl+N (in the LAVA CR).

Felix

[jcarmody]

My Quick-Drop shortcuts:

cs = Case Structure

u = Unbundle By Name

fs = For Loop

ws = While Loop

se = Select

bb = Bundle By Name

fst = Format Into String

pn = Property Node

in = Invoke Node

Most/all of these are Darren's.  I have more, but don't use them often enough to list them.  Your Quick-Drop tutor will help me learn more. Could I suggest making it independent of the operators and providing a mechanism for each of us to define our own shortcuts?

Darin.K made me laugh, again.

[Darren]

My Quick Drop shortcuts are posted on the Quick Drop Enthusiasts group, but here are the ones I use regularly. Ones in bold I use several times a day. In general, I went with the first thing that came to mind when I first created the shortcut years ago, and having been using them for years, muscle memory just takes over:

ac - Array Constant

ad1 - Increment

as - Array Size

athc - Path Constant

ba - Build Array

bath - Build Path

bbn - Bundle By Name

bc - False Constant

car - Compound Arithmetic

cc - Cluster Constant

ccat - Concatenate Strings

cr - Close Reference

cs - Case Structure

csc - Class Specifier Constant

cv - Current VI's Path

dds - Diagram Disable Structure

dfa - Delete From Array

dv - Divide

ea - Empty Array?

ecc - Error Cluster Constant (new in 2011)

eq - Equal?

eqz - Equal To 0?

erg - Merge Errors

estr - Empty String/Path?

estrc - Empty String Constant

evstr - Event Structure

ex - Multiply 😉

fs - For Loop

fss - Flat Sequence Structure

fstr - Format Into String

geq - Greater Or Equal?

geqz - Greater Or Equal To 0?

gr - Greater?

gz - Greater Than 0?

leq - Less Or Equal?

leqz - Less Or Equal To 0?

mp - Match Pattern (have to move my left hand over for this one)

nan - Not A Number/Path/Refnum?

nc - Numeric Constant

ndx - Index Array

neg - Less Than 0? 😉

neq - Not Equal?

neqz - Not Equal To 0?

nes - In Place Element Structure

nv - Invoke Node

qr - Quotient & Remainder

ras - Replace Array Subset

rn - Property Node

s1d - Search 1D Array

sath - Strip Path

sav - Select a VI...

sb - Subtract

sb1 - Decrement

sc - String Constant

se - Select

srt - Sort 1D Array

sss - Search/Split String

tc - Tick Count (ms)

tcase - To Lower Case

trav - Traverse for GObjects.vi

tsc - To More Specific Class

ubn - Unbundle By Name

vr - Open VI Reference

vtd - Variant To Data

wat - Wait (ms)

ws - While Loop

[jcarmody]

Now that I'm in front of my computer, I can look at my list.  These are more of the ones I frequently use:

ai = Index Array

ac = Array Constant

ba = Build Array

sc = String Constant

nc = Numeric Constant

bc = Boolean Constant

dd = Diagram Disable Structure

jki = guess

jk = customized version of above

w = Wait (ms)

[Mikev_341]

I have similar ones as everyone else

ac - Array Constant

ad - Increment by one

as - Array Size

There are others, i will post as more come to mind

[Ben]

Thanks to all that replied!

These list start to show how we think about the operators differently. It appears those that know the formal names go with abreviations while that is not that norm for all. Since I can't look inot your heads to know how you came up with your abreviations, I mention some of mine.

First!

I don't know the names of all of those operators. I know what they look like and can remeber where I last found them some my QD short-cuts reflect that fact.

a + generally the operartors for arrays.

ag Array Get ... index array

as Array size

sf Structures For loop

bt boolean true

But then I ran into issues keeping the short-cuts below two characters and conflicts between the palettes so I resorted to old scholl stuff

va VI server Attribute node ... proprty node

bv Boolean OR

My most used are bold

QuickDropDiagramShortcuts="

aa:Initialize Array

;ab:Build Array

;ac:Array Constant

;af:Search 1D Array

;ag:Index Array

;ar:Replace Array Subset

;as:Array Size

;ba:And;

bf:False Constant

;bt:True Constant

;bv:Or

;cb:Bundle By Name

;cd:Not Equal?

;ce:Equal?

;cez:Equal To 0?

;cg:Greater?

;cge:Greater Or Equal?

;cgez:Greater Or Equal To 0?

;cr:Unbundle By Name

;cs:Select;cv:Less?

;cve:Less Or Equal?

;cvez:Less Or Equal To 0?

;ea:Add

;eav:Mean.vi [NI_AALBase.lvlib]

;ec:Increment;ed:Divide

;eq:Quotient & Remainder

;es:Subtract

;et:Not

;ev:Decrement

;ex:Multiply

;fb:Build Path

;fc:Current VI's Path

;fs:Strip Path

;qc:Obtain Queue;

qd:Dequeue Element

;qe:Enqueue Element

;qr:Release Queue

;sc:Case Structure

;se:Event Structure

;sf:For Loop

;ss:Flat Sequence Structure

;sta:Concatenate Strings

;stc:String Constant

;stt:String Length

;sw:While Loop

;tg:Get Date/Time In Seconds

;tw:Wait (ms)

;va:Property Node

;vc:Open VI Reference

;vd:Invoke Node

;wb:Build Waveform;"

Now as far as my Quick-Drop Tutor...  I'll have to find it! Once I learned the short cuts...

Take care,

Ben

Complet line from ini follows

QuickDropDiagramShortcuts="aa:Initialize Array;ab:Build Array;ac:Array Constant;af:Search 1D Array;ag:Index Array;ar:Replace Array Subset;as:Array Size;ba:And;bf:False Constant;bt:True Constant;bv:Or;cb:Bundle By Name;cd:Not Equal?;ce:Equal?;cez:Equal To 0?;cg:Greater?;cge:Greater Or Equal?;cgez:Greater Or Equal To 0?;cr:Unbundle By Name;cs:Select;cv:Less?;cve:Less Or Equal?;cvez:Less Or Equal To 0?;ea:Add;eav:Mean.vi [NI_AALBase.lvlib];ec:Increment;ed:Divide;eq:Quotient & Remainder;es:Subtract;et:Not;ev:Decrement;ex:Multiply;fb:Build Path;fc:Current VI's Path;fs:Strip Path;qc:Obtain Queue;qd:Dequeue Element;qe:Enqueue Element;qr:Release Queue;sc:Case Structure;se:Event Structure;sf:For Loop;ss:Flat Sequence Structure;sta:Concatenate Strings;stc:String Constant;stt:String Length;sw:While Loop;tg:Get Date/Time In Seconds;tw:Wait (ms);va:Property Node;vc:Open VI Reference;vd:Invoke Node;wb:Build Waveform;"