Random Ramblings on LabVIEW Design

Well Hello programming chums

At the European CLA 2015 summit Sacha Emery presented "Actor and benefits of different frameworks" where he described his journey through various design choices when applied to a standard set of requirements. This segued nicely into various topics that were being discussed throughout the summit and it I also hijacked it selfishly to promote one of my interests.

I'm after finding some way of measuring the complexity of a system, now ideally I would like this to be something tangible like function points.

Data Functions:

Internal logical files

External interface files

Transactional Functions:

External Inputs

External Outputs

External Inquiries

The complex problem is how to identify these items within a LabVIEW Block Diagram (I haven't given up on this)

One of the advantages of function points is that you can can get them from requirements and use them for estimation. My primary interest is not for estimation tho' I want a common measure of the the complexity of a project so we can better assess and discuss our design choices. The disadvantage is that it is hard work and takes a lot of time to undertake a study.

So how does Sacha's presentation link to this?, like all good test engineers I like my processes to be calibrated and I think this might be the perfect tool to do this. Here's how we think it will work (and I say we because this is based on conversations with Jack Dunaway, Sach and various other luminaries).

We have a common set of requirements.

We apply a framework/design/architecture to provide a solution.

We tag all the project items that are original items.

We analyze all the items that are in the problem domain (i.e. separate the solution from the architecture).

We apply a change/addition in requirements.

We analyze the additional items that have been generated to satisfy the change.

This should give us several numbers

Items in Basic Architecture (A)

Items to Solve the Problem (B)

Items to Make an Addition (C)*

And this is what we call the Emery scale.

The preconception is that generally the code to solve the problem should be pretty repeatable/similar.

So dumping Function Points for the time being and going back to a more simple idea (care of Mr Dunaway), we should tag the architectural parts and count the nodes using block diagram scripting. As Chris Relf has stated there is some good data to be had from LOC (lines of code) comparisons in similar domains.

And what use is all this work? For 1 it should give us an estimate about the number of VIs our design will have on a given target (The ratio of B:C(#requirements) should give us a size) . This is an essential bit of design information.

Early stages and a long term project. It could be part of my CS thesis if I was doing one...

This is only one potential benefit of the kind of baselining that Sacha has started (from an educational perspective seeing the same problem solved with different frameworks will be invaluable)

Thoughts appreciated

Love Steve

*A late addition to give us some concept of how a change affects the project

Hello Lovelies

This years event was in Rome and in my opinion the quality of the presentations was higher than ever, it was held in the same hotel as where most people were staying and this improved the networking greatly. One of the things I look forward to most is meeting old friends and new.

To summarise :-

Rome: Excellent

Presentations: Highest quality

Access and involvement of NI People: Marvelous

Networking: What a nice bunch of people the LabVIEW community is, I didn't meet a single person I didn't like (apart from a certain Mr Mercer who I have gone right off!, I got my revenge tho' oh yes..)

I think I have garnered enough material for 6 or more articles which is a real bonus.

So to summarise the presentations (and this is all from my perspective)

Frameworks

You are in a rich place indeed if you are in the market for a framework thanks to the efforts of these folks.

James Powell - A Dynamically Reconfigurable Actor System

Fabiola De La Cueva & Chris Roebuck - Delacor QMH (mentioned in their presentations)

Jim Kring - State Machine Objects with Events

It was interesting to me as well because it got me to thinking about what makes a good framework.

Show and Tell

Dmitry Sagatelyan - Going Agile, Applying Agile OO Design Principles

Dmitry was showing off a vintage boat refurbishment (Al Capones) and it was very cool. Beautiful code on a georgious ship.

Richard Thomas - Code Reveal – Swish a UI toolkit for Windows 8 type touchscreen

Dr Thomas does the BEST UI stuff!

Philisophical

I really liked the discursive nature of a lot of these presentations.

Fabiola de la Cueva - To Model or not to Model

As always a great presentation from Fab, I completely agree about using models to clarify your designs.

My Conclusion not Fabs: use modelling to help your own brain, help your customers brains but don't have them as your controlled documentation if at all possible as it's another thing to maintain.

Stephen Loftus-Mercer - LabVIEW and Classic Design Patterns

Oh he got me hook, line and sinker. Reeled me right in. Once again this was a brilliantly researched and fantastically presented piece. If you ever get a chance to see him present you should do it!

Sacha Emery - Actor System Benefits of Different Frameworks

Sacha has done important work here by baselining a common set of requirements into various frameworks and techniques. This has important ramifications that I'm really excited about. We just need Sacha to stop be self-effacing, this could be the dawning of the Emery Scale!

Arnoud de Kuijper - An Architectural debate: How to Abstract Hardware?

Always good, talking about when and where to abstract? No conclusions but a led discussion, Arnould is a star presenter IMO and another one to just go and see if you can.

Malcom Myers - The Trusted Advisor

Well presented and extremely useful, I feel we should see more of this type of presentation in future events.

Chris Roebuck - Architectural Design Processes and Methodologies For LabVIEW

Light and interesting talk on how Chris and Fab (for indeed it was them) tried to reconcile very different ways of developing code.

Techniques and Toolkits

Jarobit Piña - Revealing The Secrets Of The Packed Project Libraries

A nicely clinical review on an area most of us hadn't really deep-dived.

Peter Horn - Assertions in LV

This is based on a section in Code Complete and is a really good piece of work and damn useful. Good software engineering!

James McNally - LabVIEW and the Web

Useful to know and very well presented. Now I need to review his slides to see what to get up to speed on!

Sam Sharp - WebSockets - Bringing LabVIEW to the Web

Extremely well designed tool-kit, one I will be using.

and of course the peerless Jeff K showing us how to visualise asynchronous data between loops, I thought it was particularly effective with producer/consumer loops set side-by-side.

Any techniques presented were usually shown with advantages and disadvantages, I really applaud this clinical approach.

After that there was the discussions that fleshed out the ideas and formulated new ones.

This is a valuable event and I am so lucky to be able attend, if you get the chance give it a go! It's also great fun.

All I can say is thanks Nancy Jones, you done good!

Lots of Love

Steve

Fabs Review:http://www.walkingthewires.com/2015/04/22/cla-summit-europe-2015-post-event-review-2/

Martins Review:http://www.dvel.se/blogg--nyheter/certified-labview-architect-summit-2015-a-quick-summary

Right then clever clogs's

Here's a blast from the past and I was quite pleased with it. I'll show the code later...

I have the following characters (0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z and 4 control chars)

I want to transmit 20 characters but only have 14bytes to do it.

How is it done?

PS. As a technique this would be useful in the FPGA world I think.

If you're coming to Rome next week come and say hello and travel safely

Love

Steve