Sponsored links

Valid XHTML 1.0!
Valid CSS!

Product: Book - Paperback
Title: Microsoft Windows 2000 Server Resource Kit
Publisher: Microsoft Press
Rating: 5/5
Customer opinion - 5 stars out of 5
An excellent resource that picks up where the MOC ends

This is a must for any serious designer of a Windows 2000 network. An excellent addition to the official Microsoft curriculum taught in training centres. For example...Currently there is very little information on IIS 5.0 availible. The resource guide for IIS 5 in this package is excellent covering many aspects including the new 'digest authentication'.
AD designers looking at changing their AD schema should access this resource before embarking upon making changes...
Excellent sections on Kerberos authentication. Which is new to many NT administrators moving to Windows 2000.
There are many potential pitfalls when upgrading a network to Windows 2000. This resource kit is an excellent way of minimising that risk.
Very readable and a must for all serious Windows 2000 engineers....

Product: Book - Paperback
Title: Don't Make Me Think: A Common Sense Approach to Web Usability
Publisher: New Riders Press
Authors: Steve Krug
Rating: 5/5
Customer opinion - 5 stars out of 5
Simple and yet so effective

Wow. Steve manages to write a book that follows his usability principles for websites down to a key. It was very practical. One of the easiest books I've ever read. I enjoy Steve's writing style, which dispenses with "Happy talk" and gets down and dirty, while still maintaining a comfortable approach to usability.
This book made me think about my users. Instead of walking away from this book feeling like a complete dolt for not implementing user testing beforehand, or reflecting on poorly designed websites over the years that feel prey to some of the common mistake he pointed out, I felt empowered to make changes and even begin user testing as early as this week.
In a nutshell, Steve tells you how to recognize it's broken, and how to fix it, and come in well under budget.

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

I have found this book has improved my code and that of my team greatly. We have resolved many problems in implementation and design by applying the ideas in this book.

Well worth the cover price.

Product: Book - Paperback
Title: Enterprise JavaBeans, Fourth Edition
Publisher: O'Reilly
Authors: Richard Monson-Haefel, Bill Burke, Sacha Labourey
Rating: 4/5
Customer opinion - 4 stars out of 5

This book gives an excellent overview of Enterprise JavaBeans and their applications. At all times the author does an effective job of relating to the reader the concepts behind this new methodology. Even performance issues involved with the utilization of Enterprise JavaBeans is discussed briefly in the book and both versions 1.0 and 1.1 are covered. The reader is expected to be an expert in the Java programming language, and have familiarity with the JDBC API or SQL.
The author begins Chapter 1 with an introduction to distributed objects, server-side components, and component transaction monitors (application servers). Enterprise JavaBeans is defined as a server-side component model for component transaction monitors. The standard 3-tier architecture is illustrated, along with definitions of stub and skeleton, and the RMI protocol. Effective diagrams and Java source code are used to describe the distributed object model. The chapter ends with a defense of using server-side components and the author employs an imaginary business application as an illustration of the concepts. This example is expanded upon throughout the rest of the book.
The architecture of EJB is covered in Chapter 2, with entity beans and session beans the two main components. The author carefully distinguishes between these two bean types. The remote interface, the home interface, the bean class, and the primary key are all described in detail and the author shows how to build a bean with relevant Java code. Deployment descriptors, which enable customization of software behavior at runtime, and JAR files, used for packaging Java classes, are both treated in detail. The author is careful also to distinguish the differences between 1.0 and 1.1.
The resource management capability of component transaction monitors are discussed in the next chapter. Application performance is critically dependent on this capability, and the author stresses the benefits of using EJB servers to meet the heavy load requirements while still maintaining optimum performance. State transition diagrams are effectively employed to explain instance swapping, the activation mechanism, concurrency, and persistence of beans. Security of EJB is also discussed with authentication, access control, and secure communication being supported.
In the next chapter the example business application is used to guide the reader through the actual development of an entity bean and a session bean. Again, two different versions of the beans are developed, depending on whether 1.0 or 1.1 is used.
JNDI is used in the next chapter to give an overview of beans from the clients perspective, and allows the application to view the EJB server as a collection of directories. After locating and obtaining the remote reference to the EJB home using JDNI, a remote reference to the bean can then be obtained. State transition diagrams are again employed to illustrate the Java RMI serialization and remote reference.
The author returns to a more detailed discussion of entity beans in Chapter 6. He outlines the advantages of using entity beans instead of accessing the database directly. Container-managed and bean-managed persistence are thoroughly treated, and the author shows how Create methods come into play for both of these beans. A nice state transition diagram is given for the life cycle of an entity bean along with a detailed description on what causes transitions among the different states.
Session beans are then the topic of Chapter 7, and the author discusses when to use session beans versus entity beans. In addition, the other properties of session beans are discussed and the lifecycles of both a stateless session bean and a stateful session are given in terms of state transition diagrams.
Transactions are discussed in the next chapter, with the concept of declarative transaction management discussed, which allows the transactional behavior to be controlled using the deployment descriptor. The author details the advantages of employing declarative transaction management. Effective diagrams are employed to illustrate transaction attributes. In addition, isolation and database locking is discussed in detail along with explicit transaction management. The later is used with the Java Transaction API used by EJB to deal explicitly with transactions. A very useful state transition diagram is given for the transactional stateful session bean.
The next two chapters are written from a design perspective, and discuss how to solve particular design problems, working with specific databases, and XML deployment descriptors. These chapters are specialized discussions and are geared toward those who are actually involved in the designing and coding of EJB applications. The author does address how to improve performance with session beans, treating in particular the network traffic and latency issues, and resource consumption. Method calls on a remote reference will initiate a remote method invocation loop, which will send streamed data from the stub to the server and then back to the stub, and thus consume bandwidth. Network traffic will mushroom as more clients create more beans, update their states, and request information. Reducing the EJB network traffic is a challenge to the application developer and many proposals have been given on the Web and in the literature for how to best do this. Network modelers have to pay particular attention to these issues when EJB is being deployed in an application to be run over a network.
The last chapter covers the J2EE with discussions of servlets, application client components, and connectivity.
There are very useful appendices inserted at the end, especially Appendix B, which gives the state and sequence UML diagrams for all of the bean types discussed in the book. Appendix D is also useful since it discusses the new features available in EJB 1.1.