No comments about Java Programming Projects.

5 comments about Java 2 Developer's Handbook.

1. Authors and editors spent very little time updating is book to Java 2. Its too bad Sybex places such little value on the quality of their books. Sybex is no O'Reilly. Really wish I had not wasted my money on this book.



2. Lots of useful code without any explanation, but nice cover and pictures with cups of coffee, wich suppose to make it easier psyhologically...but not in real life



3. I bought this book when I was a beginner and read it rather quickly. Today I started work on a telnet client and remembered the book describing the use of telnet URLConnection. Cool, so I loaded the CD-ROM and to my disappointment no protocol handlers (the telnet handler or one for the other example) were included at all. I e-mailed their support person but after a few exchanges it became clear he didn't have a clue.



4. I was reading this book for reference on ChangeListener (page 729). The examples given does not even IMPLEMENT the ChangeListener interface. What a strange way to programing. This is entirely different from LeMay's TY 21 day examples. I am really confused. I am not buying another book by the same authors.



5. all the adanced aspects of java is mentioned, but out of date

5 comments about Java(TM) Development on PDAs: Building Applications for Pocket PC and Palm Devices (Java (Addison-Wesley)).

1. It is a stark measure of how far computers have come that the author reminds us that today's typical PDA has about the same CPU power and 4 times the memory of the first Macintosh, and likewise of a comparable contemporary PC. So while you may be a programmer on a current workstation with heaps more memory and speed than a "constrained" PDA, migrating to it would still mark you as a power developer by the standards of a not so distant past.

   If you are already programming in Java for a desktop, then this book will be an easy stroll in the park. The graphics and networking libraries are different from J2SE and J2EE. But this is only insofar as they have necessarily much less functionality, though retaining just enough to hopefully do what you need. Gnash your teeth at the loss of cool graphics, if you must, but that is how things are. The neatest part of the book is the descriptions on how to offload the heavy computations via web services. This may be new to you.

   By the way, if you are interested in the book, also check out "MIDP 2.0 Style Guide" by Bloch and Wagner; also published by Addison-Wesley. The two books complement each other. The latter gives a high level description of the appearance and functionality of a UI on a small device. Wilding-McBride's book then shows code examples to actually let you do this, at least for PDAs. Surprisingly, neither book appears to reference the other, though they are by the same publisher and came out just a few months apart. So, at least let me do that for them here.




2. When you want to dive into the field of actually program a wireless device you can easily find yourself become confused. One question is simply: What do I need to get going with the first project. And although it is a simple question to ask, it is not yet a simple question to answer, because it depends! The dependency is what device you want to address and what options you have when you want to develop an application.

   This book is written by a humble and very competent programmer. He is humble because he just want to tell us how to code a PDA, be it PocketPC or Palm. He does not want to demonstrate much more than this. And this is how it should be, given the title of the book, because what he does is telling us all the steps needed. Here the authors competence really shows.

   The book starts with a brief introduction to the J2ME configurations, the CLDC and the CDC API's. Continuing then to the MIDP profile where the author already demonstrates a simple generic MIDP applet. The next two chapters really rocks the boat: Here is compared the Palm and the PocketPC platforms with regard to J2ME, so if you have the choice then you can easily decide what to go for. In any case you will here find the most needed information: What development environment should you use for a specific platform - and where do you get it. The author brings links to a collection of no-cost tools and what more: All the links are correct!

   At this point you really must begin to program at least a "Hello World" program for you selected platform. McBride helps you with every step in this for both platforms. He discusses JDBC, Internet access from the PDA's and how to use misc. connection methods, for example Infrared Connections or Mobile Phone. Everything is demonstrated with very good screen pictures of the PDA's or good program lists. He even demonstrates how to use web-services and the SOAP clients.

   The last part of the book deals with the future, meaning technologies such as JXTA (dynamic peer-to-peer network) and ideas about Jini. Bluetooth was already demonstrated earlier in the book. Again, everything is written clearly and makes you want to start the programming now.

   The book is highly recommendable! On no more than 239 pages including the index you'll get all what is needed to start doing your own development with confindence that it will work. I really believe that all the code in the book was tested. Do yourself a favor: Buy this book if you want to program JAVA on the PDA's!




3. So this book started well, with lots of sensible thoughts like making all the source code available for download to avoid long listings in the book itself. Although as I read through there still seemed to be a fair amount of code (e.g. p109 -113 is all code) but presumably this was still only the "critical" bits of code needed to understand thte points being made. Generally I thought the first three chapters of the book were very strong - the description of CDC, CLDC and MIDP left me feeling more certain about what they actually are:

   CDC and CLDC are "configurations" which means JVMs with some basic APIs
   MIDP is a "profile" which is additional APIs which will work on top of a "configuration"

   Chapter two was particularly interesting, focusing as it did on the different types of PDA available, comparison of prices, relative market shares, and performance specifications for different PDA/Java combinations. Although naturally this look at the current market will date most quickly, it provides an interesting insight into PDA trends in this period. Overall the book gives a strong impression of having been written by a single developer (which it has) who has a lot of hands on experience with Java on PDAs, and thus has a lot of relevant advice to give. This is exemplified in Chapter three where we are taken through a selection of open source and cheap development toolkits, as well as the process of setting these all up to get started developing on the PDA.

   Unfortunately after this strong start the subsequent chapters fall to some extent into the standard "work through the API" approach, so that while the chapter on user interfaces encourages us to consider carefully the restricted screen space on PDAs, the body of the chapter is simply a description of the different types of user interface component, rather than a more detailed look at when each of the component should be used and to what effect.

   I don't want to be overly critical here since there is a burden on authors of technical works to make sure that important sections of the API are covered, however I find I am not really able to take in more than trivial amounts of code from the page of a book (I need to be running it and making changes to bits before I understand it). The screen-shots from the PDA help here, but really I wanted more from something in book form. Ideally I would like to see a paragraph or two on the pitfalls and advantages of using each kind of UI component in a PDA setting. Even better would be a sample project, where we work through two possible user interface solutions, one designed without much thought on the constraints of the PDA and one designed with the PDA in mind.

   To be fair some general guidelines for developing on the PDA are outlined in chapter four but it is fairly short, and lacks examples. To make this book "really useful" rather than just "handy" I would like to see a much more rigorous analysis of two versions of a sample project, one done correctly and one done incorrectly from the PDA perspective. This kind of comparison is hinted at tantilisingly at various points in the book such as the comparison between SOAP, HTTPText and HTTPStream in the networking chapter. The author shows that he is capable of presenting the pros and cons of different alternatives in particular areas, so it is a shame that this approach could not be developed more thoroughly. The very short concluding chapter on Futures, only confirms the impression that more time could have been spent on this book to good profit.

   Still, while I think the reader can rightly ask for more, there is still alot here - I am sure that anyone developing Java on PDAs would be well advised to have a copy of this book on their desk. We can only hope that the author will be given more time to develop the themes touched upon in this work in a subsequent publication.




4. While I do not currently write anything for PDAs, it is clear that the majority of the growth in the use of new computing devices will be in handheld devices. This will of course require an enormous amount of new software to be built. While the power of the handheld devices continues to grow, convenience, if nothing else, will demand that the size remains small. This will limit the size of the screen and the amount of memory available. Therefore, while it is possible to port software used on desktop platforms to handhelds, it is not an easy task and even in the best of circumstances, significant changes have to be made.
   In this environment, it seemed logical that I learn the basics of how to program PDAs. Since I am now primarily a Java programmer, this book seemed like a logical place to start. From reading it, I learned a great deal about how the programming of PDAs is done. The book opens with a description of how the Java standards relate to PDAs as well as the availability of Java implementations on the most popular PDAs. This is followed by a list of ways to obtain the software needed to start developing software for PDAs. Chapter four covers some of the major restrictions encountered when programming PDAs. This chapter is essential and was the most interesting. The remaining chapters contain demonstrations of programs that create screens displaying the usual range of user interfaces. Buttons, checkboxes, filedialog boxes, alert boxes, textboxes and the various layouts are illustrated with code. Some of the common actions, such as serializing object data, accessing JDBC databases and using Internet protocols are incorporated into the programs. As an experienced Java programmer, I found the programs fairly routine, although there were some differences that needed to be understood.
   There are no great revelations in this book, just a solid introduction to one area of computing where the growth over the next decade could be incredible. I have elderly relatives who have never touched a computer, and yet they have cell phones and are learning how to use some of the advanced features.



5. I bought it for a friend and never heard a complain about it. I guess it's a good book.

5 comments about Applying Enterprise JavaBeans 2.1: Component-Based Development for the J2EE Platform (2nd Edition).

1. As an entry level book to Enterprise Java Beans it was a good book, but nothing special. Currently this book (1st edition) is very much outdated because of the new EJB specs. You would do better buying another EJB book.



2. This new edition of " Applying Enterprise JavaBeans" is a well written look at the Enterprise JavaBeans 2.1 specification. The explanations of the various topics are in-depth and yet easy to follow. The authors provide diagrams and supporting code samples demonstrating how to write the code for each topic covered. They also provide explanations of when a particular technology is appropriate for your applications. The book even has a glossary so that if you forgot what an acronym stands for, you can look it up.

   The book covers all the usual topics one would expect in a book on EJBs. It starts with a general overview and then takes a look at each of the various bean types. Session beans (stateful and stateless), message driven beans, and entity beans are each covered. An application example is discussed which includes packaging of the application for production. The following chapter covers integrating web services into your EJB applications. Subsequent chapters cover transactions and security. The authors have done a great job of explaining not just how to code EJBs but also how they work within an application server, which you need to know to use EJBs successfully.

   The book is similar to the O'Reilly book in size and scope although this book has the advantage of being more current. Overall, the book is well written, easy to follow, and extremely useful. If you are new to EJBs or if you are looking for a book to bring you up to date on the new specification then this book will make a good choice.




3. Several years ago, we tried using EJB 1.0 and were utterly underwhelmed. Despite using what was for its time a high powered computer, our clock cycles and memory seemed to get eaten up somewhere in the container. Searching the web revealed that many others had similar complaints.

   Sun heavily improved the EJB standard in version 2. The Container Managed Persistence was totally rewritten, and Message Driven Beans were introduced because many users wanted loosely coupled asynchronous applications. Things are much better now, and Sun released this book as part of its official documentation set for EJB 2. As usual, it is clearly written and authoritative.

   So the good news is, if you are running EJB 1, you really should jump, and EJB 2 is the logical and easiest destination to get to. If so, you might as well get this book to smooth the transition.

   But there is an alternative which this book completely neglects to mention. In the last 3 years, a rival to EJB has arisen. The open source jBoss. In 2000, I heard its founder, Marc Fleury, claim advantages over EJB 1. Since then, in various newsgroups, it does seem that jBoss is at the very least on a par with EJB 2. And given that the jBoss source is available and free, you should seriously consider migrating to it.

   You see, Sun had very little real choice but to produce EJB 2, and to write a book like this, in part simply to stay competitive with jBoss and other application servers like IBM's Websphere and BEA's Weblogic. Run and run just to stay in place.




4. Now in its second edition updated to take into account changes in the EJB 2.1 specification, Applying Enterprise JavaBeans: Component-Based Development For The J2EE Platform is the collaborative effort of computer experts Vlada Matena, Sanjeev Krishnan, Linda DeMichiel and Beth Stearns, and the latest in "The Java Series" of instructional computer programming books endorsed an authored by the creators of Java technology at Sun Microsystems, Inc. Covering support for Java Web services, security management, message-driven beans and integrating with Java Message Service, transaction management, EJB query language, and much more, Applying Enterprise JavaBeans is a hands-on, example-filled, highly practical and enthusiastically recommended instructional and reference resource.



5. I'm a bit surprised by many of the reviews of this book. Overall, I think it is a fairly solid coverage of EJBs. However, I think it tocuhes on many topics without providing enough depth to make that topic clear and useful. One of the worst examples of this is Chapter 6, entitled Using JMS and Connectors For Communication. The chapter has a rather brief high level coverage of JMS which is too short and sporadic to be terribly useful. Then is jumps to J2EE Connectors which it discusses for one and a half pages. In those 1.5 pages it gives no examples and almost no concrete information about how to use connectors. The most useful thing it says is it tells you another book you can buy to actually learn how to use connectors. Since the chapter is called "Using JMS and Connectors..." I would expect more than 1.5 pages of fluffy coverage of connectors. But at least it told me what book I should have bought instead.
   If you want a high-level view of a lot of topics, without a whole lot of depth, then I think this book is a good choice. If you want a more thorough coverage of EJBs, I'd recommend Head First EJB, Enterprise JavaBeans (O'Reilly Press), or Professional EJB (Wrox Press.)

5 comments about Mastering JSP.

1. Very infomative book, Great insight for Java Server Guru's



2. Unfortunately, this book is too much 'how I would re-invent JSP' and not enough about how to use JSP. For example, the JSP and Servlet API Reference is just a dump of the the Sun interface without any comments. I tried to get information about the Request object and was very frustrated, since this is scattered throughout the book (I think, the index was not helpfull). I'm sure this has some good code in it, but I didn't buy it to have a code snippets book. I wanted a book that would teach me JSP and be a good reference as I develop code.



3. I was looking for writing database based web applications in JSP and I found the book very useful. It is a step-by-step guide for building web applications. The book covers JavaBeans , Handling exceptions in efficient manner, Custom Tags and Displaying XML files using JSP. The book has got detailed explained examples which helped me in designing my application faster. Overall I was able to design and develop web apps in an efficent manner with the help of this book.



4. I wanted to find a book that covered both the use of JavaBeans and Enterprise JavaBeans in an easy-to-understand way. I have made a comprehensive search, and came up with this book. The book covered all I wanted it to, and still there are lots more. If you just have read tutorials on the internet (like I have), and want a book for assistance, BUY IT! Recommended!



5. When I first got this book and just thumbed through it, it seemed like it was going to be a good book. However, the more I actually read the chapters, the more I find it utterly lacking in content. The author does not explain things very much if at all. Many places, its just pages of source code listings with little or no comments and no explanations. Then when you get to the end of one source code listing, basically the only commentary is "and here's the next listing..". This annoying lack of explanations also carries through to the appendix, where a "JSP and Servlett API Reference" is included - problem is, its nothing but a commentless, explanationless dump of the member function prototypes. Fortunately, I bought this book used for $10. If I had paid the new price for it I would really be upset and would return it. That's my opinion.

5 comments about Tomcat Kick Start.

1. This book provides a lot of overly simplistic examples, and does not provide any explanations of how to get anything done. For example: instead of describing in detail what is involved in setting up a server, this book provides instructions without explanations for setting up a specific example - leaving the reader wondering how to adapt these instructions to different situations (beyond your basic 'hello world' example).

   The book is too high level to be useful for a developer or admin. I tried using it to get up and running with a new project, but honestly got absolutely nothing useful out it.




2. This book only touches the important subjects on the surface. This book is not good for someone who seriously wants to learn tomcat. It does not discuss most important parts in detail except for the installation.

   For me, it was a waste of money and I had to buy a another book called Mastering Tomcat Development, which is a great book for beginners and experienced tomcat users.




3. I think this is a very good book.

   Some who wrote in were expecting A and got B. A lot of books on the computer field are long on theory and short on practice. Tomcat Kick Start is more of the reverse, shorter on theory and longer in practice. This can frustrate someone who is expecting a lot more theory.

   One of the commenter's says, "Basically, this book tries to demonstrate how to develop enterprise applications on pretty weak examples, and this does not help you learn how to do these tasks in a generic manner." I disagree with this comment, many people do learn by example. Lots of people don't like to wait and read and read and read, then try something... I think the Tomcat Kickstart appeals to the impatient. And the simplicity of the examples encourages users to try things. I think this is a great way to get going quickly.




4. This is a decent book - I have to congratulate the authors and editors in trying to keep each topic cohesive and self-contained. However, a chapter or two on integrating with J2EE App Servers like JBOSS might have been useful.
   
   As a book author myself it is a challenge to pick examples that can be listed on a page or two supporting the topic of the chapter. So given this the choice of currency conversion example is probably o.k though for some it might look simple. Important thing is not the examples but the JSP/webapp constructs and facilities available that are being illustrated through the example. If you read CSS by Owen Briggs - he has an interesting approach to keep the reader attention on the concepts and not on the examples - the text he uses for displaying using different style sheets - "Lorem impsum dolor sit amet. ..."
   So some reviewers concerns about better examples may be uncalled for.
   
   This is a good book for someone who is familiar with Java and want to come upto speed with JSP/Servlets/Struts and those familiar with JDBC but wanting to migrate to using connection pooling available with commons-dbcp. I would expect such person to find things on their own after reading this book. Many time being impatient I used Google only to find tons of search results and wasted time reading crowded blogs/bbs when what I was looking for was right in the book - the best way to use this book - don't sit before the computer - finish readng a chapter and then try the examples in the chapter - it works straight.
   I would have preferred if the authors included ant build files with each chapter and also some explanation on how to integrate tomcat with JBOSS.
   Being written in 2002 it is still valid with Tomcat 5.0 - but an updated version would be timely and can also provide some information on other webcontainers. They could have picked a different cover image = it looks like a mechanical or aerospace engineering book .



5. Along with Jason Hunter's "Servlets" and Marty Hall's "Core Servlets", hard to beat in useful tricks per ounce: servlet listeners, DAOs, URL rewriting, custom tags. Except for some errors in chapter 5 (the downloaded web.xml is missing some tags), all the examples run.

5 comments about Web Services Patterns: Java Edition.

1. Some of the fonts chosen remember me of some books I read 15 years ago. There are bad recommendations like promoting a distributed architecture in the "Physical Tiers Pattern". The chapter describe how you can communicate between two processes with RMI or CORBA.
   
   The only two patterns that were not obvious for me were the "Faux Implementation" and "Partial Population", but few strategies are presented for implementing them.
   
   In overall, the author seems naïve and not very experimented.



2. I've been architecting Web Services since before they were called Web Services, so I was really hoping to come away with some new insights based on the other book reviews here. Unfortunately, this book fell short in several ways. Pros: I liked the idea of WS patterns - it's a good idea and he did an ok job, I also liked how he tied the example application to the text. Cons: the writing style was a little dry and repetitive, very few of the patterns actually applied to how clients interact with services (something most of us that implement services are interested in), all of the examples used rpc/encoded SOAP messages which is pretty much an obsolete practice, and the author seemed to have much less Web Service experience than pattern experience. For example, in the Partial Population Pattern he recommends that clients use "keys" to identify parts of the message that they want returned. A more XML-friendly approach would be to use a limited form of XPath rather than keys, thus allowing for more flexibility. The pattern also assumes that the response schema allows variations in the message to be returned, something that I don't believe he discussed.



3. Perhaps Monday is attempting what Martin Fowler did some ten years ago, when Fowler wrote a now classic book on refactoring. Here, Monday identifies several useful patterns in WS usage. We're talking about a collective, distributed computation here. That is (or can be) usually asynchronous. Another book ("Remoting Patterns" Wiley 0470-856629) discussed patterns for a general distributed case.
   
   But Monday focuses on what might emerge as useful within the strictures of WS. Especially if we use Web Services Description Language or Business Process Execution Language. In terms of example code, he chooses Java to express this. But the text makes clear that the patterns are of course independent of any given coding language. (The WSDL and BPEL and other WS variants are declarative languages.)
   
   You may find the book useful if you are new to WS. It gives a higher level view of what might be done. Whereas other WS books could be concentrating more on the WS syntax. Also, you may find out whether BPEL is sufficiently expressive for your needs. BPEL was conceived in large part because WSDL ran into limitations. But BPEL itself needs a practical workout by developers.



4. I enjoyed reading this book because it discusses middle-tier issues well. Many Chapters (ex. "SOA Pattern" and "Service Directory Pattern") are good descriptions of WS, but are not Patterns.There is not enough technical info to implement a WS. There are issues with WS not discussed in this book. Therefore it is not a good summary of WS nor of their Patterns.



5. If you have done a lot of work with OO design, and are designing SOA based systems, this book is for you. It does a brilliant job of explaining how SOA encourages a component Architecture style, rather than a Object Oriented design methodology. Some consequences of that include, 1) passing simple data structures and expecting simple Collections from Services, such as Arrays. 2) Using composition much more, rather than inheritance. 3) Separating the Business Logic (and process) from the Business Data, so that the business process can be exposed at a higher level of abstraction, and shared across multiple Activities that can fulfill the business logic.
   
   This book is still very relevant, and a great read for Architects, developers and Managers.

No comments about Practical RichFaces.

5 comments about The Book of JavaScript: A Practical Guide to Interactive Web Pages.

1. This book was very good for what it was intended to be, a gateway into javascript. Ofcourse one will not find every detail of javascript in this book. It was designed for the newbie.

   Every topic was well written and easily understood. The only problem I had with it was the part about functions. Using this as my first real programming language, I didn't know the fundamentals. The book did not describe how functions worked very well, hence why I have it a rating of a 4 and not a 5. It was not untill I learned some c++ that i understood functions and was able to come back and relearn all the javascript.

   all in all the book was VERY good and I HIGHLY recomend it to any newbie to javascript or to programming. (ofcourse javascript requires a good understanding of html Before you learn javascript, that was my disclaimer incase and real newbies were reading.




2. This is a great book for anyone beginning, halfway through, or an expert on JavaScript. Thau explains everything simply and gives good tips as well. Just a warning however. One of the files in the "1st page" editor (ON THE INCLUDED CD-ROM)shows up as a worm on an anti-virus scanner. Something called "Seven Buttons from Hell"or something to that effect. Other than that, fantastic book!



3. This is a great book for anyone beginning, halfway through, or an expert on JavaScript. Thau explains everything simply and gives good tips as well. Just a warning however. One of the files in the "1st page" editor (ON THE INCLUDED CD-ROM) shows up as a worm on an anti-virus scanner. Something called "Seven Buttons from Hell"or something to that effect. Other than that, fantastic book!



4. I just picked this one up because I was looking to juice up a website I've been working on. The first couple of hours I spent with it were golden. I learned a lot of what I was interested in knowing quite quickly. One thing that struck me, however, was how dated it was - the author likes to reference real world websites but every real world example that I looked up online had been completely redesigned since this book was published in 2000.
   The book also spends a somewhat annoying amount of time discussing differences between browsers like Netscape 2.0 and IE 4.0... Netscape is currently at version 7.0, IE is at 6.0. Dealing with the different browsers and the way they render java was much more of an issue three years ago (although it definitely still is an issue b/c pesky microsoft likes monopolize everything did its best to turn java into something that could only be compatible with IE). Point being his discussion of this issue is dated.
   Anyway, the book is well written and the author is not a tech head looking to show off how complex his field is. The book puts things forward practically (as the subtitle suggests it should) and the result is if you are a java novice and you want to add java functionality to your website, this book provides the answers in a way that is aimed more at the bottom line of getting that functionality into your website and less at providing you with a big picture understanding of java.
   To summarize, this book, aside from being somewhat dated, is a very well organized guidebook for someone who wants a working understanding of the elements of java that suit their basic purposes. It is not for someone looking to become a real java maven.



5. Target Audience
   Beginning JavaScript coders.

   Contents
   This is a conversational tutorial on JavaScript coding designed for people who have not used the language much (or at all).

   The book is divided into the following chapters:

   Welcome To JavaScript!; Using Variables and Built-in Functions to Update Your Web Pages Automatically; Give The Browsers What They Want; Rollovers: Everyone's Favorite JavaScript Trick; Opening and Manipulating Windows; Getting Functional: Writing Your Own JavaScript Functions; Giving and Taking Information With Forms; Keeping Track of Information with Arrays and Loops; Timing Events; Frames and Image Maps; Validating Forms, Massaging Strings, and Working with CGI; Cookies; Dynamic HTML; How to Fix Broken Code; Beyond the Browser: Plug-ins, ActiveX, Making Music, and Java; Reference to JavaScript Objects and Functions; Answers to Assignments

   Review
   There are numerous books on the market that deal with learning JavaScript. There is everything from simplistic guides to the person building their first web page, to in-depth guide for the professional web developers, to detailed reference guides that document every feature. On that scale of coverage, this book falls somewhere on the lower end of the scale. That's not a bad thing... It's just good to know what the target audience is.

   The tone of the author's writing is conversational and a little quirky. He uses a number of examples in each chapter to illustrate the subject matter, and they illustrate the points well. Each example is dissected so that the reader can follow along and understand what each line is doing. By the time you are finished, you should have a solid understanding of the basics of JavaScript. At that point, you should be ready to pick up a more detailed book and start learning the intricacies of the language.

   The only bad thing about the book at this point in time is the age of the book. He assumes that the reader is working with either Netscape 3.0 or Microsoft Internet Explorer 4.0. On one hand, most of the stuff you see here should be supported now in any browser. On the other hand, there's something to be said for learning the latest information on more up-to-date platforms. The age also shows up when you examine some of their web site samples. Obviously, the sites have been updated since the book was written, so you can't very well follow along any more.

   Conclusion
   A solid, if somewhat dated, tutorial treatment of basic JavaScript coding. Easy to read, and very good explanations of code examples.

No comments about Practical Eclipse RichClient Platform Projects (Practical Projects).