5 comments about Beginning C# Objects: From Concepts to Code.

1. It's good book valuing to read and collect



2. The book seems nice at first but as you pass to chapter4 most of
   his example programs don't compile, I get errors. Also the explanations are getting confusing. You can't assimilate all those
   remarks for 1 line of code. The author surely try hard but
   all the pics and explanations totally confused me. I won't go to chapter 5. I purchased this book & Learning C# 2005 from Oreilly. Oreilly has less examples but at least the example are clear and they compile without any errors.



3. I just finished reading B.C#O.F.C.t.C and it is about the 5th C# book I've read as I try to restart my programming skills (VB5 last tool really used) with C# and .NET.
   
   This book is a very good starting place for those who are new to Object Oriented Programming (OOP) and who want to start developing a strong OOP mindset. Being that I had a sorta-OOP background with VB5, some of the stuff was a rehash, but I think a person totally unfamiliar with these concepts would find the introductory pace helpful and properly paced. Plus the authors strong bias towards how to design (and reconsider/redesign) your classes with business needs in mind and good OOP design methods will well serve such readers into their later experiences.
   
   The C# language introduction is acceptable as long as one understands you are giving up some in depth training (it is a beginning book after all) for the extra emphasis the authors put on OOP design (e.g. the cover UML diagrams while most other C# books barely touch on such design tools/notations).
   
   The example they build out throughout the book (a Student Class Registration program) I found completely uninteresting and that made me prone to skim the code examples, not really thinking them through as I think you need to do to learn from these types of books. I can see why the authors selected such an example when they are explicit about their intention for the book to be useful to college classes in computer science departments. I also see the pros for an example that is built upon bit by bit over the course of the book. But for me, the large structure interferred with my ability to focus on my areas of interest.
   
   In short, a very good book for those coming fresh to C# and OOP, but if you like me have exposure to either, you're probably better off with two books (e.g. Jesse Liberty's C# programming books from O'Reilly for C#, OOP + UML book for training on those items). I do agree with the authors that understanding how to take it from concept to code well means "thinking" OOP from the start. This books will probably help nurture many OOP neophytes into such expert OOP C# developers.



4. The preception of a books quality depends on what the reader wants and needs. For myself, I gave this this book 5 stars.
   
   Dont expect another coding tutorial. They have their place, of course, but this one is more about project design and implementation. Its not about how to make an object, but how to make objects work together.
   
   Its divided into three basic sections. The first part is an overview of C#. Its not for beginner but will be a good refresher for a mid level deveoper. The second part is application design, and the last part shows how to bring it all together. The examples little simplistic at times, but in the end to illustrate some rather abstract concepts
   
   I've worked as a programer for the past 8 years, and I admit I have been lazy in my professinal development. Im sure the noun/verb and UML diagraming can be found else where, but I found it here first. The information was enough to take me to the next level. I feel I now have a fundemental understanding of how OOP is suppose to work. I would recommed it for a mid level programer who is eyeing project management.



5. This is the best book for beginning objected oriented programming I have read. It explains clearly step by step how object are created and used. All of the OO buzz words are explained with clearly written examples that you can actually understand.
   
   The programming concepts to fully utilize OO programming is explained with examples that are understandable so that you can use the concepts for your own programming.
   
   Also explain C# language in terms of OO programming and methodology so that you learn the language while learning how to program OO. Buy This Book!

5 comments about Beginning EJB 3 Application Development: From Novice to Professional (Beginning: from Novice to Professional).

