2 comments about Numerical Methods in Engineering with Python.

1. The content is typical of an undergraduate course in numerical methods. The author employs Python for that. It doesn't tell you how to use various modules available on the net. Instead, the author sticks to the standard few and explains numerical methods from the very basics. The book is very good for an introduction coursework. However, if you are a researcher looking for tools for serious numerical computation and thinking of using Python as an efficient and convenient organizer(or "glue") rather than a number cruncher, you might as well consult the book by H.P. Langtangen.
   
   This book is also useful if you want to get a hang on how a textbook numerical method would work on Python. You can then use the language for a quick algorithm prototyping in your own work.



2. Here is a book that lives up to its description:
   Numerical Methods in Engineering with Python is a text for engineering students and a reference for practicing engineers, especially those who wish to explore the power and efficiency of Python. Examples and applications were chosen for their relevance to real world problems, and where numerical solutions are most efficient.
   
   If you have a background in Numerical Methods and you have experience with Python then you are good to go, but don't expect the book to teach you either. It doesn't say it will do that and it does not do that. The python intro is highly simplified and has some carless mistakes. The numerical methods used via python assume that you know your numerical methods and how, where, when and why to use them.
   
   Great book, just be sure you know what you are getting into.

5 comments about Programming Web Services with SOAP.

1. This book is a nice introduction to SOAP. It doesn't get caught in the Software wars and has examples of most existing systems. Another advantage: it is a thin book and not a 1000 pages bible. So you can easily read it in a weekend and then decide where you want to dig deeper (if necessary).



2. This book was a disappointment. I got thrown into an XML/SOAP project and had to get up to speed in short order. After struggling on my own for a while I bought this book hoping it would have lots of meat on actually using SOAP::Lite, but it had pretty thin coverage.

   I did like the big-picture overview of the various technologies, but it was not very helpful in writing an actual SOAP client to talk to a third party's SOAP server. Considering that the author of SOAP::Lite also wrote this book, it seems to me that there could have been a whole chapter on SOAP::Lite from the client view.

   This will stay on my shelf as a reference, but for getting up to speed rapidly on actually writing a SOAP client, it was a bust.




3. If your pretty new at SOAP, and if you need an overview, then this is the book you want.
   If you don't care about interoperability, and you just want a book on SOAP within a particular environment (say Java), then this is not the book you want.
   If you need a reference guide, then you don't need this book.



4. If you are new to SOAP and you want to get the overall picture, and you don't care for details, this is the book you need.
   If you need a reference guide, this is not the book you want.
   If you're looking for a book about SOAP on a particular platform (say Java), this is not the book you need.



5. I was so keen to learn from this book, but no matter how hard I tried it had too much nonsense to be readable or usable.

5 comments about C# Network Programming.

1. This is an excellent introduction to network programming. Even if you don't use C#/.NET, you may still want to have a look at this book as it discusses IP programming and techniques from first principles. For example, the book includes an overview of socket programming in the Unix world, then moves on to Winsock specifics before introducing the socket and higher-level classes in .NET. I really like the author's approach of explaining multiple ways to solve a particular network programming issue, such as how to deal with the fact that using TCP by itself doesn't preserve message boundaries.
   
   All of the code samples can be downloaded from the Sybex website and there is complete and perfect tie-in to the samples from the book. In fact, all of the code is reproduced in the book so you can effectively read it from cover to cover without a computer. Besides just listing source files, the author always explains what each block of code is doing.
   
   The code samples typically consist of self-contained client and server programs that illustrate a particular network programming topic. I found most of them can be tested on the same PC (except that you won't be able to analyze the network traffic as there won't be any). A few of them require two PCs as the client and server bind to the same IP port. To test the SNMP client programs, I didn't have access to a real Cisco router so I just downloaded a trial version of an SNMP agent simulator from iReasoning to test the programs.
   
   To reach the largest audience, the book describes how to compile, build and debug the sample programs using the command line tools in the .NET Framework SDK (which is a free download from Microsoft). I used Visual Studio .NET 2003 instead and had no problems with building any of the samples.
   
   Overall, the book does a great job of explaining what can be a complex subject area. It would have been good though if the author included an advanced topics chapter that discusses popular network-aware applications (such as chat programs, file-sharing systems, etc) and how they are implemented architecturally.



