5 comments about Standard C Date/Time Library: Programming the World's Calendars and Clocks.

1. If you are a computer programmer, don't write any (more) date/time code until you see how Lance Latham does it! This book contains comprehensive, organized solutions to all the date/time problems you are likely to encounter, including tricky ones such as "What is the date N days after date X?," "How many days, exactly, are there between date X and date Y?," and even "What is my client's holiday schedule next year?"

   Even if you think you already have an adequate library of date/time code in your shop, don't be too sure until you've tested it using the methods illustrated in Lance Latham's own test programs, included in the CD that accompanies the book. The Year 2000 bug is not the only one infesting date/time code!

   For programmers with historical, international, or religious calendar problems to solve, this book is an invaluable reference for a wide range of past and present calendars and timekeeping systems. Lance Latham also includes a section on the forward-looking ISO 8601 standard, which is enjoying increasing usage in Europe.

   I recommend this book even if you write computer programs in some language other than C. The routines in this book are easy to translate into other languages, even for programmers with only a "reading" knowledge of C. The correct usage of the routines is exhaustively documented, with all parameters, returns, and limitations spelled out for you. Whichever language you use, following Lance Latham's approach will lead to concise, fast, and reliable code.

   My only caveat about this book is that the algorithms underlying the routines are not always adequately explained. Sometimes we are told no more than that an algorithm is a "standard Gregorian proleptic calendar conversion routine." Testing will verify that it does somehow give the correct results, but you may still be tempted to spend hours studying it to figure out how it works.




2. This isn't merely a list of algorithms (though the number of included date/time programs is extensive); it gives a background and an explanation for the major calendar systems and many of the obscure ones. So I'd recommend it not just for "C programmers" but to anyone who cares about calendars and their vagaries.



3. I purchased this book out of interest, but then, as always, there comes a time when you reach for a reference book to help out when you need something coded. Well, that's what I did, and unfortunately the book has basic errors in its Julian to Gregorian conversion routine. Minor, I know, but this book is billed as "the Y2K buster" to get on the bandwagon, but the supplied (tested! hah!) routines don't actually work.

   I went to the support web site to look up or report this errata. It's gone. Unforgivable. The correct algorithm is available from (the U.S. Naval Observatory's website). The transcription error from this algorithm in Fortran to C is minor, but enough to get me irate. A book that is sold on accuracy and Y2K busting should get dates right. You'd have thought that given a function and it's inverse, that the author would have checked that f(f^-1(x)) == x and f^-1(f(x)) == x. But no...

   Apart from that, you'll never use many of the other calendric functions. My faith in this tome is severly shaken.




4. I'd like to clarify the bug that was reported in an earlier review. The bug is in JD0_to_gregorian. Don't worry, though. You can just use JD0_to_gregorian_proleptic which works just fine! The strange thing is even the comments say the 2 functions are identical. I suggest copying the code of the proleptic version to JD0_to_gregorian because a lot of other functions call into it, such as JD0_to_date. It's odd that just this one function has a bug (and a very pivotal function at that) because everything else seems to work great.

   Otherwise the book is very complete and has a lot of interesting explanations of different calendars. It even has moon functions, although they are limited to about +/- 100 years from AD 2000 (it says the full versions are too processor intensive). Great book!




