Customer Reviews

Windows System Programming (3rd Edition)

5 star:		(18)
4 star:		(3)
3 star:		(1)
2 star:		(1)
1 star:		(0)

 

 

"Windows System Programming" is clearly written, with subjects presented in a logical order. The program examples tie the topics together so that you can see how the Windows API functions work in real Windows application programs. This is not an internals book; it explains the core Windows API, and the author clearly defines the book's scope.

The subject matter is very important in a lot of practical application development situations where the GUI is not an issue (this is the code "under" the GUI that does the real work). I was able to adapt two of the example programs ("JobShell" from the Process Mgt chapter and "Pipe" from the Interprocess Comm chapter) for use in a recent consulting job. Everything worked well and the changes for my particular task were easy to do, but I would not have been able to figure it out myself without spending a lot of time. I'm thinking of adapting one of the thread synchronization examples in an upcoming assignment. I looked at other books, and none of them had anything even close to these very useful examples.

By the way, the example code (download it from the URL given in the book) is clear, quite reliable (maybe it's not perfect for all I know, but what code is?), and it performs extensive error checking. The code listed in the text is usually streamlined so that the reader can see the logic without getting bogged down in error checking details (the author explains this in the text). I disagree with the March 28 reviewer about this, but maybe he was only looking at the code in the text. The code is clear, straight-forward, seldom "tricky" in any way, generally well documented, and the author goes to a lot of trouble to point out variations, other methods to solve the same problem, performance tradeoffs, and other useful and thought-provoking information. Incidentally, the coding style is compatible with professionally developed Windows code I've encountered during consulting projects.

Finally, the author maintains a web site (same as the code download URL) with corrections, updates, and a lot of additional information that is informative, helpful, and sometimes entertaining and even witty. He also responded quickly when I sent an email requesting some clarification.

So, Hart gets 5 stars for this book; it really helped me in "real world" situations. I wish more authors would write as well, take as much effort with their examples, and support their books the way this author does.

I'm an old system's programmer, and I loved this book. It provides the exact information you need if your an experienced system's coder, and just need the specifics of how to accomplish the operations on windows. Multithreading, memory mapped file i/o, process & thread management, networking, you name it, and it's in here.

I use this text hand and glove with "Windows Internals" by Russinovich. Winternals explains what needs to be done, and Hart's book describes how. This is really an excellant text.

I particularly liked Appendix "C". Sprinkled throughout the text are example programs. Then Appendix "C" compares the real world performance of running the programs. The author does an excellant job of explaining why one approach is suprior to the other, than backs it up with timing examples (on difference versions of windows, using different hardware, and even the differences between FAT & NTFS).

About the only imrpovement to the text I could suggest, is less reference to Unix/POSIX. Most systems programmers are familiar with Unix, and it helps to have previous understanding from another platform, but I think people who buy this text are looking to learn the "Windows Way". Also, the text would benefit from a deeper treatment of the Windows Security model. As it stands, a demonstration of Unix-Style permissions for NTFS is not terribly useful in the real world.

The author does a wonderful job in explaining the fundamentals of windows systems programming. His writing style is clear and concise. This doesn't mean that he glosses over the details however, he makes a good attempt at highlighting tricky or confusing areas in the API and makes sure the reader knows what to watch out for. I reccomend this book for those wanting a good overview of the Win32/64 API. It take to notice that this book does not cover GUI in anyway.

What W. Richard Stevens is to UNIX, Johson M. Hart is to Win32. Any UNIX programmer that's been around has at least one Steven's book. Johnson's "Win32 System Programming" reminds me of W. Richard Steven's "UNIX Network Programming".

Clear, concise, just what you need. It is a classic.

I used this to write several Windows subsystems over the years, including the IO layer for the Parrot Virtual Machine.

I have a short list of "gems" on my shelf, and this is one of them. If I could only keep 2 Windows Programming books, it'd be this one and Petzold's.

As a veteran UNIX developer I recently picked up this book to help me with a new Windows assignment at work. In a matter of hours I had a working prototype that involved services, thread synchronization, and named pipes. The organization, clarity of description, and comprehensive index helped me do my job quickly. I can confidently say that I can handle most system-level programming projects with this book on my desk.

What impressed me most about this book was the subject range. It doesn't cover GUI stuff, but does cover UNICODE, threading, file handling, sockets, writing services, structured exception handling etc, and is pretty much up to date at time of writing this review (it doesn't cover Vista but does touch on 64-bit issues). There are books that cover some of these subjects more deeply, but I cannot think of a book that currently attempts to cover all of these subjects to the level that this book does or with such a consistent usage of Windows techniques.

