Customer Reviews

Programming Windows®, Fifth Edition (Microsoft Programming Series)

5 star:		(58)
4 star:		(20)
3 star:		(4)
2 star:		(6)
1 star:		(4)

 

 

I would reference this book as the "bible" of win32 programming. This book covers many features of the Windows 95/98/NT features including printing, MDI, Mouse, Keyboard, and all the goodies.

This book sits upon my desk as the #1 reference when writing win32 code (without MFC). If your new to programming and are thinking about MFC I would consider starting with this non-object oriented approach so you understand what MFC is doing behind all the objects.

Easy reading (compared to other programming books) and a great deal of learning can be done.

To 4th edition "Programming Windows 95" owners:

1. If you want to use ToolBar's you better hold on to the last revision because it's missing in this one. I was very unhappy about that.

2. It's huge! If you thought carrying that last book was an issue, add a hard cover and a ton more pages and you've better start working out before carrying this around.

3. More usage of UNICODE and "NT" style information that is repeated in each code segment so be prepared.

It's a revision, and it's good. It's the best out there right now, but will not solve every problem you'll have.

Note: If you like object oriented, and uses of all the enhanced features of C++ you're not going to find it here.

This book is great for anyone who wants to learn Windows programming using its native API. It is very readable and requires only a basic knowledge of C, so it is an excellent tutorial for beginners, but there is enough meat in it that it is quite useful for advanced programmers as well. The author explains everything clearly, thoroughly, and accurately. The numerous example programs he uses to illustrate his concepts are well-written and free of bugs.

The book is peppered with occasional historical asides. If you can't stand historical asides, you may be frustrated, but it's understandable that a guy who's been programming Windows for 15 years will have a few stories to tell.

The book has excellent, awesome, unbeatable, all-that-almost-anybody-would-ever-need coverage of: window procedures and messages, keyboard and mouse input, fonts and character sets/Unicode, the GDI (including mapping modes and metafiles), dialog boxes and child/MDI windows, palettes and bitmaps of all kinds, menus and resources, timers, and printing.

The book has very good coverage, without going into the really advanced details, of: DLLs, multithreading, MIDI and wave audio, Winsock, and internet functions.

Notable omissions are: registry functions, file I/O, COM/OLE/ActiveX controls, Setup applications, the Shell (links, namespace extensions, screen savers, WinHelp), and the common controls (toolbars, sliders, tree views, property sheets/wizards, list views and header controls).

Despite its omissions, this book is well worth its money for anyone who wants to learn (or learn more) about the Windows API.

I own 'Programming Windows 95' which is a previous version of this book...this newer version adds additional information, while retaining the best of the older versions.

I'm a self-taught software engineer and have relied on books for most of my training. When I needed to learn the Win32 API to write Windows application programs, I initially turned to the Microsoft website and their tutorials, but found this approach frustrating because there was no overall picture presented...a lot of knowledge was assumed.

Petzold's book was the answer to my frustrations...it assumed no Windows specific knowledge, although general C/C++ background is assumed. The book starts with simple examples that are thoroughly explained. Once enough topics are covered, an excellent overview of Windows as an event-driven operating system is presented, and the remainder of the book is devoted to covering real-world, useful examples in enough detail that they provide starting points for the reader's own development projects.

In the companies for which I've worked, most of the programmers refer to Petzold's book as the 'bible' for Windows programming...for good reason. This is the best book for learning Windows programming if you are starting with no previous knowledge of the Windows operating system.

This is an absolutely golden book. Don't be intimidated by the page count or the title - this book is actually a very easy to use ground up tutorial in Win32 programming. He starts out talking about the basics and then slowly moves into more advanced topics.

As always it's important to know what a book is NOT. This book is not a tutorial for writing windows applications, nor does it discuss MFC or most of the common methods used today for rapidly producing computer programs. This is not REALLY a reference book on win32 either.

Instead it provides a tutorial-style documentation for the monstrous win32 API at its most fundamental levels. This book sets the standard for all other code written for any modern version of windows. It addresses real world issues and real world solutions to those problems (such as the chapter dedicated to making unicode friendly programs), as well as some historical issues (the difference between wParam and lParam).

No manual is without its flaws. This book is a bit too braod spectrum in the detail levels. There are places in the book where he will delve into details that you could care less about, and there are points that he will put in two or three sentences and assume you understand, although you may not.

Despite this, this book is essential to everyone writing code for Microsoft Windows (ANY version). You needn't read it cover to cover, but readiny section I (about 1/3 of the book) is essential. My one wish is that this book came in three volumes, if you haul it between home and school/office it gets to be buronsome. That's about all I can really complain about with this book.

This book is excellent for learning windows programming. To the reviewer who complains about no c++ examples, the author clearly states in the first few pages of the book that his intention is to give an understanding of windows programming based on C and the underlying win32 API, which is the fundamental knowledge required for windows programming. Other OO architectures such as MFC can be very useful but hide from the programmer many details which can be important for someone trying to learn how windows programs work. Also, the complaint about no asserts in the book .. well, again, the author mentions in the book that he left them out (in most places) because it makes code less readable, and students are less likely to read and understand a long program full of error checking.

Be warned, this book is huge, 1500 pages. Its not a book for those looking for a quick introduction to windows programming. Its intended to give an in-depth knowledge of windows programming and it does a very good job at that.

