Home > Store > Engineering > General Engineering & Hardware

Software Engineering Approach to LabVIEW, A

Register your product to gain access to bonus material or receive a coupon.

Software Engineering Approach to LabVIEW, A

Book

  • Your Price: $71.40
  • List Price: $84.00
  • Usually ships in 24 hours.

Description

  • Copyright 2003
  • Dimensions: 7 x 9 1/4
  • Pages: 240
  • Edition: 1st
  • Book
  • ISBN-10: 0-13-009365-3
  • ISBN-13: 978-0-13-009365-3

Create more robust, more flexible LabVIEW applications—through software design principles!

Writing LabVIEW software to perform a complex task is never easy—especially when those last-minute feature requests cause a complexity explosion in your system, forcing you to rework much of your code! Jon Conway and Steve Watts offer a better solution: LCOD-LabVIEW Component Oriented Design—which, for the first time, applies the theories and principles of software design to LabVIEW programming. The material is presented in a lighthearted, engaging manner that makes learning enjoyable, even if you're not a computer scientist.

  • LCOD software engineering techniques make your software more robust and better able to handle complexity—by making it simpler! Even large, industrial-grade applications become manageable.
  • Design to embrace flexibility first, making changes and bug fixes much less painful
  • Pragmatic discussion of the authors' tried and tested techniques, written by—and for—working programmers
  • Covers design principles; LCOD overview, implementation, and complementary techniques; engineering essentials; style issues; and more
  • Complete with practical advice on requirements gathering, prototyping, user interface design, and rich with examples
  • Work through an example LCOD project (all code included on companion Web site) to tie the lessons together
This book is intended for test engineers, system integrators, electronics engineers, software engineers, and other intermediate to advanced LabVIEW programmers. None of the methods discussed are complex, so users can benefit as soon as they are proficient with the syntax of LabVIEW.Go to the companion Web site located at http://author.phptr.com/watts/ for full source code and book updates.

Downloads

Source Code

Untitled Document

Choose from the links below for the sourcecode appropriate to your version of LabVIEW:

 

Sample Content

Downloadable Sample Chapter

Download the Sample Chapter related to this title.

Table of Contents



Preface.


1. Introduction.

LabVIEW Sucks. Don't Buy This Book. The Soap Box. What This Book Is.



2. LabVIEW Rocks.

Why Does LabVIEW Rock? What Advantages Does This Bring to the Developer? How Can Good Design Leverage These Advantages?



3. Software Design Principles.

Why is Software Complex? Coupling and Cohesion. Information Hiding and Encapsulation. Examples of Coupling, Cohesion, and Information Hiding. Abstraction.



4. LabVIEW Component Oriented Design (LCOD).

Components. Design.



5. LCOD Implementation.

Component Mechanisms. Message Sending. Persistent Local Storage. The Basic Structure of a Component.



6. LCOD Complementary Techniques.

State Machines. Graphical User Interface (GUI) Design and Prototyping. (UI Controller..Message Queue Pattern). Abstraction in the Code, Detail Outside the Code. Error Handling. Pre- and Postconditions: Check What Comes In and What Goes Out. Reuse.



7. Software Engineering Essentials.

The Usual Suspects. Requirements Document. Quote/Project Validation. Target Specification. Test Plan. Software Architecture Document. Software Construction--Build. Test--Customer Acceptance. Pictures Tell a Thousand Words. Checklists. Code Reviews. The Project Is Dead, Time for a Postmortem. Metrics.



8. It's All About Style.

Why Do We Need Standards Anyway? Block Diagram. Front Panel.



9. The Journey.

Agreeing on the Destination (Requirements). Planning Your Route (Design). Build. Uh-Oh We've Been Given the Wrong Directions. Conclusions.



Glossary.


Index.


Other LabVIEW Books.

Preface

Preface

There are many ways of designing and implementing a system. We are not trying to say that you should immediately adopt the techniques presented in this book in place of how you currently design and write software. Specifically, what we are saying is that this is how we design and implement software in real-world applications. We want you, the reader, to draw your own conclusions.It's important to note that the authors are working engineers who pay their mortgages by writing software, not by writing books.

The Test Engineer's Perspective

Steve Watts writes--

As a normally trained test engineer I've been programming test systems for years and using many different programming languages (HPBasic, UCLA Pascal, Turbo Pascal, Visual Basic, and QuickBasic). In many of the more complex systems I have had the same experience. Doing little design up front I would plow into the coding, by the 50% stage I would normally be ahead of the game, and at the 90% stage I would be 90% complete and patting myself on the back. And then it happened!

I now use the term "the complexity explosion" small changes in the software would cause problems throughout the system. The customer would throw in "unplanned-for" changes. I could no longer picture the system clearly in my head. The last 10% of the project took another 90% of the time.

I knew something was wrong but didn't have the tools or training to explain what, why, or how. In the end I put it down to software being a pain.

A few years ago when Jon came to the company he was touting a language called LabVIEW. This became the company standard, so I had to learn it. The first application that I wrote (in a very unpleasant style I hasten to add) was a small temperature logging effort. It became clear to me that something was still wrong. True, G gave huge productivity increases over Pascal and Visual Basic, which I was using at the time, but the complexity explosion was still there, lurking in the background. I went back to Jon and discussed it with him and he introduced me to LCOD. I had never thought that there was a discipline called Software Engineering (I thought by writing software I was a software engineer), or heard of Coupling, Cohesion, or Information Hiding. OOD, OOA, and structured software design had all passed me by.

I'm the sort of person who needs to completely understand a process beyond the words, and since we were dealing with reasonably abstract concepts I struggled in the search for this comprehension. I took postgraduate courses in Software Engineering and Object Oriented Programming. I experimented with the projects I was working on, using structured software design, CASE tools, and OOA. The inherent complexity that academia applies to all things and the embracing of this complexity (out of elitism perhaps!) by the software community, led me to believe that this whole process was harder than I thought. BUT IT'S NOT!

I began to see that by applying these techniques my programs were becoming manageable, they were not increasing in complexity near the end, and I could implement late changes without reducing system robustness. Maintenance was easier and faster, customers were happy and impressed, stress levels were reduced, illness and pestilence were driven from the land, neighbor loved neighbor, and there was peace in our time.

Don't get me wrong, none of this will make a complex problem any less complex, but at least by applying these techniques you won't be making it more complex.

As software engineers we should be striving for the following:

  • Deliver what we say we are going to deliver
  • Deliver it when we say we are going to deliver it
  • Ensure that it operates predictably
  • Ensure that changes and bug-fixes do not harm the stability of the program or break the bank to implement

We should be in the business of managing complexity:

Clever Software = BAD; Simple Software = GOOD

One of our customers wrote the following testimonial (and we didn't even pay him!): "LCOD has made a complex test system simple, flexible, and futureproof."

Using the analogy of a journey (as we do throughout the book), we feel we have taken enough steps forward to enable us to turn around and put up a few signposts. Hopefully, these signposts will help you in your journey.

I have never regretted adding flexibility to my software, but I have always rued the times I have omitted flexibility.

The techniques presented in this book are reasonably simple to understand. We feel that someone can only successfully apply something if they understand it. Our aim is to introduce and explore the concepts of software design using LabVIEW, and to do this in an understandable and applicable manner. A lot of techniques and methodologies get bogged down with computer science and forget about the design aspects; our intentions are to always concentrate on design and hopefully translate some of the computer science.

Index

Download the Index file related to this title.

Updates

Submit Errata

More Information

Unlimited one-month access with your purchase
Free Safari Membership