The software engineering book I should have read 10 years ago
I recently just finished reading “A Software Engineering Approach to LabVIEW” by Jon Conway and Steve Watts. The whole time I was reading it, I couldn’t help but think: “I wish I would have read this 10 years ago. It would have saved me a lot of trouble.”
Background
I started using LabVIEW back in 2007. I had just graduated from college with an electrical engineering degree. I knew a little about programming in general (mostly C and Pascal), but certainly knew nothing about LabVIEW and even less about software engineering. When I first started working in LabVIEW, I was thrown to the wolves. I inherited a very large well-established project that would have benefited from some software engineering. Over the next several years I continually beat my head against the wall while learning (mostly the hard way) many of the basics outlined in Steve’s and Jon’s book.
“A Software Engineering Approach to LabVIEW” was written back in 2004, so it was definitely around when I started using LabVIEW, but unfortunately I didn’t know about it. In fact, I didn’t learn about it all until NI Week 2017. I saw Steve give a presentation at NI Week and I thought “Wow this guy knows his stuff”. I mentioned something to one of my friends and he brought up the fact that Steve had written a book. I thought “Oh I’ll have to check that out.”
When I first looked it up, the first thing I noticed was that it was over 12 years old and that the reference code was written in LabVIEW 6. Anyone who has used LabVIEW 6 knows that a lot has changed since then. I started using LabVIEW 6 but pretty quickly graduated to LabVIEW 8.0 and the project, and soon after that libraries and classes. I was somewhat skeptical as to how useful/relevant it would be. What really changed my mind as far as getting the book, was reading a review by Fabiola de la Cueva back in 2012 where she asserted it was still relevant. I thought I would give it a try.
Review
First I must say I was wrong. The code samples in the book may be dated but they are not outdated. That is to say that it is very obvious they were written in LabVIEW 6, however, those same vi’s would likely function if written in the latest version of LabVIEW. I must warn you though, that if you tried that you might get laughed at as being too “old school”. Since Steve and Jon wrote those examples a lot has changed. The newer versions of LabVIEW provide much easier ways to accomplish a lot of their ideas.
The key to getting the most out of the book is to look past the implementation of a lot of the code and focus on the principles. Coupling, cohesion and information hiding are just as valuable today as they were 12 years ago. You can easily take them and see how they apply to the Actor Framework or the DQMH or some of the other frameworks and design patterns.
The thing I took most out of it was Chapter 7: Software Engineering Essentials. It talks a lot about process and documentation. It talks about development models, requirements gathering, quoting, test specs, etc. All very useful things that I had somehow managed to get by so far without really diving into too deeply. I’m more what Steve might refer to as a “techno sheep”:
“Techno Sheep” was a term learned from a project manager; he used it to describe the difficulty in getting his programmers to stick to the core programs on the project when all they wanted to do was wander around munching on the interesting bits.
I always found solving technical problems to be much more interesting than paperwork, but Steve makes a very good case as to why the paperwork is necessary. He also does a great job at breaking things down to their simplest level, so that we don’t drown in paperwork, but rather end up with just the right amount to guide ourselves through the project and around any pitfalls.
The biggest complaint I saw about the book on Amazon was the image quality. I didn’t think it was that bad. Apparently, Steve is well aware of it though, because when I sent him an email telling him I had bought his book, he immediately sent me digital copies of all the images. My only complaint (and it is a minor one) is that I didn’t have access to the code examples. It made it kind of hard to follow some of the last chapter where he goes into some of the details of the implemenation. The website listed on the back of the book was down. I’m sure if I would have reached out to Steve, he probably would have sent me a copy seeing as he was so responsive with the images. I didn’t bother because I was more interested in the principles in the book than the implementation. I don’t plan on writing any code in LabVIEW 6.0 any time soon.
Lastly, I must say that the book is actually a pleasure to read. I read it in 2 or 3 sittings. It flows really well. If you have ever heard Steve speak you will quickly realize that he has a great sense of humor and doesn’t take things too seriously. That definitely shows through in the book.
Conclusion
If you do software engineering in LabVIEW you should buy a copy of this book. It is a few years old, but still very relevant.