1. Over the course of a couple weeks I read the entire book. I found that the book provides the most value by doing this. I had some limited experience working on existing EJB 1/2.x apps and have developed some prototype apps using EJB 3 also. The book really filled in some gaps in my knowledge including the history of the specs. I don't know that I would use the book for a reference though. I will probably refer to the spec to get the details.
   
   Although I didn't follow the directions provided to get the code samples running in the Glassfish server I appreciate the detail the authors went through to help the reader. The directions seemed to be complete. I didn't feel like I had to go through this step because I already have code up and running deployed to Glassfish using Netbeans.
   
   Sometimes I felt like the book didn't provide enough detail using nontrivial examples in certain areas such as the lifecycle and interceptor methods. Other times it provided too much detail such as the examples using JSF. I'm about to start a project using EJB3 and JSF so I found the discussion of integrating JSF into an EJB3 app interesting but the average reader would probably be better of referring to a book specifically on JSF.
   
   The sections on performance testing were some of the best in the book. They explained how to set up the tests and the important statistics to look for. I was looking for some information on unit testing EJB3 outside of the container and was disappointed not to find any.
   
   Overall I thought the book was excellent and would recommend it to both developers new to EJB3 and more experienced ones that either want a good overview of the subject or are looking to migrate apps using the older specs. The book didn't blow me away but I still found it hard to find even minor points to be critical of. The book has definitely given me the confidence to apply the new technology appropriately.



2. EJB 3 took its time to get mass acceptance, primarily because many Java developers did not have great memories of earlier versions of EJB. EJB 3 is however now gaining momentum and a number of EJB 3 books have hit the market. Beginning EJB 3 is a Beginner - Intermediate level book from Apress.
   
   In their letter to readers, the authors say that "With EJB3, the EJB spec developers had at last settled upon a model that really made sense. Coming from EJB 2.x world, it was like a breath of fresh air.." So EJB 3, is widely believed to be a significant step forward in simplifying enterprise Java development.
   
   The book uses several examples to demonstrate the new found simplicity of EJB 3. The free, open source application server GlassFish, which is the reference implementation for all specifications in Java EE 5 is used in the book.
   One of the important changes in EJB 3 was the introduction of annotations. However XML descriptors are still very much around. Java development has a tradition of always taking the most complex approach and if there isn't one, it works at complicating the simple approach. So after the initial excitement about annotations, there's again uncertainty. It's now (Annotations) vs (XML) vs (Annotations & XML mix). On this, the authors say "A simple rule we follow is this - If we need to decouple our entity and bean classes from their EJB 3 metadata, as when we want to use the same entity classes with two different inheritance strategies, we put our metadata in XML. Otherwise, we stick with annotations" "And don't forget...whenever metadata is specified for an element using both XML and annotations, the XML always wins"
   
   Chapter 1 introduces EJB 3 and gives us a quick overview of all that's changed in EJB 3.0. Chapter 2 looks at session beans and dives into using dependency injection in session beans, interceptors, callbacks, local vs remote access even before a session bean example is deployed. So the book kind of works with the assumption that you have tried your hand or as some would say "burnt your fingers" with an earlier version of EJB. The book runs the risk of being too fast for someone who might be trying EJB for the first time.
   
   Chapters 3 and 4 look at entity beans and persistence and Chapter 5 looks at message driven beans. Chapter 6 begins with the basics of Web Services and then moves on to the various web services specs and how you can use the @WebService nd @WebMethod annotations to quickly get your app web services ready.
   
   Chapter 6 to 11 deal with web services, integration, transaction, performance and migration from version 2.1. The good thing about these chapters is that the authors first introduce the concept, the need and the basics and then delve into the actual development. Problems while deploying EJB across applications servers were commonly reported with earlier EJB versions, so it's good that the authors have dedicated a chapter to EJB 3 deployment and planning.
   
   JSF has become more or less the standard for new Java web development. So Chapter 12 is a useful one as it shows EJB client development using a simple JSF + EJB 3 application.
   
   Overall, for a beginner-level book I think it would have been good if there was more content and hand-holding in the initial chapters, as Apress has a book "Pro EJB 3" which could look at the advanced EJB topics in detail. But if you have been on the enterprise Java scene for some time and have tried out EJB earlier, this book will get you going with EJB 3 in no time.



3. I thoroughly enjoyed reading the "Beginning EJB 3 Application Development" book. (I'm a senior programmer, have been using Java since 1995 and am co-founder and co-leader of the Austin Java Users Group.) The book started off with a nice executive overview of EJB 3 and the usability problems with EJB 2 that it solved.
   
   On a side note, I have been impressed by the EJB 3 working group for making such a bold move forward while remaining backward compatible with the old specification. Typically as a given software technology matures and becomes well established, the software infrastructure and APIs develop a lot of inertia that leads to significant resistance to large improvements. The EJB 3 working group overcame this pressure and produced a bold new elegant design that should be a pleasure to work with. It always takes time and a lot of work to create a clean simple design and I think the team has done that finally with EJB 3.0. The authors captured the advantages of the new specification and leveraged the new capabilities and simplified approaches.
   
   I appreciated the section on setting up the environment and the mechanics of compiling and deploying the EJBs using the free GlassFish application server. Just enough detail of the incantations to work with the server was given in order to get started without getting bogged down in lengthy setup descriptions. The authors provide examples up front to get you quickly up to speed with the new paradigms. They continuously mix clear examples with explanations to ensure that you gain an incremental understanding quickly.
   
   Stateful and stateless session beans are covered. Comparisons are made between annotations and the XML descriptor files and the rules to override are clearly defined. I enjoyed the section on interceptors and was impressed how easy it is with annotations to intervene with preinvoke or postinvoke operations. I liked that the authors are succinct with their explanations. The authors get to the point quickly, which I appreciate given the volumes of material one needs to absorb to keep current in this industry. The examples start off simply and gain complexity as more features of the spec are added to the application. Useful process flow and database schema diagrams typically accompany the examples to clarify the problem.
   
   Early on I found a couple of small bugs in the sample code (mostly caused by a moving specification), but the authors have been very proactive about posting erratas on the website.
   
   JMS and message driven beans are discussed as well. A quick overview of JMS and MDB is given with a succinct, but very relevant status-notification example. The mechanics of setting up a JMS topic and a JavaMail resource is described, as well compiling and deploying the MDB.
   
   There is a nice brief overview of web services and the associated standards. A useful credit card verification example is provided complete with the mechanics of compiling and running the code.
   
   I thought the sections on the Java persistence API were well done. I felt the authors covered most of the typical issues that you run into when mapping Java objects to a relational database schema. Advanced sections covers hierarchical modeling and the advantages of user-defined primary keys for instance. Concrete table definitions and their associated Java mappings are illustrated.
   
   The authors demonstrated that they have solid design experience since they intermingle practical sage advice and admonishments througout the book.
   
   I thought that there should be more advice on forward versus reverse engineering of the database schema since there are a lot of lousy database schemas out there that have been generated directly from the Java object model.
   
   The authors provide a good overview of container versus bean managed transactions. The mechanics of using each approach and the associated trade offs are illustrated. I like that the authors included some of the basic information on transactions such as the definition of ACID for instance. (I need to refresh my memory every so often.)
   
   The performance benchmarking section was very well done. A clearly thought out methodical approach to performance testing is given with what I thought were surprising results between the two mapping approaches (single table inheritance and inheritance through joins). An overview of a very useful load testing tool is given as well. Salient performance comparisons between EJB 2 and 3 are also presented.
   
   For the seasoned EJB 2 folks, there is a chapter on migrating the EJB 2 applications to EJB 3. This chapter may help in understanding what EJB 3 does for you compared to EJB 2 as well.
   
   In summary, the book was definitely worth my time to read. Beginner and advanced programmers will learn from this book. I'd definitely recommend getting the book and I look forward to working with EJB 3 in practice.



4. The book is a good summary of the specs and gives a nice introduction to the new things in the world of EJB 3. The section on converting your v2 apps to v3 was particularly useful. Appropriately marked "From Novice to Professional" the book touches on many aspects of the J2EE world in a manner that treats the novice with care and the professional with grace and insight/direction.
   
   On the negative side... The book has a lot of repetition. Many pages are nearly identical (especially the sample building) and could have been condensed and made more useful by sticking to use of Ant and examination of the scripts. The same can be said for the "copy-and-paste nature" of some of the writing. However, one can tack that up to "consistency in writing style."
   
   The book is not what I would call an "easy read," but was informative none-the-less. It serves as a starting point and base reference.
   
   The authors have provided a generally well-rounded book and I would definitely recommend this to others.



5. Seems like a good book when you skim it in the book store. After you buy it and start reading, you realize that (a) there are many errors, and (b) APress (publisher) has "disappeared" the errata from their web site. Nice. I'll be contacting APress about a refund (unfortunately, I write in my tech books :-)

5 comments about Windows Forms Programming in C# (Microsoft .NET Development Series).

1. "...I had hoped it would be a convenient and quick reference to such questions as "how do I use FolderBrowserDialog and/or OpenFileDialog to open a file in my C# program?" but although these standard components are indexed in the book the discussion of them in the book is shorter than this review I am writing. What I would want is some kind of sample code, maybe a step-by-step description of how to add the components to my program..."
   
   There's no way I could have said it better. The book seems to want to cover "everything" but actually manages to say "nothing".
   
   The only part in which I would have to disagree with the previous reviewer is his rating. He gave it three stars. I think it deserves one.



2. I got this book after having already done quite a bit of WinForms programming and found it a compelling read. I'd have read after a platform/language primer but before doing any actual WinForms work, had I had it in my possession at that time.
   
   Its the first programming book in some time that I read as a 'page turner' - it's that well-written (in prose terms).
   
   It's also very well copy-edited, which shows that a lot of effort went into getting the book just right, which can't be said for all books (I guess the gap between release of .NET 1.0&1.1 and this book allowed for that more than in other books).
   
   As for the relevance of the information, I believe it to be very relevant to a wide variety of application types, regardless of that being the main criticism I see in other reviews here. I guess that comes from the fact that you can't please all the people all the time. Still, I'd venture it comes as close as any other book is going to come.
   
   For me it's very near the top of the must-have books if you're going to be writing non-trivial production WinForms apps.
   
   One thing to be aware of is that the .NET 2.0 version is on the way in the coming months, making it Essential unless you're not in a position to use 2.0 stuff.



3. 
   
   The second edition is out that covers Windows forms V2, you may want to buy it instead.



4. I'm a Java programmer who finished reading O'Reilly's "Programming C#" (very good book), and wanted to get started in Windows Forms programming. Chapters 1 and 2 were decent and Appendix B was an excellent introduction to Delegates and Events.
   
   The rest of the book, however, was very weak. All it did was give a brief summary of some of the windows forms components (and the coverage was very weak). If you want to learn about a component you are going to have to look it up it on MSDN.
   
   I was hoping the book would give me something other than what I can get by looking at an API. I was really hoping there would at least be a few chapters on how to design Windows Forms applications - there was nothing. The easy part is learning how to use a component. The difficult part is learning best practices about design an application - something this book didn't touch.
   
   Also, I'm not sure how the rest of the books in the "Microsoft .NET Development Series" are, but I think it's very cheap and dishonest to make a book 'appear' weighty. The book is 680 pages, but the margins, line spacing, and text are all very large. This book easily could have been half its size.



5. Contains all the essential information and a little bit more but not much more. Over all a pretty good starter book.

5 comments about Use Cases: Requirements in Context (2nd Edition).

1. Programmers naturally hate use cases. They seem boring, and having seen hundreds of them (written by others and handed to me) over the years, I had lost hope that this practice would ever be of any benefit. I had grown tired of constantly reading varying levels of abstraction and `use-case-itis'. All this, despite the fact that Jacobson's original work and the UDP incorporation of use cases as central to that process was clearly a better way to go than wading through hundreds, sometimes thousands of pages of `shall' statements that accompany most projects (and too often, lead to their failure).

   Then I read this book. I now use it regularly in every requirements-related class I teach, and I tell every programmer I meet to buy this book. Imagine a use case book that programmers can actually get excited about! This book blazes new territory and its practical insights and humor make it a fun read, as well.

   Here are the great highlights:
   1. Properly scoping and relating use cases
   2. Introducing Business Rules as 'first-class citizens"
   3. Applying UDP iterations to the use case development process.

   These last two items make the book stand out. Understanding the importance of business rules as enterprise-wide invariants that span use cases is ground-breaking. The four UDP iterations are ingenious because they can help to enforce the proper level of abstraction, which is a big problem area for use cases. Try it, you'll like it!

   In addition, the book is loaded with great practical advice and examples of good (and bad!) use case text. And finally, the authors present the most compelling arguments I've ever heard for ditching traditional requirements-gathering methods (which have clearly FAILED), because use cases are, after all, requirements IN CONTEXT (like the title says). If every use case writer read this book and followed it's advice, the software crisis would be dealt a serious blow.

   Bottom line : If you write use cases (or worse, are forced to implement bad use cases at gunpoint), get this book!




2. I saw this book in a stall, while searching for some other book. I had a glance at it and really liked the simplicity and practical approach. Once I bought it and read it completely, I felt happy to find such a great book on Requirements Study. To read and understand this book you need not have a lot of experience or a Requirements Specialist. I feel anyone from Programmer to Project Manager will find this book very useful. The authors teach you in a very practical manner, how to come out with good Use Cases. I enjoyed reading this book, applied the concept in my projects while doing Requirements Study and now can happily recommend this book to others.

   Three cheers to the authors for a great work.

   Note: I found Craig Larmen, while talking about Use Cases in his best selling book on UML and Patterns talks highly about this book.




3. Being in the middle of a messy project this book came to me a little late. I consider is one of the best introductions to
   the understanding of what a use case is and WHAT things you should put in it. Everbody has suffered for long endless meetings discussing which is the scope of the use cases and how it should be used, I strongly recomend to read this book before start arguing.
   I give it four starts because it lacks in some way of paths that can work as guidelines trough the process, although is not the focus of this book, it would very useful to include a couple of pages reviewing this subject.



4. Very interesting stuff and fluid understanding..Could have more topics though



5. Too often you find books on these subjects that tend to talk theory, leaving it to you to determine how you'll apply that theory. This book in excellent, not only in presenting the theory, but even more so when it deals with interviewing, testing and taking a Use Case artifact through the various iterations to the Finished (polished) state.
   
   If you've never done Use Cases, start with this book.
   If you've used Use Cases, but not studied the theory, continue with this book.
   If you want to teach others, apply this book.
   
   It is great all around.

3 comments about Creating Adobe Acrobat Forms with CDROM.

1. This book reveals one of the best kept secrets of Acrobat 5.0 - easy to create forms handling and workflow. Actually the features aren't secret, but the Adobe documentation is so confusing that only the most technically inclined users made use of it. The author clearly explains how to create forms and employ them as business solutions.

   What I like is the way you're introduced to all of the features of Acrobat, including products that are only available through direct purchase from Adobe, that places forms development into the context of the much larger picture of Acrobat's features and capabilities. The book then proceeds to systematically step you through creating basic forms (dynamic and static), and all of the associated details, such as field types and properties, calculating data and workflow considerations.

   After you've mastered the basics the book shows how to use Javascript to create sophisticated forms and handling applications. In this section of the book the author does not assume any knowledge of Javascript on the part of the reader. The tutorial is clearly written and explains the basics of Javascript, but unless you have prior programming experience you may want to skip this section. On the other hand, if you understand the basics of programming or have used some of the user-oriented languages, such as SQL or Visual Basic, you should have no problem with this section of the book.

   The most valuable part of the book is in Parts III and IV, which cover distributing and working with forms. The chapters in these two parts of the book show you how to apply forms to business solutions. In addition, the CD ROM contains example forms and a valuable collection of Javascript routines that you can either use as is, or modify to suit specific requirements. There are also trial versions of various Acrobat plug-ins, and the entire book reproduced in Acrobat format (plus two ebooks titled "101 Acrobat 5.0 eTips and Techniques" and "101 Acrobat 5.0 Forms eTips and Techniques").




2. I wish I had known that this was not going to cover Acrobat 6. The current version of acrobat does forms completely different than version 5. This is a dinosaur now.



3. This book is horribly outdated! If you have Acrobat 5, - fine. Or maybe not so fine... use the money you would have spent on this book and upgrade to the current Adobe version: Acrobat 7 as of Sept 2006.
   ..and beware of Wiley Books that don't specifiy the application version - - Wiley is notorious for this -- remember, when purchasing a Wiley book -- think twice if the version of the application is not specified..

5 comments about Agile Modeling: Effective Practices for Extreme Programming and the Unified Process.

1. For those few places left that steep themselves in documentation and don't have a legally-required reason to do so (do they exist?), this book should help motivate why producing too much documentation and doing too much modeling up front can hurt rather than help. Even for a company that sees itself as lightweight, he's got some rough assessments you can do to see if you're overdoing things, which were relevant even where I work.

   The only bad thing is that it was a very theory and ideal oriented book. It didn't contain concrete examples of what Agile Modeling would look like on a real project, how it would feel, and how what models were produced would evolve. This made it a bit difficult to verify my interpretation of the book.




2. Good book with lots of behind the scenes process info about how to implement agile modeling techniques. If you are looking for step by step instructions to modeling or how to model, look elsewhere. It doesn't cover specific modeling, but techniques. Some of the techniques are common sense, but there were lots of suggestions of how to apply them in a difficult political environment. I did not completely agree with the often repeated
   statement that unless you apply all of the techniques you cannot truly claim agile modeling success, which I think is a somewhat arrogant statement. Agile modeling is a huge cultural change and implementing as much as possible, if not all, is still a great idea.



3. Agile modeling is about the latest approach to the modeling of Business Information Systems. This book focuses on the Agile method and also describes how to incorporate the strong points of UML. The book will be an aid to "survive" in the jungle of developing modern BI Systems. There are IT decision makers that are not aware of Agile, since Agile is a mind shift, be careful how you introduce the new ideas to these decision makers. The book is for the IT professional (all levels), who wants to be in the forefront of software development. If you are in the "nuts and bolts" of systems development, do yourself a favour and look also at "Agile Database Techniques", by the same author.



4. This is a mix of good, bad, and annoying
   
   Good: the author really does know a lot about modeling (except data modeling, see "Bad") and gives good explanations and examples of many aspects of modeling at many stages in the development process. If you can plough through his 350+ pages, you will have found many stimulating and practical concepts and some good advice on implementing them.
   
   A very good chapter is Chapter 29 - a discussion of how to implement Agile Modeling - or really, any agile practice - in a usually hostile world. Some battle scars showing here!
   
   I also like that he does not consider the UML the be-all and end-all of modeling tools. Like him, I've found good use for the trusty old DFD (Data Flow Diagram) of the 70's, where appropriate.
   
   And his overall message - that the agile approach can extend to your design and modeling task, not just code, and the implications for minimizing the documentation effort - is very strong.
   
   I find his reference to quick diagrams "on the back of a napkin" a bit overdone. Sure, the quick informal diagram is excellent, but paper napkins are not the best medium! Hand-drawn on a piece of paper, or a card, sure...if you are discussing models in a bar or restaurant with that degree of focus...get a life!
   
   Whiteboard and digital camera can certainly be used much more than they are. But the overall point is excellent: that when you are documenting (and he has some difficulty separating out "modeling" from "documenting" and acknowledges the problem) you are not creating the end-product, and there is a cost for that. "Travel light" - yes. As Einstein said "Everything should be as simple as possible, but no simpler."
   
   Bad: his data model example is terrible. What's with adding surrogate keys to every table? This is a pernicious practice that has become all too common from people who never learned relational theory and try to fit relational into the object model. A giveaway is that he calls his "identity" columns "persistent object identifiers." Yes, sometimes they are necessary or useful, but in general the natural key is way better. In his Customer table, there is a customer number - but it's not the primary key, a pesky OID is! He himself acknowledges that this may give performance problems, or at least not be optimal. It implies more indexing and triggers...oh well, enough already. Just don't let RDBMS gurus like Fabian Pascal or Joe Celko see that chapter.
   
   Slightly annoying: A few little niggles about English usage etc - by now you would think that any publisher's editor would know that "supersede" has no "c" in it, and that you can't be "reticent to" something - the word is "reluctant. Odd. On the other hand, thank goodness for someone who understands why it's "co-located" not the bizarre "collocated" that I see far too often.
   
   Really annoying: Basically, Einstein's phrase above could have replaced about half the book. It's incredibly repetitious, and also over-organized, over-conceptualized, over-categorized, generally over-inflated. We need a discipline of Agile Communication! An end to ListMania! A thoroughgoing refactoring of the contents is in order. His four Parts and thirty Chapters contain massive redundancy. The matching of agile modeling precepts, in finest detail, to the equally excruciating detail of the RUP, is really an unnecessary exercise. We don't have TIME for this!
   
   As someone else said, a short White Paper could have replaced the entire book. Hence the two stars, good though some of the material is.



5. Not much information other than what you can read on his website. I was looking for something much more prescriptive in terms of how to model in an agile way and how to communicate the model.

5 comments about Schaum's Outline of Programming With Fortran 77 (Schaum's Outlines).

1. My undergrad mech. eng. program uses MATLAB exclusively and I now need to learn FORTRAN for graduate school in less than a week. Despite the low rating for this book and knowing that it may be too elementary, I picked it up anyways just because of my experience with Schaum's outline.

   Indeed, this book is very elementary and doesn't addresses some of the problems that I might need to solve. But this book is an OUTLINE of programming in FORTRAN. I consider myself an experienced programmer (not expert, just experienced) and I'm halfway through this book in an hour. It shows me all I need to know before I start exploring FORTRAN myself.

   Overall, I think this book works like the owner manual for your car. You read it once then put it aside for a couple of years. But for $17, I think this is a very good buy. It will show you what you need to know fast. Just don't expect it to do your laundry and cook your dinner (dorm life humor).




2. This is a good resource manual for Fortran code builders. It has the basic resources that define Fortran concepts and syntax. No programming book can address specific problems you might be working with in code design, but the better books give you the foundations and tips necessary to keep you on track when using the language. I have found this manual helpful as it helps build code that will compile under all later version compilers.



3. This is a very good book for those who does not know programming with fortran 77 but would like to learn it in a relatively short period of time. It is also a good reference for those who writes fortran 77 codes and in need of a source to have a quick look at programming rules and examples. I used this book to write codes for my simulations in my PhD study. I recommend it.



4. For Fortran beginners this would be a good friend of yours but using it with other books such as Introduction to Fortran or other published tutorials on the web would put the icing to the cake.I recommend 'Interractive fortran 77- A hands on Approach' by Ian D Chivers et al.-which is also an online book to supplement this book.In that way you will be kickin' some fortran.



5. This book provides a basic outline of Fortran 77 for elementary programmers. I was previously only familiar with C++ (only one introductory class). This book helped me learn the basics of Fortran quickly and efficiently, but it does not cover any advanced topics.

2 comments about Scripting VMware: Power Tools for Automating Virtual Infrastructure Administration.

1. like nearly every VMware administrator or consultant I couldn't wait for the release of this book. After a delay to the first announcement of about 7 months I hoped to get a book including all news about VI3 too.
   
   But the whole book seems to be a patchwork, mixing ESX2/VC1 and VI3 mostly without a comment at what version the reader is. It's quite obvious that some of authors have written their chapters at ESX 2 times without updating to ESX 3 like chapter 7 (backup).
   
   Some of the chapters are really useless like the first kickstart chapter, which doesn't contain any news beside the manual, even rather the screenshots are from an old beta version I think and it's not mentioned that you must change a xml file to make the kickstart generator available.
   
   Not one new esxcfg- commands of ESX3 is even mentioned!!! You are searching without success for the backup scripts like vcbmounter.
   
   Most scripting example or tips can be found for several month or even years (like APC Powerchute installation) within the VMware forum.
   
   Many people begin to use python or java for scripting VI3 - yes, you don't even find the letter j in the index!
   
   The only fact I'm giving two stars instead of one are the scripting chapters for VB .net and the downloadable scripts from the syngress website if you own that book.



2. While this book is not full of product information for administrators, it serves the purpose that it was intended for...showing you how to programmatically automate ESX and VirtualCenter tasks.
   
   The book limits the use of shell scripts and command-line tools, opting more for object-oriented programming languages. A thorough walk-through of code for both ESX 2.5.x/VC 1.x as well as ESX 3.x/VC 2.x is included in the book, with samples in VB, C#, Perl, and Java. I particularly liked the explanation of the SDK web service architecture and the idiosyncrasies of consuming the web service with typical SOAP clients.
   
   If you're thinking about creating custom software to interact with VMware products or you simply want to write custom scripts to ease administration, this is a great reference book for you!

5 comments about Hibernate: A Developer's Notebook.

1. For the versions of Hibernate and Hsqldb it was written for this is an excellent book to get you up and running, and a good introduction into the Hibernate platform.
   But Hibernate and Hsqldb both have moved on and many (most) of the examples no longer work without modification.
   Nothing that searching the web and Hibernate documentation can't find quickly though, leaving it still a viable introduction into the concepts and syntax.
   
   I personally like thin books and this one certainly doesn't try to spoonfeed you Java or anything, it assumes the reader is smart enough to figure things out for himself.



2. Yes...
   i just got it yesterday and brought it to work and it helped me solve an issue that has been buggin me since 2 days ago!
   
   The examples seem to be quiet easy to read and the format is basically what a developer would ask very intuitive.