Although this book does cover bits of the C run-time library, it concentrates more on what the Windows API can do for you that the C run-time cannot. This particularly showed through in the section on file handling. For someone like me who started working with the C and the C run-time library 20+ years ago, has worked with Windows APIs since the very first version of MS Windows appeared, worked with C++ for more than 10 years and worked on numerous UNIX projects too (often with code portable between Windows and UNIX), this book provides numerous reminders of why I should consider Windows APIs instead of C run-time libraries on projects where I don't need my code to be portable to UNIX. That's the key thing though - for an experienced developer this book largely acts as a reminder or as a trigger to go investigate certain things further, for rarely did it feel like an authoritative guide to the topics included. It is good, but not authoritative enough to be worthy of 5 stars. For example, my speciality is high-performance, multi-threaded servers handling protocols such as TCP/IP. Although this book covers multi-threading fairly well (although not brilliantly), I was particularly disappointed by the Sockets coverage - I could be wrong but I got the impression that the author prefers other interfaces to the Sockets API. Similarly, structured exception handling was covered very well, and file handling and memory handling pretty well, but the section on services felt a bit lightweight.

Example code in the book appears to be pretty good, although I have spotted a few minor issues. I haven't checked the errata on the author's web-site, but would hope that corrections do appear there.

So to conclude - yes, I think any serious Windows developer (particularly if writing server apps) should have a copy of this alongside books such as Jeffrey Richter's Programming Applications for Microsoft Windows, but having said that, I suspect that most people will think of Jeffrey Richter as the more authoritative even if in need of an update (which is planned to be happening later this year under a new title).

The best thing about this book, in my opinion, is numerous comparisons that Mr. Hart makes between UNIX and Windows. As a recent Computer Science graduate, all of my system programming experience was in a UNIX environment. (My university used that OS for programming assignment exclusively.) After graduating, however, I found myself in a job that uses Windows. From school, I was familiar with the things I needed to do - parallel programming, sockets, services, but I had no idea how to actually implement such things in Windows. Mr. Hart's direct comparisons to UNIX gave me a frame of reference that made it easier for me to learn the subject matter quicker.

Also, the book's four chapters on multithreaded programming have been extremely insightful and indispensable. Mr. Hart writes "when defects do occur [in a multithreaded application], as they will, code inspection ... often is the most effective in finding and fixing the defects' root causes" (pg. 309). If you don't have the necessary knowledge, staring at the code all day won't do you a bit of good. Mr. Hart's fantastic coverage of this subject has helped me understand the fundamentals of this difficult programming paradigm.

In addition, the information on Structured Exception Handling (SEH) and Unicode was very helpful and informative.

Lastly, I found this book to be very useful because it is very up-to-date.

I would highly recommend this book.

I had never programmed using the Win API (apart from the odd Visual Basic API call) before. I do, however, know C & C++ pretty well inside out.

The book is well written and very readable. There are plenty of examples in the book, and they are supported by a downloadable ZIP file that contains the actual code that you can simply compile & run. The only criticism I have about the examples is that they could be a little better explained. Some things are left to the reader to sort out. However, if you already know C or C++ this should not be too difficult

This is not a book for C & C++ beginners. It is bang up to date & covers all versions of the API from the earliest versions of Windows to the latest versions, even referring to the emerging Win64 technology.

I would recommend this book to anyone who needs to go beyond standard C / C++ or even go beyond MFC. It would also be useful to anyone who needs to know what goes on 'behind the scenes' in Windows or MFC.

Note that this book is not for those folk who want to point at something with a mouse and have it happen. This book is for those folk to have to actually make whatever it is happen.

In order to be functional with a large number of programs, Windows has to present a standardized interface to the programs that are going to run and actually do the desired work. This interface is called the Microsoft Windows Application Programming Interface or API. These API are how the programs tell the operating system to send/get data to/from the disk, how to handle errors, manage memory and processes, in short, how to interface to Windows so that Windows can handle the actual hardware.

In this new edition new features of Windows XP, 2000 and 20003 and Win 64 are covered. The Windows 9x series is touched upon but slightly as these versions are no longer being shipped. The biggest new area is the enhanced coverage of threads and synchronization. To get much out of this book, a knowledge of C programming is needed.

The first thing I noticed when opening this book is that I could open the book to any section I was interested and find the information in a format that is easy to read and understand. The author clearly describes each concept and then supports the information with generous code samples (supplemented by the author's website in case the samples in the book are not enough). Within each topic, he does a good job of building up the concept, first explaining the basic principles, and then extending those basics to real world use.

This book is perfect for a web programmer like me. I have been using ASP.Net as long as it has been around, but I have only started doing Windows programming this year. I often find myself inferring how the Windows Operating System works based on my interaction with it through my code. This book provides a definitive guide that helps me to understand the underlying systems. I am a C# programmer and I was surprised to see that I am able to read and understand the examples in the book (given in C) with no problem.

I think this book is ideal either for someone looking to switch from web programming, or non-windows programming. It is also good for a programming student who wants to get into Windows programming. It would be better if the reader already has some basic programming foundation. However, the book does give enough basic description of even the most rudimentary concepts that if an initiate programmer encounters an unfamiliar concept, the book will give enough information to lead the reader in the right direction.

This book is a nice addition to my knowledge library. I would recommend it to anyone who is learning or practicing windows system programming.