Jump to content

styrum

Members
  • Content Count

    35
  • Joined

  • Last visited

  • Days Won

    1

Everything posted by styrum

  1. I reported the expression node too to the NI tech support guy who's dealing with this bug report.
  2. Was there at least in LV2016. Still there in LV2020 The corresponding VIs are attached. Formula Node Shift Bug 2016.vi Formula Node Shift Bug 2020.vi
  3. A nasty caveat with "Preserve disk hierarchy" is that you can end up with too long of a resulting path string for some files in the build which is still not too long in the source. There is an apparent limit on the path length (in terms of total number of characters including the file name, not number of folders levels) after which LabVIEW (Windows) refuses to open a file with such a "too long" path (this can happen with unzipping a deeply nested archive into a too deep folder of too by the way). The limit can manifest itself even at a build stage (Error 6). But it is worse when it happens wh
  4. As I suspected, the short answer is: no, we can't. This was confirmed to me by a known expert in LabVIEW application building and deployment Matthias Baudot from Studiobods. Merci beaucoup, Matthias! Here is his answer: Unfortunately, it is not possible to embed custom files inside the executable when building a LabVIEW application. Only “code” files in the point of view of the LabVIEW Run-Time Engine can go inside the executable. Other “support” files must go in a separate location on disk. Therefore, it is not possible to do what you want. However, you could configure your exe buil
  5. I have an additional (custom) project item(file) type defined and a primary project provider for it, complete with its own icon/glyph and a dedicated editor for editing such files. Such files contain just some additional info about the class as a plain XML/JSON text but have a custom file name extension. I manage to store such files within class libraries in the project (.lvclass files are just XML text too) as yet another type of class files (in addition to .lvclass,.ctl,.vi). Just like in the case with class method VIs in classes inheriting from one another, there can exist this new type of
  6. Much longer "nail to the coffin" 😜 of THAT KIND of OOP (written 5 years earlier than the subject rant/"opinion"). Or an entire box of nails rather. And even interfaces introduced in 2020 don't help LVOOP considering all those "nails". Even if you don't read the whole thing, notice the same conclusions (recommendations of alternatives) in the end regarding the paradigms and languages to use instead: actor model (Erlang) and/or functional programming (Haskel, Closure). Again, it was written in 2014. Also notice that some comments above are too similar to "No True Scotsman..."😜 h
  7. Exactly! To implement an actor in LabVIEW one doesn't need LVOOP! Quite a few "asynchronously communicating modules" producer-consumer design patterns, developed by different people independently from each other including my LabHSM and EDQSM show that very clearly. After all, LVOOP didn't even exist when mine were developed. One can get away with just a cluster in a shift register to access any the data from any action case, but, OK, lets instead make an instance of a "regular" (LVOOP) class and make each action case just call a corresponding method of that class. It will look a little cleaner
  8. Quite a lively 😀 discussion on Slashdot: https://developers.slashdot.org/story/19/07/22/0426201/is-object-oriented-programming-a-trillion-dollar-disaster
  9. I think it is important what exactly we call "OO code". If objects are not simply "dead" combinations of data and methods, but rather have their own "life"/"process", exchange messages with the user, "environment", and other objects the way actors do, react to events, I am all for such "OO code". The "regular/"passive"/"C++/Java/C# style" objects indeed have a very limited use and I agree that the attempts to build large applications using only them by constructing and utilizing complicated inheritance hierarchies and design patterns can lead to a disaster.
  10. 😂He knew what was coming: " I expect some sort of reaction from the defenders of OOP. They will say that this article is full of inaccuracies. Some might even start calling names. They might even call me a “junior” developer with no real-world OOP experience. Some might say that my assumptions are erroneous, and examples are useless. Whatever. " I think we all still can benefit from a more substantive discussion of his particular points rather than from accusations of "not understanding", let alone "calling names" and insults. A "straw man" demagogic trick is no good either. Th
  11. Some food for thought: https://medium.com/better-programming/object-oriented-programming-the-trillion-dollar-disaster-92a4b666c7c7 Note that LVOOP is indeed the "C++, Java and C# variety of OOP" too, and is taught the same way, complete with "cats and dogs", all the same "Gang of Four" design patterns, S.O.L.I.D (https://scotch.io/bar-talk/s-o-l-i-d-the-first-five-principles-of-object-oriented-design), etc. " The bitter truth is that OOP fails at the only task it was intended to address. It looks good on paper — we have clean hierarchies of animals, dogs, humans, etc. However, i
  12. The NI definitions of tag, stream and message/command are given, for example, in this cRIO guide (p. 29): http://www.ni.com/pdf/products/us/fullcriodevguide.pdf
  13. It is indeed amazing and sad how attractive and popular "straw man argument" is. I won't even say anything else.
  14. The matching discussion on NI forums: https://forums.ni.com/t5/LabVIEW/Eleven-Ways-to-Update-an-Indicator-from-within-a-subVI-Their/td-p/3938618
  15. Yes, checking the watchdog queue takes a lot of time (if not most of) in each sender iteration. Please check out a "sequential version" in the latest posts or try putting a Disable structure around those Preview Queue Element nodes in the sender VIs (you will have to stop everything with the stop button on the toolbar of the Main then).
  16. styrum Member ‎06-18-2019 04:17 PM Set Control By Index added. Wow, it is fast! "Speed" calculation in the "sequential" version corrected to count the iterations of the receiver loops. Fastest update of indicator from subVI (5).zip
  17. Ok, OK, my bad, I left Debugging enabled. This is not a commercial app. This is is just some "food for thought", and something to play with, which you would otherwise not have the time to put together yourself. But now you can find some time (much less) to play with it. The goal was to get people to play with it, find flaws, "unfairness", etc. So I am glad that happened so quickly. Here is a version that has debugging disabled plus a "sequential" flavor of the whole thing. Some disclaimers right away: 1. Yes, I deliberately do not count the iterations completed by sender loops but no
  18. Well, the very point of putting together this code is for people to see the numbers for themselves and that I didn't "cheat" on any of the tested methods to make some look better than others. Their significantly different performance numbers are real. In summary, the main findings are: 1. (Widely known) Passing a control reference to a subVI or a VI running in parallel to the VI where the control(indicator) is located with the purpose of using that reference to update that control/indicator is the worst you can do. 2. (Not so well known) Using "user events" in event structures f
  19. Yes, I know, you wanted to do this some day too. So I did it for you. Just run (and then stop) the Main VI from the attached set (Saved in LabVIEW 2016 32-bit). I suspect (and hope) the numbers will be quite a surprise and even a shock, especially for the fans of one particular method and some very aggressively promoted frameworks which use that method. Fastest update of indicator from subVI.zip
  20. Maybe that will work too (again with a control, not with a constant). But there is no explanation there regarding the type expected as the Conpane (variant) parameter of that Set Conpane method. How do we get that Conpane from a VI we want to take it from before we can feed it to that method?
  21. OK. So OCD is "obcessive compulsive disorder" I figured. Sorry, sickos patients, my native language is not English, but I still know what past participle is and even, for example, when to use past perfect tense in English (How many Americans do?).😋 "Cast Operator: () (programming) A type cast provides a method for explicit conversion of the type of an object in a specific situation. v. cast, casted" (https://english.stackexchange.com/questions/94565/can-casted-be-the-past-tense-of-cast)
  22. For whoever is looking to do anything like this or anything else as far as programmatically changing code in a VI goes, I think I should remind that the best way to find and get a reference to any object you want to mess with on the FP or BD of the target VI is one of "hidden gems", <LabVIEW 20XX>\vi.lib\Utility\traverseref.llb\TRef Find Object By Label.vi
  23. Thank you, Darin! That's exactly what I needed! By the way, what does OCD stand for in this context? BTW2: After calling Change to Constant the constant appears instead of the terminal exactly at the same place the terminal used to be, just as if I right-clicked on the terminal and selected Change To Constant. Well, at least in LabVIEW 2016.
  24. I want to use a Call By Reference or a Start Asynchronous Call node in my TEMPLATE code. Which means I MUST have a type specifier constant (or control) wired to the Open VI Reference. In my CONCRETE code created based on the template code using VI scripting I need to replace the type specifier, or rather the VI which that type specifier extracts the connector pane from, so that the Call By Reference (or Start Asynchronous Call) node can use a new connector pane within themselves instead of the one it has in the template code. Normally (manually) we just drag and drop a VI with a desired connec
×
×
  • Create New...

Important Information

By using this site, you agree to our Terms of Use.