3. I purchased this book when it first came out, and this past weekend finally got around to doing all of the examples. I suggest downloading Hibernate2, which is what the book covers. Hibernate3 is a bit different in structure and will just slow down what you are trying to learn.
   
   Needless to say 2 days later I am building my backend with Hibernate and upset with myself that I did not read and study this book a year go.
   
   I do suggest getting a nice Hibernate reference book on top of this. This book will get you started nicely (by chapter 2 I was on my way), but it would be of value to understand more of the details.



4. not only is this book pretty outdated as it only focuses on hibernate2 and not the newer release hibernate3 which is not backwards compatible... there was also a "serious technical error" early on in the book that set me back a while... google the corrections if you use this book.
   
   the writing style was decent... i wouldn't mind reading an newer updated copy



5. When doing projects that use mapping files, everyone gets a copy of this book. It is exactly what it is - a good handbook about Hibernate.
   
   The only drawback to this book is that it covers only mapping files, without any focus on annotations.

5 comments about Foundations of Microsoft Expression Web: The Basics and Beyond.

1. If you are using expression web for the first time, this book is overwhelming. Way too many words. Now that I have been using expression web for a couple months, I am able to make use of this book and expand my knowledge base but it is not a book to get you up & running right away.



2. Overburdened technical manual - not a user-friendly guide for Microsoft's Expression Web that was released to replace Frontpage. Laborious, tedious, and difficult to wade through - if you're looking for a book to actually help you design websites using Expression Web SKIP THIS ONE. If you want something that you can flip through to answer specific questions regarding CSS and other technical questions regarding Expression Web's design and functions then this would probably be it... considering the author is one of the utmost expert's on Expression Web and answers questions on Microsoft's Expression Web help site.
   
   Still waiting on a decent book on developing websites in Microsoft Expression Web - not the technical definitions and aspects of CSS, ASP, etc.



3. I bought this book to help me transition from FP 2003 to Expression web. The book is a big disappointment. She explains everything in code... I want simple explanations, like most people moving from Front page would...She assumes that you will be writing your own code I guess...very sorry that I bought it...The book covers very little and the examples that she wants you to download are ridiculous. I'm not sure who this book will help, definitely not me. If I could give it a "0" star rating I would.



4. I have used Front Page to build numerous Web sites but found this book incomprehensible, poorly organized and difficult to use. Although it is touted as providing "the basics and beyond", it gets mired in details without providing the context needed to understand them. I hope the next version will start with an overview of what the program can do, how it works, and the ways in which is is like and unlike Front Page, its predecessor. If you're not a designer with a sophisticated understanding of Web design terminology and how sites are constructed, I'd strongly suggest starting elsewhere.



5. Excellent book for both the beginner and expert. Lots of knowledge packed into a small space. GREAT BOOK!!