This is one of those better text. In fact, the most complete Win32 API tutorial i've seen so far. Excellent for the C mediate programmer ready to step into the huge world of Windows. It moves at an average pace and after you complete it, it's a great reference for the Win32 API. I recommend this before taking on any other API programming like DirectX, OpenGL, MFC...(you'd be crazy to start those without learning the inner meanings of Windows first! )

As everybody says, Programming Windows by Charles Petzold, now in its fifth edition is the definitive guide to the Win32 API, and windows based programming in general. Anybody who has experience in C programming and would like to learn how windows programs are written will be very happy reading this book, and will come away with a new found knowledge of windows programming. Covering all the basics such as the structure of a windows program written in C, and the major aspects of the GDI, and other advanced topics after reading this book you will be ready to write your own windows programs, and then be ready to move onto more advanced topics such as MFC, where it helps to know what is really going on. The major topics covered in the book are graphics which include the printer, bitmaps, palettes, text and fonts, and also metafiles. The advanced topics go to include the basics of the multiple-document interface, multithreading and DLL's, and also sound programming and a small bit of internet programming. Those who want to know more about how the more advanced topics work would be happy reading Programming Applications for Microsoft Windows by Jeffrey Richter also, which goes into more detail about threads and DLL's than this book.

I have to say I was dissapointed in this book; not because of *how* the material was presented, but because of the *type* of material presented. It says "the definitive guide to the Win32 API" printed right on the cover, but the selection of topics seems limited only to those which deal with output and presentation (text, fonts, graphics, bitmaps, sounds, etc). Personally, i was looking almost exclusivly for the more "under-the-hood" API functions, which almost no mention is made of.
For example, there is no mention of memory management, manipulating files on the hard disk, serial and parallel ports usage, processes, debugging/kernel, and console-mode functions, just to name a few. Multi-threading, DLL files, and TCP/IP are included at the end, seemlingly only as an afterthought. To give you an idea, the chapter about the "Palette Manager" is over 170 pages long; the chapter on DLL's is only 30.
Also slightly annoying was the large amount of printed code in the book (my personal pet peeve). Many times, you'll find complete programs that span ten or more pages, with little explanation to accompany them. This seems completly unnecessary, especially considering the stout size of the book to begin with (1500 pages!), and the fact that all the code is included on the CD anyway.
So if you're looking for a in-depth book about the more 'visual' aspects of Windows, then this could be your book. But if you're looking for more low-level stuff going on behind the scenes, not even one page of this will be worth the shipping you'll pay.

I started reading this book almost by accident as I have a natural distrust of books that tend towards the size of a small family car. I believe that the people who commission computer books must be in league with the paper companies to decide that somewhere in the region of 1400 pages makes for "a good read." Over lunch with the author, just after a sumptuous raspberry coulis has been delivered to the table, they must lean forward and, sotto voce, mutter "an extra 10% if it's over 1200 pages." This can be the only reason for the vast array of shelf-strainers that must make an average Waterstone's computing section weigh more than the Isle of Wight ferry.

With such reservations, it was with more than a little surprise that Charles Petzold's contribution to deforestation turned out to be emminently readable. The text is well written, showing that Petzold clearly understands his topic, and laid out in a format that is very easy on the eye, both areas where other books fall down regularly. There is little waffle either; you can't flick 100 pages and feel that you've missed nothing. By the end of chapter one, with the page count still only in double digits, the reader has been presented with a working Windows program written in C. This is something of a novelty in this area with most other books a) first teaching you C and b) just reaching coverage of the "for" statement at about page 350.

This book is designed to teach the reader how to write programs in C for the Microsoft Windows operating system. This may sound redundant with the abundance of visual programming languages such as Delphi and Visual Basic that hide the complexity of talking directly to the operating system, but as soon as you hit a problem that requires a knowledge of what Windows is doing this is where the knowledge this book contains comes in. Without this knowledge it is also a lot harder to become proficient in that towering colossus that is Microsoft's Visual C++ development environment. To write code in Visual C++ almost invariably involves using Microsoft's Foundation Classes (MFC) which are a glorified wrapper to the OS calls that Petzold introduces us to. However, most books on this topic tend not to explain what is really going on leaving the reader with a lot of head scratching as to why something is done. Once you understand Petzold then what MFC is doing becomes, in most cases, crystal clear.

Most people will never use this book as a C programming reference. I am one of them. But, as a springboard into C++ with MFC, this book is worth its, not inconsiderable, weight in gold.

They key thing to emphasize about this book is "Windows." This book does contains little information not pertaining to the user interface. Moreover, information about the registry and DDE is completely omitted from this book.

However, there are chapters on Multitasking and Multithreading, Sound, DLL's, and Internet. While these chapters exist, they are once again geared toward the windows interface aspects of it.

Another key thing to remember about this book is that encompasses the Win32 API. This book does not touch on Microsoft Foundation Class (MFC) at all.

Given the above information and limitations, this book is the definitive guide to Windows user interface programming for C programmers. This book begins with an in-depth discussion of Unicode, and the importance of internationalization of applications. he book then progresses through the Windows user interface, beginning with simple Windows creation and manipulation operations, and continuing through graphics and canned dialog boxes. This book also contains in depth sections on device control, including the mouse, printers, and timers.

If you are developing applications for commercial use, or will need to handoff development to other programmers in the future, you will need this book. The sections on internationalization were key for me, and helped put things in perspective for me on developing applications for broader markets outside the United States. However, I only gave this book 4-stars because of the omissions outlined above.