Enhanced descriptions from Syndetics:

A Software Engineering Approach to LabVIEW , by working programmers Jon Conway and Steve Watts, applies for the first time the techniques and principles of software design to LabVIEW programming. The LCOD technique designs flexibility into applications, making them more robust and much more easily adaptable to changes, even in large, industrial applications. Complete with examples and working code.

Table of contents provided by Syndetics

• Preface (p. xi)
• 1 Introduction (p. 1)
• 1.1 LabVIEW Sucks (p. 2)
• 1.2 Don't Buy This Book (p. 4)
• 1.3 The Soap Box (p. 4)
• 1.4 What This Book Is (p. 6)
• 1.5 Companion Web Site (p. 6)
• 2 LabVIEW Rocks (p. 7)
• 2.1 Why Does LabVIEW Rock? (p. 7)
• 2.2 What Advantages Does This Bring to the Developer? (p. 12)
• 2.3 How Can Good Design Leverage These Advantages? (p. 13)
• 3 Software Design Principles (p. 15)
• 3.1 Why is Software Complex? (p. 16)
• 3.2 Coupling and Cohesion (p. 18)
• 3.3 Information Hiding and Encapsulation (p. 21)
• 3.4 Examples of Coupling, Cohesion, and Information Hiding (p. 22)
• 3.4.1 Bad (Tight) Coupling (p. 22)
• 3.4.2 Good (Loose) Coupling (p. 24)
• 3.4.3 Bad (Weak) Cohesion (p. 25)
• 3.4.4 Good (Strong) Cohesion (p. 25)
• 3.4.5 Bad Information Hiding (p. 26)
• 3.4.6 Good Information Hiding (p. 27)
• 3.5 Abstraction (p. 29)
• 4 LabVIEW Component Oriented Design (LCOD) (p. 33)
• 4.1 Components (p. 34)
• 4.1.1 So What Is a Component? (p. 35)
• 4.2 Design (p. 36)
• 4.2.1 Object Oriented Design (OOD) (p. 37)
• 4.2.2 Top-Down Design (p. 39)
• 4.2.3 Bottom-Up Design (p. 40)
• 4.2.4 Design Patterns (p. 40)
• 4.2.5 Pattern Examples (p. 43)
• 5 LCOD Implementation (p. 47)
• 5.1 Component Mechanisms (p. 47)
• 5.2 Message Sending (p. 48)
• 5.2.1 All About Enumerated Types (p. 48)
• 5.2.2 101 Things to Do with an Enumerated Type (p. 48)
• 5.2.3 Strict Type Definitions (p. 52)
• 5.3 Persistent Local Storage (p. 54)
• 5.4 The Basic Structure of a Component (p. 55)
• 6 LCOD Complementary Techniques (p. 59)
• 6.1 State Machines (p. 59)
• 6.1.1 State Machine Example--Washing Machine (p. 60)
• 6.2 Graphical User Interface (GUI) Design and Prototyping (UI Controller [right angle bracket right angle bracket] Message Queue Pattern) (p. 64)
• 6.2.1 Stack Queue Component (p. 66)
• 6.2.2 User Interface Control Wrapper VI (p. 70)
• 6.2.3 LCOD User Interface Example Diagram (p. 73)
• 6.3 Abstraction in the Code, Detail Outside the Code (p. 76)
• 6.3.1 Section Key Files (p. 77)
• 6.4 Error Handling (p. 88)
• 6.5 Pre- and Postconditions: Check What Comes In and What Goes Out (p. 92)
• 6.5.1 Preconditions (p. 95)
• 6.5.2 Postconditions (p. 97)
• 6.5.3 Conclusion (p. 97)
• 6.6 Reuse (p. 98)
• 6.6.1 Opportunistic Reuse (p. 98)
• 6.6.2 Planned Reuse (p. 99)
• 6.6.3 Merge VIs (p. 99)
• 6.6.4 VI Templates (p. 104)
• 7 Software Engineering Essentials (p. 105)
• 7.1 The Usual Suspects (p. 107)
• 7.2 Requirements Document (p. 111)
• 7.3 Quote/Project Validation (p. 116)
• 7.4 Target Specification (p. 117)
• 7.5 Test Plan (p. 118)
• 7.6 Software Architecture Document (p. 119)
• 7.7 Software Construction--Build (p. 120)
• 7.8 Test--Customer Acceptance (p. 121)
• 7.9 Pictures Tell a Thousand Words (p. 121)
• 7.9.1 Diagrams--Data Flow Diagrams (DFDs) (p. 121)
• 7.9.2 State Transition Diagrams (p. 124)
• 7.9.3 Homemade Diagrams (p. 124)
• 7.10 Checklists (p. 126)
• 7.11 Code Reviews (p. 127)
• 7.12 The Project Is Dead, Time for a Postmortem (p. 129)
• 7.13 Metrics (p. 130)
• 8 It's All About Style (p. 131)
• 8.1 Why Do We Need Standards Anyway? (p. 131)
• 8.2 Block Diagram (p. 134)
• 8.2.1 General Layout Standards (p. 134)
• 8.2.2 Wiring Standards (p. 134)
• 8.2.3 Labeling Standards (p. 135)
• 8.2.4 Self-Documenting Example (p. 136)
• 8.3 Front Panel (p. 137)
• 8.3.1 General Front Panel Standards (p. 137)
• 8.3.2 Public Front Panel Standards (p. 137)
• 8.3.3 Private Front Panel Standards (p. 138)
• 8.3.4 Icon and Connector Standards (p. 139)
• 8.3.5 Organization of Files (p. 139)
• 9 The Journey (p. 141)
• 9.1 Agreeing on the Destination (Requirements) (p. 142)
• 9.2 Planning Your Route (Design) (p. 157)
• 9.2.1 Code and Fix (p. 157)
• 9.2.2 Abstracting Components from Requirements (p. 157)
• 9.2.3 Using Patterns to Help the Design Process (p. 165)
• 9.2.4 Building the Prototype (p. 169)
• 9.3 Build (p. 180)
• 9.3.1 Code and Fix (p. 181)
• 9.3.2 LCOD (p. 181)
• 9.3.3 Hardware (p. 182)
• 9.3.4 Detail Outside the Code (p. 193)
• 9.3.5 Error Handling (p. 198)
• 9.3.6 State Machines (p. 199)
• 9.3.7 Reuse (p. 200)
• 9.3.8 Style (p. 201)
• 9.4 Uh-Oh We've Been Given the Wrong Directions (p. 203)
• 9.5 Conclusions (p. 208)
• Glossary (p. 211)
• Index (p. 217)
• Other LabVIEW Books (p. 222)

Excerpt provided by Syndetics

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. Excerpted from A Software Engineering Approach to LabVIEW by Jon Conway, Steve Watts All rights reserved by the original copyright owners. Excerpts are provided for display purposes only and may not be reproduced, reprinted or distributed without the written permission of the publisher.

Author notes provided by Syndetics

Jon Conway has 20 years' experience writing software, with half of that in LabVIEW. His fields of expertise include real time, robotics, databases, DAQ, DSP, and multiple software languages and operating systems; his idea for LCOD arose from his experience gained working on complex software projects. Jon is a partner in Structured Software Design Consultants of Hampshire, UK
Steve Watts has 15 years of experience writing test software, and has been programming in LabVIEW for 6 years. His areas of expertise include OOD, the Yourdon methodology, CASE tools, electronics, lasers, switching system design, DAQ, statistical process control, databases, user interface design, software engineering, as well as a variety of programming languages. Steve is a partner in Structured Software Design Consultants of Hampshire, UK