2. This book is a good introductory book to network programming in general. While it attempts to cover all the general topics that you can find in reference books like "TCP/IP Illustrated", it seriously lacks the breadth and depth of such reference books and falls short of tackling the real issues of Network Programming with the .Net frameowrk in C#.
   
   The .Net framework and the C# language bring some new design patterns and some paradigms that are definitely different from what we used to see with C/C++ or Java and I found that this book while containing a lot of source code examples in C# lacks coverage of such patterns and the .Net way of solving issues like high performance multi-client servers, performance oriented data handling over network connections, multi-threaded network applications design patterns in C# and .Net framework,...
   
   In summary, if you are new to C#, .Net and have never programmed network applications in another language and are looking for a book that covers a lot of subjects, this is your book. If you already have the TCP/IP Illustrated books and want an advanced book about how .Net and C# apply to network programming, I recommend "TCP/IP Sockets in C#", a much smaller book but extremely focused on what the title says!



3. I used a number of books as references for a server project in C#, including the "TCP/IP Sockets in C#" book referenced in another review, but that book is more geared toward academic use (though to his credit I emailed one of the authors of the book regarding multithreading issues that were not addressed in print and he was very responsive, so I support the purchase of that book to round out your sockets library as well). Blum's book provided far more practical advice relating to my project and was the one I consistently returned to for reference. I had an issue not addressed directly in the book, did a Google search on it and found the answer...by the book's author in an online discussion forum!
   
   In short, it is virtually impossible to find a book that addresses every last real-world gotcha inherent in starting any new project with a new language and class library as vast as .NET's, but if you have a C# sockets project to do then I can't recommend another book more than this one.



4. if you allready have some c# experience this books is the next step u need for jump into the network programming... the books compile the 99% on vs 2005 and the examples are clear, they left no doubt when you are reading, if you want to invest some money on learning this is one way you can do it.



5. This is a good book if you are a systems admin (like the author) wanting to write simple network programs in C#. However, the author has a very limited knowledge of .NET programming. In most of his numerous code samples, his ignorance of CLR fundamentals shine through. For instance, on page 192 he has these lines of code in the VarTcpSrvr.cs listing:
   
   byte[] datasize = new byte[4];
   datasize = BitConverter.GetBytes(size);
   
   The first line of code creates a new byte array named datasize on the managed heap. Then the call to BitConverter.GetBytes(...) returns another byte array and stores the reference in datasize! The first byte array will now be garbage collected, as it is no longer referenced and was never used in the first place. The book is filled with code examples like this.
   
   If you are a professional developer, the book doesn't have much to offer, as you will likely already know nearly as much as (if not more than) the author. Not to mention, seeing all the poor coding samples will likely become a distraction. I still give this book three stars because the networking content is good and the code samples do, in fact, seem to work. They just happen to be coded poorly. Since the author doesn't really understand the platform he's coding on, approach with caution -- especially if you are a beginner.

5 comments about XSLT for Dummies.

1. I like the approach the author has taken to ease you into the subject of XSLT. It's not overly verbose and is quite an entertaining read considering the subject matter at hand. Compared to the other XSLT introductory books around this one has kept my attention from cover to cover.
   
   I find that a lot of my peers are put off by the Dummies series of books because they hold themselves in such high regard that reading a book by such a title will inevitably lower their IQ. If you are a person of such ilk and looking to learn XSLT then drop the pretension of superiority and grab yourself a copy of this great book.



2. This is just a cool book. It's VERY easy to understand and has great examples.



3. I usually find myself slogging through programming books, trying to keep my eyes open, but XSLT for Dummies was one of the more enjoyable programming books I've read in a while.
   
   The material is presented concisely with humor injected to keep the tone light. Great intro for the price!



4. Actually, this book would be pretty good if you could wade through all the stupid analogies that are supposed to make the subject accessible. Each chapter begins with a bunch of really stupid examples that are simply distracting. Writing a match statement is like collecting groceries in a grocery store -- fetching the milk and cookies for your mom, etc., etc. The book is so full of this dreadful stuff that it becomes completely unreadable.



5. Really good intro book - You should read this book and then pick up another more detailed title to really get "under the hood" of XSLT.

4 comments about Parallel Scientific Computing in C++ and MPI: A Seamless Approach to Parallel Algorithms and their Implementation.

1. This book is great in describing some of the most important concepts and algorithms needed for the beginning numerical analyst. The book claims that it can be picked up by a complete novice and teach C++, MPI, and scientfic computing. I would say that the math goes very quickly and not quite as rigorous as necessary for the typical novice. The C++ is pretty basic but still the book leaves the reader a sense of confusion. This is largely because the book treats a large amount of the library functions as black boxes. The MPI starts very basic and gradually introduces the major concepts.
   
   My recommendation for anyone reading the book is to supplement it with a good linear algebra book (such as Demmel) and book on C++ (The C++ programming language). For further study on MPI, Using MPI would be a good supplement. That way whenever you have a concept that isn't fully described, you have a source to get it from.
   
   The book gets a high rating for going over the right content and doing so in a applied manner that gives the reader the skills to become a numerical analyst.



2. The book contains advanced numerical mathematics algorithms and
   fundamental elements of parallel computation.
   It will be useful for those academic instructors who believe that students should be shown the entire solution process
   from mathematical problem definition to computer implementation. It has been used as a textbook at several leading American and European universities.
   The authors professors Karniadakis and Kilby are innovators who demonstrate that combining education of applied mathematics with computer science is possible and extremely useful for students and their future employers.



