EE Books

Estimated delivery date almost a week longer than stated, how long does it take to put a book in a box...

This is a reprint of the original work without illustrations. The text is all that remains and that text is available on-line for free from the Project Gutenburg.

I will first state that I have read numbers of Mr. Roosevelt's work and I have a fond affection for his ability.
In stating that, the War of 1812 by his hand is not so much a history, but a complete (and needed) ripping apart of the British smear machine against Americans by a Mr. James.
A modern happening now is the smear against Gov. Sarah Palin by the press and lefists distorting every last detail of her life. This is what the British did to Americans in either they were unqualified or according to James it was British citizens who won the war for America against their own nation as Americans were not up to it.

This Mr. Roosevelt rips to shreds with a doctorate in details that he repeats in a style like in Winning of the West.
My highest affection for Mr. Roosevelt as a historian and writer though when he waxes poetic as in the Wilderness Hunter in hunting moose. This he accomplishes in the first chapter and the last chapter in the Battle of New Orleans wonderfully.
Readers should be warned you are going to have to know luff, tack, weather gauge and various nautical terms as mizzen and spar as sometimes it is difficult to keep track of the ships and even the soldiers on each side.

Mr. Roosevelt has fine maps his wife exclaimed in him drawing little ships when they had dinner. His drawings help immensely even in his positioning the sails.
The greatest shame is our children are deprived of the history Mr. Roosevelt describes on the Great Lakes in some of the the greatest battles in history occur there in Capt. Perry and MacDonough. MacDonough and his squandron is an epic tale of bravery, against all odds and Christian virtue in winning the battle of Lake Champlain.

Teddy could have included 500 more pages on Perry, MacDonough, Hull and Porter who were absolutely the equal of the greatest seafaring soul of all time in Sir. Francis Drake.
As Mr. Roosevelt notes being Dutch, how much it makes the veins of an American swell with pride in knowing these men and how much equal our English brethern served with distinction and honor.

This is a fine book, but it is not a child's story in an easy read. It is technical and I highly doubt the good reviews in the New York Times understood a word of the nautical tide.

I will compliment the two forwards in this book as they are written not by the typical liberal historian who would not understand the meaning of the warriors of 1812. They do a splendid job in being interesting unlike the judgmental type who did the forward on Patton.

I hope that Amazon would start carrying versions of the books Mr. Roosevelt notes in this history in James Fenimore Cooper, Capt. Porter and Adm. Faragut's memoirs in volume so one would not have to search for scarce books.
Mr. Roosevelt proved as a young 20 year old he was equal to any history phd. His work is worth the struggle in refuting the British smears of that era.
God bless

In my view a "true classic" tells not just the story that is the subject of the book, but the language used tells you about both the author and the time. Here, one of the United States' greatest leaders, Theodore Roosevelt, who subsequently became President, does just that.

This Echo Library edtion is a great disappointment. It is riddled with mistakes; words run together, first letter of many words missing, placement of footnote numbers incorrect. There are many different formats used for tables. Their decision to remove the original illustrations and diagrams was a major mistake. It is obivious that a proper proof reading was not cared out. The responsible person for this production has a lot to answer for.

In my opinion this edition should never have come to print. It is no longer a useful reference to the serious student nor is it much good for the casual interested reader.

I concur with the readers who say this book isn't just an "intro to Glassfish", that it's more of a "summary of the components of the Java EE 5 specification with emphasis on how to configure and use those components specifically with Glassfish". And that was just fine with me, because I was kind of looking for both, and in this book I got both.

We considered Glassfish as a platform of choice for deployment of a revised/updated version of a sample application (for a new edition of a book). We wound up backing off from using Java EE 5 and stuck with J2EE 1.4, for a variety of reasons. In going through this book, though, I discovered it summarizes numerous aspects of Java EE 5 in brief, readable, understandable form. The chapters on JDBC, JSTL, JSF, JMS, and EJB3 were concise summaries that covered the material well and offered solid examples. Each of these topics has had whole books dedicated to them, so it's nice to see a book that wraps itself around these individual topics and conveys the essence of what they're about succinctly.

Usually the books that attempt to cover EVERYTHING in something as broad as a J2EE/Java EE spec call themselves "bibles", and indeed that's a good name for them as they attempt to be the canonical be-all and end-all on the subject with enough laborious text and sideline commentary to be considered "biblical". While none of the chapters here is a deep thorough tutorial, each one provides enough information for you to get your head around the topic at hand, leaving with enough understanding to seek out deeper information elsewhere. That's an important thing for a book like this to do, and it's not something to be scoffed at or dismissed. In my day job I'm working with JBoss 4.2 using Java EE 5 features like EJB3 and JMS, and this book provided useful information on those subjects clearly and concisely, and explained more than a few things to me that I hadn't gotten before. The chapter at the end on Facelets, Ajax4Jsf, and Seam provided very brief overviews of those approaches/packages, again just enough to explain aspects I hadn't understood.

I may use Glassfish in the future for personal projects, as it looks like it is a robust implementation of the Java EE 5 spec, and this book will definitely be a good guide to development and deployment of Java EE 5 apps for that environment.

