Sponsored links

Valid XHTML 1.0!
Valid CSS!

Product: Book - Paperback
Title: Secrets and Lies : Digital Security in a Networked World
Publisher: Wiley
Authors: Bruce Schneier
Rating: 3/5
Customer opinion - 3 stars out of 5
Expected better

Schneier is just great, isn't he? He tells it how it is. And sometimes the truth just hurts. I don't agree with everything but for the most part he is just dead-on IMO.
This book isn't about specific software, this book isn't about specific algorithms. Its about thoughts and techniques. Issues to consider. Its thought provoking and its fascinating.
If you want specifics of certain technologies, recomendations on configurations, etc. then this book is not for you.
This book is for those people who really want to learn the ~thought~ and ~process~ behind security plans and implementation. Its thoughts and suggestions from one of the best in the industry. The book reminds me of those priceless 'from experience' gems you get from the best professors.
This is just a great book. -Ali

Product: Book - Paperback
Title: Effective C++: 50 Specific Ways to Improve Your Programs and Design (2nd Edition)
Publisher: Addison-Wesley Professional
Authors: Scott Meyers
Rating: 5/5
Customer opinion - 5 stars out of 5
Most Excellent, dude.

This was not my first "serious" C++ book, but it was certainly the most practical. Even though I didn't finish it one sitting (as did Stan Kelly Bootle) I did manage to finish it in about a month of steady reading; line-by-line, as it were. This takes the reader from the academic, beginner or even journeyman level, to consultant level. It isn't light reading, but it is well worth the time.

Product: Book - Paperback
Title: SQL Server 2000: The Complete Reference
Publisher: Osborne/McGraw-Hill
Authors: Jeffrey Shapiro
Rating: 3/5
Customer opinion - 3 stars out of 5
For a beginer like me ...... It's OK! ;)

This book is comprehensive and informative. The writing is mostly clear and accessible. You have to be pretty determined to make it through this book. The author covers a lot of ground and I did not find it to be particularly engaging. I coaxed myself through by reading chapters from the section on system administration in parallel with the earlier chapters on SQL language, syntax, and queries that were pretty dry. I didn't want to skip anything.
I rated this book 3 stars. I have read a lot of SQL Server books since 1998 and my expectations have risen. This isn't a bad book but it is among the dullest treatments I have encountered.
Is this a good book for beginners? Yes. Many readers want a one-volume source and this one meets that need. If you want to learn SQL Server this book offers the basic education you need. A few sections will make no sense to a beginner. They made little sense to me and I'm not a beginner anymore. But if you keep at it by the end you will have a good general understanding and ability with SQL Server 2000.

Product: Book - Paperback
Title: Expert One-on-One J2EE Development without EJB
Publisher: Wrox
Authors: Rod Johnson, Juergen Hoeller
Rating: 5/5
Customer opinion - 5 stars out of 5
Practical approach to J2EE

This book is a gem. Authors cover extremely well number of subjects that J2EE application architects have to deal with every day. They do not only describe problems associated with 'classic' J2EE architectures and innapropriate use of EJB, but also present very elegant solutions to them.

Chapters 1 and 2 explain why 'EJB does not equal J2EE' and why it is not appropriate for many applications. They also cover developer productivity issues when using EJB and explain why object orientation shouldn't be sacrificed so easily. There is also a section on 'phantom requirements', that architects often introduce into the system in order to boost their own egos, even though there are no real business requirements to support that decision.

Chapter 3 compares various J2EE architectures using several widely available sample applications, while Chapter 4 covers the importance of simplicity in application architecture and design. In addition to technical reasons for unnecessary complexity in many J2EE application, authors cover something that is not addressed very often -- cultural reasons for complexity. Everyone who worked on a large project will be able to relate to at least some of the problems described and get some consolation from the fact that he's not the only one dealing with such political bs.

Chapter 5 looks at EJB in retrospective and describes where it failed, where it succeeded, what we want and what we don't want from it. It also touches on EJB 3.0 and why it will be 'too little, too late'.

Chapter 6 describes concepts of Lightweight Containers and Inversion of Control (IoC). It explains why we need containers, what their advantages over EJB are and how they enable clean separation of interface and implementation. Various IoC (or Dependency Injection) strategies are described, as well as their implications on coding style, testing and development process.

Chapter 7 introduces Spring Framework, that will be used to implement replacements for various EJB features throughout the rest of the book. It covers basic Spring concepts, such as Bean Factory, Application Context and Resources and lays a solid foundation for the rest of the book.

Chapter 8 provides an excellent introduction to Aspect Oriented Programming (AOP), describes various AOP implementation startegies and explains how AOP is implemented and used in Spring.

Chapter 9 builds on previous chapter and shows how declarative transaction management can be handled using Spring's AOP implementation. This chapter is one of the places where Spring's flexibility and configuration really shine, with authors showing how application can be scale to use JTA transactions instead of local transactions by simply modifying configuration file. Extremely cool stuff.

Chapter 10 continues to impress the reader, by showing how several different persistence technologies can be used within Spring and how much Spring simplifies their usage. It also explains why and how data access technology should be chosen at the beginning of the project based on application requirements, and why it is usually not worth the effort to design portable DAO interfaces.

Chapter 11 explains how Spring can be used to both simplify access to remote objects and to expose business interfaces as remote objects. Technologies covered are RMI, EJB, JAX-RPC and Caucho's Hessian and Burlap.

Chapter 12 addresses other EJB services, such as thread management, instance pooling and declarative security and explains why they are not always as good or necessary as people believe them to be.

Chapter 13 takes us through web tier design, explains MVC concept and shows how various popular MVC frameworks (Struts, WebWork2 and Spring web MVC) can be used in conjuction with Spring to build web applications. This chapter is probably the only one I am not completely satisfied with. While it does show how to use different frameworks with Spring, it doesn't have a single example of how data binding between web forms and command objects is defined. On the other hand, book is not about Spring web MVC, but about replacement for various EJB fetures. My opinion is that this chapter could easily be expanded into a book on its own, that would walk reader through the whole process of building a typical Spring web application (hopefully something more realistic than JPetStore sample).

Chapter 14 covers unit testing and TDD. It is one of the best introductions to TDD that I have seen and contains a number of very practical advices for different testing scenarios, including how to make application more testable, when and how to use stubs and mock objects, etc.

Chapter 15 addresses performance and scalability, again from a very practical point of view. It covers architectural choices that can significantly impact performance, application tuning, benchmarking and profiling among other things.

Chapter 16 puts many of the previous topics together and improves iBATIS JPetStore application by implementing Spring middle tier, Struts and Spring web tiers, and exposing remote services using Spring. Overall, not a very exciting application to look at, but it does show how various pieces of the puzzle fit together and how easy it is to integrate various MVC, view, persistence and remoting technologies into Spring applications.

Chapter 17 wraps things up and provides a valuable set of guidelines for architecture in general, programming style, IoC, AOP and testing.

Overall, I was very impressed with the authors' topic coverage and no-nonsense approach. I do not agree with the comment that 50% of the book is rehash of J2EE Development and Design and other 50% is in Spring Reference Guide. While this book does refer to J2EE D&D in many places, it reads more like a sequel to it, with author's updated thoughts on many topics. Things that are repeated are the ones that should probably be repeated in *every* book on J2EE architecture and design.

At the same time, this book is very different from Spring Reference Guide because it does not really focus on Spring features and APIs per se. It does cover much of Spring, but in a very different context, showing how lightweight framework such as Spring can be used to easily replace EJB features that many people think would be hard to replace.

Objection could be made that book is strongly biased towards Spring, but in reality, only Spring offers complete replacement for all the services authors describe in the book. While there are other solutions to individual problems (and authors do mention them and give credit where it's due), only Spring offers all of them as a one-stop-shop. That, and a fact that authors are leads for the Spring Framework, more than justifies use of Spring throughout the book.