4 comments about Object-Oriented JavaScript.

1. Object-Oriented JavaScript by Stoyan Stefanov is a first among JavaScript books in my opinion. OOP in JavaScript is not new, but has gained much popularity since the use of JavaScript in Ajax and the development of JavaScript libraries and widgets from various web companies (especially Yahoo!). Learning how to create component-based applications using JavaScript is not an easy thing to master if all you know about JavaScript is doing "mouse-overs" or neat little effects. There really isn't a book out there that really explains how OOP works in JavaScript completely.
   
   There are books from Apress and WROX that are geared towards "intermediate" topics in JavaScript such as creating objects and so forth, but they quickly go into sing custom libraries which really doesn't teach you anything apart from using a library.
   
   This book really goes into detail in explaining how the syntax of JavaScript can be used to create scalable applications from the ground-up. I would say this book is geared for the developer who has a grasp on the language itself but wants to learn more in creating real useful applications for the web using JavaScript and wants to learn without depending on any pre-built library or component.
   
   The author goes into the basics of the language first (chapter 1-2) then spends a chapter on functions (chapter 3) which is the many ways in JavaScript to create objects. Since JavaScript is not a fully OO language, it can get confusing on understanding the many different ways to create an object. Stoyan explains it very well with many examples so anybody can understand it.
   
   The next few chapters (4 - 6), the author goes into OOP practices like how objects work, the Prototype built-in object, inheritance, and many of the built-in methods and properties you can use to manipulate your custom objects. Yes, object literal notation is covered in-depth since it really is the standard way in JavaScript to create objects.
   
   The rest of the book has some excellent chapters on the BOM, DOM, Ajax and Design Patterns which really round out the book and make it worth it. I have never seen a book so complete on some of the more intermediate to advanced features of JavaScript and explaining it so anybody can learn it.
   
   Go get yourself a copy of this book today!



2. This is a keeper on my bookshelf. I am not new to JavaScript but routine for me includes finding better or books that look at things from different perspectives. This book is sort of a handbook with short cut concepts explaining how JavaScript thinks from one end of the language to the other. It also shows several different takes and methods for achieving concepts. To date this is the best book I have seen explaining 'closures'. On an issue of style my love of OO programming is more 'class' oriented. So this book approached things slightly different from what I was expecting. With that said there was no regret for reading this book. It will solve other programming needs and will be one of the routine books to come off my shelf again and again for sure!
   (FYI... by way of reference I am the author of ColdFusion 8 Developer Tutorial )



3. Object-Oriented JavaScript is a must-have for web developers building functionally rich applications using JavaScript. Stoyan starts out with a brief history on the evolution of the web and background on object-oriented programming, then immediately dives into data types, arrays, loops, functions, objects, prototypes, inheritance, DOM, and more. His book is full of thoughtful examples, useful tips, and excellent review exercises at the end of each chapter. Fantastic book and author! (Disclaimer: I helped review this book and also hired Stoyan to join Yahoo!'s Exceptional Performance team.)



4. I am a PHP and MySQL web developer and I have always resisted using Javascript in my projects. So I have kept my Javascript knowledge to minimum.
   
   But there are times when you simply can't avoid JavaScript, so I decided to take my JS programming to the next level. After reading this book I have certainly learned a lot more, but it did not change my opinion about this language. I still HATE this language and the idea of using Javascript as a serious Object Oriented Programming is nothing but a JOKE.
   
   It made me appreciate the PHP and its Object Oriented paradigm.
   
   I can't wait for a day when HTML5 and CSS3 are implemented in all modern browsers so I can kiss Javascript Goodbye forever. In the meantime I have no choice but to use this ugly language.

5 comments about Test Driven: TDD and Acceptance TDD for Java Developers.

1. This book is an great resource for Java developers wanting to get started on TDD. It covers the majority of tools and techniques available, along with useful tips and best practices.
   The first part is already worth the book's price. The author presents TDD and its benefits, shows how it works with a lot of coding, and ends it with an excellent chapter on concepts and unit tests design patterns. By the end of it you'll feel eager to, at least, give the practice a shot.
   The book proceeds showing how to test technologies commonly known as "hard" to unit test, like web components, database access code, threads, and swing. Although the author doesn't go into too much detail in any of them, he presents good solutions to make their testing easier.
   The last part is a very good introduction to Acceptance TDD and how to write tests with Fit. It is not as thorough as the TDD introduction, but will give you a very good understanding of what ATDD is, how it should be done and how it can (and should) be complemented with unit testing.
   Essential reading for Java developers looking for ways to improve the quality of their code.



2. Bas has already done a good job outlining the content. I won't repeat that here. Instead I will say that TDD is hard. It took me several years of trying before it all came to together for. In the past few months I've recommended this book to more than a few developers in the past six months.
   
   In at least two of those cases it has been the turning point in their understanding of Test Driven Development. Net result - I'm can spending my time coaching/mentoring in other areas.



3. As an experienced developer in an XP shop, I am always on the prowl for good books on TDD. Alas, this is not one of them.
   
   The author uses a lot of exclamation points! And little puns! And a conversational tone that is both annoying and condescending.
   
   In addition, he quotes so many other books that I felt as though I should be reading *those* books instead of his.
   
   Much better material can be found for free at the various XP and Agile resources on the Web.



4. I had been trying out Test Driven Development from past couple of years and found it very interesting. Its a time consuming process in the begining but once we jump into it then everything will go smoothly.
   
   This book provided me a good cross verification point and corrected me in lot of places. I feel its a good investment for all Java Development Team.



5. For the last five years, I have worked for companies that espouse "agile" technologies and development practices. At my last job, the company contracted with ObjectMentor to come in and provide direct training and mentoring as we transitioned our old waterfall process into a shiny new eXtreme Programming (XP) one. We were even so fortunate to have some one-on-one time with Ron Jefferies, Michael Feathers, and Robert Martin to further help up along the path to XP enlightenment. At the time, I was a software architect and largely skeptical of many of the XP practices. Practices like short iterations, collective code ownership, user testing and a planning game were an easy sell to us; the practice of test-first development was not. In fact, in the controversy over whether design and code should be written "test-first" or not, I always sided with folks who felt that architecture should be worked out first, followed by coding it up and then testing. Even though I understood the importance of writing tests to ensure the quality of my code, I still clung to my old waterfall style for actually driving and writing those tests.
   Fast forward a number of years to the present day and even though our development practices are very agile, test-first is still not one of those practices. As a champion of unit testing on my team, I happened to come across the book "Test Driven" by Lasse Koskela at book store one day. Thinking that this was just another one of those post-modern XP books (You know the ones that take one of the original XP practices, re-brand it with a new name and then claim to have invented something new?) with a slightly different take on test-first development, I almost didn't give it a second glance. Since I had time to kill, I decided to thumb through it to see if I could confirm my suspicions. After the first few pages I found that I wasn't skimming the book at all; I was actually reading it. My initial skepticism gave way to understanding. When my legs started aching from standing for so long, I retired to a comfortable chair to continue. I was impressed enough that I ended up purchasing the book that same day. So what did I discover and was it enough to change my mind about test-first development? Read on for the answer!
   In chapter one of the book, Lasse starts out by dividing the topic of Test Driven Development (TDD) into two different, but related subtopics: Practical TDD and Acceptance TDD. Practical TDD is more or less re-branded test-first development (TFD) from the early days of XP, and the Lasse spends some time going over the advantages of developing software using a TDD approach. Many of these advantages have been hammered on before and to any agilist should consider them standard fare: ensuring high code quality, ensuring that the code isn't over-designed, ensuring that defects are caught early, etc. Into this mix of vintage advantages, he then tosses the concept of Acceptance TDD (ATDD). In contrast to regular TDD (RDDT?) which is primarily aimed at the development of classes and components, ATDD is aimed at the development of systems and subsystems. In short, ATDD is about writing acceptance tests first that the system as a whole must pass in order to be acceptable to the customer, while RTDD is about the development of the individual classes and components that comprise the subsystems. Lasse asserts that being able to do both forms of TDD will ensure high quality code that the customer actually wants. Having been burned countless times at customer acceptance time, ATDD was a topic that interested me immediately. Unfortunately, we have to wait until the later chapters in the book before we get into the details of ATDD. I felt that Lasse makes an excellent case in chapter one for TDD, and his overview of both RTDD and ATDD left me very interested to hear more. The chapter ends on a rough overview of some of the existing tools for doing automated testing and builds and for doing code coverage. Depending on your existing understanding of agile methodologies, you might just consider skimming this chapter.
   
   In chapter two and three, Lasse jumps off into how to begin to do TDD. In order to introduce the reader to the nuts and bolts of how to do TDD, Lasse walks the reader through a contrived development story and the development of a module to fulfill the requirements. Unfortunately, this chapter was not my favorite one but not because it wasn't well-written, or wasn't very informative: quite the contrary is true! My problem with this chapter was that the example was too simple: developing a simple template engine. This has been one of my biggest gripes about TFD for years: all the books and articles that I've ever read about doing TFD just present very simple, almost trivial, examples of how to write code in a test-first manner. In this regard, Lasse goes through the motions of writing the failing test, coding the module, writing the next failing test, etc. until we have a module that passes the tests and meets the requirements. I understand that this is probably the first time that the reader might have seen the entire process laid out end-to-end, but I was disappointed that the complexity of the example wasn't a little more in line with what a developer is likely to see in their daily queue. In chapter three we see how refactoring plays into the process of TDD and Lasse demonstrates how to modify code and tests in the template engine. Chapter three seemed a little too short to me, and seeing as how it was a continuation of the template engine example, most of the information could have been folded into chapter two.
   
   Chapter four steps away from the examples of the previous chapters and focuses on the strategies and patterns for testing. He presents testing patterns, guidelines, and concepts in a very general sense. As a true believer in unit testing already, I found most of this chapter to be rehashing the case and the techniques for unit testing. His section on testing patterns and mock objects was fairly short, but as a first look at the topic, it might be adequate. If you find chapter four to be interesting, you should definitely check out "XUnit Test Patterns: Refactoring Test Code" by Gerard Meszaros, which is considered to be the definitive work on the subject. Lasse does an admiral job of adding his own mini examples, like why one should avoid static singletons in production code, why isolating dependencies make code easier to test, and so on. Again, most of this chapter should be familiar if you are already an agile tester, but it is a very good introduction to the subject.
   
   In the second part of the book, Lasse addresses how unit testing should be applied to specific technologies. In chapter five, the topic is how to apply TDD to web components. This section really raised my interest level because testing web applications has always been a pain for me. Even though this section only weighs in at about 40 pages or so, the information presented is pretty dense. I did feel that the page or two that he spends covering how MVC works was wasteful: if you aren't unit testing web applications then why wouldn't you just skip this chapter? If you are unit testing web applications then you should already have a good notion of how MVC works. Not that this should be considered a serious criticism, it just seemed a little out of place. The rest of chapter contained very useful information to me: how to get started unit testing controllers and views. He also covers testing with the Spring controllers, which is very useful if you have a fortune to be using Spring MVC or Webflow. In the last part of the chapter, Lasse goes over how to create the view in a TFD manner, and he goes over how to use tools like JspTest to do so. He also covers how to do TFD in other web frameworks, like Wicket and Velocity. The section for these last two was very short and I wish that Lasse could have included more examples.
   
   Chapter six deals with testing the database. Lasse makes the compelling case of why it is important to test your database layer and gives some examples of working with straight JDBC to accomplish this task. He quickly moves to higher order abstractions, like DAOs and Hibernate and why these are unit test Nirvana. Since I have the good fortune to be working with Hibernate already, there wasn't anything particularly new or earth-shattering here, but his examples of how to set up and run an in-memory database for testing were solid. Tacked on to the end of the chapter was a page or two about how to test file-system access. Lasse provides some good advice if you are unit testing file accesses, but I found the page or two that he dedicated to the subject insufficient to do the topic serious justice. I would also have liked to see some example code and this is an area that I felt should expanded in the 2nd edition.
   
   Chapter seven deals with unit testing time-based components and threads. Using the same approach of abstraction that he uses elsewhere, Lasse explains how to test logging systems where time-stamp and time formatting are used. He also covers how to test multi-threaded code in the second half of the chapter. I felt that this was a very important chapter since multi-threaded and multi-core is where the industry is headed, and I felt that Lasse's introduction to how to test threaded code was a solid introduction to the subject. Like most things so far, I did feel that it was laking in depth somewhat and I would have been happier with some more examples around the Java 1.5 concurrency API.
   
   Chapter eight addresses how to unit test Swing UI components. If you are doing Swing development, then this chapter is a must-read. After the obligatory discussion about why you should unit test your Swing components, Lasse then gives some very good examples of how to actually do it. From unit testing View components, to working with standard widgets, to drawing custom graphics, there is something here for every Swing developer. If I found his examples in other sections of the book a little sparse, it was definitely not the case in this chapter and I found myself really getting excited about being able to test components that I had previously believed were untestable.
   
   Part three of the book was worth the purchase price of the book for me. As I mentioned earlier, this is the section where he describes Acceptance TDD, the process involved and some of the tools that can make the process easier. In order to cover the subject, the book goes back over some familiar ground: the user story, and shows how ATDD fits into the process of writing the story with testability in mind. The anecdotal stories and methodologies described in this chapter were enough to get me thinking about how I could integrate ATDD into our development process. Chapter twelve of the book addresses exactly this topic and I was able to compile a list of ideas and ways that I could get ATDD to work for me.
   
   So was the book worth it? Absolutely. In addition to reinforcing my already strong beliefs in the power and necessity for unit testing, it also gave me some very good starting points for being able to write the hard tests (web and Swing UI components). In addition, the chapters on ATDD were surely an eye-opener into how productive me and my team could be.

5 comments about Programming Embedded Systems: With C and GNU Development Tools, 2nd Edition.

1. Programming Embedded Systems with C and GNU Development Tools appears in its second updated edition to include even more real-world and Linux examples, and is a recommended pick for programmers with a familiarity with C. It's been used as a college textbook and covers everything from basic debugging skills to determining the applications and needs of real-time projects. In updating details and clarifying routines, the 2nd edition of Programming Embedded Systems should be considered both a classroom and lending collection standard.
   
   Diane C. Donovan
   California Bookwatch



2. This book gives an excellent overview of programming embedded systems. It provides numerous examples of real-world hands-on embedded programming. I'd recommend that you have experience in C. Experience with operating systems concepts (such as interrupt service routines) would also be helpful.
   
   Unlike usual programming books, you won't be able to pick up the book, download something, and start working. You'll need to have an embedded system that you can use. The authors use a system from Arcom that will run you about $300. I've not used it and was very wary about it when I first started reading, but as I read through the various examples I gained a great appreciation for the system. It looks like a great way to gain hands-on experience with embedded programming.
   
   Before getting this book I read through the Lego Mindstorm NXT documentation and felt very lost. I didn't understand the symbols on the schematics and they used strange acronyms (like I2C and PWM). I also have an Iguanaworks USB infrared transceiver. I bought it to use in a MythTV system I am building. This book has enabled me to understand the schematics of both the Mindstorm and the transceiver as well as the documentation of both systems. I now feel ready to do my own embedded systems programming.
   
   That said, I did not like everything in this book. They gloss over areas that I felt would have helped me (such as how to use a JTAG adapter and how to create an interrupt service routine under Linux). There are areas where the writing does not flow well and is redundant. The book switched from using an embedded x86 processor in the first edition to using an ARM processor in the second and there are still references to the old processor.
   
   Even with its faults I am glad I got this book. It filled in many of the gaps that I have as a software engineer who is wanting to learn about embedded systems programming. I feel a whole new world has just been opened up to me and I can't wait to jump in.



3. If you are just getting into embedded systems and you want to understand the myriad of interacting concepts, this book is a good start. You will get a solid overview of the basic elements, such as hardware, software tools and techniques, memory and peripherals, processing controls and design strategies.
   
   As with any embedded systems book, there has to be some alignment with specific hardware and application examples. The author uses these examples to tie together embedded elements, but the integration is a bit choppy.
   
   The book is organized as a general introduction to embedded systems. About half the book describes the system elements and about half provides full system examples. A single book cannot cover all topologies and development platforms, so I wouldn't recommend it for someone who is trying to solve a specific problem on his/her embedded application. For cases like that, your vendors and FAEs are probably your best bet.
   
   So if you are trying to learn embedded systems development, this is a great resource. If you intend to use it to guide a current project or debug an embedded problem, it may become more of a distraction.



4. Presents a good introduction to embedded system programming; no complaints there. However, their choice of development kit is poor. The Arcom (now EuroTech) kit is $600, rather than the $300 stated in the book. And it took almost 3 weeks for them to respond to a quote request. Fortunately, there are kits available from other vendors (BiPom, Olimex, etc.) which can be substituted for less than $300. However, the impracticality of using the Arcom kit robs the book of its purpose of being a hands-on, guided tutorial.



5. The book is based on using the viper lite dev kit from arcom. In the appendix it suggests that this costs $299 which is the only reason I bought this book. However, upon contacting arcom they say it costs $1000 which is totally crazy for the newbie hobbyists trying to learn something.
   
   So either Arcom are not telling the truth or there is a pretty important detail in the book that is incorrect. This book is now pretty much useless to me because I can't get the dev kit at that price!!!!!

5 comments about PHP Objects, Patterns, and Practice, Second Edition.

1. This is a really great book for advanced developers who whant learn abount php5 OOP technique; it explain very well how objects work and how to use the most famous patterns but it fails in third section: "The Practice".
   
   CVS, PHPDoc and Phing, for me, are not enought for a good "Practice".
   
   The entire book use too much simplistic examples, and so, is very difficult, for a beginner, to use all book concepts in real world.
   
   I hope that in the next edition, Matt will fill this gap.
   
   Bye From Italy



2. This is the best book I've read on Object Orientated PHP. This book does a great job of explaining the ins and outs of OO in PHP 5. As a self taught PHP developer of 5 years, I had lots of questions about "am I doing this right", "how should this be done" and the book has answered most of those questions.
   
   I'd recommend the book to those who already have an advanced PHP knowledge but are looking to take their code another step forward by improving it's re-usability. It's also a great read if you want to find out the power that PHP 5 has over PHP 4.
   
   Note: this book doesn't contain code that you can use. It teaches you the principles that you should use in your own projects.



3. I've owned PHP Objects, Patterns, and Practice for over a year, and it's still one of those books I go back to. It's a well written, generally well executed book on what constitutes Object Oriented Programming in the PHP5 environment.
   
   First, the good news:
   
   This book is a crash course on OOP design and thought. It borrows heavily from two monumentous texts in the field - the Gang of Four's book, and Java Enterprise Patterns - and condences their essences into an easy to swallow form. The basics are all here: how to create well designed classes, how to instantiate objects, etc. There's a hidden gem in the introductory portion of the book: the Reflection API. This API is built into PHP, and gives the coder unparalleled access to the guts of the classes and objects in a given project. It definitely has its uses.
   
   The patterns are all generally useful, with the only exception perhaps being the Interpreter pattern. I'm just not convinced that creating one's own command line interface syntax is necessary, given that PHP projects aren't usually interactive. It seems like something best left to an appendex, or extra web content.
   
   Now, for the bad news:
   
   Some sections of the book, especially some of the code examples, could've used a better editor. Small things, the kinds of things that can trip up inexperienced coders, crop up. Using private properties instead of protected. Using the wrong variable name between examples. That sort of thing.
   
   There's also a lack of a satisfying conclusion, so-to-speak. Zandstra himself claims that generating objects is perhaps the hardest thing to demonstrate. Yet, most of his examples (excepting the patterns late in the book) are canned. Objects and classes exist only to drive the theory behind a pattern home. Few real world examples are given. Admittedly, some patterns are simple to transfer to a real project, but concrete examples of that nature could serve to further cement his point. For example, it's not difficult to see how the Composite pattern would work well for dealing with an XML document, but would there ever be a need for a Visitor object to act on one?
   
   Finally, and in continuation of my last criticism, Zandstra never touches one of the things PHP is used the most for: form handling. Can forms be represented by classes? Could forms be generated by objects (perhaps using a Factory pattern)? What about form validators? Wouldn't the Strategy or Decorator pattern work? Supplementing his online Civilization game and CLI/quiz examples with this would've really put the book over the top.
   
   Still, with that said, PHP Objects, Patterns, and Practice is still a text that gets far more right than wrong. It's definitely a must-buy for those PHP coders looking to write modular code.



4. I have experience in a variety of object oriented (OO) languages, but not PHP. This book has helped me understand how PHP supports objects and some of the typical design patterns you will see in OO PHP.
   Although it is written with PPH5, it even covers some aspects of OO in PHP4.
   It is easy to read, interesting and contains good code examples.
   This isn't a PHP Beginners book, although I'm not fully familiar with PHP and haven't had a hard time reading this book, probably because of my OO background and basic PHP knowledge. Still, if you just need a PHP beginners book, this isn't the one.
   It is a great book if you want to learn OO PHP or even just some OO principles in general. Very glad I picked this book up.



5. Explica con palabras sencillas los conceptos de programacion orientada a objetos (POO) y como aplicarlos en PHP, sin embargo pienso que el autor aveces se extiende demasiado para explicar sus ideas y no concreta del todo. El libro es ideal para unir el concepto de POO y PHP, mas no para aplicarlo, no es un libro para ejercitar.
   
   Explains in simple words the concepts of object oriented programming (OOP) and how to apply them in PHP, however I think that he sometimes stretches too much to explain his ideas and not specific at all. The book is ideal for combining the concept of OOP and PHP, but not to implement it, is not a book for exercise.

5 comments about Expert SQL Server 2005 Development (Expert).

1. The book presents real-life SQL Server problems and shows you how to solve them. It is written in a friendly and story-like fashion. The amount of detail presented is just right - detailed enough to understand the topics yet simple enough not to feel overwhelmed by the amount of information presented.
   
   In the first chapter, the author reviews coupling, cohesion, encapsulation and database role in the application development cycle.
   
   Chapter 2 is extremely useful for testing and tuning queries. It teaches you all you need to know about SQL Profiler. Other topics include unit and functional testing and performance counters. The chapter also introduces the SQLQueryStress Performance Tool which is a free query performance and load testing tool designed by the author.
   
   Chapter 3 covers the different types of errors and exceptions and also shows you how to write error handling code using new error-handling construct added in SQL Server 2005.
   
   The chapter on Dynamic SQL, chapter 7, is a must read for every database developer as it teaches you how and when to use dynamic SQL to make your application both efficient and secure.
   
   Other advanced topics covered in the book are encryption, SQLCLR security and designing systems for application concurrency.
   
   Recommended for SQL Server professionals of all levels.



2. Frankly, I was expecting a very SQL Server 2005 specific book. Instead, what we have is a good general RDBMS book that happens to be using SQL Server 2005. Encryption, access control, testing, basic software engineering and exception handling are never touched in SQL programming books -- including my own! The spatial chapters were new to me. The little asides were also worth looking up. Good clean style, great job.



3. This is really a great book. It covers specific topics really extensively and it is very easy to read. I was impressed because I was able to find great information about topics such as Encryption or Hierarchies that cannot be found very easily in other books. The examples are very descriptive but the most important thing is that the author will show you all possible solutions and will prove why the one he selected is the best. It is not a beginner's book but it is a fantastic book for advanced DBAs/Developers.



4. I have read (well, ok, read through or I would post more reviews) quite a few technical books about SQL Server. Where many books follow a very rigid path through a subject, quite often in a very feature driven manner (Here is this command, and you can do this. Next, this command) or process driven manner (First we do this, then we do this...).
   
   This book is very different from that. The title includes the word "Expert" for good reason. This is a book that doesn't assume you know nothing and start from scratch, nor does it try to teach you every knob and switch on all of the SQL commands. It it more about going to the next level and becoming the expert at programming with SQL Server by covering several deep dive subjects that every person needs to make the transition from "Pro" to "Expert".
   
   It has eleven chapters, each of them about a distinct facet of programming SQL Server, from the common stuff you need to do or use right (testing, errors, privilege, CLR, encryption, dynamic SQL and concurrency) to three chapters on really deep applied stuff (spatial data, temporal data, and graphs/trees). Each chapter has some very deep information, and a lot of code that could make you dizzy if you try to ingest it too fast. It is all explained nicely though, and if you take the time to understand the code you will be far better off for it.
   
   I would not suggest this as a book for the casual "I would like to know a bit more about SQL" reader. It is more for the reader who is already good and wants to become a solid professional/expert SQL programmer who know the right way to do things. For that reader it should be on your required reading list.



5. The author imparts a wealth of knowledge on the reader in a mere 445 pages. His style is direct, clear and doesn't waste any pages on trying to get you up to speed. He gives you just what you need and nothing else. I wish they were all like this.
   
   By providing actual performance testing Adam Machanic doesn't just make expert claims for his methods. In fact, my favorite quote from the book: "The hallmark of a truly great developer, and what allows these qualities to shine through, is a thorough understanding of the importance of testing."
   
   Having never worked with spatial data before, I found the coverage of the topic fascinating. Also, entire books have been written on tree's, hierarchies and graphs. Adam provides enough information in a single chapter for the developer to choose a strategy that works.
   
   5 stars - easy

5 comments about JBoss at Work: A Practical Guide.

1. I am most of the way through this book and so far, it's been extremely helpful and informative. It breaks all the steps down one by one and takes you from a simple Hello-World type app, to a more complicated enterprise application. A great read all-around.



2. Its a great book if you have just started your development with JBOSS 4. It is easy to read from a developer/deployment perspective and also delves into how to automate the deployment descriptors and deploy into JBOSS. Covers most of the common J2ee/Web applications using hibernate and Ant. Probably needs upgrading to JBOSS 5 but is great if your current development is in JBOSS 4.



3. Aimed at the beginning J2EE developer, this book does a great job of encompassing several exciting technologies and showing how they can all work together (JBoss, Ant, XDoclet, Hibernate, etc.) to achieve the end goal of deploying a robust ear file. XDoclet and ant pair to automate several of the tedious tasks (read deployment descriptor generation) no developer wants to be bogged down with. I am a huge fan of how it introduces all the necessary technologies involved w/o diving into the mundane detail of each and every one. If more depth is required, citations are always provided to other great O'Reilly titles. This book stays true to its title w/o going off on tangents due to other author's personal bias. All decisions are objectively defended (like their decision to illustrate Hibernate as their ORM of choice) and options are always provided. Very practical and a great starting point. Overall, two thumbs up.



4. JBoss at Work: A Practical Guide
   
   Great book. It is as the subtitle implies: a practical guide. It was easy to work through the book and the sample code and get a quick yet detailed overview of JBoss and Java web technology. Unlike some huge books, I did not get lost in the complexities. Any technology like this is complex enough as it is. I like to start with an overview, and this book is exactly that: a great introduction and overview. Even so, it's practical enough to put the knowledge to work right away. Hence it's "JBoss at Work."



5. Some books have alot of pages with little information. This book is short, but every page is rich with facts and insights.
   
   I work with integrating a 3rd party application that uses JBoss, and come from a Microsoft development background, so this whole world of Java/JBoss/EJB was a bit new to me. I needed a good guide which would explain what JBoss is, how it works, and how to set it up.
   
   JBoss at Work was exactly what I needed. It walks through setting up JBoss and using it a practical application of a car sales website. Though the entire system is quite complex, the authors have distilled the essence of how it works and why. The examples are simple, yet reveal the full power of JBoss. And the examples build on each other, with sample code that you can edit, compile and deploy yourself. It was an incredible thrill to me (a java newbie) to actually create and deploy a full EJB application on my low-end laptop in just a few short chapters!
   
   Though I know this is the tip of the iceberg into the JBoss world, Tom Marrs and Scott Davis have written an excellent map, laying down a good foundation for anyone who wants to understand JBoss.

5 comments about Oracle PL/SQL For Dummies.

1. This book has a lot of good technical data, but it's not well organized for learning, more of a reference. Also, it assumes you are already an experienced SQL programmer.



2. I am very pleased w/ the purchase of the book. If your goal is to learn PL/SQL quickly and comprehensively, this is the book to buy. It covers all the fundamentals you need to know about PL/SQL and it is excellently written. I have been a developer for 20 years in many languages. Learning new languages from overly technical books and writters, I find, often times make your learning process slow and ineffective. I took this class at Oracle, but there were topics that the training manual and the instructor did not do a good job presenting. This book clarified many of the topics I that were presented in class in a simpler, clearer, and more effective manner. I highly recommend it.



3. Fantastic text for beginners in PL/SQL. Clearly laid out concepts and samples, and hints at naming conventions and other standards to be used. A very solid introduction to the language.



4. This is absolutely, hands-down, the worst computer-related book I've ever had the misfortune to read. It's also the first "For Dummies" book I've read, so it may be the fault of the series rather than the book.
   
   The book is poorly written and poorly edited. There are errors in the code examples and numerous inconsistencies in the text. The book doesn't really say anything except, to paraphrase, "There are many things that you should know, but they're beyond the scope of this book. Check somewhere else."
   
   I bought this book based on the recommendations on this page-- my mistake. I'll never buy a "For Dummies" book again.



5. Easily one of the best programming books I've ever bought, in my life. I can't tell you how many strange programming assignments I have been able to pull off because of this book. From cursors to clobs and whatnot. Everyone in the office thinks I'm a wizard because of this book. It is also a very good reference book with great examples anyone can pick up easily. I agree, with one of the reviewers, not really really a beginners book, but if you write PL/SQL for about 3 months this should be an indispensable resource.

5 comments about Expert One-on-One J2EE Design and Development (Programmer to Programmer).

1. I thoroughly enjoyed reading this book, particularly well-thought out design guidelines for developing J2EE application with or without EJB. The author introduced several best practices particularly the concepts and usage of Spring and Hibernate based j2ee development is quite helpful. In addition to this book, I find patterns and bestpractices from "Core J2EE Patterns /Deepak Alur", "Core Security Patterns /Christopher Steel" and "Enterprise Integration Patterns /Gregor Hohpe" would be helpful - especially if you are building a enterprise-class j2ee applications.
   Now the downside, the book needs a complete revision to include changes with J2EE 1.4. The CODE SAMPLES explained in this book does'nt work now - please update.



2. It is a great book. But I give it only 4 stars is because it is hard to read. English is my 2nd language. I cannot read this book quickly. I even need check dictionary at least 2 times per page. I do not have the same problem when read other tech books.
   "What is WebSphere" is another book I like. Also help me to learn system level stuff. It is much easier to read. Though it does not have so many stuff like Johnson's book.
   I would like to suggest the auther to consider many tech readers are not very good at English.



3. Frankly, this book has gotten a little long in the tooth. One might say that, from the products it mentions and evaluates, it is out of date. But never mind!
   
   Rod applies principles that never go out of date - only the examples do - or seem to. A product is stuck with its basic design forever. Thus a critique of the 2002 version of Struts is as valid as a critique of the 2007 version.
   
   Pros: Readable. Insightful. It will make you a better architect.
   
   Cons: Typos (how do chapters get mis-numbered in the ToC?!?) It really should be in a high-quality hard binding (though the binding is quite good for paper).
   
   Summary: 'J2EE Design...' is worth much more than its weight in gold. Buy it. READ IT!



4. I bought this book because I've read very good reviews. I found this book amazing. This books shows you how to make good designs and develop in J2EE, all the chapters with full of comments from Rod's experience. Many of the concepts of this book were later applied in Spring framework. I strongly recommend read this book for advanced Java developers.



5. This book gives the right approach to programming with J2EE tools. It explains when to use J2EE and when not to.
   It's not only useful for J2EE programming but also for non-J2EE enterprise projects as well. I STRONGLY recommend it. I have learnt so much from this book.

No comments about Head First PHP & MySQL.

5 comments about Programming Microsoft® ADO.NET 2.0 Core Reference.

1. I am a huge ADO.NET nut and David's first book was absolutely priceless. After his last book, he set a very high bar that was going to be hard to meet, yet that's exactly what he did.
   
   Pros:
   
   - He discusses every facet of the ADO.NET library and does it well
   - He doesn't shy away from difficult topics and in particular, goes straight at them in his Advanced Update section
   - Excellent flow
   - Won't leave you hanging if you don't know the 1.x framework but doesn't bog itself down in it either.
   - Stellar writing style. David is interesting and always keeps you wanting to read more. He's concise, to the point yet does both without ever leaving you wanting for more.
   
   CONS
   -Calling this a con is probably a bit unfair but if there's one thing I didn't like was the coverage to TableAdapters. This has nothing to do with Sceppa's coverage and everything to do with the objects themselves. Since I never use them I have a bias against them. With that said, I doubt you could do a Core Reference without covering them so this doesn't really count.
   
   The specific areas that this book really does a great job in is Transactions, Advanced Updates and client side data manipulation. Items like the syntax for DataTable.Select are covered in such stellar detail there's probably no situation that you will be unprepared for. Transactions are another complex area and this section alone makes the book worth its price. Advanced updates are a must in any ADO.NET book and history repeated itself here.
   
   Pure Gold plain and simple.



2. I normally buy Wrox books and up until .NET I was very happy with them, but their .NET books (ASP.NET 2.0 and VB.NET particularly) were poorly organized with massive numbers of errors in them. I wanted an ADO.NET book but the customer reviews of the Wrox title were poor so I kept looking and found this book that has much better reviews. I'd not bought a Microsoft Press book recently because I didn't like the last one I tried so this was an act of faith for me.
   
   I have to say, thought, that this book is an order of magnitude better than the recent Wrox books I have bought. I don't know if the single author approach simply results in a better book or if the particular author (David Sceppa) can take the credit. Either way, I think Wrox needs to stop publishing books with multiple authors.
   
   The problem with ADO.NET is that everything is intermingled and it's hard to discuss, say, DataSets without mentioning DataTables or DataAdapters. David (or someone) say down and very carefully figured out the sequence to explain stuff with the minimum of forward referencing. This means there are only a few unresolved references I have to hold in my brain at a time for which I am very grateful. On the down-side, this means there is some repetition as he discusses the same class relationship from different perspectives in different chapters. At first I found this annoying until I realized that this was actually making my life as the reader much easier.
   
   I have yet to find a single error and the sample code in particalar seems to be error free which is in stark contrast to the Wrox .NET books. The samples themselves are compact and clean and writen in both VB and C# which is a handy way for a VB programmer like me to learn a little C# on the cheap. I certainly never found myself thinking 'The purpose of this sample is to add 10 unncecessary pages to this book' unlike other books *cough*XML Bible*cough*.
   
   I'm only about one third of the way through right now but I am very impressed.
   
   I really hope someone from Wrox reads this because I'd like the old Wrox back that published great technical books.



3. This book does a great job at explaining each concept it covers. I started the book with many misconceptions of disconnected data and other ADO.NET items. The book has many great code examples that are kept short and to the point. I definitely recommend this book to my team and anyone else wanting a stronger understanding of how to effectively use ADO.NET. Some of the performance tips it provides will suprise you.



4. I want one that may tell me step by step. Obviously this one is not such a book. It is too professional and focused in details that make things longer than you expected. if you are a beginner you would better not buy this one.



5. It is not "ADO for Dummies" or a tedious quick tutorial. Have a working handle on either C# or VB going in because it's not going to explain it. There are no lengthy history lessons or idle chit-chat.
   
   With that said, this is a fast pace process through ADO with examples in both languages. It neither glosses nor dwells but moves through what you need when you need it. It is well structured from getting started with hookups and data readers through heavy lifting with parameterization on multi and mixed providers at the end. Most everything else is in between including working offline, online, modification and return to database.
   
   Physically doing the examples, in sequence, provides the tutorial and the opportunity to play what-if to soak it in. Each sections assumes you understand the previous. In the end, this will give you a working foundation. It's well indexed and makes a good reference text for the bookshelf after teaching the basics.
   
   I've had this book over a year and is still one of my go-to's. Recommended...