3. The authors attempted to combine introductory material in C++, numerical methods and parallel computing. That is quite a brave endevaour. They certainly break the new ground writing an introductory material for a "simulation scientist", but I believe they have achieved mixed success.
   
   On the one hand, the material they present on all subjects is really top quality, packed with 100% usefull information. Bibliography is also very good and usefull. But the organisation of the book is quite confusing. They introduce all the topics toogether - throughtout the book. Hence each chapter introduces some numerical algorithms, few new concepts in C++ and eventually MPI. I beleive a novice would experience serious difficulties following it. For example, authors introduce objects before introducing curly braces "{}" as scope delimiters and before semicolon ";" as statement delimiters.
   
   Further, very soon after introducung the very basic concepts in C++, the authors move on to BLAS. BLAS is usefull, of course, but a novice in C++ may wonder why does he needs libraries written in Fortran, if C++ is a language of the choice for numerical computations. (At least it is claimed so by the authors).
   
   Another confusing example is the one of memory memory access. In section 2.2.6 Memory Management, (pg. 41) the authors introduce basic concepts of memory management and how can loop constructs influence the efficiency of the code. Very usefull indeed, no question about it. But very soon bellow, in section 2.2.8 Exploiting the Structure of the Sparse Matrices, they come up with the claim (pg. 58): "... optimization-savy individuals, as the old saying goes, often miss the forest for the threes" :-( Hence, a novice reader might think: "Well, why do I need to worry about the memory management explained just 17 pages above?".
   
   My most serious critic of this book by far (and I hope the authors will read this) are the contents pages. The contents list only chapters and first level sub-chapters. Secind level chapters are not present!!! That makes the book very hard to use as a reference material. That is really a pitty, since there is some good material in it which is hard to find and might stay hidden. (For example, the chapter I mentioned above: 2.2.6 Memory management is NOT in the contents, so I had to browse slowly throught the book to find it and refer it here). I suggest the authors introduce: "Contents at a glance" (the present one) and a "Detailed Contents", where one could find references to all the chapters in the book. The contents is THE reason why I gave this book 3 stars instead of 4. One it lost on the confusing organisation of the book.
   
   I think the authors should have organised the book in four parts: 1 - Numerical algorithms, 2 - C++ and 3 - Parallel computing with MPI, 4 - Advanced topics. Part 1 could introduce numerical algorithms and have pointers to their implementations in Part 2 and corresponding parallel implementations in Part 3. Part 2 and 3 could have started with introductions, which a reader already familiar with those subjects, could skip. Part 4, could bring advanced topics, such as optimisation, BLAS, etc.
   
   Bottom line, it is:
   
   - brave and usefull endevaour,
   - full of excellent material,
   - organized confusingly,
   - and has a very poor contents.
   
   Buy it if you are simulation scientist or teacher, but prepare to struggle with its organisation and contents.



4. Scientific parallel computing is what this book is all about, and it does a very good job kneading MPI into the mathematical dough. The book assumes knowledge of mathematics (through Calculus, in some sections, and quite a bit of linear algebra) and little programming experience. This is not a book on C++ programming (not even close, and it does not pretend to be), nor is it a book on MPI programming, parallel computer design, or even the setting up of a suitable software development environment. In fact, it assumes all of the above, which leaves the way uncluttered for the exploration of the application of parallel algorithms upon familiar mathematical concepts.
   
   An introductory C++ section is provided to get things rolling, though the level of C++ in the book amounts to simple classes and cin / cout in lieu of C's `printf' nonsense. This is good news, because it maintains the book's focus on the parallelization of mathematical procedures rather than on the irrelevant details of how cute it would all look wrapped up in a needlessly complex object hierarchy. Basic applied C++ and MPI, as and when needed to get the job done.
   
   I personally use this text at home on my home-grown parallel Linux computer to investigate the partitioning of algorithms, such as going from a complex function to a Taylor series that may then be distributed to compute nodes.
   
   Further MPI, C/C++, and extremely high-level parallel concepts are introduced through the book in a natural progression, as the problems at hand require their introduction. This keeps the book from being bogged down and off-topic. Kudos to the authors for remaining on course through a sea of such tempting distractions.
   The book is the `how'. BYOW:)
   ps: my CD was damaged so couldn't evaluate it.
   4-stars

3 comments about Agile Software Development: The Cooperative Game (2nd Edition) (Agile Software Development Series).

1. Cockburn emphasises a flexible approach to writing code, especially when you have a team of programmers. Unlike other approaches, like CMMI, the methodology advocated by the book seems deliberately informal. Now, certainly, the book does enumerate various steps typical in an agile approach.
   
   For example, we see a list of methodology design principles. One of which is independent of whether you use Agile or not, and which especially caught my eye. It says that larger teams need heavier methodologies. There are several methodologies floating around in the IT industry. And Agile is only one of these. But that particular principle can be very useful. As the text explains, with 6 or less people, say, you can put them in one room, and have little or even no methodology. Because people can just talk and plan things together. But as teams get bigger, and they get dispersed over different rooms, buildings and cities, then you need more elaborate methodologies. And your choice need not even be Agile.
   
   The book also has a writing style with lots of little side notes or anecdotes, that can help some readers assimilate the ideas in the main narrative.
   
   The biggest problem to me with the book is its relatively uncritical acceptance of XP (Extreme Programming). It quotes that the first XP project was successful, in delivering results, compared to a larger team that had failed. But the first XP project that I am aware of, from another text, "Extreme Programming Refactored", was at Chrysler, and it failed to meet its deliverables. That book gave a far more plausible analysis of XP and its brittleness. Cockburn's text does allow that XP can have its limitations if the team gets too big. Because both admirers and critics of XP generally acknowledge that an XP team must intensively share knowledge and coordinate actions, and this just does not scale.
   
   But if we put XP aside, then the Agile approach can be useful.



2. The agile model of software development has become an industry leader, making the second updated edition of Agile Software Development: Cooperative Game an even more essential reference. Agile's pioneering developer updates his Jolt Productivity winner to cover all aspects of the agile model, from its applications in an organizational structure to how to blend agile ideas with others. Any needing a basic introduction to Agile principles, history, and construction must have this.
   
   Diane C. Donovan
   California Bookwatch



3. I picked this book up because of the Jolt Award. I was amazed as what I read. I give kudos to anyone who tries to apply game theory to their decision making process. This has grown to be the accepted way economists discuss decisions between agents, so why shouldn't we apply that to architecture or project decisions?
   Still more kudos to any author who heavily references 'philosophy' and then correctly references a real contemporary philosopher (Wittgenstein)!
   Sadly though, I would have loved to see cooperative game mapped out a bit more. The tools of game theory are there, so we should use them.
   My favorite take aways: ShuHaRi analogy, Cooperative Game analogy, Selection of *implemented* project methodologies as starting points, and a methodology to create methodologies. All in All this is an excellent book to get you started in Agile or to bring you up to date with the 'why' questions of Agile.

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.

5 comments about Professional ASP.NET 2.0 XML (Programmer to Programmer).

1. I would recommend this book to anyone working on ASP.NET 2.0. XML is the integral part of .NET framework and used widely on all projects.
   Book explains XML classes, Data Validation, XML transformation, XML and ADO.NET, Web Services and use of XML in Web.Config and Configuration files.



2. This book was very useful. It covered a wide variety of topics and explained most topics very well. I would have liked the book to get into some more subjects a little more in depth, but when you are covering so many topics that is a little difficult to do. This book did cover a lot of the new XML classes in the 2.0 framework. I would have liked some more info on the sql server 2005 xml stuff, particulary xquery. The book talked about OPENXML and even made the statement that you should use .nodes for these types of queries now. But it made no mention of how to do so. Overall, this was a very useful text.



3. This is an excellent book covering the XML features of ASP.NET. It is very professional but, not for any beginner. It has the first 2 chapters which pretty much cover the basics but, throughout the rest of the book you need to know what you are doing. It is very detailed but is not really "step-by-step" like 1-2-3...It will walk you through how to do something through reading; so if your not one of those people who don't like to read, I wouldnt fully recommend this book to you. It shows a many screenshots in there so it makes it fairly simple to follow along. The book has almost 500 pages that are completely dedicated to the XML features of ASP.NET. If you are willing to take out the reading glasses and read a little bit. Overall, its an outstanding book!



4. Thiru Thangarathinam is one of the few authors out there who truly know how to teach and convey the knowledge they are presenting. The manner in which he approaches and expounds a topic should be formulated and used in all books. Most books these days simply show how to do the simplest of tasks and never provide real world scenarios. But guess what, in the real world your tasks are never that simple.
   
   Thiru does a great job in not only showing "how to" but also provides best practice tips so that you know "when to", "when not to", "when you do be sure to". These are the things I need to know in the real world. Without a doubt this was one of the best technical books I have read in a while. I will definitely buy any future books that he authors. Glad to see he's a fellow Phoenician also!



5. This is an excelent book. The section about MsSQL server and XML is excelent. I highly recommended

5 comments about Agile Java(TM): Crafting Code with Test-Driven Development (Robert C. Martin Series).

1. I'm not a beginning programmer, or even an absolute Java novice, so maybe this book isn't really aimed at me. My biggest gripe is that the code snippets continue on and on making the book very poor for anything other than cover-to-cover reading.



2. I've gotten about 6 chapters into this book and I love it. I've been developing Java for almost 7 years and am currently teaching myself Agile principles and this book comes as a great help.



3. This book is primarily for new programmers who want to learn Java as their first programming language. The book can also be helpful for programmers familiar with test driven development (TDD) but new to Java, or vice versa. I am an experienced Java developer, and I found that going through Agile Java presented me with a new and better way of approaching Java code development. This book covers Java 2 Standard Edition (J2SE) version 5.0, but covers only a few of the additional APIs at an introductory level. Technologies that are used pervasively in the majority of enterprise applications, such as logging, JDBC, and Swing, are presented in Agile Java. Some of the information, such as that on logging, will teach you all you need to know for most purposes. Other lessons, such as those on Swing and JDBC, will give you a basic understanding of the technology and will tell you where to go when seeking further information.
   
   The core of Agile Java is fifteen lessons of about 30 pages each. It starts with baby steps in Java, TDD, and OO. The book finishes with a strong foundation for professional Java development. The core lessons should be read sequentially since each lesson builds upon the previous ones. Once you have completed the core lessons, you should have a solid understanding of how to build robust Java code. If you haven't completed the fifteen core lessons, you should not assume you know how to write good Java code. Each of the fifteen core lessons in Agile Java has you build bits and pieces of a student information system for a university. This single common theme helps demonstrate how you can incrementally build upon and extend existing code. Each lesson also finishes with a series of exercises. Instead of the student information system, the bulk of the exercises have you build bits and pieces of a chess application. Some of the exercises are involved and quite challenging, but they are where learning the methodology really begins.
   
   There are three additional lessons to cover a few more Java topics. Two of the lessons present an introduction to Swing. These two lessons will provide you with enough information to begin building robust user interface applications in Java. But the bigger intent is to give you some ideas for how to build them using TDD. The third additional lesson presents an overview for a number of Java topics that most Java developers will want to know such as JARs, regular expressions, cloning, JDBC, and internationalization.
   
   I really liked how the author integrated the three concepts of Java programming, TDD, and object-oriented design without confusing matters. The book is very clear with good illustrations. I highly recommend it. The following is the table of contents:
   
   Lesson 1. Getting Started
   Lesson 2. Java Basics
   Lesson 3. Strings and Packages
   Lesson 4. Class Methods and Fields
   Lesson 5. Interfaces and Polymorphism
   Lesson 6. Inheritance
   Lesson 7. Legacy Elements
   Lesson 8. Exceptions and Logging
   Lesson 9. Maps and Equality
   Lesson 10. Mathematics
   Lesson 11. IO
   Lesson 12. Reflection and Other Advanced Topics
   Lesson 13. Multithreading
   Lesson 14. Generics
   Lesson 15. Assertions and Annotations
   Additional Lesson - Swing, Part 1
   Additional Lesson II. Swing, Part 2
   Additional Lesson III. Java Miscellany
   Appendix A: An Agile Java Glossary
   Appendix B: Java Operator Precedence Rules
   Appendix C: Getting Started with IDEA
   Agile Java References



4. This is my new favorite-book-to-give-to-anyone-who-is-learning-or-using-Java.
   
   The title is misleading in that this book is about much more than just the Agile Programming stuff. While it does a great job talking about Agile techniques and always starts by creating a unit test, the book really is about all aspects of Java (specifically Java 5) programming. Anyone who takes the time to work through the examples will become a much better Java programmer.
   
   OO patterns, collections, type safety and more are covered and explained in the context of a rich, in-depth example. And because the author has you construct a high-quality test suite around the example, you are free to experiment with different ways to implement each new feature - thus proving to yourself the benefits of Agile design.
   
   Just like it says in one of the quotes on the cover, this book is now required reading for the Java programmers at our company.



5. I had originally bought this book for son who was going to spend the summer working for my development team writing unit test for our database POJOs. I was so impressed way in which concepts were incrementally introduced I read the book cover to cover. It is now the only book I recommend to beginners and I introduce it as a 'must' read for all my new hires.

No comments about Microsoft Visual Basic .NET Programming: From Problem Analysis to Program Design.