5 comments about The Apache Modules Book: Application Development with Apache (Prentice Hall Open Source Software Development Series).

1. Apache is more than a popular Web server; it's a versatile and complex platform covered well in THE APACHE MODULES BOOK, the first guide for developers who already work with Apache and want to make the most of its features. From code security and basic processing to C-based shortcuts and techniques, APACHE MODULES BOOK uses real-world code examples and techniques to provide an excellent manual of basics. Perfect for any serious programmer's Apache reference collection.



2. This book came recommended to me from a well-learned Apache module developer, and I can't laud it enough. It is simply impossible to find another reference text out there that covers this topic with this level of completeness. I'm not really sure why the HTTP RFC and the Apache Software License is tacked on to the end of the book, but the real content of the book make it well worth the relatively hefty price tag.



3. I tried to write an Apache module using only the documentation and reference material available on the net, and failed. The documentation you can find on the net (even on Apache.org's own website) is either completely out of date or maddeningly vague. If you spend enough time in trial and error you might get your module to work. Then again, you might not.
   
   If you're trying to write or maintain an Apache module, this book is an invaluable tutorial and resource. It saved me a great deal of time and frustration.



4. This book easily earns five stars despite a few glaring issues. Why? It's the best, most consitent, and approachable guide you'll find to writing Apache modules.
   
   I spent two weeks scouring the net for APR examples and explanations. I started with the O'Reilly books only to find they are incredibly out of date. I moved on to Apache sanctioned module source code. I dissected source code for other modules only to find that the examples fluctuated on approach and, apparently, on the author's grasp of the entire APR libraries. Some folks wrote against previous APR version libraries and macros. Others used the updated APR. Still others rolled their own versions of functions that were already written, just not discovered. Tutorials varied in reliability with similar issues. And my desk quickly filled with highlighted and sticky-noted annotated examples.
   
   This book replaced all those loose inconsistent notes with a solid example-centric nicely bound guide. Five stars. Just for that.
   
   This book is not without problems though. First, it makes reference to programming paradigms which, frankly, I've never heard of before and which this book inadequately explains. Brigade buckets is an example. Bridage buckets are incrementally explained as a ring data store (eh?), a doubly linked list (okay, firm ground), and then a mechanism for passing data through layered IO (another eh?). I couldn't get much from the explanation. Googling "brigade bucket" led to IEEE DSP circuit design and a heated debate on using solid state delay effects for guitar pedals. Apparently brigade buckets don't quote share the same prolific status as, say, something more Knuth-ess.
   
   The book explained thread safety in a similarly gap toothed summary. It offers this fatherly advice: avoid shared memory and make sure functions are reentrant. That wasn't much help for me. I'd prefer to have a detailed explanation of why the APR libraries have both reentrant and non-reentrant versions of the same functions. Wouldn't any reasonable programmer always use the reentrant version? If not, I'd like to know why... with some precision.
   
   The final gripe: the book includes RFC 2616 in it's entirety. This needlessly adds 200 pages of non-original and otherwise easily (and FREEly) accessibe volume. Granted, the publisher formatted the RFC nicely. It's a bit easier to read than the fixed format of the real RFC. But why not add a few notes? The author could have taken the edge off of the RFC-legalese and made it a bit more approachable (think learning bible with more notes than text). At the risk of discouraging future books of this level, the RFC is a blatant copout and just a really disgusting way of bumping page numbers.
   
   So, those are the issues I had. I'm still giving this a solid five as it outshines any other information I've found to date.



5. This should be considered a required resource if you need to learn about writing apache modules. It is the best introduction available to writing modules for Apache 2, and holds up well as a reference.

5 comments about Better, Faster, Lighter Java.

1. I loved the premise of this book, because I, too, believe that Java - and programming in general - is getting out of control. Languages, frameworks, and products are adding so many features that it is now literally impossible to have a handle on the language - or even the subset - that you are using. Gone are the days where you can sit and try to figure something out; now programming seems to have boiled down to finding code you can cut and paste (Can you really figure out how to implement, say, an SSL client on your own?), then wrestling with the overwhelming complexity of the APIs, configuration, deployment, framework(s), your IDE, you-name-it.
   Anyway, enough ranting. That's what the book does. And I agree with it. I also agree with all of the good programming principles that the book espouses. The problem I have with it is that it seemed to be a hodgepodge of ideas, practices, and solutions that did not always seem to relate to the title of the book. Don't get me wrong - they're good, but I... well, I guess I was just hoping for more. Like I said at the outset, I think this is a SERIOUS problem that needs to be addressed, and I'm not sure the book did it. ("Not sure" being the operative phrase there. Maybe I just missed the overall picture.)
   Then I started thinking, well, how does one address/attack this problem? Truth is, I don't know. Maybe you can't. Can any one of us, or any one organization or any one book, change the direction of Java programming, which is being chartered by a small group of large companines? Heck, look at the Java Lobby (www.javalobby.org) It's a great website that has been around since Java's beginning, but have they really effected any change? They try, but mostly it boils down to the same cast of characters sharing their ideas (and flames) with one another.
   Bottom Line: I don't know what one can do to change the state of Java programming. These guys try - they certainly did a lot more than I'll ever do - but I'm not sure if this book will do anything except encourage certain good, common-sense programming habits. And some of its advice - like "Life is too short to be stuck with a bad manager. If you don't like your job, find a new one" makes sense on the surface, but have they looked around the real world lately?
   In closing I want to firmly agree with what one reviewer said: The fact that this book has two authors, but is written in a *strong* first person sense, is definitely, definitely weird.



2. They work on five basic principles which, as another reviewer hints, makes it read a little like Covey and that is bad. Covey is a snakeoil salesman who reinvents his time management systems every three years to sell a new book. This book with its daddy Walton house building and kayaking action man morality tales is all quite patronizing.
   
   The home spun tales seem to be Tate's, so I assume Gehtland does the coding. Unfortunately I don't think he read the book since he does not follow the principles that the book espouses: way too much duplication, not very OO (too many if/else; poor exception handling), unthinking dependencies on implementation (e.g Axis, Lucene).
   
   Hibernate and Spring are powerful tools that help in the real world and there are better places to go and find out about them without all the whining.



3. This is a great book. It compares different tools, and shows how to keep things simple and maintainable. Whether it's common sense, like other reviewers wrote, depends on your experiences.
   
   It's easy to get overwhelmed by all the different Java tool acronymns- this is a sane response to all the marketing based feature creep.
   
   If you are a beginning/intermediate programmer, I think this is a worthwhile read.



4. I recommend the first set of chapters in this book for EVERYONE. While it helps to know J2EE/EJB to step through the examples, the author provides a wonderful, thought-provoking and inspiring coverage of software design in general.
   
   The first pieces of the book (actually, up to Chapter 7: Hibernate) discuss the joys and perils of simplistic approaches, over-architecting, under-architecting, evaluating available libraries/APIs, etc.
   
   This is a great coverage of the software engineering process from gathering requirements to coding and from choosing a programming language to dealing with management. A simple, easy read.
   
   The downfall of the book is that it doesn't promise what it advertises: Better, Faster, Lighter Java. The primary focus is on the underlying, architectural choices, not on the Java language itself. However, my downfall was purchasing based on title (as a dual-Amazon suggestion) instead of reading the description.



5. The book starts off well and the author makes several good points about having lighter objects and not being tied to a particular framework, but then it digresses into refactoring evangelism. Despite what this apologist believes, design cannot be neglected altogether as refactoring becomes more and more expensive as a system grows larger and parts get more complex. Just look at all the items still left over from Java 1.0 or 1.1. How many methods has Sun deprecated that are still around? Take many of the concepts to heart up to about page 50, then just chuck the rest.
   
   Design well, but have allowance for refactoring. Build smaller pieces and not monolithic objects.

5 comments about Designing Object-Oriented Software.

1. I am a System Analyst by profession. I needed a book which will help me in understanding the basics of Object Oriented Technology to enable me to perform System Analysis and Design for developing OLTP applications using the Object Oriented Technology. I must admit the book served the purpose.



2. I am a veteran lecturer of object oriented programming> Unfortunately, despite the popularity of the subject and the (seeming) abundance of books in the discipline, I still have a difficulty in providing my students with a comprehensive source of information. This book, however, covers more than any other book I know of, in the clearest form.



3. This book is great because it makes sense. Its simply well thought out, consistent in its approach, and extremely insightful. Even if you dont use CRC cards or dont use the term "Responsibility Driven" in your work, you will find this text and the concepts it presents fit in nicely with the newer UML notation and "way of being." Although you won't find "Use Case" in the index, the stability of the common sense put into this book will map easily to whatever modeling doctrines you use. The fact that Amazon.com is shipping a software design book that is almost 10yrs old in 24hours should also tell you something about its credibility. Simply, a great book.



4. When the book is more than 10 years old and still a required literature in the area, that really tells you a lot. Especially if the area is software engineering where things tend to change quickly. After more than 10 years this book is still a fundamental reading from OO design. Even IBM recommends this book for it's Object Oriented Programming exam. First several chapters are really classic - everything is there: why OOP?, objects, classes, responsibilities, collaborations, hierarchies. If you read this first and then go for any C++/Java/put_your_favorite_oop_language_here book, everything is going to be much much easier and more clear even if you have a decent OO design background. There are even couple of presentations of complete implementations of fair software projects using the terminology and techniques described in the book (last two chapters). If you are beginner in OO design or you have to read just one "theoretical" book from OO design or don't know where to start concerning OO design, I recommend this one. The only drawback is that book is still pretty expensive, but I am sure that you will not regret...



5. When I started learning Object Oriented Design, I was a C programmer with some COBOL experience. I was having a hard time making the paradigm shift to object orientation. This book was the best of several that I read. It was while reading this book that "the light came on". Since then, I've been recommending this book to anyone who is trying to make that paradigm shift themselves.

   The book is language neutral - just as design should be. So you won't get hung up on examples in a language that you don't have.

   Wirfs-Brock takes you through the design process, from the requirements to finished design, helping you understand how to discover your objects and assign responsibilities to them (Responsibility Driven Design (RDD)). She uses Class/Responsibility cards (similar to if not the same as CRC cards) to illustrate the documentation of information. Though there are more modern tools (UML) to capture some of this information, I still use these cards early in a design process because of the ease of changing/correcting them.

4 comments about Advanced LabVIEW Labs.

1. I bought the book last week and since then I can't stop reading it and going through the well presented Labs. I find the book very interesting, well written ,to the point and clear. It will get you up to speed with Labview quickly. I own other Labview books but this is the only one that I didn't find boring or confusing. This is definitely a book I would recommend to all the students who want to learn Labview in a short period of time and also to the instructors; it can be a great teaching tool ! Finally, the price is ...very affordable. Great book ! ...



2. I needed a new software platform for data acquisition following the demise of an older platform. All of my friends at various national laboratories were using LabVIEW so it was a natural choice. I then started looking for a "directed tutorial" that would get me up to speed for data acquisition without first mastering the vast multitude of LabVIEW features (until I really needed them). I found Essick's book to be head and shoulders above the other novice-level books I tried (which were helpful but were taking too long). My undergraduate research students now first encounter LabVIEW with the guidance of this clear, concise, and well-written book. It would also be my first choice as a textbook for a class on LabVIEW (or on data acquisition techniques in general). I recommend this book very highly.



3. This book is a fantastic hands-on introduction to LabView, probably the best book on this topic a beginner can find. It is extremely clearly written, very well edited (i.e., there are practically no mistakes), and it has excellent illustrations for each step in the process of building VIs.

   The book was developed by the author as a student manual for the class he taught. However, it is written so well that I do not understand why a student who has such a book needs an instructor at all. It consists of 12 chapters, all very practical. The first chapter gives a brief introduction to the LabView interface and its editing tools and introduces very simple VIs illustrating the while loop and the waveform chart. Chapters 2 through 8 teach increasingly complicated VIs which utilize the waveforem graph, XY graph, For loop, Formula node, operations with data files and character strings, shift registers, and case and sequence structures. The reader learns how to create arrays of data, perform mathematical operations on them, save them in files and read from files, and how to plot them. There are many practical tips how to navigate the LabView interface quickly and efficiently. Chapters 8 and 9 introduce the advance analysis VIs (included only in the "full" but not in the "base" labview package) and demonstrate how to program nonlinear least squares fitting and Fast Fourier Transform. Finally, the last 3 chapters teach programming of data acquisition boards - analog to digital conversion (digitizing oscilloscope), digital to analog conversion (PID temperature control), and GPIB control of instruments. While the book covers only the essentials of labview, the topics covered and the examples presented are extremely useful, and they all a must to know to program in LabView.

   The book comes without a CD, but it is not necessary as the book describes the process of building of each VI so accurately and in so detailed way that it is very easy to follow the guidelines.

   The book came out in 1999 and most likely was written using LabView 4. Three more versions of LabView came out since that time. It turned out that using it with newer versions of LabView is quite straightforward. The small changes that were introduced after the version 4 sometimes make it necessary to change the VIs slightly, but it is easy to figure out what changes are required using the error messages and LabView help. For instance, newer versions of LabView require that the conditional terminal in the While loop be wired; Replace Array Element is now called Replace Array Subset; there is no need to construct Global Variables using a while loops' shift registers (although it is interesting to learn how this can be done), etc. I counted only 10 small changes which had to be done to the programs on the first 220 pages of the book - and no errors or typos whatsoever!

   To run the programs in Chapters 1-7 any LabView version will do; to run the programs in Ch. 8 and 9 one needs "Full" package (the "base" one does not contain the advanced analysis VIs); and finally, for the last 3 chapters one needs a computer with DAQ and GPIB boards. However, the book is so well written that you can read the text,look through the VI diagrams, and learn from this even if you do not have the proper software or hardware.

   The book is very detailed, but at the same time everything that is in there is necessary; there are no off-topic discussions or jokes - almost 400 pages of straight-to-the-topic presentation.

   The bottom line is that it is a fantastic introduction to LabView for beginners, which I can highly recommend. Well deserved five stars - and an example for the other authors how such books should be written!




4. As all the other reviewers have noted, this is an excellent book. I used it for a class I taught on LabVIEW and both the students and I liked the book. The problem is that it was written for LabVIEW 5. There is a 32 page online update available for the many changes between version 5 and 6.1 but that was a pain and even that is now two years out of date. (To get it, do a Google search for "John Essick" then go to his home page and follow the obvious link.) You had to keep remembering to refer to the update list or you had to go through the book and make notes that would remind you to see the updates.
   This is a wonderful book. But as of this review LabVIEW 7 is now the standard version and this book is now two versions out of date. I would be thrilled if Essick would write an updated version.
   When I learned LabVIEW I used 3 or 4 different books (along with the poor quality manual that came with the original software) and Advanced LabVIEW Labs was a godsend. It taught me the software in language ment for scientists and I immediately connected with it. I'm sorry that I can no longer use it for my class and am now looking for a newer book.

5 comments about Handbook of Relational Database Design.

1. This book is basic and lacking anything new - perhaps becauseit is more than 12 years old. I picked it up at a library, and wasthankful that I didn't pay for it myself.

   Don't you just hate when you pay for a book that doesn't tell you anything and is basically out-of-date. I read the other comments about this book and was awed at their comment. I guess it's the old saying "To each his own". END




2. This is the best intro RDBMS book out there. It explains everything you need to know to design a database. It isn't vendor documentation and isn't trying to be. There are some areas that would benefit from a second edition but nothing in it is patently "wrong" or "out-dated."



3. I purchased this book because it was a mandatory reference in database course. This contains lots of fundamental concepts of relational database. It is a well-organized book starting from LDM rules then to RDD rules with tons of practical examples. The authors does a very good job in explaining and clarifying all the essences, even a trivial point is made clear. This is a must-have for all of you who have to deal with relational database.



4. Database design has taken so many leaps since this book was written, but the concepts you'll find in this book are still very sound. As a beginning data modeler you would gain a lot from these pages.



5. This book teaches a product independant step by step approach to design a relational database. The autors clearly differentiate between data modeling (ERM) and Relational Database Design. Even if the book is older than 10 years, it is very helpful to design databases with current products like Oracle 9i, DB2 V8 etc.

5 comments about Pro Ajax and the .NET 2.0 Platform (Pro).

1. Pro Ajax and the .NET 2.0 Platform gets high marks from me because it is concise, informative and easy to follow. After reading the first three chapters I had a clear understanding of what Ajax really is. Author Dan Woolston has extensive experience with AJAX and he seemed to share it all here without overwhelming this reader.
   
   Woolston did not waste my time in getting me up to speed. In the first three chapters I learned how to write my own reusable (cross browser) JavaScript functions that will work together to execute an Ajax call.
   
   Of course I might rely on one of the various existing frameworks to do this for me. However, now I know what's going on under the covers and I can make an informed decision about what Ajax to use and when. I know exactly what is happening when Ajax is implemented and why.The book also does a nice job of covering CSS and the DOM (document object model). As you know (or will know after reading), these combine with JavaScript to create the foundation of Ajax! Once you understand how they work together you'll know more about Ajax than 90% of your developer friends.
   
   Excellent Feature #1: The overview of JavaScript, CSS and the DOM is fantastic. I really appreciated the fact that it was concise and dead-on accurate in addressing the specific elements that a .NET developer needs to understand in order to code Ajax.
   
   Continuing on, after the book had me up to speed with Ajax, it went into n-tier design. This is important because, in theory, a programmer can go hog wild on Ajax and break tons of rules regarding sound application architecture. So I was impressed that Woolston transitioned directly into best-practices for how and when to use Ajax.
   
   The first third of the book covers Ajax theory and best-practices. With Ajax, one size does not fit all. Therefore, chapter seven includes overviews of many popular Ajax frameworks including non .NET frameworks such as Ruby on Rails, WebORB, xajax (PHP) and Direct Web Remoting (Java). It also covers .NET frameworks including Ajax.NET, Anthem and Atlas.
   
   The other two thirds of the book are devoted to Ajax programming concepts. The author uses the Anthem framework for most of this coding. Anthem is an open-source, .NET framework in C# that is compatible with ASP.NET 1.1 and 2.0. It is extremely lightweight, requiring only one class file for core functionality.
   
   Excellent Feature #2: The book's code walkthroughs are based on a fully functional n-tier sample application that you can download free. The sample application uses the AdventureWorks database which is also a free download from Microsoft if you don't already have access to it.
   
   You might think that some .NET features and topics lend themselves to Ajax technology and therefore should be covered in more detail. You'd be right. Woolston sets aside complete chapters on Web services, Custom Controls, ASP.NET Security and Web Parts.
   
   Excellent Feature #3: When you're done learning how to build your own Ajax, there are two chapters devoted to debugging and testing Ajax.
   
   One of the last chapters was my favorite. Chapter 19 is all about usability. As you may know, Ajax solves many usability problems. But can also create new ones. Woolston addresses the good, the bad and the ugly.
   
   The book provides ideas and examples of good Ajax. The author has test-driven many Ajax controls and shares his trials and tribulations. This feedback no doubt will save developers valuable time.
   
   The book also discusses potential pitfalls of using Ajax. Woolston tackles cross-browser compatibility issues and how to best overcome them. He also talks about how to deal with the browser's back button. How to handle browsers with disabled JavaScript and how to work past the problem of pageshifting.
   
   Some of the other usability topics covered in Chapter 19 include Ajax menus, bookmarking, type-aheads, connected controls, code visibility and page paradigms.
   
   Suffices to say this book packs a big Ajax punch. I highly recommend it to any of my peers who are interested in building Ajax functionality into their web applications. This book is applicable to .NET developers who are working with ASP.NET 1.1 or 2.0. In my opinion, web developers of any skill level will find it helpful.



2. About 3/4 done with this book. Today I just built my 1st Ajax feature in a few hours at work with the suff I learned. This books is a quick read with great examples works in both 1.1 and 2.0. Buy it!



3. i didnot think that i would like this book because for me apress is famous with their books having lacking style of examples. Normally you find yourself lost in the examples eventough the topic is covered very well.
   This book is different than others absolutely; it starts with what is ajax; and why ajax and with simple examples.
   if you dont know javascript; it is still ok because one of the chapters covers javascript; so you can learn enough javascript to handle the simple ajax pages.
   Before diving into ajax; it tells you about different ajax libraries; so i like this part too; you will have an idea about other ajax libraries too.
   I could not run the first example which is the easiest one and i struggle a lot to solve it;but most of the codes in the book is easy to implement.
   And guess what; as you can see from the title; the book is for .NET developers; so if you are a .NET developer; this is right book to buy.
   It is not like other apress books that have coding examples problem. the sequence for the chapter makes the book easy to follow.
   After reading this book; i start reading some tutorials about Atlas ( which is basically Microsoft's Ajax ) and it really helps you to understand atlas too;
   If you like google maps; or virtual maps; this books has a suprise for you :)
   i read 4-5 different books from apress and this one is the best; i will highly recommend this book to all .net developers who want to learn ajax with .net



4. I had done some little test applications utilizing Ajax and/or Atlas prior to reading this book, and I wanted this book to really give a solid base from which to move forward with.
   
   Mr. Woolston's writing style is personable but not too over the top. One thing I did not like about the writing style is the manner in which code is laid out at times. For instance, with many of the sample applications, Mr. Woolston will dump about 5-6 pages of code into the book and then work towards restating it in part afterwards with some explanation. I can see where it would be useful if not in front of the sample code/a PC, but in reality this book will not be useful if not in front of a computer working on the examples.
   
   There are other times where some of the content is not really useful in furthering education about Ajax and certain examples it feels are stretched to make the chapters longer. I think there was likely a challenge in filling out a reasonable sized book because simply put - the fundamental elements of Ajax aren't that complex. I found myself done with the book in a period of less than a week.
   
   Those things said, after reading the book I can certainly say the overall content has an excellent "perspective of the landscape". From a history of Ajax to a little primer on Javascript, CSS/DOM, and the XmlHttpRequest, he moves forward to examples of Ajax demonstrating the technology with an Ajax framework named Anthem. The main meat of the book are really these examples, where practice implements the ideas from the prior chapters.
   
   Lastly, the book closes with a few chapters covering security, testing, usability, performance, and a token chapter on Atlas.
   
   One other element that I appreciated in this book was the identification of a few free tools out there to aid in Ajax development. Those tools in their own right would have definitely contributed to some time savings a week or two ago when I was struggling with a couple DOM/CSS issues prior to reading this book!
   
   In summary, perhaps a book stretched to fit it's cover but nevertheless a very useful read to me and I would certainly recommend it.



5. I hardly ever review books and probably wouldn't have bothered this time if it were not for an email from Amazon seeking one. I decided to go ahead with a review because this book really filled a need I had for working with AJAX for the first time. It had me up and running in very short order. Did it go over a couple things along the way that I already knew? Yes. But I didn't mind it in that it treated all topics in an intelligent manner and helped explain where AJAX fit into the broader world of web development. Definitely geared for .NET. That's what I wanted. If that's what you're looking for, you won't be disappointed.

4 comments about Photodiode Amplifiers: OP AMP Solutions.

1. This book lives up to its title by giving a thorough review of photodiodes driving op-amps. It does not consider specialized, discrete photodiode amplifiers. By limiting the coverage to op-amps, the bandwidths are necessarily those of op-amps, a few tens of megahertz at the time most of the book was written, perhaps 100 MHz or so today. Truly wide bandwidth solutions (GHz) are left to the imagination of the reader.



2. Excellent book for design of optical measurement etc type of application and undrestand noise and errors in the circuit.



3. This book is an excellent reference for understanding the Photodiode circuits. It is gives good coverage of the limitations of the transimpedance amplfier, gives good comparision of different schemes for I to V convertors and covers noise in photodiode circuits extensively. It is a good text for low frequency application . Not meant for real high speed design reference.



4. Basic stuff. This book collects dust on my lab shelf. Transimpedance amplifiers - you can find this stuff on the web for free. Absolutely no talk of charge integration.

5 comments about Python and Tkinter Programming.

1. It is a great book for doing the most simple of
   GUI tasks and for a reference once you have been using
   Tkinter for an extended period of time. The book leaves out
   key definitions when they are most needed, isn't organized
   well and generally falls short when you really start getting
   interested. Don't get this book if you are trying translate
   other GUI skills to Tkinter. It is good for learning the
   absolute basics and as a reference.



2. I have programmed several commercial Macintosh and Windows applications and I have become fairly proficient with Python, so I figured that writing GUIs with Tkinter would be pretty straightforward and Grayson's book looked like a great place to start.

   Not so. While it's fine to have lots of code samples, what would have been even better was much more nitty-gritty discussion of Tk itself. Tk is very clever and powerful, but it is not straightforward. This is even more true of Megawidgets, upon which Pmw is based, and which is widely used in Grayson's examples.

   The appendices at the end are great if you know exactly what you are looking up but frustrating if you don't have a good overview of how Tk works. I recommend Effective Tcl/Tk Programming by Harrison and McLennan to fill in some of the many gaps in Grayson.




3. I find that the author is out of touch with how to present material. He's already tackling a 'calculator' application by page 22. Quite a jump! He should have consulted with someone more experienced in material presentation for someone learning and/or trying to tie concepts together.By starting with basics in the early going, it would have made understanding a little easier in the more complex examples.



4. Tkinter gets a too-brief treatment in Grayson's rush to get on to the subject of Pmw, the Python megawidget library, which seems to be the real subject of the book. If you're not going to work in Pmw, most of this book is useless.

   The basics of Tk are poorly presented, apparently on the assumption that the reader is already familiar with Tk. The first appendix is devoted to the mapping between Tk and Tkinter, a typical "nugget" being the revelation that the Tk construct "-label string" maps onto the Tkinter construct "label=string", which conveys no useful information in the absence of a complete Tk reference.

   Appendix B, a Tkinter reference, has often left me frustrated. It begins with the understandable space-saving device of a list of "Options shared by most widgets," but then continues with "Options shared by many widgets" (why separate?) and "Common widget methods," whose connection with the rest of the appendix is obscure. Studying a widget's entry in Appendix B seldom produces a confident grasp of how to use that widget.

   The book is mostly tutorial in form, suited for leisurely reading but frustrating as a reference.




5. It's a decent book for the experienced python programmer. Definitely not for the beginner. Try working with the "Python Programming" by Lutz before you tackle this book. The examples work for a system with python installed. The book does not cover the subject of standalone applications adequately even though there is supposedly a chapter.
   
   The book has what would be an excellent reference on Python/Tkinter and Python/Pmw objects and interfaces but numerous typos and deletions make it awkward to use. I have seen books rushed especially one of mine which was in rough form without being spellchecked! I took the flak for what was an editorial snafu. The same may have occurred here with the reference sections.

5 comments about Object Oriented Software Engineering: A Use Case Driven Approach (ACM Press).

1. This book is considered a classic by many. The key contribution of the book is the introduction of Use Cases for requirements capture. Jacobson also provides some good hints on how to develop an OO design after starting from Use Cases.

   There are two big weaknesses with this book. Firstly, the book is vague on the amount of detail that should go into a Use Case. This has led to a great amount of confusion and widely different usages in industry. Secondly, the book provides only weak design guidelines beyond those provided for extracting objects from the Use Cases.

   Another criticism of the book is that it is written in a very academic tone, which may be hard to understand for some readers.

   Another book that covers much of the same ground but in a clearer fashion is Ian Graham's _Migrating to Object Technology_.




2. Although this book is seminal in as much as it presents use-cases, it is definitely not the clearest introduction to OO. It does however present Jacobson's OOSE methodology (which is a simplified version of the Objectory methodology). The book is due for an update - and I believe one has been in the pipeline for a while. However, with the release of UML and the new Rational methodology, it is perhaps best left as is.



3. This book was written in 92 yet continues to be a visionary text. The chapter on Components maps closely to the principles used today in distilling software patterns. The section on testing is key to understanding how to design objects properly (so they can be maintained over time). The appreciation of objects expressed in terms of data (entity) and tasks (operations) is crucial to good analysis and design. What Jacobson conveys is the essence of good software engineering. If you want to understand this book, read it several times as you gain knowledge and experience in the OO arena. Each time you will discover new pearls of wisdom.



4. This book, unlike others in the field, shows an indepth understanding of the software development process. Jacobson has definitely spent time designing real world apps. His view of OO as a mere component in the development of quality software is visionary and pre-dates the overemphasis and primacy given to it by latter day authors. If you understand the large picture he presents, you will go far in the pragmatic field of designing and deploying real systems.



5. Lucidly describes the fundamental principals of object-oriented analysis, design, and programming. Excellent coverage of object-oriented analysis including the introduction of use cases. Uses an awkward state transition graph that resembles a flow chart in the design methodology. Emphasizes traceability from analysis model to design model to source code. Describes how object-oriented technology impacts specialized topics such as real-time systems, relational databases, testing strategies, component reuse, and product management. The "warehouse management system" case study is more stimulating than the longer "telecom" case study. Compares the OOSE method with other standard object-oriented methods.

3 comments about Pro SQL Server 2005 Integration Services.

1. Not sure how to study it since there is no source code to download. I can not believe it.



2. I've read several books on SSIS and this is by far the best yet. Explains it at a more advanced and PRACTICAL level than the others while still being easy to follow. Higly recommended. Source code is available at apress.com.



3. Not sure why even one reviewer can rate this bad, this author is awesome. He is very encouraging, he had me drawn by his enthusiasm and love for SSIS. I am still making my way through the book, but wow, I am truly impressed, not only with the way the author elucidates the info, but by the power of SSIS.
   
   Microsoft rocks......