5. When I looked at this book, I checked the terms and conditions on using the code, and bascially, those Ts&Cs say "thou shalt not alter a darn thing in the code". I think those who attempt to fix bugs in it should be very wary -- the licence as I read it (but I'm not a lawyer) said that you could do nothing with it. And the licence makes it difficult to read it as well -- see for example a search at ... with key words Latham Standard Date, news group comp.std.c, and a date range from say 2000-01-01 to 2002-12-31 will pick up three different threads mentioning this issue.

5 comments about OLE DB Consumer Templates: A Programmer's Guide.

1. With high hopes, I bought this book. But it has been a big disappointment. The book explains the concepts of OLE DB templates and the various macros, quite well. Lot of figures explaining the relationship between objects. But it is very much lacking on real usable examples. There is not a single complete example. Most examples are real simple. Inserts and Deletes get just one page each, hardly useful, and also the example used for these is with a CTable. How many people use a CTable for inserts and deletes? It is like saying "Delete/Update the first row in the database", which is hardly practical. There are about 30 OLE DB types, but no examples on how to use these. In summary, the book is better than the SDK documentation on OLE DB templates, but not much useful if you want to get into OLE DB programming quickly.



2. The coverage for basic OLE DB is not good in this book. To get a decent coverage of this in my opinion you can do no better than: "Beginning Components for ASP" which not only explains basic OLE DB well, but also explains MTS and Writing components for ATL to work with ASP amongst other things.



3. This book isn't exactly what I had hoped for. It seems that only about 30% of the book is actually devoted to "Consumer Templates" and the other 70% talks about raw OLE DB interfaces. However, since it is the only book that covers anything on consumer templates ... it is better than nothing.



4. As you can see, there are not many books on the subject. However, this book contains very few code lines and it is not organized well. The fact that a programming book does not have even 1 (!) full example can't be good. You will get a fair amount of information from this book; however, YOU WILL visit MSDN regularly. The author spend time on known subjects like performance again and again (although that C++ programmers are well aware to this subject) and less to the whole concept of the templates. He is breaking up all the objects very well, but failing terribly in providing the whole system. A "nice to have" book as a second or third reference. Don't buy it as first.



5. I am by now several months into a project using the consumer templates. I have to say at this point that the decision to use them was the biggest mistake I have made on this project. They do not make the grade and it is too late to back out and user another interface.
   
   The templates would be a good idea if carried to completion and fully supported. They are not. The template classes Nallet presents are not a full wrapper, but just a series of incomplete examples. They do not compile under newer versions of C++ and must be hacked just to build. Each hack in turn produces more problems. The publisher's web page no longer contains any reference to this book, nor to it's source code. The author's web page is "404", and the code exists on the Internet only in "pirate" sites. I have turned up references to the author through search engines but see no sign he is maintaining his code.
   
   Microsoft is in the process of abandoning OLEDB in any case in favor of ADO.
   
   In short and in other words: DON'T BOTHER!!

4 comments about Schildt's Advanced Windows 95 Programming in C and C++.

1. Schildt provides an excellent introduction to some of the more advanced features of Windows 95. This book is a great way to learn about how to do some of the things that make Win95 apps look professional (Wizards, property sheets, etc.).

   I thought that it could have covered some more topics, but I'm looking forward to reading some of his other books to fill in the gaps.




2. A good book but lack some issues like win32 new memory management.



3. Please TAKE CARE if you are new to Windows Programming. Mostpraising this book will have some experience with Windows Programmingalready.^M

   The author still lives in the past, where one needs to pay for "Hello, World" source code. For each of this book and its Introductory version you need to pay $24.95(US resident)/ $24.95+5( Non-US) and allow 4-6 weeks to be given illustrative source code. There is NOT EVEN on-line download of source code. Watch out!^M

   ^M For a newbie, the offer by Amazon.com for Charles Perzold's classic book on Windows programming is the best deal. You have a CD-ROM with the source codes to play with.




4. This 2-volume set is a nice tutorial/reference for people who know to code. It shows nice examples how to use WinAPI. It EXPLAINS how the system works (many books just tell you what to do). It does not spend time to explain how does the logic work. It's was not written to. However, It does an exceptional job showing how to write for windows.

   If all you want is to know is how windows work, that book IS for you. You won't HAVE TO spend much time with it. Each book takes about a week (20-40 hrs) to MASTER.

4 comments about C++ Programming And Fundamental Concepts.

1. The authors are excellent educators and extremely knowledgeable of the C++ subject matter. This is an excellent text book for anyone wanting to gain a explicit knowledge of C++.. Relative to comparable texts available on the C++ paradigm, the listed price of $51.00 seems to be out of line with most contemporary literature on this subject. Unfortunately, the listed price is definitely a deterent for purchasing this item



2. This book is really pretty bad. The index is TERRIBLE. Buy the Lippman book.



3. This is an excellent book, and it's sad that it hasn't been updated with a second edition. I certainly expected to find one by now, as I've had my copy for several years.

   As an 'old timer' C programmer looking for a conversion course I found the book to be written at just the right level. When C is brought into the picture it is to compare and contrast, and not as ab initio text. So the book is not at all suitable for beginners, or for those who do not have hands-on experience with C. In fact it is exactly what it says it is in the title, and a refreshing change from some lesser texts that promise more.

   I particularly like the way this book explains the underlying mechanisms of C++, but in a machine independent way. I've had no problems using the examples with Borland C++ Builder (in a command line environment), and found the best way to learn C++ was to modify, and play with, the extensive code examples.

   There are a few typos, but these are fairly obvious and don't detract too much. Contrary to other reports I've found the index to be quite adequate, and I have used it (and continue to use it) extensively. Because of the typos and the failure to update I'd like to give it 4.5 stars, but will have to settle for a good 4.

   As to whether the book is good value for money: Well admittedly it is not as thick as some tomes, but there is little padding, and almost every page has been useful at some point. My copy cost the equivalent of about $40 in England, and that was $40 well spent!




4. I've been using this book since 1992, and I have yet to find a book that covers so much so precisely and so concisely (about 450 pages). For mature C programmers who want to get into C++, this is the perfect introduction, if there is ever one. If you don't know C, or if you are a novice C programmer, this is _not_ for you. It is clear, to the point and presents code that clearly highlights the concepts. Chapter 6 alone is worth the price of the book. Example: What are the three situations under which the memberwise initialization function is created [by the compiler] and called? If you have read one of those "thick" intro books and don't know the answer, you'll appreciate the clarity and directness of this book. The authors clearly explain why things work the way they do. They also separate what is fact from what is their preference. The production values are high; code in easy to spot boldface, and all white space is there. Within the confines of its target and the page limit, it is a superb book. To master C++ [and its STL], you'll need several books, a lot of studying and a lot of time. But, this one will put you on the right track.

   Chapters:
   1. Introduction to C++
   2. Non Object-Oriented Extensions to C++
   3. Overview of Data Abstraction and Object-Oriented Features
   4. Fundamental Concepts and Building Blocks
   5. Classes and Abstract Data Types
   6. Constructors and Destructors
   7. Friend Functions and Operator Overloading
   8. References
   9. Inheritance and Virtual Functions
   10. Conversions
   11. Input and Output - iostream Library
   12. File and In-Core I/O
   13. Manipulators
   14. Formatted Stream I/O
   15. Porting C Applications to C++
   Appendix A: Program Sizeof
   Appendix B: Program to determine implicit conversions
   Appendix C: iostream Library Synopsis
   Index

No comments about Algorithms in Combinatorial Geometry (E a T C S Monographs on Theoretical Computer Science).

5 comments about The C/Unix Programmer's Guide.

1. well, this book has proven handy for reference and review, but i would certainly NOT recommend it. the author repeatedly used obscure functions(imho) that were prone to bugs, and he introduced totally new concepts in breif 10-word sentences only to use them all-too-frequently in most examples following. yes, im a 16 year-old, shift-key-fearing mexican, but i've seen good code, and mr.bacon's code doesn't fool me. if you want to take full advantage of this book, read the ENTIRE THING in one sitting so every little concept sticks with you throughout, and don't you dare approach a computer without reading a book that emphasizes on structure, organization, and clean, effective code first



2. The C Unix Programmer's Guide was the only book I could find that provided useful background information as well as thoughtful, applicable coding examples. What impressed me most is the fact that all the information found in the man pages on C as well as further insight was combined into an easily readable and searchable format. As a student of computer science, I was familiar with Borland/Microsoft C++, but I had no previous experience with C or Unix. This book helped me get an A (one of three) in Operating Systems! While my classmates struggled on assignments, I was able to find exactly what I needed to complete the assignments on time. I truly believe that without this book I would not have performed nearly as well. Thank you Mr. Bacon for writing such a great book!



3. This book did an amazing job of introducing many important concepts about C, and C in UNIX.
   
   The description of the material is very clear, and the examples are well thought out.
   
   If you're looking for a beginner/intermediate text on C and UNIX, this is THE book to get.



4. I wish this had been my First C programming book. It teaches all the basics required for you to start some worthful programming under *nix. It doesn't go into as many details for e.g., as given in 'C programming: A modern Approach by King but it still gives many details on what things are. It starts with basics of Unix and provides a lot of information on the C development tools in *nix. A very good starting point for learning programming in C under *nix.



5. I have seen good C programming tutorials, and this is not one. It isn't very descriptive. It will introduce you to new library functions and not give a good explanation on it, and then it rarely describes the code snipets. The C Primer Plus by SAMS is far superior to this for learning C. Having said that, this book is decent in its coverage for UNIX system calls with C, in that it is easier for a beginner to understand the code snipets in this book as compared to other books I have seen. Other books I have seen require you to at least already be an intermediate C programmer, and use examples that require you to study the complex code snipets before you can begin to understand what is being accomplished with the system calls.
   
   The author/publisher hasn't updated this book with regard to hardware, and it talks about 286's, 386's, 486's and Pentium processors. It considers 16 bit and 32 bit processing, and it puts too much emphasis on 16 bit, when every compiler I have seen for C is 32 bit. It even gives suggestions based on 16 bit technology. It references DOS, and if anyone is still running DOS, they shouldn't be reading a book about programming. They should be reading about survival skills and moving to Montana and building a bomb shelter.
   
   So, to learn C, this isn't a good book. If you are dealing with the C/UNIX environment and are a beginner, the end of this book is decent for understanding system calls, as long as you already understand C from some better, more up to date source.

5 comments about Object-Oriented Design & Patterns.

1. I came away from this book wondering just who was meant to read it. It starts with "A Crash Course in Java." (Somehow, I never learned to like any "crash" in the context of program design.) This is much too brief to teach the language, or even summarize it well. Any of many other books would be better for teaching Java to C++ programmers.

   Next, the book goes through two chapters of object oriented design. These chapters are over in about 100 pages - again, not nearly enough time to address OO design in with any real insight. The OO paradigm is truly different from previous generations of software design, and can not be summed up in a few pages of rote rules.

   Worse, the author identifies "javadoc" as a design documentation tool! It is not. Javadoc does a very good job of documenting implementation, but it documents design very badly. If you're not a programmer, trust me - implementation and design are as different as carpentry and architecture. Neither is better than the other, and both are needed to build a house. Implementation is not design, though, and the two require very different documentation.

   The rest of of the book continues in an odd pastiche including:
   -- ideas the programmer already needed to understand the earlier material,
   -- afterthoughts on the Java language, scattered among other topics,
   -- a weak discussion of design patterns, and
   -- a severely flawed discussion of multithreading.

   Only this last deserves attention. Multithreading is a subtle topic. It's easy to write multithreaded code, but very hard to write it correctly. The author actually does a good job of discussing interruption in threads. However, the book's description of synchronization and deadlock is so brief that it leaves me worried - student programmers might read that material and come away thinking they understood the topics. Insufficient knowledge may be worse than none at all, in this case. Most distressing, the author makes no apparent mention of "volatile" data in Java. Multithreaded applications don't need to use volatile data. The programmer MUST understand when volatility is a problem, though, and avoid it or address it directly. It is unacceptable to ignore the risks addressed by "volatile" declarations.

   I can not recommend this book. It claims to address object oriented design, Java, and design patterns. I feel that it does an inadequate job on all counts.




2. This is my textbook from the OOD course I am currently taking with Dr. Horstmann. The course along with the text has completely transform the way I think about programming in general. The book teaches OOD Design process in the first few chapters and goes into more in-depth focusing on Design Patterns and using the JAVA API to illustrate them. I also have the classic "Gang of 4" Design Pattern text, which I had tried to read with no avail before. For a novice programmer, without enouogh programming experience, one does not appreciate the utilities of the Design Patterns. In Horstmann's text, he poses interesting programming tasks, and solves them by using design patterns. This provides a context that a novice programmer can appreciate and learn from. He also references other texts, and tools to help you get more information. The book is not meant to be an in-depth study of any particular topics, but rather, it interwovens many important concepts of medium level difficulty and present a rich and entertaining view on the subject. This is excellent text for a second or third course on programming.



3. The previous reviewer sounds like he is looking for an all in one reference. Indeed, if you are a professional programmer and need a reference book, this one is not for you. However, if you're a student, new to OO programming/design or just want to add to your programming knowledge, this is a perfect book. It's designed for the classroom first (see the preface and exercises!), but is also useful for anyone who learned to program in C++ or Java and wants more sophisticated OO coverage. It is certainly not intended to teach the entire language. Rather, it assumes you already know how to program and want to learn more about Object-Oriented Design, including UML and design patterns. This is an important topic and it's never been introduced in a clearer, more intersting way than it is in this book.



4. OK, in spite of the fact that I develop in C# versus Java and the price is steep, I still think this is a great purchase. Horstmann provides an insightful introduction into serious software development. The book provides a lot of detail that is aimed at increasing your understanding of the language (or related languages) versus simply conveying languge semantics. His introduction to patterns is fairly light (I'd recommend Metsker's "Design Patterns in C#") but solid enough. Although in many respects the material was "refresher" stuff, the prose was entertaining and I found myself picking the book up time and time again just to read a few pages.



5. Reviewer: Dr. Alexander Yakhnis, ayakhnis@brockport.edu
   
   I like the book and have taught Spring 2004 Object-oriented Development (CSC 429 ) course at SUNY College at Brockport, New York. I have taught the material from Chapter I through 6. I have also used the material from Ch. 8 Object-Oriented Frameworks for 2 Independent Study Courses with 2 students during Summer 2004.
   
   I find chapters 4 and 5 the best hands on introduction to Design Patterns that makes the corresponding material of The Gang of Four book quite understandable and it is better by far than many other attempts to introduce design patterns. The author plays to an advantage the use of Java and its libraries already based on some of the design patterns that many other authors have not exploited despite existence of Design Patterns presented in Java.
   
   I also find the choice of 5 patterns: Iterator, Strategy, Observer, Composite and Decorator very tasteful as well as very useful. The author's problem examples illustrating the use of design patterns, particularly, the Invoice example is excellent.
   
   The material in Ch. 4 on Interface Types leads to design patterns gracefully, and one can obviously recognize Strategy patter playing important role unnamed yet. This looks to me a good arrangement. Exercises reinforce the ideas very well. If some more exercises will be added that would be a nice improvement.
   
   The author succeeds in making clear the concept of Object-Oriented Frameworks in introductory textbook. Separation of a framework and applications built on it is very well presented. Use of sequence diagrams helps to understand OO Framework. I would suggest that the concept of a Use Case and collaboration diagrams as alternative to sequence diagrams helps to get into the heart of how a framework achieves a goal relevant to a user. An excellent example of such a goal is presented in Ch. 8 for the Graph Framework.
   
   When I was teaching the course I have attempted to replace The Object-Oriented Design Process from Ch. 2 by elements of Craig Larman textbook Applying UML and Patterns (Completely different patterns there than the 5 mentioned above). It helped me to reinforce software engineering concepts taught by Craig Larman that I have taught in software engineering course and also provided good point of view for understanding the OO Frameworks where some of the goals served by an OO Framework are viewed as Use Cases.
   
   I would use the book again for CSC 429 Object-Oriented Development without hesitation should I be teaching this course again. Also, I continue to use OO Design and Patterns as a source of material for Independent Studies.
   
   Finally, I congratulate the author for making available and understandable the concept of Design Patterns as practical way of building OO software at undergraduate level.

1 comments about Lafore's Windows Programming Made Easy: Only What You Need to Know (Bk&Disk).

1. The best thing about this book is that it is more like reading a middle aged knights story rather than windows programming. An excellent book to start off windows programming.

No comments about Matrix Calculus and Kronecker Product With Applications and C++ Programs.

1 comments about Instant C Programming.

1. This book is actually pretty good! It covers most of the basics of C and I havn't found one compiler error using the source code from the book!