drjdpowell

Yes, I try to do that with "Messenger Library". Unfortunately, I find that if I stress that it is a library of messaging (with optional "actor" templates) that it gets dismissed as not to be considered when comparing "frameworks", but if I present the whole thing as a "framework", then people assume it is very restrictive.

That "accidental complexity" is a killer. It's a big part of that exponential increase in complexity you showed on your graph a couple of posts ago. Helping to get that out of the way so you can address the true complexity of the actual problem is no small thing.

How does MVA relate to your STREAM framework that you've blogged about?

Here is a beta version, 1.11.0, with changes to TCP Messengers to support the various TCP options about ports and the like. Also adds a Keep-alive to detect half-open connections. Bitbucket Issues 26, 27, 33. I have not had time to do more than a basic test; it would be a help if someone could give it a try. Note that I've replaced some of the creation VIs for TCP Messengers in the pallette (originals should still work, but I wanted to change VI names). drjdpowell_lib_messenging-1_11.0_116.vip

That is Issue 34, which will be fixed in the next version. In the meantime, the fix is quite easy and described in Issue 34.

Does your variant have a name? If it doesn't that's why it's name is "". Re attributes, you have to provide a variant containing default values of those attributes. This is because the JSON doesn't contain the LabVIEW type information (can't tell a string from a timestamp from an enum). I realize this is not the answer someone who uses variant attributes wants to here. Personally, though, I use sub-JSON instead of variant attributes, with cluster elements that are strings with the <JSON> tag in its name.

Issue 33

What number do I feed to "net address" to make it local host only? I wasn't aware of such a feature.

Worse, writing the image ref only triggers the need for a refresh of the control; the actual read of the data is asynchronous (like all LabVIEW indicators) and happens a short while later, possibly after the image has been changed.

A big part of the payoff of a good framework is making large complex applications simpler. But it's hard to see this when you're on the wrong side of the learning curve.

Unfortunately, there is a significant learning curve for all frameworks, so it is hard to compare them. Here though is a GDevCon1 talk by Richard Thomas, where he discusses frameworks: Frameworks: An Executive Summary

Ah, by-ref objects, GOOP, G#, and the like. That should have been a poll option.

I remember a conversation, which I can't find now, where AQ mentioned that most messages will involve multiple bits of information, but I was surprised because I think it's natural for messages to usually only having a single piece of info. Often just a simple number, path, string. Even when the message contains a typedef cluster (or class) that typedef usually exists for reasons beyond the message. So I might have a "Data Set" object that passes through multiple actors for different types of processing, using a generic message rather than a number of type-specific messages.

BTW, I was partly prompted to do this poll after seeing there is yet-another-framework on the Tools Network: WORKERS by Scarfe Controls.

Your right, the question of strict versus weak typing is an important question and involves trade offs, and different frameworks make different choices. I, in using Messenger Library, seem to spend almost no time bothered by problems caused run-time type mismatches, so I am not much impressed by the edit-time type safety if it comes with the negative trade offs of requiring large scripting tools to work productively. Why that is might be a long discussion about other features of how I code, and what information is put in a message. I've tried to point out before that code frameworks support mental frameworks, sets of guidelines that work together, and it can be difficult to compare code frameworks because it is hard to full grasp the full set of its mental guidelines. You found that yourself when AQ's strong criticism of State-Machine-Objects didn't really move you, because you just have to "impose some rules when developing with this framework".

Ahh, your illustrating my point. DQMH is similar to SMO in having custom-type "plumbing", with new messages requiring changes in multiple places. AF also has its own busywork of multiple things to do for each message. Now, all this work is highly repetitive and thus scriptable. So you can value the strength of DQMH's scripting tools, because similar tools would be a help for SMO. But from the point of view of Messenger Library, which uses more generic messages, scripting is just a way of reducing one of the weak points of custom data-type messages: all the extra work to carry the new custom types through the communication code. Scripting Tools aren't a strength, they're the minimization of a disadvantage that is shared by DQMH, SMO and AF.

Didn't think to include G#, GOOP and similar, as I've never used them.

Apologies to JKI for not explicitly including State-Machine-Objects in the poll. Though I think what you compared was two common community frameworks, plus the framework you use, and largely developed, regardless of how common it is. Difficult to make such comparisons, as the stuff-you-know-well usually trumps stuff-you've-read-about. Even getting unbiased comparison categories is hard; I'd probably have "messaging pattern support" and "network communication", two things Messenger Library does well, yet not "Teststand Integration", which I've never tried.

I was interested in the relative numbers of LAVA developers using different "frameworks" or types of architecture. Apologies, my list of poll options shows my biases towards a message-passing, actor-ish, style of architecture. Sorry, I seem to have forgotten to allow more than one option, so you'll have to pick the the best answer and explain more in a post. I pick "Messenger Library", though as I developed that, my honest answer is that I use my own internal framework.

Oops, two things called "name". The "Names" output is an array of item names. Your item name is, confusingly, "name". "Cartographie" is one of your date values. It is a string, and I in my example provided a string as the data type. But you provided as data type an empty/void Variant, which will fail. Use a string like in my example.

Your names are strings, not variants.

You certainly can do this with LAVA JSON, but I would suggest you use the JSONtext library instead, if possible:

Your right, there is a reference leak here. That Queue is a reference created in the actor's calling code, and is used to trigger the "Autoshutdown" message when the caller stops, thus invalidating the Queue. There is an async component called the "ReferenceMonitor" which watches that Queue and sends the Autoshutdown message then closes. ReferenceMonitor also polls the actor's address, so it can shut itself down if the actor dies. However, I forgot to destroy the Queue in that case. Here is an image where I have added the needed Close operation: Thank for spotting this, -- James

Yes, these references are intended to only be closed when the actor that created them stops running. The term "reference leak" is used by the trace toolkit to indicate any reference cleaned up by LabVIEW when a vi goes idle, regardless of whether it is an actual leak.

A JSONtext example, ssumming all dictonary items are the same type: Alternately, keep items in JSON format so they can be treated differently at a later step: