Write Portable Code: An Introduction to Developing Software for Multiple Platforms |  | Author: Brian Hook
Publisher: No Starch Press
Category: Book
List Price: $34.95
Buy New: $8.94
as of 3/10/2010 12:08 WIT details
You Save: $26.01 (74%)
New (20) Used (12) from $8.05
Seller: kewlbookz4u
Rating:  9 reviews
Media: Paperback
Edition: 1
Pages: 272
Number Of Items: 1
Shipping Weight (lbs): 1.2
Dimensions (in): 8.7 x 7 x 0.8
ISBN: 1593270569
Dewey Decimal Number: 005.1
EAN: 9781593270568
Availability: Usually ships in 1-2 business days
| |
| Features:
|
| Similar Items:
| |
| Editorial Reviews:
Product Description
Portable software development is writing software that runs on a broad range of computer systems instead of just one (e.g., Windows). Programmers often pick up the idioms, tricks and methodologies for developing cross-platform software through sheer trial and error, as they encounter the same mistakes and patterns of code over time. If youre an intermediate- to advanced-level programmer whod rather cut to the chase, Write Portable Code contains the lessons, patterns and knowledge youll need for developing cross-platform software. Write Portable Code explains how to: * avoid common portability mistakes when starting out a new project, thereby saving time when a port must occur * re-factor existing, non-portable code so that it can be easily transplanted to new platforms * find bugs masked by platform specific behaviors Programmers who avoid becoming married to a specific development environment or target platform greatly expand the target market for their software products. Whether you design cross-platform software from the ground up or have to move large amounts of code from one platform to another, the information contained in Write Portable Code will help you achieve your goals and grow as a programmer.
|
| Customer Reviews:
Showing reviews 1-5 of 9
 Packed with specifics which lend to both an overall understanding of concepts and the ability to troubleshoot common problems September 5, 2005
Midwest Book Review (Oregon, WI USA)
1 out of 1 found this review helpful
Brian Hook's Write Portable Code: An Introduction To Developing Software For Multiple Platforms covers all the basics of writing code for cross-platform use. From avoiding common portability mistakes and finding bugs inherent in platform-specific behaviors to understanding filesystems and understanding preprocessors, Write Portable Code is packed with specifics which lend to both an overall understanding of concepts and the ability to troubleshoot common problems.
A good addition to my book collection July 28, 2005
John Krane
3 out of 4 found this review helpful
As a full time system administrator I don't get much chance to program, but on occasion I have to write little utilities that something like Python or Perl might be too slow for. The problem is that I work on a mixed network of Solaris, AIX, Linux, and Windows machines, and since I'm not a full-time coder it takes me a long time to figure out how to get something working on one machine to work on another. Write Portable Code has been a great resource and I've already avoided a few potential hair pulling bugs that I didn't even know were bugs!
My only complaint is that it doesn't get into deep details about moving stuff like sockets from Linux to Windows, but if Mr. Hook did this I'm sure the book would be 2000 pages long.
I'm surprised no one has written a book on this topic yet, but I'm glad this one is available now.
Terrific book on good programming practice. August 18, 2005
James B. Rimmer (San Diego, CA United States)
2 out of 3 found this review helpful
"Write Portable Code" is not just about writing code that ports from one OS to another or from one architecture to another; it's about writing code that will handle new feature requests, minor OS upgrades, and minor hardware differences. The author fills the book with a surprising amount of information on different storage formats, different C and C++ standards and different OS-dependent APIs for such a small book.
No book could cover every possible detail of every possible software port. Instead, the author focuses on the right attitude towards writing portable code. He demonstrates by example in each chapter, with C and C++ code you can download from his web page. Although the author focuses on C and C++ for the purpose of this text, the principles apply to any language, even supposedly portable languages like Perl.
It's not an expensive book for what you get. Even the most experienced programmer should find plenty to use here. The author's prose is easy and fun to read, and I laughed out loud more than once at some of his examples.
I recommend this book for all programmer levels.
An excellent book with many practical ideas... July 25, 2005
Thomas Duff (Portland, OR United States)
7 out of 11 found this review helpful
If you're building commercial software (or even software for your own company), there's a reasonable chance you'll need to make sure it runs on more than one platform. Brian Hook's new book Write Portable Code - An Introduction To Developing Software For Multiple Platforms (No Starch Press) should appeal to you.
Contents: The Art Of Portable Software Development; Portability Concepts; ANSI C and C++; Techniques For Portability; Editing And Source Control; Processor Differences; Floating Point; Preprocessor; Compilers; User Interaction; Networking; Operating Systems; Dynamic Libraries; Filesystems; Scalability; Portability And Data; Internationalization And Localization; Scripting Languages; Cross-Platform Libraries And Toolkits; POSH; The Rules For Portability; References; Index
Hook does a very nice job of writing a practical book that looks at software development techniques that aid the ability to port your code to multiple platforms. While it's not possible to guarantee compatibility in all cases, you can take solid steps to reduce the chances of painting yourself into a corner early on in the game. From a language perspective, Hook focuses on the C/C++ language, so that's the area where you'll see the most advantage as a coder. But the other chapters are applicable to just about any environment. For instance, using a number of compilers set at a very strict message level helps weed out any coding practices that may work in one environment but not another. In another case, you should carefully choose supporting software libraries (like graphic packages) based on potential portability. A platform specific library might be easier to use, but it locks you into that environment. Porting code can then become a complete rewrite instead of a matter of tweaking. Very important stuff to know and take to heart...
With the ongoing battle between Windows and open source environments, the ability to cater to both might be the difference between life and death in your business. Write Portable Code might be a really good investment in your survival...
 Excellent Book, Misleading Title February 19, 2006
David Chazin (Denver, CO USA)
10 out of 10 found this review helpful
This book is an excellent read. The material is presented completely, concisely, and in an easy to understand manner. However the title of this book is misleading. It really should be "Write Portable code in C". There is some limited discussion of C++, but mostly to discourage you from using it. All other languages are dismissed out of hand, or just completely ignored. As long as you understand this caveat there is much to learn from this book.
This book is really focused on writing software that will run on essentially any platform that has a C compiler, which today is almost all processors. If you need to write software that will run on embedded 16 bit processors as well as the latest 64 bit ones, then you should read this book. However, there are large classes of software that have a more limited notion of portability (such as running on most 32 bit Unix or Windows platforms, or any platform that g++ can target) where Standard C++ or Java are the way to go. Unfortunately the book does not adequately address the tradeoffs, design, and implementation decisions one should make in these cases. In particular, I am puzzled by the total lack of Java solutions.
Since the book emphasizes C programming, there is minimal content on GUI programming, Web programming, database programming, and similar areas where C programming is rarely used anymore.
Showing reviews 1-5 of 9
|
|
|
|
