LabVIEW Style Book, The | 
 enlarge | Author: Peter A. Blume
Publisher: Prentice Hall
Category: EBooks
List Price: $71.20
Buy New: $56.96
You Save: $14.24 (20%)
Rating:  12 reviews
Sales Rank: 13743
Format: Kindle Book
Media: Kindle Edition
Edition: 1
Pages: 400
Number Of Items: 1
Dewey Decimal Number: 005.438
Publication Date: November 30, 2007
Availability: Usually ships in 24 hours
| |
| Similar Items:
|
| Editorial Reviews:
Product Description
This is the eBook version of the printed book.
Drawing on the experiences of a world-class LabVIEW development organization, The LabVIEW Style Book is the definitive guide to best practices in LabVIEW development. Leading LabVIEW development manager Peter A. Blume presents practical guidelines or -rules- for optimizing every facet of your applications: ease of use, efficiency, readability, simplicity, performance, maintainability, and robustness. Blume explains each style rule thoroughly, presenting realistic examples and illustrations. He even presents -nonconforming- examples that show what not to do-and why not. Coverage includes - Significance of style: How good style improves quality and actually saves time over the full project life cycle
- Before you code: Configuring your LabVIEW environment, and organizing your files on disk and in the LabVIEW project
- LabVIEW project specifications: A specialized standard for specifying LabVIEW application requirements
- Efficient VI layout and development: front panel, block diagram, icons, and connectors
- Data structures: Choosing data types, efficient use of arrays and clusters, and special considerations with nested data structures
- Error handling strategies: Trapping and reporting errors for robust and reliable applications
- Design patterns: Standard VI architectures and application frameworks that promote good style
- Documentation: Essential rules for source code documentation and streamlining the process
- Code reviews: Enforcing a style convention using a checklist, the LabVIEW VI Analyzer Toolkit, and peer reviews
- Appendixes: Convenient glossary and style rules summary
This book will be indispensable to anyone who wants to develop or maintain quality LabVIEW applications: developers, managers, and end users alike. Additionally, it will also be valuable to those preparing for NI-s Certified LabVIEW Developer or Certified LabVIEW Architect exams, which contain significant content on development style.
|
| Customer Reviews: Read 7 more reviews...
 many recommendations apply to any GUI design March 24, 2007
