ACCU Home page ACCU Conference Page
Search Contact us ACCU at Flickr ACCU at GitHib ACCU at Google+ ACCU at Facebook ACCU at Linked-in ACCU at Twitter Skip Navigation

Search in Book Reviews

The ACCU passes on review copies of computer books to its members for them to review. The result is a large, high quality collection of book reviews by programmers, for programmers. Currently there are 1918 reviews in the database and more every month.
Search is a simple string search in either book title or book author. The full text search is a search of the text of the review.
    View all alphabetically
Title:
Programming the Win32 API and UNIX System Services
Author:
Donald Merusi
ISBN:
0 13 025969 1
Publisher:
Prentice Hall
Pages:
291pp + CD
Price:
£39-95
Reviewer:
David Nash
Subject:
MS Windows
Appeared in:
14-2
The back-cover blurb on this book describes it as 'must reading for all serious professional enterprise programmers'. That is stretching the truth rather, but it does contain some useful titbits for developers who need to port from one of the title platforms to the other, or for those who are well-versed in one and need to learn about the other.

Having said that I am glad it doesn't purport to teach programming, because I was seriously unimpressed by the quality and consistency of the example programs. For a start, the author seems unsure, or at least undecided, whether he is using C or C++. Most programs look like ordinary C except for the use of C++ style comments. It appears that for some reason, most - but not all - Unix programs are C and most Windows programs are C++. Also he mostly uses (pre-standard) iostreams, except in those programs where he chooses to use C stdio - even those where C++ comments are used.

Finally he seems really confused over what the correct signature for main should be - I found all of the following spread amongst the samples in the book -

void main(void)

void main()

main()

main(void)

int main(void)

int main()

and even INT main(VOID) and VOID main(VOID).

One longish listing (5-3) even contains two different versions in the same example, where two programs are shown to demonstrate Windows virtual memory management.

There are other irritations, such as insisting on using the term 'calling sequence' instead of 'prototype' when showing system calls and not taking his own advice in example 6-6 which demonstrates the use of Unix message queues, but only includes two of the three header files the text states are required to do so.

This is a pity, as the actual content of the book is not all that bad. The subject matter is quite interesting, covering useful things such as thread and process management, file and record locking, memory management and inter-process communications. This is done with a chapter devoted to each topic (7 in total), each chapter having first a Windows section and then a Unix (Solaris or Linux) section. In some cases the same things are demonstrated in both Unix versions and in other cases techniques are described for one platform that are not available on the other. Given that this is all done in 290 pages, including the index, the descriptions of the system calls referenced are necessarily brief.

There is a CD-ROM supplied with all the examples on it, which might be useful as a starting point if you want to try any of the techniques referred to in the book.

The inconsistencies I referred to are not serious but are sloppy and detract from the main content of the book, raising nagging doubts about the accuracy of the technical information given. In fact in one case I know there are inaccuracies - several tables in chapter 6 state that the Unix call to close a socket is closesocket, the same as the Windows call. This is plainly untrue to anyone who knows and in fact the example program uses the correct call, to close. As a result I would not unreservedly recommend the book, although I would say it is worth a look - but don't use it as your only reference.

Methodologies