In under 400 pages, the author managed to do a pretty good job at introducing both what's in Java EE 5 and using it on GlassFish.

If you already know EE and GlassFish and want a specific topic covered in details, then you're probably better off picking a book on just that. Again, this book has JSF, JMS, EJBs, security, web services, and so on, but just enough to cover what most people will want and still keep it in a manageable number of pages.

Well worth my money - I don't regret buying and reading cover to cover.

I had pretty high hopes for this book but I'm pretty bummed out. It seems well written and I'm sure it is good for some people but just about everything in this book is available for free elsewhere. I wanted a book about GlassFish and really specific stuff like configuring a domain *in detail* and not a recap on how to run the basic commands. JNDI in GlassFish - I don't think it's covered. Writing applications with the Java Web Start and the nice appclient utility - not covered. Sure, most of that is mentioned (as in...the words are used) but basically this book is for people who want to learn how to write the simplest servlet, ejb, and web service and with the exception of the security chapter, pretty much none of it is really specific to glassfish. Oh well. I'll probably refer to this book on occasion when something isn't working and I want to check my sanity but for the most part this will sit under my much better books on EJB and JEE in general.

My overall opinion of the book is good. The book is very well written, and the code examples in the book work. Working code examples are the number one criteria for me. The code examples start with some examples in Chapter 2 that are used throughout the remainder of the book. This provides a coherent flow through the book. You may also download the code examples from the Packt Publishing support site.

I would recommend it as a book to have on your development bookshelf.

The book claims to be the complete guide to installing and configuring GlassFish. I would not give it that much credit. There is room for more extensive books on GlassFish. There are a number of topics that are very general and have nothing to do with the actual configuration of the server. A better book summary would be a guide to installing, configuring, and developing applications for the Glassfish server. It is really a Java EE 5 tutorial which features Glassfish.

As a book on GlassFish, it is very light in its coverage. As a tutorial for developers acquainting themselves with Java EE 5 and deployment on Glassfish it is very good. In my opinion it is targeted at developers familiar with J2EE who want to switch to JEE5, or junior developers trying to get a better comprehension of the EE environment. It is not for novice programmers.

Chapter 1

Getting Started with GlassFish

This chapter covers getting and installing GlassFish. It is very basic, but will get you up and running. It also includes how to set up your JNDI database connections. The majority of this information can be readily found on the GlassFish site on Java.net. There is a good example of how to set up multiple domains on GlassFish which is not easily gleaned from the site. There is a chart which shows how the --portbase command line option is used to set the ports on which GlassFish services connections. This provides the best explanation for this command line option and graphically depicts what the results are.

Chapter 2

Servlet Development and Deployment

This chapter is a very basic tutorial on servlet technology. It includes writing a simple servlets, web.xml files, and deployment file layout (war files). It includes some examples on html forms, request forwarding and response re-direction. There is nothing GlassFish specific and the files will just as easily deploy on Apache Tomcat unaltered. There is one item of note which is sun-web.xml related which has to do with how to change the context root. This is used if you do not want the default deployment context to match the name of the war file.

Chapter 3

JavaServer Pages

This chapter again has a basic tutorial on JSP technologies. There is a really good example of creating custom JSP tags and how to use them. Again, there is nothing that would prevent the war files from being deployed on Apache Tomcat. I wish that the author would have covered Unified Expression Language (EL) in more detail. It is more central to this technology on JEE5 platforms.

Chapter 4

Database Connectivity

This is the first chapter which covers a really important topic in the enhanced JEE5 database access functionality, new Java Persistence API (JPA), and its reference application server (GlassFish). The first example shows a servlet and how to connect to a database using the old form of JNDI lookup without resource injection. The next example shows the simplified version using resource injection of the DataSource. This removes all the plumbing of fetching our data source.

The next section covers Java Persistence API (JPA) and provides an in-depth tutorial. This is a key concept in JEE5. It introduces the Entity annotation on a POJO to convert it to a persistable object. The simple example that follows it demonstrates correctly how to to use JPA in a non-thread safe environment of a servlet using a UserTransaction. It also covers the persistence.xml file.

This chapter is a must for anyone who wants to learn JPA. The sections on entity relationships, and composite primary keys are done extremely well.

This chapter concludes on Java Persistence Query Language (JPQL) which is the follow-on from EJB QL.It is very light. I wish the author would have covered this very important topic in more detail. That being stated, the code sample is a perfect example.

The book is worth purchasing for this chapter alone.

Chapter 5

JSP Standard Tag Library

This chapter is a basic tutorial on the JSTL. I found a number of syntax mistakes, which were submitted back to Packt. The SQL JST Tag Library is covered. It was very simple. There is one note on No Suitable Driver SQL Exception which is often a hard thing to track down.There is nothing substantive about this chapter.

Chapter 6

JavaServer Faces

This is another JEE5 technology that needs more coverage in general. This chapter provides a good foundation on the reference JSF implementation. It is very well written. I am a big advocate of JSF and thoroughly examined this chapter.

The introductory examples are well done and give a good overview of the technology. The example Customer bean is the same bean that is used in JPA in chapter 4. This shows the consistency and flow between chapters. In this case we use the bean as a managed bean in the JSF context.

The chapter also explains the changes needed in the web.xml file for JSF.

The section on validators is very well done. It includes an example using the Apache Commons Validator framework. The point is to show that you should look for good validators rather than creating your own. Roll your own for domain specific requirements. It also covers validator methods in some detail. It also covers another useful utility from the Apache Commons Language Library.

There is a section on customizing messages that provide feedback to the user on various validation errors. It contains a section on how to modify the default messages on GlassFish. It is nice to know how to do this, but I would encourage users NOT to do it. You can Google for the default messages to see what they mean. If you change them, that option no longer exists. Also it is not intuitively obvious where the message is coming from. There is another example using a message bundle for your customized messages. I would HIGHLY recommend using this method.

There is a wonderful section on integrating JPA and JSF. This is a must read, and covers the practical side of JSF and JPA. It uses a model-view-controller paradigm. It shows how to use the JPA as a managed bean that gets set from the JSF page and saved/modified from the controller servlet. This is an excellent example of how to do it.

Finally, the chapter closes with a reference to the JSF Core components. I personally believe that this should have been an appendix. It really does not contribute to the flow of the book, or chapter. I went through the reference with a fine-toothed comb. The examples are really clean. I submitted some errata for the section, but it was done very well.

This is another chapter that makes the book worth purchasing.

Chapter 7

Java Messaging Service

This is a chapter that has a very specific setup for GlassFish. Most of the previous chapters were general enough on the specific technologies that they could be used on Apache Tomcat. The JMS server setup which is covered for GlassFish is very specific to the server.

The first part of the chapter covers how to set up the JMS connection factory, and JMS destination resources (Queue and Topic).

The examples that follow are very well done on how to use the various topics and queues.

I was really impressed with the authors examples. They were clean. I questioned one of the examples on durable topics, only to discover that the author was correct.

Chapter 8

Security

This chapter seems out of sequence. The Enterprise Java Beans (EJB) and Web Services chapters follow it. I would have recommended it to follow those two chapters. The author does cover securing EJBs and web services which require a security pre-cursor, but it seems to disrupt the flow of the book.

This chapter was a big disappointment. The topic is covered in minimal detail. This chapter is so important that it needs more coverage.

Here are some of the major omissions:

* Setting up a SSL/TLS connection using a self-signed certificate, or CA certificate
* Setting up an LDAP realm
* Optional attributes for the various realms

There is coverage of the various realms with a focus on file and JDBC.

The JDBC realm is complex. I understand that setting up a JDBC realm requires more work, but I am not sure how many people would use this type of realm.

The file realm coverage is detailed, but I am not sure that any enterprise would use this arrangement. It is not scalable.

The example login form using j_security_check is very useful, as well as, the example LogoutServlet.

The certificate realm is covered in fine detail. It is one of the best examples of how to configure this setup.

The LDAP and Solaris realms are weak. There is nothing here but a placeholder explanation. I can imagine that most enterprise users will have an LDAP domain that they will connect to. This topic could have included an example using OpenLDAP with its configuration in an appendix, or using openDS (http://opends.dev.java.net).

The JDBC realm setup has a number of serious errors which were reported as errata.

The section on defining custom realms is ok. It glosses a topic which requires more detail. I would HIGHLY recommend using a pre-defined realm instead of defining your own.

Chapter 9

Enterprise JavaBeans

This chapter provides a good tutorial on the JEE5 EJB 3.0 technologies. It covers the use of the new @Stateless, @Stateful, and @MessageDriven bean annotations.

There is an excellent example of using a stateless session bean as the DAO controller for JPA. It is well done. This is followed by another excellent example of how to use DAO EJB in a web application using resource injection.

Transactions are covered in very good detail. There is an excellent table which explains the various types of container managed transactions, and the @TransactionAttribute annotation.

The real jewel of this chapter, in my opinion, is the section on Bean-Managed Transactions which includes an excellent example with all of the correct annotations.

There is a section on the new EJB Timer service. I wish they would have included a practical example, but the included example gives you a feel on how it works.

EJB Security is covered lightly. There is a great note about automatically matching Roles to Security Groups on GlassFish. It is a very well hidden feature, and one which I was not aware of. This simplifies some of the security mapping and is a great time saver.

This is another good chapter.

Chapter 10

Web Services

This chapter provides a good tutorial on Java API for XML for Web Services (JAX-WS). It has some simple examples, and demonstrates the great GlassFish web service testing facility built into the platform. The tester is a web based page which allows you to enter values and see the results, as well as, the SOAP messages (Request and Response). This is a real time saver and can help a developer check the expected messages quickly.

The chapter includes a section on how to include attachments and expose EJBs as web services.

The chapter concludes on a light coverage of web service security.

Chapter 11

Beyond Java EE

This chapter covers some alternative and complementary technologies for JSF like Facelets, Facelets Templating, Ajax4jsf (providing AJAX functionality to JSF applications), and Seam. The chapter includes some sample applications and how to install and set up these technologies.

Appendices

The appendices include coverage of using JavaMail and integrating GlassFish into various IDEs.

Again, I would recommend this book for anyone who wants to learn the basics of JEE5 programming with GlassFish.

I do have to agree with others who remarked that the book is not a comprehensive discussion of GlassFish. In this respect, it is somewhat of a downer. But, perhaps albeit inadvertantly, its best merit is elsewhere.

Over the years, the Java world has grown hugely from just the Java language. Roughly, the latter is more or less J2SE. But in the J2EE field, or what Sun seems to just be calling EE, many extra layers of code and packages have been added. Entire books have been written on each of the topics of servlets, Java Server Pages, Enterprise Java Beans, Java Server Faces, Java Messaging Service, JDBC, Web Services and Ajax. Where do you start, if you don't know any of these? One answer is right here. This book. Heffelfinger gives a concise overview of each topic. Enough technical details that a programmer can understand and appreciate. More to the point, you can see how these tie into each other.

Frankly, you'll still need those other books, to do serious coding in a given topic, or between topics. But the understanding and top level view here is valuable.

This book is a good self-studying book. It provides JavaEE knowledge systematically with good examples, which helps understanding JavaEE.

Es un libro de referencia muy bueno, realizado por los de Sun.

De volumen es un tocho (casi 1400 páginas) pero si lo usas como referencia de trabajo tienes toda la información necesaria sobre java EE.

Muy recomendable.

A Good Book. Good for getting basic examples. Doesnt go very deep on each subject.

It's an excelent service and very fast, i have not problem with all this items

This book makes sense only if you already know Java EE, but in that case you don't need it. One of the worst tutorial I've ever seen. Wasted a lot of time trying to understand what it says, but that's so hard because it keeps referring to concepts that are be not covered until later chapters (forward referencing). The examples are working, but no clear explanation on what each of them does, how to reassemble them, etc. No step by step guide. Even concepts aren't explained well enough.

In my opinion, this book is one of the best books on Inorganic Chemistry. From first edition to last one F.A. Cotton's book becomes better and better. Now, this is excellent comprehensive textbook on Inorganic and Coordination Chemistry.

I have read this book with great interest. I think this book is marvellous in describing the features of three dimentional inorganic molecules.

With this edition of "Advanced Inorganic Chemistry", Albert Cotton and his co-authors have proved that they kept track of all the recent developments in the field.
This text provides clear and balanced coverage, as it applies to Inorganic Chemistry. Every branch of the course was browsed, and with generous details too. In addition to the general principles and laws, there are updated information on: Atomic Structures of elements, Chemical Bondings and related associations; as well as Chemical Equilibria and Enthalpy.
Together with its insight in Nuclear Chemistry, the details this book provided on inorganic elements and compounds is worthy of praise. It is a fine textbook, which anyone who has the basic knowledge of elementary chemistry should be glad to read.

This was one of the best book for inorganic chemistry, but this edition is very different from the previous ones. Many useful chapters have been done away with; they have been replaced with chapters rather poor, especially those about catalysis.
I advise the fifth edition, which is much better, even if it's quite old: the updates of new edition don't offset its flaws.

The 5th edition of this book had been compulsory reading during my undergraduate inorganic chemistry courses: it was the inorganic chemistry bible. This edition fails to reach the high standard of its predecessor. In fact, it isn't even a good advanced inorganic chemistry text. Much of the really useful stuff that forms the basis of an understanding of inorganic chemistry has been omitted in favour of niche topics. The book would be better called 'Advances in Inorganic Chemistry' or 'Selected Topics in Inorganic Chemistry'.

The book is well organized and the writing style is clear, albeit very dry/academic. The author gives a well-researched overview of:
* Software architecture concepts and architectural descriptions
* Architectural lifecycles, views, and representations
* Architectural quality, quality models and their attributes
* Architectural styles, patterns, frameworks, and design principles
* Software architecture and design methods, domains, models, and metamodels
* Software design fundamentals, philosophy, general heuristics
* Software architectural quality, complexity, modularity, and other aspects/concerns

All in all, The Art of Software Architecture looks to be a very informative book that covers the basics of software architecture, design, and quality that I wish all software developers knew. I was surprised by the omission of working with legacy systems, product-line/family architectures and model-driven architecture (MDA).

Software evolution and maintenance tends to be about 80% of the lifetime of a software project. Issues of dealing with legacy systems, reworking dysfunctional or decaying architectures, interfacing and integrating with other legacy systems, managing to create and sustain survivable architectures amidst the real world of ever-changing volatile requirements with aggressive deadlines and unreasonable expectations, all seem largely underemphasized for this reviewer's tastes. Important non-technical issues of leadership and communication, coordinating with project and program management, and playing the role of architecture "salesman" to management and stakeholders aren't addressed strongly enough. This is enough to prevent the book from serving as a complete and practical "how to" guide or "survival guide".

The book comprises fourteen chapters, summarized below ...

Chapter 1 provides an introduction to software architecture that discusses software development evolution and software engineering fundamentals along with the basic elements of software architecture. It touches on the subjects of reusability, general and special purpose programming languages, and modeling languages and notations. Basic software architectural elements presented include components, connectors, qualities, architectural descriptions, types of architecture, and the difference between architecture and design methodologies.

Chapter 2 covers the product lifecycle including a RUP-like management view (inception, elaboration, and construction); a waterfall-like engineering view (requirements analysis, specification, design, implementation, testing, deployment and maintenance); an engineering design view of the specification of information, principles, layout, and production; and an architectural view of predesign, domain analysis, schematic design, development and build.

Chapter 3 delves into the architecture design process of understanding the problem, identifying design elements and their relationships, defining system context, identifying modules, describing components and connectors, and evaluating and transforming the architecture.

Chapter 4 introduces basics of software architectural design, including the Vitruvian triad of function, form, and fabrication, and their interaction with planning, interaction and architectural design, "cognitive friction" and application architecture. It then discusses overall design activities and tasks, the psychology and philosophy of design, and general methodology of analysis, abstraction, synthesis and general heuristics such as: persistent questions, negation, forward steps, backward steps, factorization, and systematic variation.

Chapter 5 is devoted to complexity and modularity. It covers granularity and context, modules and their import/export, coupling, cohesion, design elements and rules, the task structure matrix, and modular operators of: splitting, substituting, augmenting, excluding, inversion, and porting.

Chapter 6 is about models and knowledge representation and talks about the use and purpose of models, the roles that models play, problem and solution domain models, functional/behavioral models, information/data models, and nonfunctional models (e.g. performance models). It segues nicely into chapter 7, which is concerned with architectural representations and architecture description languages.

Chapter 8 is all about quality models and quality attributes for process and product quality and quality requirements. It mentions issues of measuring quality attributes and system knowledge, barriers to achieving quality, and some common quality attribute misunderstandings. Quality attributes covered include functionality, interoperability, security, performance, resource efficiency, modifiability, availability, reliability, recoverability, usability and portability.

Chapter 9 dives into principles of architectural design and applying systems thinking. It discusses design "operators" such as decomposition (including identifying functional components, composition/aggregation, and component communication), replication, compression, abstraction (including virtual machines and adaptability), resource sharing, and functional design strategies of self-monitoring, recovery, and instrumentation.

Chapter 10 builds upon the previous chapter by increasing the scale/scope of view of design principles to the application of architectural patterns and architectural styles. It discusses their activation models and quality attributes for such styles and briefly describes the common architectural styles and paradigms associated with dataflow systems, call-and-return systems, independent components, virtual machines, and repositories.

Chapter 11 introduces metamodels and reference models. It describes the three-layer model of knowledge representation, the Seeheim and Arch/Slinky reference models, enterprise application reference models, and technology stacks and architectural layers. It goes on to describe a fundamental metamodel for describing software components and then gives an example of content management system reference models.

Chapters 12 and 13 discuss architectural descriptions, and common architectural frameworks (sets of architectural views). They touch on how to identify stakeholders, select and specify viewpoints, view interdependence and traceability, recording view inconsistencies and capturing rationale for the viewpoints and the overall architecture. This is followed by advice on applying architectural descriptions to both new and existing systems and performing an architectural assessment. Some of the different architectural frameworks described are: Kruchten's 4+1 views model of architecture (which UML and RUP use), and the reference model for open and distributed processing. The discussion for each framework and its viewpoints includes the stakeholders and concerns addressed, and the construction of t he architectural view representing the viewpoints of the corresponding set of stakeholders.

Chapter 14 finishes the book by tackling the subject of software architecture quality: its importance, how to improve it, how to evaluate it, and how to assess modifiability and performance. It discusses the use of a systematic design process, understanding the right problem with a system-level view of the requirements and differentiating between requirements and design. The section on assessing software architectures talks about scenarios reifying nonfunctional requirements and the role of an architectural description, before moving on the subjects of evaluation, modifiability, and performance.

Ever since "The Mythical Man-Month", it has been clear that lack of strong architecture will sink a software project. (It was probably true before TMMM, but that was before my time.) Architecture, implying an architect, is a requirement for any major piece of software.

I can agree with Albin only to a point: architecture is not implementation, analysis, or software engineering. It's different even from "design", as the word is usually used. An architect really does a different job than other members of a software team (but the architect may design and implement, also).

That said, I didn't quite make out how to go about -
- training someone as a software architect,
- developing a sound and appropriate architecture,
- measuring its success in objective and repeatable ways,
- making it a part of the project plan and documentation, or
- preserving it across generations of maintenance.

Most importantly, I did not see any discussion of adapting an existing architecture to new needs, or of extending an archtecture beyond its original bounds. Typical software spends 10% of it's life in design and implementation, and 90% in maintenance. The initial 10% is the fun part. I have real reservations about authors who choose not to discuss the other 90% of the problem.

The book has value to the extent that it opens the topic for discussion. Too often, though, it confuses the skill of architecture with the tools of an architect - sort of like looking at a pencil drawing by Rembrandt and saying "Wow, if I get a pencil like his, I'll be able to draw like that too."

I've been looking for books and articles about software architecture. This one has some value, but I'm still looking.

This book uses real world examples and practical advice coupled with academic rigor. It provided tremendously helpful insights into how I can improve the efforts of my team.

Much of this introduction is lost in a profusion of nouns. How useful is this: "In commercial enterprise software development, it is not always possible to produce a single-system context model, but rather may require several exemplar contexts"? All this without introducing what challenges are faced during "commercial enterprise software development" as opposed to some other kind and prior to an attempt to define a "single-system" or a "context model" (btw doesn't a model give context?)

For someone interested in the promises of the title and "Design, Methods and Techniques" I found this book lacking in a crisp description of what design is, what methods exist to get one and how to apply oneself to the getting of an understanding of the constraints that often weigh-down design decisions.

I also found the discussion that tried to introduce the term "architecting" and the differences in meaning between programming, software engineering, software development and software architecture rather odd.

If you're looking to start making your own landscapes for your bonsai, this is a great book to begin with. I didn't buy the book, it was at my library, so maybe you can save a few also.

This is a useful book for a very specialised application of bonsai landscaping. If you have every other book on bonsai, then this will complete your collection, though you may not practice what you read because of the specialised and complex application.

The writer presents 18 miniature landscapes which, she says, "represent a very personal synthesis of the bonsai and penjing traditions". These landscape are made up of the usual tiny trees, moss and gravel, but they also contain intricate rocky "outcrops" which form the basis of the entire landscape. Her creations combine the delicacy of the tiny landscape with the ruggedness of rock and tree to unique effect.

The writer gives detailed instructions for making each of the landscapes, including - I kid you not - how to make all the rocky outcrops yourself. Given patience, skill and delicacy of touch almost anyone could follow these instructions and make a very attractive table top landscape.

The writer was born in Singapore and studied art in England. She is a judge in the bonsai category at the Chelsea Flower Show in London. She approaches her miniature landscapes from the point of view of a painter, and she incorporates the Chinese principles of Tao and the balance of yin and yang to create harmony in these beautiful miniature worlds.

This book covers many topics, unfortunately it does not go into great detail and less than a hello world example. I am confused and don't know what the authors really mean about interoperbility with this book. The content is a bit vague and poorly written. The examples are hardly usable and the best practices sections does'nt make sense. Some of the topics covered have nothing to do with interoperability, they are integration topics. If you are really looking integration guidance, choose Enterprise Integration Patterns by Gregor Houpe et all.

As much as Microsoft might want you to be an all-.NET shop, the reality of the enterprise computing environment is that both .NET and Java will be used in some way, shape, or form. If you're a developer or architect responsible for integrating platforms, this book could help you out... Java EE and .NET Interoperability : Integration Strategies, Patterns, and Best Practices by Marina Fisher, Ray Lai, Sonu Sharma, and Laurence Moroney.

Contents:
Part 1 - Java EE .NET Interoperability: Java EE Platform Interoperability Essentials; .NET Platform Interoperability Essentials
Part 2- Synchronous Integration Solutions: Exploring Synchronous Integration; Web Services for Synchronous Integration; .NET Remoting for Synchronous Integration; Resource Tier Synchronous Integration
Part 3 - Asynchronous Integration Solutions: Exploring Asynchronous Integration; Asynchronous Web Services Integration; Messaging; Resource Tier Asynchronous Integration
Part 4 - Addressing Quality of Service Requirements: Addressing Quality of Services; Managing Distributed Transactions; Java EE .NET Security Interoperability; Java EE .NET Reliability, Availability, and Scalability; Managing Java EE .NET Interoperability Applications
Part 5 - Implementation: Migrating .NET Applications to Java
Index

The book is targeted towards developers as well as architects and managers responsible for these types of projects. The focus and approach tends more towards the practical, "here's one way to do it" methodology. There's no hesitation to suggest third-party frameworks and applications to help you accomplish something, as well as providing enough code to allow the reader to get a feel for how it all fits together. It's not a comprehensive approach to every last thing you need to know, but if you're charged with platform integration, this will give you the practical foundation you'll need to start examining the options available to you.

Given the right needs and the right audience, it'll offer value to the reader...

The first couple of chapters are OK. Thereafter I found the integration concepts and strategies half done and hardly complete. The code examples are not commented at all. I noticed the code would work only on sun application server and the configuration details are not discussed are missing. I tried to deploy the code example using websphere 6 it did'nt run at all. The chapters in part3 and part4 are more of theoretical coverage and kind of standards work in progress. In comparison, I like Application Interoperability - Patterns and Best Practices from Microsoft Press over this book. This book did'nt help me at all.

For the first time I've felt the need to write a review. I felt inclined to do so because I am so appalled by the spiteful reviews that have come before me. I just finished this book and thought it was wonderful. In fact upon finishing it I called my friend (who recommended the book) thanking her.

Some of the other reviewers seemed to not realize that this is a light read for the purpose of enjoyment. It is not a spectacular work of literature that is going to change our worlds and leaving us reeling in deep thought.

Essentially, this book is about a woman that doesn't love her life (and just because someone is rich doesn't mean they should love their life, to clear that up for that reviewer that seems to believe so) that encounters some unique challenges during this particular time in her life. In my opinion it is a quick read that is great to bring to the beach or as a little escape from your own reality.

For someone that is looking for something light that is not particularly earth-shattering this is a great choice!

This was a fun book and I did enjoy it. We get a slice of rich New Yorkers' lives. They have so much money, it actually harms them and the people they should love and care for the most...their families. Got money? You can get a manny. So the manny is supposed to fix it all and help out the stressed Momma
Thank goodness I do not need a manny

This book seemed to be trying to be one of substance. There were some interesting plot elements begging for exploration. Jamie is in her thirties, a mother of three small children. She finds herself ten years into a marriage with a guy she doesn't really like, living the good life surrounded by wealthy people who seem much more comfortable in their wealth than she is. Jamie can't seem to relax into her expected role, and chooses to work part-time for a television station. Her children miss the attention of their parents, and her oldest son, who is nine, seems especially affected.

It would have been interesting to explore in detail these lives of the rich and unhappy, to check out their dysfunctional families. It would have been interesting to see a more in-depth treatment of Jamie's job and her career-boosting assignment landing an interview with a woman who claims to have dirt on a respected Congressman.

In the end, though, this book is simply a frivolous story of a married woman who moons over the male nanny she hires to get her son back on track. He's too perfect in every way, with his easygoing attitude, incredible physique, and knack for charming small children and hired help alike. Jamie and the manny flirt with each other in a variety of situations, with no regard to who is observing. He seems to have no problem with the fact that she is married and has three children, and she seems to have no problem leading him on when she isn't sure if she is going to leave her husband.

For most of the book, Jamie floats, not making any real effort to fix her marriage or to get out of it, not making more time for her kids, not trying to get out of the society she hates nor trying to get more comfortable with it. She passively waits for something to happen to her, and ultimately things do happen. It's not nearly as satisfying, though, as if she had been a character who figured out what she wanted in life and took steps to make it happen.

The book was rather predictable and, as the characters never really sprang to life for me, also rather forgettable.

This book was soooo bad, I don't even know where to begin. Since I had to give it a rating, it gets 1 star. But in reality it would be a zero star.

The main character is so whiny and obnoxious that I didn't like her at all. She's suppose to be someone with values and integrity but I thought she was just as bad as her "supposed" Park Avenue friends if not worse. Yes these rich bitches are snobby and condescending but at least you know where you stand with them. The main character whines throughout the whole book about her life. She lives in a posh apartment in Manhattan, her husband makes over $1 million each year, she has 2 full-time staff, and can afford the luxury of working part-time not for the money but to "make her a better mommy". Give me a break! She should live in the real world like the rest of us who have to work for a living and do everything ourselves (cooking, cleaning, laundry) and who, heaven forbid, have to send our kids to public school. The scenario with the manny was so unbelievable, I just couldn't imagine why he would be interested in her. As well, she didn't start getting interested in him until he was rich. What a hypocritical gold digger.

This book was a total waste of time. Thank God I borrowed it from the library and didn't waste any of my hard earned cash on it. The premise was utterly stupid and the writing was incredibly bad. I can't believe this rubbish got published. It goes to show you that any no talent person can get a book deal if they know the right people.

Don't know much I can add to what people have already said, but I love chick lit and can enjoy almost any book, but I found this book painful to finish. The writing wasn't great, the characters were cardboard, and the story was so drawn out. It was a cute idea, but it wasn't well executed. So please just trust me and save your money. This book and Trading Up by Candace Bushnell are the only two chick lit books I have ever not enjoyed.

I bought this for a programming languages concepts class and this book definitely has some very solid principles and concepts that everyone should know about programming languages. I would recommend this if someone is looking into what really makes up a programming language and a deeper look at theory over trial.

The fact that this dreadful, outdated, poorly written textbook is in it's 8th edition is proof of the graft and corruption in the text book industry. This books focus on outdated technology and sparse, unsatisfactory coverage of functional and concurrent languages makes it suitable for only the most basic course on languages. For such a course the previous 7 editions of this book would be more than adequate.

Instructors: Say NO to requiring the most recent edition! Say NO to support corrupt business practices of textbook publishers who exploit students and their families!

This book is decent for what it is, and that is an introductory programming languages textbook. The background material on what makes languages different and how those types of languages function differently is pretty good.

Once the book gets into the survey of the different languages, the material is very shallow. I don't expect a lot, but I did expect more than simple looping and list manipulation for examples to compare the different languages.

I'm highly disappointed in this book. The biggest problem with it (and it's mighty big for a book that's supposed to talk about the concepts of various programming languages) is that it focuses almost entirely on a subset of imperative languages. Almost exclusively, the descriptions and examples involve Fortran, C, C++, Java, C# and Ada. Only in the last two chapters does the author really talk about other types of programming languages and those two chapters are devoted to them. It's like they were just tacked on.

After that, the other problems with the book are relatively insignificant. First, the book is badly edited. In spots, it reads like it was mechanically translated from a foreign language. Second, an awful lot of his explanations are unnecessarily filled with pretentious-sounding multi-syllabic words. For instance, on page 183 he gives the following description of a top-down parser:

"Given a sentential form that is part of a leftmost derivation, the parser's task is to find the next sentential form in that leftmost derivation. The general form of a left sentential form is xAa (my note: that "a" is actually the letter alpha in the book), whereby our notational conventions x is a string of terminal symbols, A is a nonterminal, and a is a mixed string. Because x contains only terminals, A is the leftmost nonterminal in the sentential form, so it is the one that must be expanded to get the next sentential form in the leftmost derivation."

And finally (for my purposes here), he defines things using undefined (or merely "later-defined") terms. For instance, on page 220 he says, "stack-dynamic variables are allocated from the run-time stack." He doesn't define what a run-time stack is until page 433 and that definition is: "This stack is part of the run-time system, and therefore is called the [b]run-time stack[/b]." The real kicker is he doesn't explain WHY the use of a stack is important here.

If it were just a matter of those smaller problems I have with the book, I could give it a decent rating. But, his focus in imperative languages just kicks the legs out from under the book. The best I can give it is a Not Very Good two stars out of five. A much better book is Michael L. Scott's Programming Language Pragmatics, Second Edition.

I have just finished my Programming Languages class that used the 8th edition of the book. My school is online so what is in the book is all I had to work with. I have not learned anything from this book. I am not a programmer but this book expects the reader to be one of not just a couple of languages but of several. While it may hold some value for the wide range of topics covered it fails to really explain the "Concepts", rather it is just an assault of programming pieces. The parts it shows you are not complete programs you could actually do something with unless you knew how to program in that language. Showing me a piece of something I don't know anything about the rest fails to teach me the "concepts". It would be better named "Exercises in Several Programming Languages".

I am a book collector and find it hard to get rid of text books. This book fails to impart $120 worth of information to the student. If you need random information about programming languages this book might be able to help, but not worth the money even for that.

Pros:
Covers a lot of material

Cons:
Index is minimal (making finding concepts difficult).
Arranged by languages rather than concepts (You know the part you needed).
Very unreadable writing style.

Suggestion:
Put it in PDF Form so that it can at least be searched since the index is horrible.

I bought this book with the hope of getting a better idea of how I should build the Web Flow flows in my Grails ( [...]) application. I know it is my own fault, and that I should have more carefully read the excellent reviews of this book, but I was a little disappointed to discover Web Flow was the topic in just two of twelve chapters when it is approximately 50% of the book's title.

If anyone knows a good source of reference on how to design Web Flow flows so that my web app has a nice natural user experience (e.g. able to use the browser 'back' button having gone though a flow's end state without getting in a mess) then please let me know. I want to aim for the sort of experience I have when using the amazon dot com shopping cart, not the sort of experience I have when using an ERP solution. So far with Web Flow my efforts have tended towards ERP quality :(

The book was great pre-release book, but like most programming books for specific frameworks becomes almost useless within a few months

I completely agree with the reviewer who points out how almost chaotically the information is delivered in this book - for the most part. Generally, you need to skip from section to section and back a few times before you can get all the pieces together. That's unacceptable. It's impossible to use this book as a convenient reference since each example generally provides only partial answers, and you have to scan back and forth through the pages to look for the clarification on the missing pieces. Often, the coverage is quite superficial. The official Spring Reference Guide on the Spring site does not get into too much detail on Spring MVC, leaving out lots of important and interesting details. Nevertheless, much more - and better - information is indeed available on-line today - at no cost. I haven't yet seen a perfect one-stop source for Spring MVC, but this book is definitely a waste of money. It may have been okay a couple of years ago when much less info was available online, but certainly not today.

The only part of this book that is very well written is the chapters on Spring Web Flow. Indeed, it appears that the chapters were written by someone other than the authors of the rest of the book. Someone who understood and appreciated the importance of a very thoughtfully organized FLOW of any sequence of logical steps, be it a software application, or a flow of information such as an instructions manual, or a tutorial. That's why Colin Yates, the apparent main contributor to Chapters 11 and 12 (on Spring Web Flow), does a much better job than the rest of the authors. Unfortunately, those Web Flow chapters are largely obsolete today. Some code in the book won't work. You'll immediately see that the classes in the org.springframework.webflow.test package you get with your latest Webflow distribution differ from the ones used in the book's examples. What's even worse is that the flow configuration XML files in the examples apparently use the old/obsolete XML schema. That means you shouldn't use them as examples for your own code. Just compare the code from the latest Spring [on-line] Reference Guide and the examples in the book and you will instantly see the difference.

For a very good introduction to Spring Web Flow, see the Spring Reference Guide (http://static.springframework.org/spring-webflow/docs/1.0.x/reference/introduction.html) and the article by the author of Spring Web Flow at http://www.ervacon.com/products/swf/intro/index.html, which is excellent.

Do not waste money on this book! Honestly. ;)

The book provides really good information and I was able to build out an application after reading it. The only problem is the editing and I hope a 2nd edition is released with fixes and updates for Spring 2.0. There are good PDF presentations out there that give a quick overview and one good tutorial that's a working example. I would google for those and read them alongside with this book.

As computer books continue their never ending slide into the abyss, Apress and Manning seem to be leading the way. This book is one of the best works of fiction ever written. From incomplete and non-working examples to the many errors, the publishers would be better served by pulling this tome off the market and starting over. There is nothing "expert" in this text nor is there anything the least bit helpful. Well, ok, I will admit the UML diagrams are nice.

Avoid this book at all costs.