eCLA Summit 2018 Quick Highlights
European CLA Summit in Madrid
I had the pleasure of being able to attend the European CLA Summit last week in Madrid. It was my first time at the European Summit. Just like the Americas summit, it was kind of like drinking from a fire hose. The quantity and quality of the information presented was very high. There were plenty of great presentations. I took something away from every single presentation that I was able to attend. However, there were a few that stood out to me.
“Modular Design Deep Dive” by Steve Watts
Steve is just a great presenter. He is very animated and energetic. If you haven’t seen one of his presentations, it is worth it for the entertainment value alone. Obviously, the content is also fantastic. When I think of Steve, I think of a phrase that I learned while studying martial arts: “The better you understand the basics, the more advanced you are.” While Steve’s presentation style maybe be somewhat flashy, his programming style is not. He doesn’t use the latest frameworks, LVOOP, or other shiny tools. But he does have a great grasp on the basics. His presentation was all about Coupling and Cohesion. To a software engineer, those are probably pretty basic concepts. However, since most of us LabVIEW developers are not software engineers, Steve did a very good job of breaking it down and making it very accessible. My key takeaway was “Here are the general rules and ideas. Sometimes you have to make tradeoffs. When you do, just make sure it is a conscious decision and that you understand the implications.”</p
Clarification from Steve:
One correction in perception I should make is; I do use LVOOP for things I think it’s good at (HALs specifically), I have nothing against shiny new things, but we tend to work on a fixed price and this makes us conservative in our designs. If I jumped on every new toy in LabVIEW I’d be very much poorer than I am (which is pretty poor!)
“Efficient Actor Framework Development” by Allen Smith
Allen gave a very technical presentation on the Actor Framework. If you use the actor framework, I highly recommend you watch it, because it will definitely change the way you do a few things. The presentation was basically about doing more with less. The one big tip I took away was to use a Self-Addressed message instead of an abstract message when you needed to send a simple trigger message (ie. no data) to the caller. It requires fewer messages.
“UI Design” by Jorge Vasiliadis
Jorge just did a very brief demo of a UI that he had built. It was easily one of the most impressive LabVIEW UIs I have seen. He didn’t get into too much of the details about how he built it other than that he uses subpanels and moves them around. Just watch the video, when it comes out and you will be impressed. He mentioned he might do a follow-on presentation where he would talk more about the implementation, so keep your eyes open for that.
“LabVIEW Team-based development” by Paul Morris
I always go to these NI events wanting to learn all the technical stuff: the latest frameworks and toolkits, etc. However lately I have been coming to the realization that what I really value are the process and business management presentations. I found Paul’s presentation probably one of the most useful, in that afterward I had a big list of action items. Paul talked about how as their team grew they realized that they needed to work a lot on their process. He outlined how they brought Fab in as a consultant and showed some of the processes they came up with as a result of that. I really liked a diagram he had that showed a gitflow type model with icons depicting at what stage various unit tests and vi analyzer tests were run. I thought that was a good way to visualize things.
“Team-based Development” by Chris Roebuck
Chris’ presentation has some very good content, but the real reason to watch it is for the entertainment value. It will have you rolling on the ground laughing as he identifies various LabVIEW developer personalities. You will recognize all of them, in fact, you probably work with some of them. In all seriousness, Chris’ presentation provided some good insight into managing difficult developers and trying to get them to work together as a team.
“Guide to Scripting” by Fabiola de la Cueva
Just like Steve, Fab is a very energetic presenter. Her presentation was filled with links to all kinds of tips and tricks for scripting. If you want to learn scripting, it is all there. She also did a few slides on calculating ROI, which could be very useful.
OOP and Interfaces
I would be remiss if I didn’t mention something about OOP and Interfaces. There was a lot of interesting discussion at the conference on that topic. Those of you at the Americas CLA summit may remember Stephens presentation on vims and how you can use them to implement static interfaces. Steven gave a repeat of that presentation (with a lot more detail). But the most interesting part was Andrei Zagadorni’s presentation. He had come up with a very good implementation of dynamic interfaces using very basic LabVIEW classes and library features.
Andrei solved almost the entire problem, except for one little thing: dependency. In Andrei’s original idea his interface class was dependent on all the other classes that implemented the interface, which obviously poses some problems. Luckily Stephen was super-enthusiastic about this whole idea and he talked Andrei into having a separate brainstorming session after the conference. A bunch of us sat down and discussed various options and ideas and came up with a pretty good solution. It relies on the call-by-reference node. There were some questions about its performance with regards to data copies. Stephen was going to look into that and get back to us. If that works out, then Andrei and Stephen will have found a way to implement dynamic interfaces in LabVIEW, which is very exciting.
Thanks to all of the presenters. You all did wonderfully. Thanks to all of the attendees for some excellent conversations. Thanks to chair
Pascal Heinen and co-chair James McNally, and everyone at NI for organizing. Thanks for Jeff Kodosky for his visionary presentations on what he sees as the potential future of LabVIEW.