W Boudville (Terra, Sol 3)
10 out of 12 found this review helpful
Labview has grown so complex and powerful that the necessity has arisen for a book like this. Inevitable, I suppose.
A lot of the recommedations by Blume are applicable to any GUI designer. Like minimising the text in labels. Few users want to or will read large paragraphs or long sentences pasted into labels. These act instead to clutter up the real estate of the display, and often will confuse the new user or irritate the experienced user, who does not need such a laborious elaboration.
Another tip is to avoid string controls unless really required. The problem here is that the user then has many ways to enter a badly formatted string. Perhaps it should be an integer. But she sticks a letter or decimal point in it. Opps! You'd better then have logic to check for this. But it is even better to prevent such errors from occurring. In general, you should make the input widgets as robust as possible against faulty user input.
Yet another general tip is to have data output in XML format. These days, it makes it much easier for someone else to come along and write code to read in your output, for other applications. By writing in XML, you take advantage of powerful parsers that are freely available.
Of course, many tips are specific to Labview. Try to have data flowing mostly in one direction in a circuit diagram. And not left to right, right to left, up and down. More generally, whenever you have wires, minimise the number of bends. Makes the overall picture much clearer for a user to grasp.
All of which makes this book well worth it for a Labview designer. Granted, there is a lot here, and it is definitely not a trivial read. But even just taking in some chapters has the prospect of quickly improving your circuit designs.
Informative Book July 12, 2008
T. Boehnlein (Dayton, Ohio, USA)
I read the first couple chapters and was impressed with the quality of information. I then gave it to a programmer I am supervising for a project. I had him read it and told him to adhere to the standards of the book. After a couple weeks the code he is turning out is much improved. The flow is better, the code is documented and there is actual error control being used. It will be much easier to maintain the project as time goes on. The point of the book is to write better labview diagrams so I think it works quite well in that regards.
Just excellent. December 8, 2008
C. Bailey (Maryland United States)
I'm reading this now and learning plenty as I do. It is very thoughtful and insightful. This book is defining, for me, the step up from being able to use LabVIEW to appreciating good programming style and aspiring to it. This book is much more about why some ways of doing things are better than others, much more about ways to think of LabVIEW, and not just another reference explaining how to use each of LV's features.
If all new LabVIEW developers read this book . . . November 30, 2007
Carsten Thomsen (Copenhagen, Denmark)
5 out of 8 found this review helpful
then their efficiency would be much higher.
In our organization we have seen the classic LabVIEW evolution: People with little or no programming experience start with the 3 icon demo, and then start wiring like crazy, and soon are wired into a corner and have a spaghetti bowl of LabVIEW code.
People with Classic CS training may try to force object-orientedness down LabVIEW's throat, and end up having too complex, abstract structures, with a lot of overhead relative to the actual functionality.
Peter Blume's book is an excellent medicine against the above mentioned problems. Probably the absolute three most important rules is to always use Typedefs, choose an design pattern that matches your applications, and learn to use Queues.
Typedef is easy to learn, and should be taught the first day you learn LabVIEW. The time savings are enormous.
The choice of design patterns is a lot more difficult for beginners to intermediate programmers, because it really requires a lot of "wisdom" to pick the right one. Therefore, in my opinion, Chapter 8 is the most important chapter in the book, and also the Chapter that could benefit from even greater detail in learning why the shown patterns are used and going more into details about which things to avoid.
Once you have crossed that hurdle, LabVIEW becomes much easier, more efficient and fun. But for many the "best practice" design patterns seem to break the fundamental data flow rules you learn as a LabVIEW beginner.
* Front panel controls are handled in event structures (instead of being polled)
* Data and front panel controls are often accessed by reference instead of being "hardwired".
* Queues are a cool, safe, and efficient way to move data and control around between parallel loops, but may also confuse users because they also access data by reference, and hence could be considered to be "impure" in terms of data flow.
In addition, traditional LabVIEW wisdom says "avoid massive use of references", and avoid large hierarchical clusters. In my recent experience these rules seem antiquated, in that historical performance related issues with these don't seems to have a significant impact when running on modern machines.
I have also seen programmers who explicitly have avoided queues due to the difficulties associated with them in many textual languages.
In summary, the book is well written. Internally at DELTA we are in the process of adopting variations of Peter Blumes more advanced design patterns, which really are conceptually quite simple and clean, once you understand them.
One consequence about using these design patterns goes quite against the grain of certain ideas in classical programming, i.e. information hiding.
Typical object oriented LabVIEW code shows virtually no specific functionality at the high level. The consumer/producer design patterns in which functions and data are stuffed onto queues and de-queued in appropriate parallel executing loops, actually allows a lot of specific program logic to be visible at the top level, without getting cluttered.
This is thanks to the user interface being handled in case structures (at the top level) and resulting actions being fired (at the top level) in queue selected case structures in the consumer loops.
I have found this actually increases the readability of the code enormously, particularly if carefully lay out your wiring so that you create a Typedef of references to Queues and unbundle by name only the references that are used inside each consumer loop. Thus the master control logic is concisely represented at the top level, even though the diagram is relatively small.
Compared to OO code, it is much leaner, more readable, and easier to maintain. I believe OO is important and relevant, but only for large proejcts and/or large multi-person teams. For typical LabVIEW aps which are in the weeks to month range, I believe the above described design patterns are by far the most efficient to develop, and easiest to maintain. They are also very readable if done well.
Peter Blume is to be congratulated on a truly excellent book. Concise, well written, and worth a lot of money if you follow the most important priniciples.
Perhaps a good follow-on would be a more in-depth discussion of design patterns, which is where efficiency is made or broken, depending on whether the right patterns is chosen.
A final observation, is that I was not able to find the word object-oriented anywhere in this book. I surmise this may be a conscious decision, by showing how far LabVIEW actually can extend its reach with its native paradigms.
Carsten Thomsen
Excellent October 12, 2007
Governatori Graziano (Italy, Pavia)
1 out of 2 found this review helpful
This book is a really good effort to present software engineering concepts, applied to LabView. Not secondary aspect: it is very easy to read (also for non-english mothertongue people).
Of course, you can't agree 100% with what P.Blume says, but it's useful to know his point of view, and maybe discuss on them.
|
|
|
