2 comments about Inside Microsoft Dynamics AX 4.0.

1. I found this book helpful when trying to figure out how to do a variety of development tasks such as debugging, reverse engineering, compiling, etc. The section on the development tools was helpful because it provided a guide on what's available for developers. It's easy to understand and provides some good background information on a lot of the tools and techniques. Very useful for either developers or consultants.



2. Microsoft Dynamics AX is another of the very high end development system that Microsoft has been developing to make the implementation of sophisticated applications relatively easy. Specifically Dynamics AX (which has gone by several names during it's development cycle) is oriented to enterprise resource planning (ERP) applications developers. It might be viewed as a library of subroutines that perform the fundamental actions needed by an ERP system. It is then up to the developer to simply connect these subroutines together in order to produce application.
   
   The end result can be viewed as a very high level language that contains many functions written to perform the actual work. As with any other computer language, it is something non-trivial that has to be learned. And this book is basically a tutorial on the language. It probably is something that could be learned as a language by itself, but experience in other languages, particularily C++ and SQL will ease the learning task. Obviously the reader should have some experience in ERP.
   
   This book is written by members of the development team. It is complete and thorough, but it is a book on the Dynamics AX system, not on ERP.

2 comments about Sams Teach Yourself WPF in 24 Hours (Sams Teach Yourself -- Hours).

1. I believe I have every book on WPF. My first impression was 24 hours books have very little information, but it has changed my perception. The book has 24 small chapters and every chapter's information is to the point. The whole book has 4 applications and every example worth looking. I am impressed with authors. Everyone is talking about Adam Nathan's book, but this book has its own place.



2. The first 6 chapters in this book are the best introduction to WPF I've come across in any book on the topic. Its starts at square one and moves very logically and clearly along. If you're looking for basics that will help you understand the layout panels, binding data, WPF architecture from a real world work need perspective, this is a great book to have. The authors do a great job of showing you the ropes and explaining the background of the WPF architecture in a way that clarifies why you would use this control over that one, or this panel instead of this one. Very good conceptual model for both designers and developers!

5 comments about Death March (2nd Edition) (Yourdon Press Series).

1. It is mostly a synopsis of ideas from several better books (e.g. Peopleware). I'd suggest reading them instead. Of course, the bibliography from this book is very useful. It is a decent guide to what resources are available for dealing with Death March projects.



2. The very first page of this book defines what the author means by a "Death March"; any project whose project parameters exceeds the norm by more than fifty percent. In essence, this book is meant to help you in those unpleasant circumstances when you've got half the amount of time, half the amount of staff, or half the amount of money that you would rationally need to finish a project.
   
   Unsurprisingly, Yourdon advises anyone reading the book to avoid these projects as much as possible, even counseling that it is sometimes better to resign early rather than sacrifice your health and professional reputation trying to do the impossible. But if you feel compelled to embark on a Death March, this book is an invaluable guide to the pain that lays ahead.
   
   One of the reasons the book is so valuable is that it articulates many of the things we would like to think are common sense. These are items that, when you read them for the first time, make you think "of course that's true". But if you ask yourself whether or not you would have instinctively and firmly followed the advice, the answer is often no. I found the chapters on politics and negotiation (2 & 3 respectively) to be particularly helpful in this way. OF COURSE I should negotiate the scope and the specific team members needed at the start of a death march project, but reading Yourdon's words I came to the realization that my first reaction is instinctively "we'll make it happen" rather than the sometimes appropriate "we've only got a chance if I can have..." It's important to get gut checks like this before you find yourself in the middle of a tense situation so that you can anticipate your own feelings and counter them when necessary.
   
   Another very interesting concept is the Triage system described in chapter 5. This is based on the idea that, no matter what else happens in a death march, the team will not be able to deliver 100% of the features that are initially asked for. I actually see a very strong argument here for using some of the newer Agile project management methods, where the items that deliver the most value are implemented first and evaluated by the end users. Combining such a system with a triage effort on behalf of the project manager and management could, on occasion, allow a death march project to produce nearly 100% of the value required without completing 100% of the features.
   
   There is much else in here that is useful, especially on the subjects of why people participate in these sorts of projects and what they expect to get out of them. If it's impossible for you to avoid a Death March, make sure you've read this book before you plunge in.



3. I was required to read this book for a Masters-level class in project maanagement. Overall, it provides good insight into the challenges facing IT projects and why they often fail. At times Yourdon shows a slight engineering know-it-all slant in his writing, but in the end Yourdon accurately portrays the fact that IT projects alone do not provide panacea for organizational, social, and business problems.



4. Mediocre. Uninspired writing, much like his other books. I keep hoping for better but he never delivers. About 200 pages, padded by notes for each chapter that repeat things in the main text.
   
   Occasional interesting points, but not enough to make it a keeper. Borrow it if you can for a quick read.



5. Definitely a must-read for anyone involved with project or technical management.
   
   Yourdon exposes a series of reasons that move organizations into death marches, and also the reason why many employees still embark on those projects.
   
   He also tries to propose some solutions, although many times you will be facing a no-win scenario.
   
   An short book and an eye opener for those who don't have time to read (beacause they are already involved in a death march)
   
   [...]

No comments about Pro ASP.NET MVC Framework (Pro).

5 comments about Java Cookbook, Second Edition.

1. I make no apologies about being an "R&D" developer... "Rob & Duplicate". I learn best by seeing something that works, and then adapting it to my own needs. Therefore, a book like Java Cookbook by Ian Darwin (O'Reilly) is the exact type of book I look for and use on a regular basis.
   
   The chapter breakdown: Getting Started; Interacting With The Environment; Strings and Things; Pattern Matching with Regular Expressions; Numbers; Dates and Times; Structuring Data with Java; Data Structuring with Generics, foreach, and Enumerations; Object-Oriented Techniques; Input and Output; Directory and Filesystem Operations; Programming External Devices: Serial and Parallel Ports; Graphics and Sound; Graphical User Interfaces; Internationalization and Localization; Network Clients; Server-Side Java: Sockets; Network Clients II: Applets and Web Clients; Java and Electronic Mail; Database Access; XML; Distributed Java: RMI; Packages and Packaging; Threaded Java; Introspection, or "A Class Named Class"; Using Java with Other Languages
   
   For those unfamiliar with the "Cookbook" style, the chapters have a series of real-life problems, such as playing a sound file, playing a video clip, and printing in Java. The problem is followed by a short one or two line solution and an expanded discussion of the issue complete with code. This approach makes it really easy to find something that is similar to the issue you're facing and to see how someone else would solve it.
   
   For me, the quality of this book is really high. It's a second edition covering the Java 1.5 package, so it's fully up on the current technology. In fact, the Generics chapter deals exclusively with new features in 1.5. Some of the solutions are code classes developed by the author and made available for download. But unlike some books I've reviewed where the author supplies code, this isn't an attempt to push their company or product. It's just a clean way to use a solution that someone else has worked through.
   
   This isn't a book you'd use to learn Java from scratch, but it's a book you'll use on a regular basis as you continue to expand your Java knowledge. Highly recommended.



2. This is an excellent book-it manages to make itself appropriate for both introductory and experienced Java developers. If you've ever looked at any of the books in O'Reilly's "Cookbook" series, you'll know that the book is organized into "recipes", which illustrate how to accomplish various development tasks in Java.
   
   Many of the beginning recipes are pretty basic, but will be used by developers new to Java to get started. Recipes include setting up the IDE to work correctly, working with a debugger, and even an introduction to JUnit. The next few sections of recipes are similar to what you would expect from any "Learn to Program in Language" book. There is a discussion on strings and string use, numbers, and date time values.
   
   As the book progresses, the recipes become increasingly technical. I was quite impressed to see a discussion of Generics in chapter 8, which were added to 1.5. Additional technical recipes include I/O, graphics and sound, and using sockets in Java. The author is able to successfully discuss a lot of different topics in a very clear and concise way. Additionally, I was both pleased and surprised to see the author include brief discussions on software patterns and agile methodologies, both of which are very much coming into vogue.
   
   Naturally, this book isn't easy to read from cover to cover, but it was never designed that way. Much like an actual cookbook, it is designed to best be used as a reference manual. Experienced non-Java programmers will benefit from this book, which can be used as a good tutorial to learn the Java language quickly. Java programmers will also benefit greatly from this book, and will likely want to have it next to their computer as a reference manual. I would highly recommend this book to anyone either wanting to learn Java or anyone looking for a good Java reference book.



3. Anyone who has been involved in programming very long soon comes to realize the value of the various programming cookbooks. The cookbooks are not for the person who wants to learn how to program in a particular language, but are very useful for programmers with a basic knowledge of the language. The idea is simple, take the most common problems people deal with and put the solutions into a book. Simply state the problem and then show the code to resolve it. So, if you need to know how to do something you can look it up, enter the code, and test it.
   
   Some of the chapter subjects include Interacting with the Environment, Strings and Things, Pattern Matching, Numbers, Dates and Times, Object-Oriented Techniques, Directory and Filesystem Operations, Graphics and Sound, Network Clients, Server-Side Java, Database Access, XML, and Threaded Java. Typical of any of the programming cookbooks, it is a quick and easy source for answers. Each item has a short explanation of the problem and then goes straight to the code to demonstrate how it works. A great time saver and required resource for Java programmers, Java Cookbook, 2nd Edition is highly recommended.



4. I am a Java newbie and purchased this book in addition to the Head First Java text to get me started. I am a big fan of the Cookbook series, and have generally been very satisied with them. However, the Java Cookbook has been a disappointment.
   
   I must echo the sentiments of "schrapnel" in his review of this text. The recipies given seem designed to teach general concepts rather than solve common programming problems. The result is a general Java textbook that is encumbered with the Cookbook format of Problem, Solution, Discussion. There are numerous instances of the Problem being trivial, or downright silly. For example, "You really want to know about end-of-line characters" and "You need to learn the syntax of JDK 1.4 regular expressions" are presented as Problems for recipies. Clearly, the author is reaching a bit too far in his attempt to present the material in cookbook format.



5. I bought the first version of the Java Cookbook many years ago and it was a huge find back then. There were few online resources at the time loaded with really great, consistent sample code, like http://www.javaalmanac.com. The Java Cookbook filled a need then and it fills a need now.
   
   The book covers subjects of interest for programmers with any level of Java expertise. It is written in the classic 'cookbook' format. Each chapter concentrates on a specific area, like 'Strings and Things', 'Pattern Matching with Regular Expressions', 'Object-Oriented Techniques', 'Network Clients', 'Database Access', 'Threaded Java', etc.
   
   Within each chapter, several problems are tackled. One or more pages are devoted to each problem, with a general format of: 'Problem', 'Solution', and 'Discussion'. Many of the problems build on previous solutions. Nearly every solution contains a Java example and the code tends to be simple enough to grok at a glance.
   
   The book has been updated to cover most of the new Java 1.4 and 1.5 goodies, but doesn't have as much coverage as I would have liked. However, the most fundamental topics are covered well. The 800+ page book includes 312 recipes that cover a wide range of topics.
   
   If you are like me and spend a lot of time learning by example, you will find this book an excellent resource.

No comments about MooTools Essentials: The Official MooTools Reference for JavaScript™ and Ajax Development (52008firstpress).

5 comments about GWT in Action: Easy Ajax with the Google Web Toolkit.

1. I liked this book. It walks you though the subject with enough detail to get you started. It will not give you a very deep insight into how GWT is implemented, but still leaves you with sufficient understanding and plenty of practical examples to borrow



2. This is the 2nd book I bought to do GWT. "GWT in Action" is by far the best book to learn GWT (at least when I bought it in summer 2007). Since I had already been using GWT, I used this book to successfully resolve a number of issues I was having, especially with event handling.
   
   An area that could use improvement in future editions is explaining how to integrate with existing javascript code libraries, something that really has to be assumed is a requirement with GWT. A good javascript reference, like O'Reilly's "Javascript: The Definitive Guide" should also be acquired.
   
   I use Instantiations GWTDesigner Eclipse plugin to do my code work.



3. I would recommend this book for web developers currently writing web applications in any language and who are looking to add Ajax to their application. Although Java back ends benefit the greatest from GWT with GWT-RPC, JSON, a lightweight data format, can be used and so ASP.NET, PHP, Perl CGI, etc. can be used. Also a great reference guide for those currently using GWT. Here is a more detailed review (and a shameless plug for my blog): http://www.jlhdevelopment.com/wordpress/?p=6
   
   Also check out this title coming out soon: GWT in Practice



4. I am starting with GWT with this book after using various internet tutorials. The book proved really helpful to get me started. As an added bonus, the authors really like to write and provide small yet inspiring examples which you can download and test yourself.
   
   Some reviewer criticized the order of the chapters. I did not have any problems with that - there is a very useful short introduction in the beginning. I could jump ahead to interesting chapters like RPC without any problem.



5. I was very impressed with the quality of the writing as well as the depth of coverage. The authors explain them well and it is easy to follow the examples. I especially liked the fact that authors present GWT code using design pattern, e.g. Facade - I was able to re-factor my own code.
   
   Using this book, I was able to teach myself GWT and also successfully build a GWT based Ajax application at work.

5 comments about Database Systems: A Practical Approach to Design, Implementation and Management (4th Edition) (International Computer Science Series).

1. I was almost put off buying this book by some of the very negative reviews. I bought the book. I have designed a few databases but that is not my main job, and I wanted to get up to speed on database design and use for a short project that I am leading. I have bought several books on the subject, and this is one of the most useful. The book is detailed, which means that if you want to go into detail you can, e.g. on what normal form is and how to use it, of the difference between relational and OO design. However, the book is designed so that one does not have to go into detail, one can get a good overview of the subject and start creating databases soon after reading it. Perhaps this book offends some tecchy purists, but most business people who need to understand databases will find this book valuable.



2. This book was required by a course I am taking, so I can not buy another one, but I think it is a great book. It has also helps you learn a database language. I forgot what it is bec I did nt use it yet, but it very helpful.



3. It should be named "how to writing SQL for MS Access, Oracle 7i and xxx" since that is all about. It is weird to me why "Design" is in the title. There is absolutely nothing covered on what is inside a RMDB, man.



4. I purchased this book for a Database Management Systems course and found it to be a very useful text-book. The concepts are easy to understand and the authors provide plenty of examples for better understanding.
   My only problem was that our course instructor used the same examples as the book in class and that got boring towards the end of the semester.
   However, overall I believe that the book is very useful and will definitely recommend it to friends.



5. For two quarters now, I have had a one-chapter reading assignment out of this book for a total of 20 chapters. This book is nearly impossible to read. The only reason you would want a text this expansive is if you planned to write your own database system to compete with MySQL, PostgreSQL, etc..

5 comments about Leading a Software Development Team: A developer's guide to successfully leading people & projects (Practitioner Series).

1. This is an excellent "how to" book. It describes in detail all the steps required to properly lead a software development team. It pays particular attention to conflict resolution including examples on how to handle difficult situatuions and people. I get the impression that in Richard Whitehead's limited project experience he has had significant exposure to conflict.
   It would have been useful if he had fully explored some of the other paths during conflict resolution. He explains what to do in certain circumstances, but does not go the additional step; what if it doesn't get results, what then?



2. While the programmer in me has often railed at the managers of software development, generally with very good reason, but admittedly sometimes for reasons that were less than pure, I do readily admit that it is a very difficult job. Humans tend to have distinct sets of skills, some of which seem to have a fundamental incompatibility. Writers of good software seem to be predisposed to having limited social and managerial skills and in general one needs to be able to understand a great deal about software in order to be able to manage its' creation. Programmers are also known as being "somewhat difficult" to organize, so even the best managers can be challenged by what is oftentimes an unruly bunch of developers.
   However, difficult does not mean impossible, I have yet to meet a quality programmer who did not have a "weakness", that properly exploited, will cause them to work intensely and log an enormous amount of keyboard time. Teams are built in many ways, and Whitehead quite properly notes that many (most) successful teams are made of people who respect and rely on each other's skills, but may not personally like each other. Some of the most successful sports teams of all times were made up of players who did not speak to each other outside the bounds of play. Arguing and bickering, as long as it is within clearly defined boundaries, should be considered normal and tolerated. Attempts to dictate that people like each other and engage in silly "teambuilding" exercises more often lead to failure rather than success. Other examples in the book show the same good sense, as Whitehead clearly has experience in making projects work.
   The book is split into sections, which are

   * The new leader.
   * Project management.
   * Leading people.
   * Requirements capture.
   * Stress and conflict management.
   * Relationship with management.
   * Making decisions.
   * Analysis and design.
   * Testing and project release.

   Under these sections, there are a total of 40 different points, with a header and explanation of some of the rights, wrongs and different shades of gray inherent in the points. While forty is not large enough to cover all possible contingencies, I cannot find a reason to criticize those that were chosen.
   Writing good software is hard, and managing hard people is difficult. However, from this book you can find some very sound advice that will improve your chances of managing a project to a successful conclusion.




3. After reading this book, I would say for sure that Richard Whitehead understands the role of the project lead. I would buy this book for a new, or existing lead, if I wanted him to understand the challenges he might face. I really applaud this and would add that many books feel like they were written from the outside looking in (sure, everyone on the outside wants twice the functionality in half the time!). I would love to see an update that included more strategies for success however. A lot of the solutions seemed to be based on a specific set of circumstances and personalities. Perhaps adding some examples from others who faced similar challenges, and overcame them with different methods, would increase the impact of this book.



4. Whitehead covers alot of the basics of team management. It shouldn't be difficult, and that what Whitehead explains through "questioned" title chapters. It works quite well because you can zero in on the question about leadership in your situation that may be plaguing your mind. The book is short and easy to read, so it can be read in about 3 days on a bus.

   The author subscribes to making you aware of the qualities of good managers and how to handle common types of problems, like what to do when you don't have the technical knowledge about a problem, or how to handle difficult/disruptive team members. In summary, Whitehead helps you get into thinking like a ternary leader, that is you are part of a group, all working towards a common goal and you, (the teamleader/manager), should not dictate your "will and whim" to others.

   The only criticism is that it is probably too light on the aspect of project management. There are issues about project management of people in terms of requirements, risk, scheduling that are not discussed. This book is about working with your colleagues not clients.... but overall a good read at a good price.




5. I bought this book in the middle of a project where we face lots of problems. We come accross about 90% of the problems that are describe in this book. How I wish I could have read this before involving in leading a project. The recommendation and advice are very practical. It took me a few trials to get to the solution by myself before this. Now I can just refer to this book whenever I have problem in handling project issues and save me lots of unnecessary trials. I highly recommend this for new project leaders.

5 comments about Java Messaging (Programming Series).

1. As we look at how much we use the web, it is sometimes hard to remember just how new this concept of worldwide packet switching really is. Java was started as a new language before a lot of the new concepts like XML and SOAP were conceived. But as a new language it has been able to move into using these new concepts faster than nearly any other language.
   
   What I especially liked about this book was the first chapter. So often computer books start with programming. This one starts with a description of what we're trying to do here. He gives several examples of the types of communications that he is going to cover in the book. I had a particular application in mind when I got the book, but in reading the first chapter I began to see several other ways that messaging would help our system.
   
   After the first chapter, I've go to say that it's a pretty regular computer software book. It tells you how to do the things that you want to do. It is quite clear on all the different software protocols, packages, and philosophies. Basically it is all that a Java programmer needs to implement messaging in Java.
   
   The CD included with the book gives you all the sample code from the book, as well as the complete messaging toolkit and several open source tools.



2. Eric Bruno's JAVA MESSAGING explores different ways of messaging using Java software, from JavaBean events and JMS to SOAP. Web programmers receive all the basics to using these features, tips on how and why to use each feature and when to choose something else, how to combine features, and more. The basics of Java communication processes are revealed in chapters which form 'classes' to link related information in a logical progression. An excellent, basic foundation for Java users.



3. Excellent introduction to messaging, including healthy portions on JMS and web services.
   
   The writing style is clear, consistent, and to the point. Probably what I liked most was this no-nonsense writing style. If it's on a page, it's important to understand. The author doesn't waste your time with irrelevant discussions or out of scope topics.
   
   Editing and code presentation are top notch, making it easy to follow, and build upon from one example to the next. The author also shares some gotchas and considerations that I wouldn't have expected to see in an introductory discussion which were particularly valuable.
   
   Another great feature is one of the drawbacks of the book. The framework presented in the book is elegant, but in many of the examples, there is too much cognitive overhead involved in grokking the level of abstraction in the framework, and this takes away from actually learning the concepts. I would have liked to see more non-framework code for the introduction, which is then tied together with the framework.



4. Although the book uses a specific JMS engine for the examples the details and the concepts were all right on and covered everything I needed for JMS. It literally saved my bacon, especially the peer to peer stuff over topics. Whew!
   
   Super job.
   
   Sam



5. As other reviewers pointed out, this is indeed a nice work on Java Messaging. For the most part, the concepts are presented clearly and I had no trouble following them. What's good about this book is that there are enough examples to play with and most of them indeed work as promised in the book. This book uses ActiveMQ 2.1 for JMS Provider while the current version is 5.x. However, the ActiveMQ 2.1 libraries are included in the CD, so using those you will have no problem in running most of the examples. I could not get the examples that use Java Web Service Developer Pack (JWSDP) to work however (chapters 8 and 9). This book uses JWSDP 1.4 version which I could not find on the web (at the time of this writing only JWSDP 2.0 is available for download on Sun's site). The book says that JWSDP 1.4 is included on the CD but it was not. Except for these minor issues, this book is worth reading and owning. Highly recommended.