More books in category: Labview
by: Jon Conway
AMAZON multi-meters discounts AMAZON oscilloscope discounts
Topics include:
CLICK HERE for more information and price
Description
If you're writing test or analysis software, responsible for a team of engineers, or an engineer using LabVIEW for a reasonable percentage of your job - this book has the practical applications that guide you through the software engineering process. It fills the gap between more mature software engineering practices and the methods that are currently used in the LabVIEW arena. The book's contents are the culmination of the experiences gained in designing software and the lessons, trials and tribulations learned by the experienced authors. KEY TOPICS: Written in a light-hearted and easily understood style, Conway and Watts describe the LabVIEW Component Orientated Design (LCOD) design methodology. Using LCOD in constructing an application has resulted in simpler, more flexible and more robust applications. This is especially important to LabVIEW users writing large industrial grade applications. The book also demonstrates the application of LCOD to an example project, so readers can follow the application of LCOD more closely and in a real world environment. The theories and principles of software design have never really been applied to LabVIEW - until now! MARKET: The book is aimed at intermediate to advanced LabVIEW programmers.
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
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.
Reviews: