5 comments about Performance Analysis for Java(TM) Websites.

1. This is an excellent book, providing thorough coverage of performance analysis. Although this book is aimed at Java based sites, it would serve as a good primer for anyone learning how to tune a website with dynamic content. The authors assume the reader has only basic familiarity with internet technologies, and explains concepts as needed. After providing a basic theoretical grounding, the authors illustrate the concepts with a case study, going from simple to complex.

   The book is well-organized and thought out, and presents its information in an understandable, easy to follow fashion. I particularly like the inclusion of the test and capacity planning forms in the appendix. This gives readers the chance to put the information to work, instead of just giving case studies or presenting only theory.

   A highly recommended and informational book.




2. It takes a comprehensive look at the java performance analysis. It is very good at describing common bottlenecks be in architect, hardware (load balancing) , user interface etc.

   Ideas are well received by our team and book provide food for thought on diverse topics. We have continuous integration testing and continuous inspection (and adaptation) for performance testing and this book was very helpful.




3. The team of authors who wrote this book have two things going for them - in-depth knowledge of performance analysis, and, most importantly, the ability to impart that knowledge in a crystal clear manner.

   I like the way this book starts out, showing the contrast between a bricks & mortar store and its online equivalent. This introduces the basics - throughput, transaction, page and user rates, response times and states. More than an easy to follow introduction, it contains all of the key elements of performance analysis, doled out in easy to understand chunks, and sets the stage for the rest of the book.

   Every facet of a typical environment is covered, including Java server performance factors, external and internal factors related to networking, load balancers, protocol behavior, and Java internals. The chapter on performance profiles of common web sites is especially useful. Different site types are characterized in a set format that shows caching potential (of the site type), any special considerations, and specific performance testing considerations. This allows you to go directly to the type of site you are going to test, get the relevant information, then proceed to conduct the testing, which is covered in subsequent chapters.

   The chapters on testing begin by showing how to develop the test plan, associated test scripts, and select the right tools to support the testing. The areas covered in these chapters are comprehensive. Actual test execution and results analysis are covered in equal detail, using examples and scenarios. One especially useful chapter is 13, Common Bottleneck Symptoms, which is useful to track the cause of observed results that do not match expected ones during testing.

   This book goes beyond testing, though - it also covers capacity and performance planning, which is normally a discipline onto itself. Again, excellent advice and coverage of key points. The appendices are an invaluable collection of templates, worksheets and checklists.

   I cannot recommend this book highly enough. It exemplifies top notch writing, is well illustrated, and is technically accurate, and based on proven approaches.




4. This book's title has "Java" in it (and book covers Java performance analysis very well), but large part of it is about web performance analysis approach and methodology that can be applied to non-Java web sites. This is a great resource and a must have for those who deals with performance of web sites. Simply look at the table of contents and you'll love it: http://www.amazon.com/gp/reader/0201844540/ref=sib_rdr_toc/104-1411948-5301507?%5Fencoding=UTF8&p=S00H#reader-link



5. One of the most difficult hurdles a QA new to performance testing can go through is shifting their testing methodology from specific to componenents to a balanced environment-wide perspective. This book helps guide the Architect or QA through the process of discovering HOW we look at metrics and WHY we use certain metrics over others. This is much more useful in the long run than rather just looking at WHAT to look at since this can vary depending on your specific infrastructure.

   If your reading a RedBook on WebSphere Performance Tuning and you haven't yet figured out what your Peak Average Load is, your performance testing is doomed to fail. This book guides you on the right path to the methodology that will work for your testing. It provides test plan guidelines and even sample scripts. In addition, there are several guidelines for analysis and interpretation.

   The book only requires a couple of things to be a truely complete performance testing guide in my opinion: More detailed information and guidelines for Performance Testing Failover situations and slightly more concise guide for scripting. For the type of sites that you'll use this book for, you'll most likely have more complicated scripts and script requirements.

   Over all, this book provides a great introduction of the core concepts and outlines quite a few of the more overlooked requirements in this increasingly important field.

5 comments about Pro Java ME MMAPI: Mobile Media API for Java Micro Edition (Pro).

1. This is an excellent book for those with an interest in creating Multimedia Applications for J2Me Mobile devices.
   
   I would say that the book is split into three sections:
   
   Section 1 (chapters 1 to 3): This section gives detailed information about the architecture of the MMAPI and how it fits within the J2Me platform. There is also has a good "getting started" guide to be found here.
   
   Section 2 (chapters 4 to 8): Deal with how one uses the Player object in all its forms from playing simple tones, to playing back captured and streamed video.
   
   This section was the most useful to me. It provides excellent
   background information about each of the subject areas. An example of this is that it gives a full history of the MIDI standard, and an overview of the protocol itself, before it starts talking about how you write the code to play a midi file in J2Me.
   
   Section 3: (the last chapter) is a case study, providing yet more code examples, and a companion blog site.
   
   The only criticism that I have, is that the book, could have delved into the realms of streaming media a little deeper. The company that I work for, weComm is actively involved in the mobile TV space and I was pivotal in the creation of our application for streaming TV, and therefore I was hoping that this topic would be covered in more detail. That aside, I was very impressed, the subject matter was covered very thoroughly, and I felt guided through the MMAPI as I was reading it.



2. This is a well written book. It's not for beginners but then again you don't have be a J2ME (Java ME) guru to understand it. The writing style is technically clear and straight forward without a lot of personal fluff.
   
   Since MMAPI is a subset of Java ME, the scope of the subject is fairly limited but the author covers it well. The only area I might like more explanation is with respect to DataSource and SourceStream. This is covered briefly at the beginning of the book, but it would be nice to know how to implement a custom protocol.
   
   The biggest problem I have had with the MMAPI is it's inconsistent implementation and the author is quick to acknowledge this. One could probably write a whole chapter about the quirks of various mobile devices.
   
   In conclusion, I doubt you will find another book specifically on MMAPI that has the depth that this one does. I highly recommend this book if you are looking to get your feet wet with the MMAPI.
   
   BTW, I really appreciate the time the editors spent to proof read the text as there are very few errors, if any. It's always frustrating to me when I read a book with a lot of code and spelling errors. That's not the case here. Well done!



3. Pro Java ME MMAPI: Mobile Media API for Java Micro Edition has amazed me. The book is unique as it covers and desmyifies one of the most fragmented and confuse Optional Packages for JME.
   
   I've read more than a dozen books about JME but this is the first book that has really cleared some doubts I had regarding Mobile Media in JME.
   
   I strongly recommend this book if you are developing Multimedia Applications using JME.
   
   Vikram Goyal has done an outstanding job by clarifying and detailing every aspect of MMAPI, discussing the way it has been specified, emphasizing the differences that may occur from one implementation to another and also providing clear, detailed and error free examples that illustrate the aspects being discussed.
   
   Also, the text is very well-written and I've found only 3 typos. Very impressive! Apress is also doing a wonderful job.
   
   Chapter 1 introduces MMAPI and presents its features and requirements as defined by the JCP - Java Community Process, compares MMAPI and the MIDP 2.0 Media subset, where it fits regarding the JME Software stack and at last it lists the manufactures and market players supporting MMAPI.
   Nice introduction!
   
   Chapter 2 explains the MMAPI Architecture, the main high-level interfaces, delivers an introduction to the supported protocols and content types, presents the relevant feature sets and the security issues one must take into consideration. It also details the MIDP 2.0 Media subset so that one can understand what's left out on devices implementing it.
   
   Chapter 3 introduces the reader to MMAPI hands-on programming by explaining two simple MIDlets. It also builds the foundation regarding the overall development process and environment.
   
   Chapter 4 is unique, it details the Media Player lifecycle, its possible states and transitions. It explains each state very thoroughly as well as Player events and how to work with them, even the limitations and issues regarding custom events. I've never read a book covering MMAPI with such a detailed explanation.
   
   Chapter 5 covers all the issues regarding the access of media over networks. It starts with a very clear explanation of Threads in JME as well as the security permissions for media acess over networks. Then it puts it all together in a very clear and easy to follow example.
   
   Chapters 6 and 7 are the best ones in my opinion. Those two chapters do pay the book, definitely.Vikram has been brilliant and desmystified Synthetic Tones and the MIDI protocol. He has remembered me of my of childhood, when I've had musical theory classes as it explains everything music and shows you how that all fits into programming with MMAPI. Those chapters are so complete that they have a lot of tips on how to convert from RTTTL to MMAPI format, the MIDI specification and message format and how to work with MIDI in MMAPI, how to create JTS files and other niceties. Thanks Vikram :)
   
   Chapter 8 explains how to work with Audio and Video, playback, capturing, storing, controlling, mixing, it's everything there. It also describes the details of Media Encodings and Sampled Audio as well as the GUI options for dealing with Video.
   
   Chapter 9 has a very cool Device Blogging application that builds upon all the subjects presented so far and also gives a good example of MVC pattern in JME.
   
   Well, the only criticism I have is regarding the section about Streaming Media and also the Appendix C about the JSR 234 - Advanced Multimedia Supplements. Considering that Vikram has proved he's really a subject matter expert He could have provided better sections about them.
   
   In fact, He has already written an article about Streaming in JME and it's available on his web site (so I forgive him) but AMMS is still to be covered. What about on the second edition of his book? Let's wait and see!
   
   A must have book, absolutely!



4. When I got this book I jumped straight to Chapter 9 viz. "Case Study: Device Blogging". This chapter nicely explains how to write a blogging Midlet for a phone device which includes writing a Blog post, capturing/uploading images to a blog, and capturing/posting audio to a blog. The author explains the MMAPI concepts using the MVC paradigm along with complete source code for client and server side processing of application and interaction logic.
   
   The rest of the book goes deep into the MMAPI architecture and concepts with the help of source code of working applications. The functional Multimedia player example in the 3rd chapter explains the role of various components of MMAPI architecture. A dedicated chapter on Media player lifecycle and events is very helpful in understanding the basic concepts of event handling. The book also covers some of the fundamental concepts behind controlling pitch, tempo, audio mixing with the help of examples.
   
   Chapter 7 is dedicated to the MIDI specification which is very comprehensive and well explained within the context of JavaME framework. Writing a book like this requires a thorough knowledge of both JavaME and the various subtleties of tone, pitch, sequencing, octaves, frequency, audio conversion and their treatment on the device and at the network level. In my opinion the author has done a great job.
   
   All in all this book is a great resource if you are planning to develop the next Mobile video sharing, photo sharing application or your next multi-media player for a Mobile phone.



5. I have a litte doubt and try to solve my problems talking with the writer email showed in the book, but I never received a anwser...

5 comments about Processing XML with Java(TM): A Guide to SAX, DOM, JDOM, JAXP, and TrAX.

1. I bought this book when it first came out. I really enjoyed reading it. The book is well written. It has a lot useful code.
   The author code that can be used in the real world of JAVA and XML. I liked the books section on JDOM. This book shows the differences between DOM and JDOM. Also, this book has a lot of information on SAX, DOM, JDOM, and it shows the differences when using each. I would recommend this book to anyone who wants to learn JAVA and XML. Make sure you are an experienced developer before purchasing this book.

   Michael




2. This is definitely a valuable resource for anybody dealing with XML and Java, written by one of the best tech writers in town. The author covers in details a huge amount of topics and API, so many that you couldn't ask for more.
   Be advised that some basic understanding of XML and intermediate Java skills are required to get the best out of this book



3. I really like reading this book. It is easy to read and understand. The author does a good job of describing the XML technologies related to JAVA. This book has a lot of code to analyze. This book is a must have for the experienced developer who wants to do JAVA with XML. I have a message for the experienced developer: THE CODE WILL CHALLENGE YOU; IT CHALLENGED ME!!!

   Michael




4. If only every technical book was written this well! Anyone who is working with Java and XML should have a copy of this book. Highly example driven with clear explanations, the author makes using XML in your Java programs a breeze. Even better, the author has a style that makes the book fun to read as you feel like you are learning all sorts of secrets from an XML insider.

   The book starts with a quick introduction to XML and then gets into how to create XML documents in your programs. The first four chapters cover everything you need to know about creating XML whether it is for XML-RPC, SOAP, or simply to store in a file. The next section covers parsing XML documents. SAX and DOM are compared and then the next eight chapters discuss these two methods of parsing documents, explaining how to use them, comparing them, and helping you determine how to decide which technique to use for which situation. The section on DOM explains not just how to parse documents using DOM but also how to create new documents. The final chapters of the book cover JDOM, XPATH, and XSLT.

   Did I mention that this book is full of examples? The author doesn't rely on simply explaining how something works or how to use a technology (even though his explanations are excellent), he has examples to demonstrate everything he discusses. Each example builds upon the previous example and makes learning the techniques easy and enjoyable.




5. great book on xml, specially on different kind of parsers, their purpose, advantages and weakness.

5 comments about Java Number Cruncher: The Java Programmer's Guide to Numerical Computing (Prentice Hall PTR Oracle Series).

1. At one time or another, most of us will likely have to write code performing some amount of numerical computation beyond simple integer arithmetic. As many of us are neither mathematicians nor intimately familiar with the bit gymnastics our machines must perform in order to manipulate numbers, we can get ourselves into trouble if we're not careful. Luckily, "Java Number Cruncher" comes to the rescue.

   This book is an introduction to numerical computing using Java providing "non-theoretical explanations of practical numerical algorithms." While this sounds like heady stuff, freshman level calculus should be sufficient to get the most out of this text.

   The first three chapters are amazingly useful, and worth the price of admission alone. Mak does a fine job explaining in simple terms the pitfalls of even routine integer and floating-point calculations, and how to mitigate these problems. Along the way the reader learns the details of how Java represents numbers and why good math goes bad. The remainder of the book covers iterative computations, matrix operations, and several "fun" topics, including fractals and random number generation.

   The author conveys his excitement for the subject in an easy-to-read, easy-to-understand manner. Examples in Java clearly demonstrate the topics covered. Some may not like that the complete source is in-line with the text, but this is subjective. Overall, I found this book educational, interesting, and quite enjoyable to read.




2. As the author says, last time I looked Java still had the +, -, /, * and % mathematical operators.. though most programmers end up forgetting it lost as they are in the boring, vulgar and repetitive coding of boiler-plate "enterprise" (read "sell sell sell") applications. This book does a very good job of introducing a Java programmer to one of the most fun and interesting powers that Java can offer ... that is playing with numbers and exploring the world of mathematics. Forget (at least for a little while) Servlets, JSP, EJB, and database massaging... and give a look to how you can use your JDK to study functions, solve differential equations, integrals, system of equations, discover prime numbers and admire the beauty of fractals. The treatment of the various subjects is done is sufficient detail to be clear and sound, but without burderdening the reader
   with detail and depth best left for more specialized and hard-core texts that the curious reader can explore after this one. Refreshing.



3. I have got hold of this book just recently. This is an excellent book on numerical computing using Java that covers many important aspects in numerical computing. I have been writing numerical methods in Java back in graduate school as well as in my professional career for mission critical programs. I must say this book has addressed many issues that must be taken into account such as machine epsilon, choices of numerical methods for different problems, limitations and precautions in using different data types, etc in Java in which if taken for granted, would produce disastrous results.
   
   Ronald Mak has taken the trouble to explain IEEE floating point standards in a fun and easy-to-understand manner.
   
   Another thing about this book that is worthy of a mention is its great OO programming styles. Codes are also well commented and reader friendly. Overall, it is a great source to learn not just on how to program numerical methods in Java but how to write good OO programs.
   
   The only two bad things I could say about this book is that I should have gotten of this book much earlier and if only Amazon allows a Six Stars rating.



4. The book doesn't teach you Java. It is assumed that you already know Java.
   doesn't cover all of Numerical calculus and not all of mathematical proofs but great if you are looking study practical programming with Java.
   
   I recommend this book only if you know Java and have basic numerical knowledge.



5. This book is an introduction to numerical computing that is both comprehensive and fun. It is not a textbook on numerical methods or numerical analysis, although it shows many key numerical algorithms all coded up in Java. The book examines these algorithms enough that you get a feel for how they work and why they're useful, without formally proving why they work. There are also demonstrations of many of the algorithms with interactive graphical programs. Overall I enjoyed this book a great deal. It is not a beginner's book on Java - you should be a pretty good Java programmer already. Also, you should be at least somewhat mathematically mature for the material past part one. That is, you should have had some Calculus and some Linear Algebra prior to reading the last 3 of the 4 parts of this book. I further describe this book in the context of its table of contents.
   
   Part 1: WHY GOOD COMPUTATIONS GO BAD - Simply copying formulas out of a math or statistics textbook to plug into a program will almost certainly lead to wrong results. The first part of this book covers the pitfalls of basic numerical computation.
   
   Chapter 1 discusses floating-point numbers in general and how they're different from the real numbers of mathematics. Not understanding these differences, such as the occurrence of roundoff errors, and not obeying some basic laws of algebra can lead to computations that go bad.
   
   Chapter 2 looks at the seemingly benign integer types. They don't behave entirely as the whole numbers of mathematics do. Arithmetic operations such as addition, subtraction, and multiplication take place not on a number line, but on a clock face.
   
   Chapter 3 examines how Java implements its floating-point types. The chapter examines the IEEE 754 floating-point standard and shows how well Java meets its provisions.
   
   Part 2: ITERATIVE COMPUTATIONS - Computers are certainly good at looping, and many computations are iterative. But loops are where errors can build up and overwhelm the chance for any meaningful results.
   
   Chapter 4 shows that even seemingly innocuous operations, such as summing a list of numbers, can cause trouble. Examples show how running floating-point sums can gradually lose precision and offer some ways to prevent this from happening.
   
   Chapter 5 is about finding the roots of an algebraic equation, which is another way of saying, "Solve for x." It introduces several iterative algorithms that converge upon solutions: bisection, regula falsi, improved regula falsi, secant, Newton's, and fixed-point. This chapter also discusses how to decide which algorithm is appropriate.
   
   Chapter 6 poses the question, Given a set of points in a plane, can you construct a smooth curve that passes through all the points, or how about a straight line that passes the closest to all the points? This chapter presents algorithms for polynomial interpolation and linear regression.
   
   Chapter 7 tackles some integration problems from freshman calculus, but it solves them numerically. It introduces two basic algorithms, the trapezoidal algorithm and Simpson's algorithm.
   
   Chapter 8 is about solving differential equations numerically. It covers several popular algorithms, Euler's, predictor-corrector, and Runge-Kutta.
   
   Part 3: A MATRIX PACKAGE - This part of the book incrementally develops a practical matrix package. You can then import the classes of this package into any Java application that uses matrices.
   
   Chapter 9 develops the matrix class for the basic operations of addition, subtraction, and multiplication. It also covers subclasses for vectors and square matrices. The chapter's interactive demo uses graphic transformation matrices to animate a three-dimensional wire-frame cube.
   
   Chapter 10 first reviews the manual procedure you learned in high school to solve systems of linear equations. It then introduces LU decomposition to solve linear systems using matrices. An interactive demo creates polynomial regression functions of any order from 1 through 9, which requires solving a system of "normal" equations.
   
   Chapter 11 uses LU decomposition to compute the inverse of a matrix efficiently and reliably. A demo program tests how well you can invert the dreaded Hilbert matrices, which are notoriously difficult to invert accurately. The chapter also computes determinants and condition numbers of matrices, and it compares different algorithms for solving linear systems.
   
   Part 4: THE JOYS OF COMPUTATION - The final part of this book covers its lighter side of numerical computation.
   
   Chapter 12 covers Java's BigNumber and BigDecimal classes, which support "arbitrary precision" arithmetic--subject to memory constraints, you can have numbers with as many digits as you like. This chapter explores how these classes can be useful. You compute a large prime number with more than 3,000 digits, and you write functions that can compute values such as the square root of two and e^x to an arbitrary number of digits of precision.
   
   Mathematicians over the centuries have created formulas for computing the value of pi. Enigmatic Indian mathematician Ramanujan devised several very ingenious ones in the early 20th century. An iterative algorithm supposedly can compute more than 2 billion decimal digits of pi. Chapter 13 uses the big number functions from Chapter 12 to test some of these formulas and algorithms.
   
   Chapter 14 is about random number generation. A well-known algorithm generates uniformly distributed random values. It examine algorithms that generate random normally distributed and exponentially distributed random values. The chapter concludes with a Monte Carlo algorithm that uses random numbers to compute the value of pi.
   
   Mathematicians have mulled over prime numbers since nearly prehistoric times. Chapter 15 explores primality testing and investigates formulas that generate prime numbers, and it looks for patterns in the distribution of prime numbers.
   
   Chapter 16 introduces fractals, which are beautiful and intricate shapes that are recursively defined. There are various algorithms for generating different types of fractals, such as Julia sets and the Mandelbrot set. In fact, Newton's algorithm for finding roots, when applied to the complex plane, can generate a fractal.

5 comments about SCJP Exam for J2SE 5: A Concise and Comprehensive Study Guide for The Sun Certified Java Programmer Exam.

1. This certification study-resource from Author: Paul Sanghera is a great tool for quickly getting up to speed in java with a view to taking the java programmer exam! As someone who recently succeeded at the SCJP 1.5 exam, i can vouch for this book. The following review is thus for those interested in preparing for the exam and not quite sure whether this book is the right tool for the job.
   
   As a green-horn in Java, I found the following 2 exam-study resources very useful in learning how to program in java, and taking the Sun Certified Java Programmer for J2SE5 certification:
   (Book 1.) SCJP Exam for J2SE 5. - (SCJP E5)
   (Book 2.) SCJP Study Guide. - (SCJP SG)
   
   Note: (due to review real-estate constraints, i shall limit this review to (Book 1) ie: [SCJP E5 (Sanghera)] -( the current book in question). you'll find a (Book 2) review on the customer review page for : SCJP SG
   
   Like most new-comers to java, I wanted to get-up to speed in java rather quickly. Therefore, the (SCJP E5) book from Sanghera was chosen as the first reading-reference, as it seemed concise, compact & condensed. However, if i had to do things-over, and choose which one book to use in order to scale the SCJP 1.5 exam -(whilst learning the Java language as well), I'd pick the [SCJP SG] from Sierra & Bates.
   
   Here's why...
   
   About the (SCJP E5) book : this book is great for beginners. i found that it brought me up to speed quickly Re: java, as well as preparing for the exam. However, unless you have previous knowledge & experience coding in java, you might need another book for deeper clarity and more rigor regarding 5 SCJP1.5 exam-objective related areas, viz:
   (1.) - Generics
   (2.) - Threading
   (3.) - I/O + Regular Expressions + Parsing
   (4.) - Packages + Jar Files & Static Imports
   (5.) - Exceptions
   
   Note that: while the 5 exam-objectives above are quite well treated in the (SCJP E5) Sanghera book, I found that the (SCJP SG) Sierra & Bates book, provided the finer level of details that i believe a beginner might further require in order to have a better grasp Re: these 5 exam-objectives cited above (AND) (the questions in the real exam do require this further finesse with those details).
   
   Otherwise, with the material in this book alone and without any hands-on experience, i reckon, a beginner might struggle a bit to pass the real exam by a comfortable margin.
   
   and this is why i cant give the book alone all 5 points of credit. (I would however award 4.5 points!)
   
   Upon completing the book, any access to good exam-revision practise material would be very useful in order to pass at the exam-level. while the (SCJP E5) book features useful questions and answers at the end of every chapter, as well as a further round of 73 questions in Appendix-D of the book; I believe people preparing for the exam would find it useful to seek out further resources for exam-question practise & revision purposes .
   
   As review-space is short, i shall include below only 2 of the exam-revision resources which really helped prepare for the actual exam (for details Re: The other key resource used, u might want to refer to the customer review posting for (Book 1): SCJP SG
   
   u might want to check these out:
   (1.) "Tiger notes" on JavaRanch. look under the SCJP FAQ section for : [Mikalai Zaikin's SCJP Tiger notes ]. You can get a paperback copy of notes similar to these on Amazon if you prefer. lookup: Java 1.5 Tiger. However, i'd advise that you use it only as a prep-extra, just to cross-check certain topical-details you may need to clarify ie: (java: "Exceptions"). I wouldn't recommend it as your sole & unique study guide.[ kittybooboo's notes ] on JavaRanch are also quite good.
   
   (2.) Turn to a SCJP Group for advice on the forums. They represent people in the same boat as those trying to prepare for and pass the SCJP exam. here are 2 such groups you can join.(Yahoogroups): Google: [" tech groups yahoo + scjp5" ]; (Another is): Google:[ "jchq + net" ] (-OR-) if you are preparing for the SCJP 1.4:( scjp 1.4 groups ) : Google:[ "uk groups yahoo + java_balk" ] ps: a good book for SCJP 1.4 is :A Programmer's Guide to Java Cert
   
   (3:) refer to my customer review posting for (Book 1) ie: SCJP Study Guide
   
   Schedule, Sit and Ace the exam in 2hrs:55mins, when you've finished with these various exam-practise questions and study-guides.
   The exam is comprised of 72 questions of which several are fashioned as drag & drop coding-scenario questions. Although, the pass mark is 59%, I think most people -(myself included!), view the exam as tough, because of its code intensive nature. I think reading, tackling & spotting possible coding errors in code-samples 6-30 lines long is tough under such time-constrained exam conditions, Plus, No credit is given for partial answers. However, on the up-side, it is do-able with the appropriate revision preparation regime.
   
   Curiously, in comparison, the previous SCJP exam ie: the SCJP 1.4 exam, is comprised of 61 questions , for which one has 2hrs to complete. Plus, the pass mark is 52%. That exam, is generally deemed to be an easier exam compared with the SCJP 1.5 exam; at least so attests certain in the user-community on JavaRanch.
   
   for those wondering, i took the SCJP 1.5 exam on March 19th 2007. the passing-score achieved was: 98% ie: (71 out of 72 questions ). The pass-mark is 59%.
   
   Good Luck!
   
   next stops: SCBCD, SCWCD, SCEA, SCJWSD.
   
   Cheers :-)



2. I have just passed the SCJP for J2SE 5 exam largely after preparing from this book. However, to be on the safe side it might be good idea to consider using more than one resource to prepare for this exam, because the exam is certainly not a walk in the park. I have read all the three SCJP for Java 5 study guides from cover to cover. So I would like to share my experience with these study guides in the context of both the exam and learning Java:
   
   "SCJP Exam for J2SE 5" (this book) by Paul Sanghera.
   I found this Study Guide the best among all, especially for the beginners. As another reviewer said the author has the unique approach of saying only what is necessary. He also has the skill of making difficult concepts easy to understand without compromising accuracy. The material is organized in such a manner that we also learn Java while preparing for the Exam. Because everything is explained from scratch, and there is no hopping from topic to topic, this book is especially suitable for the beginners. Here are some features in the book that I especially liked:
   
   * All concepts are clearly defined and explained by using visuals where necessary. It makes this book self-contained.
   *Tons of code examples explained in the book, which I downloaded from the book website and experimented with them to build confidence.
   * The Exam Quick Prep appendix. I went through this just before the exam to refresh all the important points quickly.
   * Exam's Eye View, Caution, and Notes throughout all chapters, which re-enforced important points.
   * An appendix that provides useful information and analysis for those who are considering updating the J2SE 1.4 certification to J2SE 5.
   If you are a beginner, this is your book. If you are an advanced Java programmer, this book will still take you through the exam without boring you.
   Bottom line: I agree with another reviewer that books like these are hard to find.
   
   "SCJP for Java 5" by Kathy Sierra and Bert Bates.
   This is a good book for advanced Java programmers, but rather over-hyped. If you are planning to buy two books to prepare for the SCJP exam, this is the second book I will recommend. However, this is NOT the book for the beginners. If you do not have intensive Java programming experience, do not use this book as your first book. If you want to use this book, first study Sanghera's book.
   
   "Complete Java 2 Certification" by Phil Heller and Simon Roberts.
   If you want to buy three SCJP for Java 5 study guides, this is the third one I will recommend. It does not do justice with some of the exam objectives. Overall exam coverage is not that great, but you will learn some Java topics.



3. This was the only book I bought and I passed the cert. I found the book to be generally good. I felt a couple of the examples were poor. For instance on page 141 the finding the area of different shapes, a classic example of where one should use polymorphism, the book provides an example of overloading operators. Yes, in the sense the code is "correct" but I find the misuse to be confusing. There are a number of items including some questions in the review exam that are just wrong. That is if you type the code in and run it you don't get what the book claims that you should. These do not seem numerous and I have not found any certification material that is without this sort of problem. The reality of preparing for the test is that if someones answer doesn't make sense you have to test it for yourself. It would be nice if publishers would hire someone to go cut and paste all of the code into a compiler and find this stuff.
   
   More importantly there is not enough material on generics and there is only ONE practice exam.
   
   Having complained I should and that the text is readable and helpful in preparing for the cert. I found it to be a good starting point for my preparations.



4. In the beginning of the year, Java equals "null" to me ( I know C/C++). I decided to learn the language and take the SCJP as a measure of my learning. I tried the Deitel book but didn't like it. Then I started to read the Kathy Sierra book, but they assume you know the basics (not my case). Due to the comments of one of the reviewers, I bought this book and liked it very much. I read it twice, tried all examples, fragments and tests and then went back to the Sierra book, which is more comprehensive (it is a much bigger book), has better explanations of generics and threads and has more tricky questions. I was able to pass the SCJP exam this month thanks to these two very good books.
   I do not give 5 stars due to the presence of several typos and some other minor errors in the text. These errata are not yet in the book site, but as you are studying for the exam, you will spot then when you compile or cross-check with the SUN Java documentation. But these are a small nuisance considering the overall value of the book.



5. your reading this based on my rating '1' stars.
   
   The book starts off good and explains OOP (abit) but the ending chapters which is the important stuff is like a "quick cram", you know, if your buying this book to get your SCJP - well, you need to know java, because in the interview you will be asked questions and your general knowledge of java will only do.
   
   if you know java GREAT - buy it, read it and after a few weeks of 'reading' - take the exam. CONGRATS
   
   BUT -- Please save yr/self the time which is the most important, to click the 'back' button on IE7 and search for a more complete title.
   
   just my input

5 comments about JavaScript: The Definitive Guide.

1. As a nuts and bolts kind of guy, I appreciate the layout and information available in the newest revision of this Book on JavaScript. If you're looking for a tutorial, this isn't it, but if you're looking for a reference manual, this is for you. Very cool book.



2. I just read first few chapters of this book. Good news is that the material is expressed in an accessible manner. However if you have an interest in programming languages and trying to read this book as JavaScript language tutorial or reference things like "lambda functions" (should be "lambda expressions"), or discussions about how (in authors view) JS interreter "inserts semicolums" (it does not. whitespace is used as token separator while parsing) make it look pretty bad.



3. Great book, easy read, well formated and very instrutive. You will find everything that you need about JavaScript (covering standard ECMAScript v3). From the basics to the most advance about the language.



4. This is the book all the JS rockstars out there tend to recommend to people. I don't think it's for everybody personally. It's very thorough and explains JS and its various incarnations at a high level of intricacy that I wouldn't recommend to beginners who are easily distracted (i.e. more heavily creative-brained designers). I'm fairly evenly brained myself and I occasionally found myself zombie-reading as exciting as some of the specifics are too me.
   
   On the other hand, if you want to know just about everything there is to possibly know about JS, this is the book. And that's worth five stars to me.
   
   A good place to get a start with JS if you've never programmed is a decent class or self-teaching the basics online. Then I recommend Jeremy Keith's DOM scripting. Then the Complete Reference. Then this bruiser when you really want get in deep.



5. This book is downright comprehensive and thoroughly deserves its "definitive guide" title.
   
   But, the example scripts the author gives are long and deadly boring, which is why I won't give it five stars.
   
   To "get" JavaScript, you need shorter scripts which are easier to learn from.
   
   My recommendation is to use this book in conjunction with the w3schools website.

5 comments about Schaum's Outline of Programming with Java.

1. The book offers a quick ramp up into Java coding. It chooses to omit many descriptions of graphics classes. The focus is on the pure computational classes. You can get a fast understanding of the core of these classes. Enough to write simple programs. While 1 chapter is about graphics, it is very skimpy and you should not be encouraged to learn from it.
   
   A shortcoming is the lack of exercise sets. Schaum's books are often replete with these. Here, no less than in other topics, exercises are needed. The cover is somewhat misleading. It says fully solved exercises are present. Indeed. But what is also needed are exercises that are NOT fully solved.



2. I would say add the word advanced to the title. I am a beginner and the way Schaum's Outlined Java is for people who already have a knowledge of the basics but I have to say Schaum's books are never bad books. This one is just not titled correctly. Thanks



3. This Schaum's outline really disappoints me. First of all, it doesn't even come close to the typical Schaum's formula - some theory, some worked examples, some exercises with solutions, some additional unsolved exercises. I would expect some deviation from the formula on a Schaum's outline that is about a programming language, but the biggest problem in this outline is the complete absence of programming exercises. It is impossible to know if you understand a programming language if you cannot come up with a program that works yourself. Also, the instruction part of the Schaum's is not detailed enough to really "get" the material. Especially flimsy is any material on event handling in Java. This is tricky material to explain to a Java newbie, but it is essential, since otherwise a user really has no way to interact with a Java program. I suggest if you want to learn Java that you pick up either "Head First Java" or "Core Java", and skip this outline completely. I give it two stars only because, even though I found a few errors in the code here and there, there is nothing really wrong with the facts given or the examples presented, even though they are not helpful to the end task of learning Java.



4. Easy to read, abundance of exercises, starts at a low level and moves on quickly - just what you need to get started in Java. Up to the level I usually experience with Schaum's Outlines...



5. If you are starting in the Java Programming world this could be a great book for you. I found it easy to understand and follow. The examples are mainly done for that. Of course, if you want to go deeper in java Programming you will need other books.

No comments about Java 5: Objects First.

3 comments about Java Methods A&AB, AP Edition.

1. I use this textbook for my Java programming class. The explanations are quite readable, the exercises are interesting and relevant, and the book is overall one of the strongest offerings available. I highly recommend this book.



2. You won't find a better texbook to teach high school computer science. Who uses "Foo Fighters" in an example or talks about throwing away extra coffee cups to explain an inefficiency of the immutability of strings?
   
   This book has every quality I could possibly want to teach either Intro or AP Computer Science in high school. The authors have beautifully achieved a difficult task: to write with an accessible and fun style while keeping the content complete and rigorous enough to prepare students to earn a 5 on the AP exam. The book sets students up for success by exposing them to many concepts in early chapters on object-oriented programming, but not expecting mastery until the detailed chapters on the same topics that come later. The exposure is supported with skeleton code so that students can feel confident about completing projects. When re-visiting a topic later in the book, students are well-prepared to write complex programs from scratch.
   
   There is an abundance of paper and pencil exercises so that students think through their process before jumping to the keyboard. These exercises are particularly prevalent in the chapter on algorithms. (Finally an author that gives this topic at the heart of computer science its deserving coverage!) The exercises and programs are divided into sections of the book making it easy to break down a chapter into teaching days. The code in the PowerPoint slides are laid out and explained so well that you could practically display them without explanation as your only source for lessons. The test questions are varied in style (multiple choice, true/false, and free response) and written in tried-and-true MS Word format. The programming projects are so much fun that I hurt with envy wanting to be a student myself again. A few notable project titles include Dance Studio, Chomp Game, and Instant Messenger.
   
   Reward yourself and your students by purchasing this book.



3. This was an excellent book for going over the basics of the topics covered for the AP test and the questions' difficulty ranged from the fairly prosaic to challenging and the projects could be involving, however, it seemed to pall in comparison to Barron's AP review book when it came to depth and all the intricate technicalities/special-cases governing the Java language which the AP test partially dwells upon for its subset. This book seems to sugarcoat the topics of AB without going into much depth which I found somewhat dismaying when it came to effectively and efficiently studying for the AP test. Otherwise, it gives an effective overview of the individual topics and leaves a basic understanding of the concepts of introductory computer science: for depth and technicalities including java-level implementation(particularly hash tables), I'd look elsewhere.
   
   (I Originally used this but found myself attracted to the more densely-packed information in Barron's AP after about 3 weeks of study in this. I was a student self-studying for the exam and needed a textbook to study the material as no instructor accessible to me taught it. Eventually, I earned a 5, though I credit that more towards Barron's than this.)

3 comments about Java Programming for the Absolute Beginner, Second Edition.

1. This is a book oriented to the complete beginner. It basically starts with a blank sheet of paper and begins with a simple applet that just outputs a single line of text to the screen.
   
   From here he goes on to provide a very simply step by step tutorial to cover the fundamental rules of Java. In this book he doesn't get everything there is to know about Java. It's an introductory book, it covers the bases of the language well enough to get you started. You will probably want an additional book before you become the local master.
   
   If I have one complaint about the book it is one that I complain about a lot on Java books. On page 5 he starts talking about object oriented programming. And he talks on for two or three pages. Then he skips saying anything more about object oriented programming for about 160 pages. By then the reader has completely forgotten about the few pages on page 5.



2. When this book says it is aimed at the absolute beginner it means beginner to programming rather than a programmer with no experience of Java. The book's format of making the topic interesting by gradually building up examples that are games is a good concept but the book does not execute the concept very well.
   
   In practice the book launches into Java and programming in too complex a fashion for the total beginner, there are lots of abbreviations (often not explained) and it discusses terms and concepts that are not explained until a much later and do not need to be introduced this early. It seems odd to be using terms like how many bits a data type has without explaining the term, particularly considering the audience of this book. References to hex and octal are not explained, and as you go into chapter 3 the book covers methods of the random and math class before covering how to use "if" and even what classes are. The flow and structure of this book feels very awkward, covering try/catch and the basics of exception handling very early in the book before the total novice even knows WHAT you are trying to catch and why.
   
   The general jokey examples such as snippets of song lyrics and how to add comments around them, or a fortune teller routine demonstrating random numbers that print text such as "You will talk to someone who has bad breath" seem aimed more at attracting kids that want to write simple games on their home computers rather than someone who wants to learn Java and computer programming for professional reasons. If you are serious about learning Java, try the latest editions of either "Head First Java" or "Core Java" and skip this book. If you have never programmed at all, first try "Sams Teach Yourself Beginning Programming in 24 Hours". The Sam's Teach Yourself series can be rather hit-or-miss, but that particular book is definitely a hit.
   
   Since Amazon omits the table of contents I show that next:
   1. Getting Started
   2. Variables, Data Types, and Simple I/O
   3. The Fortune Teller: Random Numbers, Conditionals, and Arrays
   4. The Number Guesser: Using Loops and Exception Handling
   5. Blackjack: Object Oriented Programming
   6. Making Your Life Easier: The java.util Package and Generics
   7. Learning to Read and Write: The java.io Package
   8. Creating a GUI Using the Abstract Windowing Toolkit
   9. Advanced GUI, Layout Managers, and Event Handling
   10. Writing Applets
   11. Rendering 2D Graphics
   12. Animation, Sounds, and Threads
   13. Putting it All Together: The Block Game



3. This book helped me get my foot in the door for Java programming. Before this book, I was getting "stonewalled" trying to get started into Java programming. This book is aimed at people who want to start computer programming and is making Java their first language. May not be adaquate for experienced programmers who want to learn Java and already know programming conventions.