Global Shopping Center
UK | Germany
Home - Books - Computers & Internet - Authors, A-Z - Flanagan, David Help

1-14 of 14       1

  • Flanagan, David
  • click price to see details     click image to enlarge     click link to go to the store

    $29.67 $27.11 list($44.95)
    1. Java In A Nutshell, 5th Edition
    $26.37 $24.73 list($39.95)
    2. Java Examples in a Nutshell, 3rd
    $26.37 $19.99 list($39.95)
    3. Java Enterprise in a Nutshell
    $29.67 $27.60 list($44.95)
    4. JavaScript: The Definitive Guide
    $26.37 $24.50 list($39.95)
    5. Java in a Nutshell, Fourth Edition
    $8.96 $5.98 list($9.95)
    6. JavaScript Pocket Reference (2nd
    $20.37 $14.99 list($29.95)
    7. Java 1.5 Tiger : A Developer's
    $19.77 $4.44 list($29.95)
    8. Java Foundation Classes in A Nutshell
    $0.99 list($29.95)
    9. Java Examples in a Nutshell, 2nd
    $13.19 list($29.95)
    10. Java in a Nutshell : A Desktop
    $65.50 list($99.95)
    11. Limited Edition Java Library Set
    12. Java Power Reference: A Complete
    13. Enterprise Storage 2001 : From
    14. Java in a Nutshell (In a Nutshell

    1. Java In A Nutshell, 5th Edition
    by David Flanagan
    list price: $44.95
    our price: $29.67
    (price subject to change: see help)
    Asin: 0596007736
    Catlog: Book (2005-03-15)
    Publisher: O'Reilly
    Sales Rank: 1525
    Average Customer Review: 4.0 out of 5 stars
    US | Canada | United Kingdom | Germany | France | Japan

    Book Description

    With more than 700,000 copies sold to date, Java in a Nutshell from O'Reilly is clearly the favorite resource amongst the legion of developers and programmers using Java technology.And now, with the release of the 5.0 version of Java, O'Reilly has given the book that defined the "in a Nutshell" category another impressive tune-up.

    In this latest revision, readers will find Java in a Nutshell, 5th Edition does more than just cover the extensive changes implicit in 5.0, the newest version of Java.It's undergone a complete makeover--in scope, size, and type of coverage--in order to more closely meet the needs of the modern Java programmer.

    To wit, Java in a Nutshell, 5th Edition now places less emphasis on coming to Java from C and C++, and adds more discussion on tools and frameworks.It also offers new code examples to illustrate the working of APIs, and, of course, extensive coverage of Java 5.0.But faithful readers take comfort: it still hasn't lost any of its core elements that made it such a classic to begin with.

    This handy reference gets right to the heart of the program with an accelerated introduction to the Java programming language and its key APIs--ideal for developers wishing to start writing code right away.And, as was the case in previous editions, Java in a Nutshell, 5th Edition is once again chock-full of poignant tips, techniques, examples, and practical advice.

    For as long as Java has existed, Java in a Nutshell has helped developers maximize the capabilities of the program's newest versions.And this latest edition is no different. ... Read more

    Reviews (5)

    5-0 out of 5 stars There are some things you can count on in life...
    ... and a solid "Java in a Nutshell" is one of them. What can I say? I started with v1.1 and have bought every version up to v5.0.
    I can relate to the main complaint of the other reviews: the book'ssize. I agree that the second half of the book parrots the JavaDoc, but it is somewhat different and helpful, especially if you've grown used to looking through it to find stuff.
    I don't know what the answer is. Hey, I have an idea: blame Sun, not David. At the risk of getting flamed and/or flack, I have oftentimes thought that the Java language is just growing out of control. Some might argue that we need all of this stuff. Perhaps that is true, but is it really worth the hit that each and every developer takes every time they try to find something is this vast ocean of APIs?
    Ahh, remember the good old days of K&R "C"?

    4-0 out of 5 stars good sign of Java's vitality
    Recently, Sun gave us a significant upgrade to Java - the release of Java 5. A slew of the inevitable bug fixes. But also key new features, as explained here by Flanagan in the 5th edition of his long running reference.

    Some new abilities lead to notational simplification, like autoboxing. So if k is an Integer, you can now say "k=5" instead of the clumsier "k=new Integer(5)". With a similar inverse process if q is an int, of being able to write "q=k" rather than "q=k.intValue()". Though of course the older forms are still valid, for backward compatibility.

    Hey, varargs are now allowed! Much to the pleasure of some of you who came from C programming and used this nice feature. Ever since Java came out, there has been a continual, albeit quiet, push for varargs. Finally!

    By now, experienced Java programmers may be familiar with earlier versions of the book. There may be mild astonishment at the sheer heft of this edition. Thanks to its popularity, Java has bulked up in the number and scope of its classes. The book is a reassuring sign of Java's vitality.

    4-0 out of 5 stars Still a must-have classic, but it's getting rather large...
    Here's a classic that just keeps on keep up with the state of the language...Java In A Nutshell (5th Edition) by David Flanagan (O'Reilly).But it's definitely getting pretty large...

    Rather than list the chapters like I usually do, I'll forego that this time in that I'll probably overrun the Amazon word limit.Suffice it to say that if it's a core part of the Java language as of version 5.0, it's probably in here...

    The good stuff...Flanagan has once again done an outstanding job in providing a succinct reference manual that covers the latest version of the Java language.He's added a new chapter to cover Java 5.0 features such as generic types, enumerated types, and annotations.There is also coverage of some new features in chapter 2, such as autoboxing and the new for/in statement.This coverage method (most of the new stuff in one area) means that readers who are upgrading their copy can easily flag the new material they need to read.And rather than keep a lot of older material floating around, he's also eliminated some language features that are either deprecated or are not widely used.Granted, if *you* are one of the few using it, that's not good, but you have to draw a line somewhere.Other than that, it's the same solid, no-fluff coverage of the Java language in the first 400 pages that you've come to expect in this Nutshell volume.The reminder of the 1200+ pages covers Java API documentation, which is useful if you're looking for a particular method or property you're not familiar with.

    The bad part is probably the page count...Although the print is small and the information is packed tightly, 1200 pages still makes for a pretty thick book.Some will make the argument that you can get the last 800 pages (the API documentation) on-line, which is true.I tend to prefer having pages I can flip through without having to do a lot of hyperlinking.Plus you can jot down notes or flag certain parts you reference quite often.I'm almost of the opinion that perhaps it's now time to split the book into Java In A Nutshell - volumes 1 and 2.Put the API info in a second volume and make it easier to work with...

    I still think this is a "must have" book for any Java programmer...It just may be time to take a hard look at the packaging for the 6th edition.

    4-0 out of 5 stars What size nutshell?!
    I agree with the review above.It's a great book but the part II API Quick Reference is too much to be included.If they were split and available for purchase separately, you would have a much better product.That said, Part I is really good!

    3-0 out of 5 stars A bit much...
    As far as the information inside the book goes, it's a great book that describes the basics of Java in a simple, here's what you need to know format.It describes everything you need to know about Java syntax, objects, etc, etc, etc.The big reason to get this is for the Java 5.0 info, which is scattered throughout Chapter 2.There is also Chapter 4, which goes into more detail on some of the more interesting features of Java 5.0.

    However, the bulk of the 1200+ pages are essentially the javadoc, with some additional notes.In thumbing around and looking at random class descriptions, I didn't see anything I couldn't get from the javadoc.This is obviously a personal preference - if you like the hardcopy, it might work for you.It just seems like a waste to me.

    I would have been much happier with the first 400 pages and a note on page 401 that said "buy another book if you need the apis" or "go read the javadoc".A 400 page Nutshell book I can throw in the backpack, thumb through, and carry around.A 1200 page Nutshell (like Java 5.0 for that matter) seems to be suffering from a bit of unnecessary bloat. ... Read more

    2. Java Examples in a Nutshell, 3rd Edition
    by David Flanagan
    list price: $39.95
    our price: $26.37
    (price subject to change: see help)
    Asin: 0596006209
    Catlog: Book (2004-01-01)
    Publisher: O'Reilly
    Sales Rank: 31710
    Average Customer Review: 4.75 out of 5 stars
    US | Canada | United Kingdom | Germany | France | Japan

    Reviews (4)

    5-0 out of 5 stars Excellant
    This is an excellent book covering Java 1.4 with practical examples. The book is divided into four parts: Learning Java, Core Java APIs, Desktop Java APIs, and Enterprise Java APIs. The book is very succinct and to right to the point with its examples. Each chapter starts off with a one to three page introduction of the topic, before heading into the examples. Each chapter introduction gives a high-level overview and history of the need for that API.

    The examples are well written and complete. You don't have to search back for prior examples to understand the code. Before each example is an explanation of what the example is trying to do and the concepts it will demonstrate. The comments in the code fully explain why the author is doing something or choosing a particular API method. This book is good for someone who understands the language, but is trying to learn some new APIs. One of the best chapters is the chapter on threads, because it has just about everything you would need to understand about threads to use Java.

    This book is a valuable reference. I am sure that I could use this book to understand an API that I have never used before (2D graphics, javax.sound, etc.) by just reading the examples and explanations that accompany them.

    5-0 out of 5 stars A must-have for any beginning or experienced programmer
    Now in a newly updated and expanded third edition, Java Examples In A Nutshell is a 720 page instructional compendium by Java expert David Flanagan expertly covers Java 2 Version 1.4, and the tutorial companion to "Java In A Nutshell." Featuring 193 complete examples with practical applications, over 21,900 lines of thoroughly commented, professionally written code, new chapters on the Java Sound API and New I/O API, and much more, Java Examples In A Nutshell is a must-have for any beginning or experienced programmer seeking to learn by doing and hone their skills for adapting to any given programming task. As a tutorial companion, "Java Examples In A Nutshell" does not focus on excessive explanation but rather direct learning through experience; both "Java Examples In A Nutshell" and the more pedantic "Java In A Nutshell" are highly recommended.

    4-0 out of 5 stars Great for core Java API - J2EE section weak
    In this 3rd edition, author David Flanagan has updated the book with coverage of Java 1.4. In keeping with the tradition of the other nutshell books, this book is an instant must-have book. This book is divided into 4 sections. The first section is a short yet very nice Java and OO tutorial. This book is not meant to replace your regular tutorial book, but can certainly act as that for someone who already knows the basics and is trying to bone up on the language API and usage.

    The second section of the book covers the core Java API, including I/O, NIO, threads, networking, security and cryptography, serialization, and reflection. This section of the book is really solid and includes great working and commented examples of most of the core set of Java API. I really liked the network section as it includes code that will fulfill most of your needs in terms of network related development.

    The third section of the book deals with graphics and user-interface including Swing, Java 2D graphics, preferences, printing, drag-and-drop, JavaBeans, applets, and sound. Not being much of a UI guy, I glossed over most of this section but it seemed complete and comprehensive. I know where I am going to turn if I ever need to work with Swing or applets.

    The last section of the book includes coverage of the server-side Java or J2EE development, including JDBC, JAXP (XML parsing and transformation), Servlets 2.4, JSP 2.0, and RMI. Being a back-end or server side developer, I spent a lot of time consuming this section and I was very impressed with the quality of the coverage, explanation and examples included in this section. The section starts off with a nice introduction to JDBC, database metadata and includes some nice examples configurable example that are ready for use with little or no modifications. I think that's important to new developers that are getting familiar with an API. In reading the code, it was nice to see the author using the execute() method instead of executeUpdate() or executeQuery() method along with a simple explanation of why he is doing that. Sounds simple, but I can't tell you the number of times junior developers have come to me and asked me about this exact topic.

    After JDBC, the book jumps into XML with a nice intro to SAX, DOM, and XSLT. Not a lot of meat here, but XML is always a moving target in terms of the API. I wish this section had a little more to it as it is missing the whole idea of Java-XML data binding which is a useful topic. After XML, the book moves over to Servlets and JSP. Nice intro to servlets and JSP, but leaves you wanting more. I think the whole server-side Java just needs to be another book and I think David should just come up with a Java Enterprise Examples in a nutshell. O'Reilly already has some great books in this category including the Java Servlet and JSP cookbook.

    Having said all that, I still really like this book for how it deals with the core API. This book contains 193 complete, documented examples which makes it a must for any junior developer that knows or is learning Java and wants to know how to apply the API. The examples from this book are available for download from the author's website located at davidflanagan dot com.

    5-0 out of 5 stars A must-buy book for your Java library
    Target Audience
    Java developers who are looking for working examples of code that illustrate specific concepts.

    This book is a companion volume to the Java/Java Enterprise/Java Foundation Classes In A Nutshell books. It provides code examples for many of the classes used in those books.

    The book contains the following chapters:

    Part 1 - Learning Java - Java Basics; Objects, Classes, and Interfaces

    Part 2 - Core Java APIs - Input/Output; Threads; Networking; New I/O; Security And Crytography; Internationalization; Reflection; Object Serialization

    Part 3 - Desktop Java APIs - Graphical User Interfaces; Graphics; Printing; Data Transfer; JavaBeans; Applets; Sound

    Part 4 - Enterprise Java APIs - Database Access With SQL; XML; Servlets and JavaServer Pages; Remote Method Invocation; Example Index

    Often when you are learning Java or exploring a new aspect of the language, it's difficult to make the bridge from the raw documentation to working code. The O'Reilly "Examples In A Nutshell" series is designed to make that transition from theoretical to practical, and David Flanagan's Java Examples In A Nutshell is no exception. It should be an essential part of your personal library if you are a Java professional.

    Rather than spend time teaching the reader a particular class, the book assumes that you have one of the other Java Nutshell books for all the details of the class. In this volume, Flanagan jumps right into complete, well-documented examples of code that use those classes, thereby giving you a feel for how they work. Because he documents his code better than most of us do, there isn't that waste of time trying to figure out what the coder intended. The examples are easy to follow, and they are definitely helpful when you are working through the details of an unfamiliar class or concept. I often find myself looking through the chapters when I'm coding just to get a glance at how someone else would code a solution. It's almost like having a partner to bounce ideas off of.

    In this latest edition, the author covers some of the new features in Java 1.4 like the New I/O and Sound APIs. Personally, I probably wouldn't do much with the sound code, but the New I/O section will be useful. He also covers the regular expression features which are new in the New I/O API. While I would also want documentation on regular expressions since I'm not a Perl expert, these examples will help me when I get to the point I need to use them.

    Quite simply, this should be a "must buy" for your Java library. This book bridges the gap between reference material and your actual coding better than any other book of its kind. ... Read more

    3. Java Enterprise in a Nutshell (2nd Edition)
    by David Flanagan, Jim Farley, William Crawford
    list price: $39.95
    our price: $26.37
    (price subject to change: see help)
    Asin: 0596001525
    Catlog: Book (2002-04)
    Publisher: O'Reilly & Associates
    Sales Rank: 37709
    Average Customer Review: 4.24 out of 5 stars
    US | Canada | United Kingdom | Germany | France | Japan

    For the intermediate to advanced Java developer, Java Enterprise in a Nutshell shows how to work with all of today's relevant Java APIs. Plus, it's a topnotch reference for all enterprise classes. Part tutorial and part reference work that you can use everyday at your desk, this title is a worthwhile resource for any Java developer building Web or enterprise software.

    The practical, succinct focus here on actual Java enterprise APIs helps distinguish this text from the pack. Early sections provide short, clear examples along with just enough background to help you use APIs like JDBC, servlets and JSPs, EJBs, and others. Coverage of Java's ability to interface with legacy CORBA systems is just excellent, with a full tour of Java IDL, CORBA services, and Remote Method Invocation (RMI). Typically, readers will be familiar with some J2EE APIs and not others. This book can help fill in the gaps.

    Updated with the latest standards from Sun, including JDBC 3.0, Servlet 2.3, and EJB 2.0, this is an essential primer for today's high-end (and high-paying) Java. The basic presentation of servlets/JSP and EJBs (among the most important APIs for current Java Web development) is concise and nicely digestible. We also liked the chapter on JMS for messaging (also a hotbed of Java job activity).

    The second half of this text lists every J2EE class, along with methods and properties, in a very valuable reference section that makes good use of two-toned shading for easy access. Entries are organized by package name. (One small oversight here is that an index of cross-listed packages, classes, and methods omits page numbers.)

    Overall, this book is truly indispensable for any working Java programmer. The second edition of Java Enterprise in a Nutshell is a fully up-to-date tutorial and reference that lives up to the standards of O'Reilly’s Nutshell series. Both thorough and concise, it's a handy resource for anyone who works with the hundreds and thousands of Java enterprise APIs on a regular basis. --Richard Dragan

    Topics covered: Introduction to enterprise computing with the Java 2 Enterprise Edition (J2EE), survey of Java enterprise APIs, JDBC 3.0 (including database connections, ResultSets, prepared statements, BLOB fields, transaction support, stored procedures), the JDBC Optional Package (and connection pooling), Remote Method Invocation (RMI) described (building stubs and skeletons, dynamically loaded classes and remote object activation, RMI over IIOP), in-depth tutorial for Java IDL (with CORBA) and designing remote objects, Java Servlet 2.3 APIs (basic servlet processing and the servlet lifecycle, chaining and filters, thread safety, managing state, cookies, servlets used with JDBC), JavaServer Pages (JSP): including custom tags, JNDI and directory tutorial (contexts, looking up objects, accessing and modifying directory entries), Enterprise Java Beans (EJB) 2.0 (conventions for entity, session and message beans, using transactions), Java XML APIs (DOM, SAX and XSLT), Java Message Service (JMS), point-to-point and publish-subscribe messaging models, message selectors, JavaMail, reference to SQL and relational databases, RMI tools, reference to all IDL keywords, data types and declarations; CORBA services, Java IDL tool reference, Enterprise JavaBeans Query Language (EJB QL) 2.0 query language, and an alphabetical listing of all APIs for Java enterprise programming (listing of classes, methods, and properties). ... Read more

    Reviews (17)

    4-0 out of 5 stars Good quick reference for intermediate-level Java developers
    "Java Enterprise in a Nutshell" is a good quick reference guide to the entire J2EE platform for intermediate-level Java developers, and the 2nd Edition seems very up-to-date with J2EE 1.3. The book is a lot larger than other 'in a nutshell' books, mainly because there is such a huge amount of information to be covered for the J2EE platform. It is divided into two main sections - the "Introduction" section, which gives an overview of all the major J2EE technologies, and the API-reference, which I found to just be a rehash of what is in the online Javadoc API. The Introduction it easy to understand and straight-to-the-point for the intermediate Java developer, giving good examples of how to use the technologies. I found it to be a good guide to quickly learn some of the technologies I was not very familiar with. (but needed to use right away...) I did not use the API reference, but it could be useful for understanding the basic purposes of each package and class. It does not go into the method-by-method detail that the online Javadoc has.

    5-0 out of 5 stars A Good Quick Reference
    The book "Java Enterprise in a Nutshell" is a dense overview of some of the packages in J2EE. The book has three parts: An introduction, an enterprise reference and an API reference. The introduction describes each package, gives some examples and pointers for further readings. The second part contains reference material on SQL, RMI Tools, IDL and IDL tools and CORBA Services. The API reference lists the complete API of the packages covered by this book.

    This text is very well written and does an exceptional job in describing the J2EE packages JDBC, RMI, JNDI as well Servelets, EJB and the Java IDL. The chapters are well structured and very clearly written. And they achieve their goal without filling hundreds of pages. Very good.

    Unfortunately the book does not cover all of today's packages of J2EE but I guess that's the price to pay if the book has to be on the market early enough.

    The book has some holes, but for the material it covers, it is one of the best, if not the best, books available.

    4-0 out of 5 stars Very good reference book
    Another large and impressive manual to add to your collection. This title is meant to be the third volume of a three-volume set that covers the entire language. Volume one covers the basic core Java APIs, while volume two covers the foundation classes.

    Of the three volumes that make up this Nutshell series, this is the one that you'll be able to bypass if you're just moving into the world of Java. I think that even experienced programmers might end up heavily using some chapters while never touching others. The format is the same as other Nutshell volumes, where there is a lot of detail with not a lot of fluffy explanation.

    Each of the Part 1 chapters give a quick overview and tutorial as to what the technology is (such as JavaServer Pages) and how it works. There are some examples of code to help you understand how it works. But the authors acknowledge that they do not expect you to be an expert after reading that chapter. You have to either already know what's going on or seek out another book to more fully learn and understand what is going on. O'Reilly has a vast array of books that go into each of these subjects in a more detailed manner.

    For Notes/Domino 5 developers, I would say that there is little in this book that would be of value to you. You might be interested in JDBC as a replacement/supplement to ODBC. The XML chapter with information on parsers might also be of interest. Moving into the Notes/Domino 6 world, more of the book becomes valuable. Those chapters would include the information on servlets and JavaServer Pages. As Notes/Domino becomes more tightly integrated with Websphere, you'll need to start understanding servlets and how they function. This book could be a good tool to help you build them.

    If you're an advanced Java developer and are working on enterprise Java applications, get this book. If you're a Notes/Domino developer looking to move into servlets, JavaServer Pages, and XML, you should also get this book. If you don't fit into either of these categories, you probably won't do much with this volume.

    4-0 out of 5 stars Great for Overview!
    First of All, this book does not cover everything about J2EE,but it has many of the significant things related to J2EE (such as CORBA,IIOP).

    In my opinion,this book is very suitable for any person who need to have a J2EE overview/introduction.And also suit for J2EE developer who need the good references rather than print all J2EE API.

    I recommend you to put it on the bookshelf!...

    4-0 out of 5 stars Not as deep as some, but great value for money
    One of the seemingly endless "in a Nutshell" series from O'Reilly, this book follows the basic series format. A few chapters of concise introduction followed by a detailed, if compressed, API reference. In this case the book covers a lot of ground - all the Java APIs which form part of the Java 2 Enterprise Edition: JDBC, RMI, CORBA, JNDI, Servlets, EJB as well as some material on JMS. Check which edition you get as the information dates quickly, though.

    I was worried when I bought this book that they were attempting to cover too much, but I think they have done a remarkable job. This book really is the most readable introduction to J2EE I have found so far. It's just about small enough to carry about (unlike the massive Wrox tomes), and the API reference can help to keep it useful after you've absorbed the introductory material. It even has a basic SQL reference, which you don't get in some JDBC books! ... Read more

    4. JavaScript: The Definitive Guide
    by David Flanagan
    list price: $44.95
    our price: $29.67
    (price subject to change: see help)
    Asin: 0596000480
    Catlog: Book (2001-12-15)
    Publisher: O'Reilly
    Sales Rank: 3868
    Average Customer Review: 4.31 out of 5 stars
    US | Canada | United Kingdom | Germany | France | Japan

    Since the earliest days of Internet scripting, Web developers have considered JavaScript: The Definitive Guide an essential resource. David Flanagan's approach, which combines tutorials and examples with easy-to-use syntax guides and object references, suits the typical programmer's requirements nicely. The brand-new fourth edition of Flanagan's "Rhino Book" includes coverage of JavaScript 1.5, JScript 5.5, ECMAScript 3, and the Document Object Model (DOM) Level 2 standard from the World Wide Web Consortium (W3C). Interestingly, the author has shifted away from specifying--as he did in earlier editions--what browsers support each bit of the language. Rather than say Netscape 3.0 supports the Image object while Internet Explorer 3.0 does not, he specifies that JavaScript 1.1 and JScript 3.0 support Image. More usefully, he specifies the contents of independent standards like ECMAScript, which encourages scripters to write applications for these standards and browser vendors to support them. As Flanagan says, JavaScript and its related subjects are very complex in their pure forms. It's impossible to keep track of the differences among half a dozen vendors' generally similar implementations. Nonetheless, a lot of examples make reference to specific browsers' capabilities.

    Though he does not cover server-side APIs, Flanagan has chosen to separate coverage of core JavaScript (all the keywords, general syntax, and utility objects like Array) from coverage of client-side JavaScript (which includes objects, like History and Event, that have to do with Web browsers and users' interactions with them. This approach makes this book useful to people using JavaScript for applications other than Web pages. By the way, the other classic JavaScript text--Danny Goodman's JavaScript Bible--isn't as current as this book, but it's still a fantastic (and perhaps somewhat more novice-friendly) guide to the JavaScript language and its capabilities. --David Wall

    Topics covered: The JavaScript language (version 1.0 through version 1.5) and its relatives, JScript and ECMAScript, as well as the W3C DOM standards they're often used to manipulate. Tutorial sections show how to program in JavaScript, while reference sections summarize syntax and options while providing copious code examples. ... Read more

    Reviews (191)

    5-0 out of 5 stars Excellent reference, not a "how to" book
    I have yet to meet an O'Reilly book I didn't like, and this is no exception. As an instructor I am always looking for good reference texts and O'Reilly publishes some of the finest computer references available on the planet. They are NOT, however, "how to" books that most beginners will find useful.

    Once you have grasped the basics of JavaScript and can tell the difference between a function, a method, and an event handler, THEN buy this book! Until then, stick with references from PeachPit Press, or the Dummies Guides. They will help you get started with a much lower frustration factor. O'Reilly texts assume some working knowledge of how computers work, and Javascript: The Definitive Guide will be much easier for you once you have an understanding of basic programming concepts and theory.

    The Third Edition of Javascript: The Definitive Guide has several improvements over the Second Edition. For example, the reference pages include the availability of each command described (i.e. is it JavaScript 1.0, 1.1, 1.2 and which version of Netscape or MSIE will it work in). That aspect alone makes it worth every penny because it will save you HOURS of time when trying to write cross-browser friendly code.

    Chapter 1 also contains some excellent background information about the history of JavaScript, dispels a few myths, provides an overview of client-side features and addresses security issues. (Not many texts even bother to mention that there ARE security issues when using JavaScript!)

    Highly, HIGHLY recommended for intermediate to advanced JavaScript developers, or anyone who is already familiar with object oriented programming and wants to add JavaScript to their tool kit.


    5-0 out of 5 stars THE Javascript Reference!
    I can't imagine any serious Javascript developer not having this book in his or her collection. It is the most complete reference I have seen on Javascript, and one of the most professionally written books period.

    Where I work, the book is near ubiquitous among our web developers and has proven to be a valuable desk-side resource. I recently bought the 4th edition, after some of my coworkers commented on how worn my 3rd edition had become. No surprise, really, considering that I had to share the 3rd edition among six developers, all of whom were learning Javascript for the first time. I'm glad to once again have a nice, fresh copy of this book, and even more so, glad to have an updated reference with coverage of the new features in Javascript 1.5.

    I'm pleased to say that the 4th edition lives up to the reputation of its predecessor. Reading is easy and informative, and the reference section provides answers to just about any question you'd have regarding the language syntax and object model.

    If you're a web developer and have no other books in your collection, make sure you have this one.

    5-0 out of 5 stars Best reference on JavaScript I have ever seen
    I have read many books on JavaScript before but this is by far the most comprehansive guide to the scripting language. This book is not for beginners.
    I use it as a reference guide. If you know the object's name or the method's name on either client side or server side, you can just look it up in this book's index section and it will reference you to a particular page with detailed explonations and more often then not with examples.
    Absolutely love this book

    5-0 out of 5 stars Must have for learning and reference
    As a long time C++ programmer, I found this book to be neither too hard or too easy. Readers with no programming experience at all might have a harder time with the text, but if you have any kind of programming background, the text will serve you well. As a reference, the text is second to none. Even the DOM reference is one of the best out there.

    3-0 out of 5 stars Decent Definitive Guide
    This a very decent reference and so-so tutorial of JavaScript. If you're doing JavaScript you definitely need this definitive guide, definitely. ... Read more

    5. Java in a Nutshell, Fourth Edition
    by David Flanagan
    list price: $39.95
    our price: $26.37
    (price subject to change: see help)
    Asin: 0596002831
    Catlog: Book (2002-03)
    Publisher: O'Reilly
    Sales Rank: 19017
    Average Customer Review: 3.2 out of 5 stars
    US | Canada | United Kingdom | Germany | France | Japan

    Book Description

    The new 1.4 release of Java 2 Standard edition increases the size of the platform by 50%, to 2757 classes in 135 packages., so aall of these exciting new features, the 1.4 release of Java 2 Standard editionbrings potential for frustration. How will all this affect your applications? Don't worry, our new 4th edition has answers. With the accelerated introduction to the Java programming language and its key APIs, you can start writing code right away, and because its classic quick reference contains all the classes in the essential Java packages, you'll find exactly what you need to make the new version work for you.With more than 250 new pages, the book brings you up to speed on new APIs for high-performance low-level I/O, logging, user preference, and user authentication with the JAAS. You'll also find information on the new Collections classes, support for XML parsing using both the DOM and SAX APIs, support for pattern matching with regular expressions, and much much more. For as long as Java developers have existed, this perennial bestseller has been there to take you to the heart of the program. ... Read more

    Reviews (25)

    5-0 out of 5 stars Simply the BEST
    This book is aimed at those who either already know Java or want to learn it in an efficient manner.

    Some learn best from a book where the author jokes around and has all the info spread out, and slowly brings you up to speed, covering a topic, and then going back to cover it later in greater detail. The reference section would be integrated into the text in the appropriate places. If that's what you are looking for, this book is NOT for you.

    For those with a previous programming background wanting a no-nonsense way to quickly learn how to program in Java, this book is EXCELLENT. There are no wasted words. The author gets down to the point and writes clearly. Each topic is covered in detail as it is presented. It is very possible to learn Java with this book and Java Examples in a Nutshell (I did it and I had no object oriented programming background, just assembly, C, and Basic). You'll also want Java Foundation Classes in a Nutshell (for AWT and Swing classes and methods).

    There is a great index at the back. By its thickness and detail it is obvious that a lot of time was spent here. There is a separate index from the regular text index for listing the packages, classes, and methods. If you don't know what class a method belongs to, you can quickly find it here. I find the index section to be one of the best features of the book and quite useable.

    The second half of the book is the class reference. This information can be found online, but the benefits of having it in book form are many: I can write in the margins, I'm not constantly flipping back and forth between windows, I don't have to worry about the format changing, an frankly, the information is presented in a much more understandable way than the way Java decided to put it on their website.

    About the reference: You wont find anything about AWT or Swing, they are in Java Foundation Classes in a Nutshell. Some reviewers have claimed there are no printed tabs in the 4th edition. This is false. There are gray/black tabs printed along the edges. My only gripe here is lack of printing on the book edge of what the tabs are, but I wrote that on the edge with a pen. At the beginning of each package a class hierarchy is presented. This is invaluable, especially for the package (if you ever got lost with all the Reader and InputStream combinations this is a godsend.) In addition, the major classes will have a nice graphical chart so you can trace them back to Object. Each object has a full method list, with version numbers for those methods appearing after Java 1.0. It should be emphasized that this method list is presented in a very easy to read and visually clean format. Properties will have the default value printed. A summary of how to use most of the methods is presented before the method list. Usually this gives enough info to understand on its own, but some methods are not summarized. These summaries should be expanded in future editions to cover each method, and in greater detail. At the end of each object additional information is given about what other objects use the object, or return it. Also, there is no reason the class hierarchies can't be put at the top of every class.

    One thing missing from the reference section is example code for each class. However, I can't think of a way this can be added without turning the book into an encyclopedia set. It's already very thick as it is.

    I am very happy with this book. I recommend it to everyone I know as THE Java book to own. Don't take a Java class without it. I was the envy of my class, writing programs with ease. Others rewrote standard classes from scratch because they didn't know where to find them.

    5 out of 5.

    2-0 out of 5 stars Ruined a great reference
    The java in a nutshell series was the most often used book in my arsenal off reference books. That was until now. Many of the most useful features of the previous three editions have been removed.

    First the "tabs" printed on the edge of the book which would help you quickly find a package are now gone... so now I have to flip through MANY pages just tho find tha package I want...

    From there I now have to find the class I am looking for, but the are not necessarily listed alphabetically anymore either. For example java.util.prefs.Preferences is on page 710, and java.util.Set on 677... ordered by package, leaving you with more to page through. Not exactly intuitive.

    And the package heirarchy diagrams are gone now as well.

    Its a reference book, but certinaly not a "quick" reference. I highly reccomend buying the third edition, but stay away from this one, at least untill they put the tabs back!

    4-0 out of 5 stars Best guide for the working programmer
    This isn't a textbook. It's a handbook, and gives good, clear descriptions of every corner of the Java language. Java isn't a big feature-sodden language, but has a few obscure corners. If you just can't remember the syntax for up-reference from an inner class, you'll find it fast and explained well.

    The API guide is fairly complete, but terse. Well, it has to be - the API keep growing. No one book could hold a complete description of everything. Sad to say, earlier editions had more complete API descriptions. The second, for example, had a very good introduction to reflection. As the Java API grew, however, the old descriptions had to shrink to make way for the new, and the reflection discussion was squeezed out. Still, it gives a good quick look at the API. This isn't as complete as the Javadoc API information, but is hugely more browseable. Use this to direct your query into the right area, then use Sun's Javadoc to get the details.

    If you have room for only one Java book, make it this one.

    5-0 out of 5 stars I love my nutshell
    I keep this book by my side and reference it at least twice a week. An integral part of my Java programmer's desktop library.

    5-0 out of 5 stars A classic reference needed by all Java developers...
    This is a LARGE nutshell! This title is meant to be one volume of a three volume set that covers the entire language. Volume two covers the foundation classes, while volume three covers the enterprise classes.

    If you're just starting out with Java and you're trying to learn the language, this isn't the book for you. While Part 1 could be used as instructional material, it is truly "no fluff". It's best suited for an experienced object-oriented programmer making the leap to Java, or a Java programmer looking for a concise review. A good learning book would be "Learning Java" by Pat Neimeyer and Jonathan Knudsen from O'Reilly.

    The really valuable part of this book is Part 2. Each chapter defines the classes in that package with an explanation on what it does and how it works. There's a diagram that shows the class hierarchy from the root Object class, as well as what version of Java supports that class. This is then followed by all the constructors and methods used in the class. Don't expect detailed explanations on these methods. As a nutshell book, you get all the basic info on what's available, but you'll need to experiment with some of the methods before you understand them.

    A legitimate question might be... Why get this book if I have the online API documentation from Sun? I see them as complimentary. You can probably find much of the reference material in either source. Some will prefer the online hyperlink navigation, while others will appreciate having all the information on a subject in four or five pages that can be thumbed through. I know when I'm stuck on a problem I want both sources!

    For a Notes/Domino developer, it is somewhat similar to using online Notes help versus the manuals. In that case, the material is identical, so it's more your preference in how you like to look up information. In the case of this book versus the Java API documentation, you'll get good information from both sources, so you should avail yourself of both.

    If you've completed something like Teach Yourself Java In 21 Days and now you have to DO something with Java, you owe it to yourself to get this book. This will be one title you'll go back to again and again as you explore the wild, wild world of Java. ... Read more

    6. JavaScript Pocket Reference (2nd Edition)
    by David Flanagan
    list price: $9.95
    our price: $8.96
    (price subject to change: see help)
    Asin: 0596004117
    Catlog: Book (2002-10-29)
    Publisher: O'Reilly
    Sales Rank: 33045
    Average Customer Review: 3.69 out of 5 stars
    US | Canada | United Kingdom | Germany | France | Japan

    Book Description

    JavaScript--the powerful, object-based scripting language that can be embedded directly into HTML pages--has earned its place in the web developer's toolkit, to the extent that it's now considered required knowledge for web developers.You can use JavaScript to create dynamic, interactive applications that run completely within a web browser.JavaScript is also the language of choice for developing Dynamic HTML content.The JavaScript Pocket Reference, 2nd Edition provides a complete overview of the core JavaScript language and client-side scripting environment, as well as quick-reference material on core and client-side objects, methods, and properties.The new edition has been revised to cover JavaScript 1.5, and is particularly useful for developers working with the latest standards-compliant web browsers, such as Internet Explorer 6, Netscape 7, and Mozilla.Ideal as an introduction for beginners and a quick reference for advanced developers, this pocket-sized book is easy to take anywhere and serves as the perfect companion volume to the bestselling JavaScript: The Definitive Guide, 4th Edition. ... Read more

    Reviews (13)

    3-0 out of 5 stars Not Complete - But Not Useless
    Luckily I already had a solid handle on the basics of JavaScript before reading this book, because otherwise I'd be lost. One of the things every beginner programmer books needs is real-word examples of code with an explanation for almost EVERY line containing something new.

    It sounds excessive, but if you want to learn something, that's how it works. This book, for example, seems to have devoted half a page to the built in Date() function - which is ridiculous! Dates in JavaScript are a big deal to me, and something I want to learn a lot about.

    Ironically, the accompanying pocket reference that I happened to buy along with this book had more information concerning dates than the book, and answered the questions I had at the time, albeit with some guesswork on my part.

    The only thing I will praise this book on for now (still going through it) is its chapter on the DOM - Document Object Model. So far it seems quite plentiful, which is good. I'm no JS buff, but it seems as if the DOM is a major part of the language.

    Bottom line: do not buy this book if you're new to programming. If you already have a handle on variables, functions, arrays, and other such things, then you might be able to make do.

    5-0 out of 5 stars The API guide to know and love
    If you already know how to program and just need to learn the JavaScript syntax this is THE book to get. Can't wait until their SQL Pocket Reference is available!

    2-0 out of 5 stars If you've already got the "Definitive Guide", skip this
    I was hoping and expecting that this little book would be the same quick-and-easy reference book that e.g. the "VBScript Pocket Reference" is -- I was sadly disappointed.

    Since "JavaScript: The Definitive Guide" is by the same author and publisher, I also expected this book to be a (somewhat) boiled-down version of the very thorough JavaScript Reference from that much larger book. I was even more disappointed there.

    In a "pocket reference" such as this I want and need nothing more or less than an alphabetical listing of the JavaScript universe. However, this book is divided into numerous chapters that require you to already know what category the thing you seek belongs to. Since there's no index in these little books, it is useless to me as someone who's still learning this stuff. I've set my copy aside and use the "Definitive Guide" exclusively.

    4-0 out of 5 stars Great to carry around with you
    I've found this is a great little reference that I can carry around with me when working on creating web-related programs.

    Its primarily a quick-reference guide to all the attributes on each of the common Javascript objects in the DOM (Document Object Model) and a very light overview of syntax.

    Don't get this for any kind of help on actually programming Javascript .. this is just primarily a reference.

    3-0 out of 5 stars just not meaty enough
    I use it on occasion to refresh my memory about an attribute name or a method, but I usually have to go to the big books to get any more help than that. It's skimpy. ... Read more

    7. Java 1.5 Tiger : A Developer's Notebook (Developer's Notebook)
    by David Flanagan, Brett McLaughlin
    list price: $29.95
    our price: $20.37
    (price subject to change: see help)
    Asin: 0596007388
    Catlog: Book (2004-06-25)
    Publisher: O'Reilly
    Sales Rank: 18521
    Average Customer Review: 4 out of 5 stars
    US | Canada | United Kingdom | Germany | France | Japan

    Reviews (1)

    4-0 out of 5 stars Quick learning about 1.5
    Java 1.5 has started to emerge into general usage. But most of us Java programmers are still safely ensconced in 1.4. Not a few are undoubtedly wondering what the big deal is about 1.5. If you're like me, you are probably quite satisfied with 1.4.

    Well this book quickly attempts to change that opinion. It hits all the new stuff, with simple descriptions and example code. Like autoboxing. Nothing deep about this, to say the least. But it really eliminates a lot of visual clutter in your source code, when you have to go between a primitive and its wrapper type. It is the analog of how you can do (eg) System.out.println(' t='+t+' d='+d); where t and d can be any primitive types, and the jvm figures out the printing for you. You don't have to specifically describe the output format for each type, as you have to in C. The wonder about autoboxing (and its inverse) is that it was not introduced way earlier. Well, anyway, you have it now.

    Long time C programmers will also welcome varargs, which are variable argument lists. Ever since Java came out in 1996, many asked for this ability. This push has gone on for years. Finally, they scored and we have varargs.

    Other 1.5 changes are covered. But the above should be enough to give you a flavour of what the book offers. ... Read more

    8. Java Foundation Classes in A Nutshell
    by David Flanagan
    list price: $29.95
    our price: $19.77
    (price subject to change: see help)
    Asin: 1565924886
    Catlog: Book (1999-12-15)
    Publisher: O'Reilly
    Sales Rank: 206700
    Average Customer Review: 4.5 out of 5 stars
    US | Canada | United Kingdom | Germany | France | Japan

    The JFC/Swing classes offer a powerful way to build user interfaces in Java, and this richness comes with a lot more complexity. Java Foundation Classes in a Nutshell provides the documentation needed for understanding the most important features of Swing and serves as a handy reference to every package, class, and method.

    The book is especially good at introducing the essential elements of Swing compared to the older AWT standard. Early chapters compare the fundamentals of AWT and Swing, including the architecture of each, plus the new possibilities for user interfaces offered by today's Swing. Standout sections on Java2D graphics (which is a lot more complicated than AWT graphics), printing, and Swing's advanced UI capabilities round out the tour here. Short examples and clear explanations, somewhat dryly written, provide a starting point for learning Swing.

    The heart of this book is its 500 pages of reference material for every Java Swing (and AWT) package, class, and method. Some readers may quibble with the ordering here. (For instance, the model classes for advanced UI components like JTables are separated from the components themselves). But this reference has a good sense of visual clarity (with alternate lines of text highlighted with gray so that you can find what you need quickly). There are also some nice graphics, showing the relationship of Swing classes to one another.

    In all, Java Foundation Classes in a Nutshell provides a very worthwhile reference to today's Swing classes. This text is as good as any available in getting to essential information on the powers of Swing for practical Java development. --Richard Dragan

    Topics covered: JFC/Swing 1.1 and AWT basics, components, layout managers, events, Swing advanced user interface features, serialization, AWT and Java2D graphics, shapes, buffered images, affine transforms, printing, data transfer (cut-and-paste and drag-and-drop, applet basics, JDK 1.1 and Java 2 API package and class reference), UI classes, pluggable-look-and-feel, image APIs, tables and trees, text, and HTML viewer classes. ... Read more

    Reviews (4)

    5-0 out of 5 stars Great reference tool...
    This title is meant to be the second volume of a three volume set that covers the entire language. Volume one covers the basic core Java APIs, while volume three covers the enterprise classes.

    Like all "In A Nutshell" books, this isn't probably where you want to start if you are trying to learn the language. Part 1 is set up such that topics are introduced and discussed with code examples, but it is not a "hand-holding" type of explanation. It assumes you are at least familiar with the information at a high-level, and understand the basic core Java fundamentals. If you are at that point, you should be able to learn a lot from the first section.

    Part 2 is where an experienced Java GUI programmer will live and breath. There is detailed documentation on each of the classes that are covered, as well as a diagram that shows the class hierarchy within the class, and where the class fits into the overall Java class hierarchy. Once again, it's strictly documentation with no explanation. Don't expect the author to explain how each method in the class works. It's up to you to figure out how the method best integrates into your project.

    I can pose the same question I did when I reviewed Java In A Nutshell... Why get this book if I have the online API documentation from Sun? I see them as complimentary. You can probably find much of the reference material in either source. Some will prefer the online hyperlink navigation, while others will appreciate having all the information on a subject in four or five pages that can be thumbed through. I know when I'm stuck on a problem I want both sources!

    For Notes/Domino 5 developers, I would say that there is little in this book that would be of value to you as you code a typical Notes/Domino application. While Notes/Domino does support applets within the application, you would most likely code those outside of the Notes/Domino framework. If you are tasked with developing a Java application that uses Notes/Domino APIs to capture some of the inherent power of the platform, then this book would be useful as you develop the GUI interface that you'll need for your project.

    If you're a Java developer working with client-side applications, get this book. If you're a Notes/Domino developer looking to use Java in your applications, you should probably focus on the Java In A Nutshell book. This is a very well written book, but the usefulness of the information depends on what type of Java programming you are doing.

    5-0 out of 5 stars A book for Java programmers....
    This is a truly good reference on the JFC with a thorough coverage of the various packages. It is not intended as a tutorial and is clearly not for beginners. Combine this with Java in a Nutshell and Java Examples in a Nutshell and you have nearly 2000 pages of detailed reference material.

    4-0 out of 5 stars Complete Reference but no Tutorial
    The book "Java Foundation Classes in a Nutshell" contains an introduction to the Java Foundation Classes and a complete reference to them.

    The major part of the text (~550 pages) is the reference to the Foundation Classes and lists all of the JFC classes with their class hierarchy structure information, all methods and a brief description of the class. This reference part has the same quality as the references known from the other Java in a Nutshell publications (Java in a Nutshell, Java Enterprise in a Nutshell). It is comprehensive, gives a good overview of each package and lists the class methods in a very readable way. The introduction to packages and classes are brief but cover the essentials very well.

    The first ~150 pages of this book give an overview of the Swing architecture and an introduction to the key APIs in the JFC. It covers graphics, printing, data transfer and applets. This part of the book is more problematic than the actual reference part. The selection of topics is limited and not very intuitive (why a hole section on Applets?). Although this introduction is written very well, the it is too short to serve as a tutorial and yet too literary and incomplete to be part of reference manual.

    Anyhow, this is a good and complete reference manual that comes handy whenever you don't have access to the online Java API documentation.

    4-0 out of 5 stars Only if you need a printed Java reference
    A brief but good reference of the JFCs. Again none of language features are covered in dept so don't expect this book to be a tutorial or an introduction to Java. Buy it together with another title that has more hands on examples. ... Read more

    9. Java Examples in a Nutshell, 2nd Edition (Nutshell Handbook)
    by David Flanagan
    list price: $29.95
    (price subject to change: see help)
    Asin: 0596000391
    Catlog: Book (2000-10-01)
    Publisher: O'Reilly
    Sales Rank: 271009
    Average Customer Review: 4.57 out of 5 stars
    US | Canada | United Kingdom | Germany | France | Japan

    Aimed at those who have some previous Java experience, Java Examplesin a Nutshell, 2nd Edition provides an outstanding collection of codesamples that are designed to help you improve your programming skills--bystudying code that works. With over 150 expert examples that illustrate a widerange of Java APIs, this volume definitely can bring your knowledge of Java tothe next level.

    Many programming titles rely on code excerpts to illustrate key programmingconcepts. This book reverses that approach by emphasizing the code itself,enhancing it with introductory material and explanations. While some shortexamples illustrate simple algorithms (such as random-number generation andsorting), many of the examples are substantial: for example, how to create amultithreaded Web server, a proxy server, and even a simple Web browser (byusing built-in Swing classes for a user interface). These longer examples occupyseveral pages; generally, they're well-commented models of coding clarity.

    This second edition adds extensive support for the Java 2 JDK 1.3 standard.Later sections provide sample code on most recent developments in enterpriseAPIs, including Swing, JDBC, and XML. This text concludes with one of the bestshort tutorials that you're likely to find anywhere on JSP and servletprogramming, including excellent detail on deploying JSP-based Webapplications.

    Although it's designed to be a companion title toJava in a Nutshell andother O'Reilly Java offerings, there's little doubt that this book stands on itsown quite well. And, given the short exercises at the end of every chapter thathelp you expand your command of Java features and APIs, this is a worthy andup-to-date resource for all levels of Java programmers. --RichardDragan

    Topics covered:
    • Library of Java 2 code samples
    • A "Helloworld" example
    • Mathematical calculations and algorithms (the FibonacciSeries, factorials, prime-number generation, sorting, exception handling)
    • Basic class design (classes for graphics, random numbers, and a linked list)
    • Java file I/O (including opening, reading, and writing files)
    • Filteringfile streams
    • Java threads and multitasking techniques
    • Java networkingclasses (URLs and connections, sending e-mail)
    • Sample code for custom Webservers and proxy servers
    • Security and cryptography
    • Basicinternationalization
    • The Java reflection APIs

    • Objectserialization
    • Swing user-interface design
    • Code for a simple Web browser,based on Swing
    • Tutorial for AWT and Java 2-D graphics
    • Printingtechniques
    • Cutting and pasting data in Java
    • JavaBeans (customcomponents, bean property editors, customizers)
    • Applet basics (including JDK1.0 event handling and JAR files)
    • Remote Method Invocation (RMI)
    • Samplecode for a Multiuser Domain (MUD) server
    • Database and JDBC programming
    • Servlet and JavaServer Pages (JSPs) tutorial
    • XML and Java (includingJAXP, SAX 1 and 2, and JDOM)
    • ... Read more

      Reviews (35)

      5-0 out of 5 stars Great companion to any JAVA curriculum
      I learned JAVA using the Core Java books and found that I wasnt learning anything from just typing in the examples in the book. I wasnt "thinking" JAVA. I saw a friend of mine at work with this book and picked up a copy for myself. First of all it contains source for several concepts for each of the various language topics. Then it gives exercises to complete. They were challenging, but not overly challenging that I needed to spend an entire day writing UML diagrams to do it. Good companion to any learning method you are using.

      4-0 out of 5 stars Good but better with the other books...
      This book, combined with Java in a Nutshell and Java Foundation Classes in a Nutshell make for one great reference on Java. The examples are easy to follow and are well commented. Flanagan includes examples covering Java basics, objects, classes, input and output, threads, networking, security and crypto, internationalization, reflection, object serialization, GUI's, graphics, printing, data transfer, java beans, applets, RMI, DB access, servlets and JSP and some XML. Alone this is a nice book but like I said to get the most out of it, buy the other two books as well. It's well worth it to anyone wanting to further their understanding and knowledge of Java.

      5-0 out of 5 stars Good book
      The examples of this book are high-applicable, clearly. Essential step-by-step for beginners and handbook for developers. Readers will find everything they need to help them on learning and understand Java generally. If you are new to Java technologies, you will find thoroughly grounded in the basic pieces.

      4-0 out of 5 stars Good reference to a reference
      This book is a wonderful addition to a java developer's library. This book will greatly complement introductory or textbook-style books with its concrete examples and thorough coverage of concepts in a realistic context.

      IF you are looking for your first book on java - this book won't be your first choice - but it will be a very strong second to complement your new found java skills and show how to apply those new found skills will interesting, full-functional, "meaty" sample programs that are easy to reference based on topic. Great Reference!

      If you are found of the O'Reilly style of reference a great first java book would be "Learning Java" by Niemeyer and Knudsen.

      5-0 out of 5 stars Very Useful
      Most programmers learn by doing. When programming using a new API for the first time, I very often look at sample code to get the real feel for how the code should work. I also sometimes adapt existing code to suit my purposes.
      In any case, example code is invaluable, and this book has a lot of it. Although this book is tauted as a companion to the other Java "nutshell" books, this book is infinitaly more valuable. In fact, I don't recommend the other books in this series at all. ... Read more

      10. Java in a Nutshell : A Desktop Quick Reference (Java Series) (3rd Edition)
      by David Flanagan
      list price: $29.95
      (price subject to change: see help)
      Asin: B00006AVRY
      Catlog: Book (1999-11)
      Sales Rank: 1411526
      Average Customer Review: 4.0 out of 5 stars
      US | Canada | United Kingdom | Germany | France | Japan

      The release of Java 1.1 brings many new features to the Java language. Java in a Nutshell, 2nd Edition, a worthy successor to the author's bestselling first edition of the book, offers an excellent way to keep up with most of them.

      You'll find that the second edition carries over many strong points from the original, including a quick-start introduction to Java for C or C++ programmers and the handy quick-reference format. It also details the many new features of Java 1.1, including extensions to the object model and the new release of the Abstract Windowing Toolkit (AWT), Inner Classes, Java Beans, and Java ARchive (JAR) files. The book does not attempt to cover "enterprise" application programming interfaces (API), such as Java's new commerce-related security features, Java Database Connectivity (JDBC) and Remote Method Invocation (RMI). The author plans to document these features in a separate volume.

      The second half of Java in a Nutshell, 2nd Edition, is a quick reference to all the packages that comprise the Java API. In the course of over 300 pages, the author introduces each package with a summary and a graphical hierarchy diagram. He then documents each package's component classes and interfaces in detail. For cases where you know the name of a class, but not its package, an index of classes, methods, and fields provide a useful cross-reference to the packages that contain them. This edition removes some of the example code of the previous edition, but provides many samples that cover new language features. ... Read more

      Reviews (105)

      5-0 out of 5 stars Inexpensive Knowledge Repository
      A long time fan of O'Reilly books, the CD bookshelves and this deluxe edition are one of the best ideas I've seen from a publisher.If you don't mind reading onscreen these will save you money.If you do pick this up in addition to the hardcopy simply for the search capabilities.A great reference tool from any serious programmer.

      5-0 out of 5 stars The Jr. Bible of Java
      I've read the first 4 chapters as my introduction to Java. It was a struggle, but worth it.

      I'm now taking a college class and find Java a slippery beast to get one's hands around.Our text introduces snidbits that create so many unanswered questions my head swims.Reading these chapters layed a great foundation for understanding where Java's creators are coming from and why.

      There were many very insightful tips that lifted some very dense fog for me. He builds one's knowledge from the ground up. If you manage to get through it (ie: you have had lots of prior programming experience and about 5 days to read 165 pages) you are left with a pretty good idea of why the syntax and practices are the way they are. I'm sure other books are equally insightful, but this one sure says a lot in only a few words.

      Buy this book if you like to know that each sentence was written because the author had something to convey, not just because he wants another crack at clearing up the confusion he just created. Mr Flanagan (the author of Nutshell) says it crystal clear the first time. (note: He does bother to repeat a few very important concepts, but its rare).

      The remainder of the book is a library reference of selected Java packages.I'm not sure the usefulness of the list other than to see the headers and method signatures that are available.I would liken it to having a pocket dictionary - sometimes its all you need and sometimes the definition isn't useful and you have to break out the Webster.

      However, the presentation in the initial 8 chapters is so outstanding that I would give it 5+ stars if allowed.This is where to find the magical explanation to clear the smoke.

      1-0 out of 5 stars use the sdk documentation instead.
      it is much better to use a jdk documentation which you can download instead of this reference book.

      3-0 out of 5 stars "Help! I'm in a nutshell!"
      JAVA IN A NUTSHELL (THIRD EDITION) is one of those computer science books that I had always been told was excellent.Professors, friends and co-workers all recommended it to me so many times that I eventually bought it soon after I began programming in Java.Having used this book as a reference on numerous occasions, I must say that it doesn't quite live up to its hallowed reputation, although it does have a number of positive points in its favour.

      The opening few chapters of the book are really good at setting the stage for the beginning Java programmer.While it probably isn't simple enough for someone who is a complete newcomer to the language, it is excellent for people who already know a little bit and require more information.The sections on Java syntax are quite thorough and understandable.The Object Oriented Programming portions are readable and informative, without bogging the reader down with endless detail.The background information on Java (the structure, the way methods/variables work, the flow of programs, etc) is all handled brilliantly.Part One of this book is definitely something you'll want to treasure.

      Part Two, the bulk of the book (Chapters 9 though 29, and covering a staggering three hundred, seventy-six out of six hundred, forty-eight pages), is devoted to what is referred to as the "API Quick Reference".It's the self-proclaimed "real heart" of the text.Unfortunately, this is the portion where the book really falls flat.What David Flanagan has done is to go through the most common Java packages/classes/APIs and cut them down to a bare listing of all their methods, exceptions, hierarchies, etc.While this covers a broad amount of information, it does not cover it deeply at all.I agree with his choice of most-used APIs, but he doesn't go in to nearly enough detail about them.Almost all of the methods are given no description; they're just named.If you are using this to look up the precise spelling/capitalization of your favourite methods, then this will do nicely.However, if you're curious as to what each method actually does, you won't find any enlightenment here.When one boils down the Java documentation this far, one finds that there really isn't much left at all.Certainly nothing that's actually useful.

      The first part of this book is first rate.It's easy to understand, well-organized and great for beginners learning the language as well as for experienced programmers who require reference material.The second part of the book is not so good.For any detailed information you require, you'll find yourself forced to consult other sources (probably Sun's own API specifications which are available for free on their webpage).Make sure you know what you're buying.The first half of this nutshell is excellent, but you'll need something else to go with it to have a completely worthwhile reference.

      1-0 out of 5 stars Incomplete, badly organized, terrible index
      Avoid this book. Although there is no indication on the cover, it completely skips major sections of the language, such as everything pertaining to Sql and databases. It is organized around package names, which makes it difficult to look anything up. The index is incomplete and doesn't indicate what pages classes are actually defined on.(...) ... Read more

      11. Limited Edition Java Library Set (4-Volume Set)
      by Kris Magnusson, David Flanagan, Jim Farley, William Crawford, O'Reilly
      list price: $99.95
      (price subject to change: see help)
      Asin: 059600107X
      Catlog: Book (2000-01-15)
      Publisher: O'Reilly
      Sales Rank: 957302
      Average Customer Review: 5 out of 5 stars
      US | Canada | United Kingdom | Germany | France | Japan

      Book Description

      The Java Professional Library contains durable, hardcover editions of ourfour indispensable Java references:

      • Java in a Nutshell, the essential quick reference for all Javaprogrammers. This accelerated introduction to Java and its key APIs letsseasoned programmers start writing code right away. The third edition coversJava 1.2 and Java 1.3.
      • Java Examples in a Nutshell, 2nd Edition, updated for Java 1.3.The164 complete, practical examples with over 17,900 lines of densely commented,professionally written code cover 20 distinct Java API's, including Servlets,JavaServer Pages, XML, Swing, and Java 2D.
      • Java Enterprise in a Nutshell, O'Reilly's classic-style quickreference to all of the classes in the various packages that comprise theEnterprise APIs, such as JDBC, RMI, Java IDL, Servlets, JNDI, and EnterpriseJavaBeans (EJB).
      • Java Foundation Classes in a Nutshell. This companion volume to Java in a Nutshell is a fast-paced introduction to the Java APIs thatcomprise the Java Foundation Classes (JFC) for writing applications that usegraphics or graphical user interfaces.
      ... Read more

      Reviews (2)

      5-0 out of 5 stars man pages give me a headache
      I recently got some gift certificates for the holidays and spent them on this set. I am an experienced C/C++ and Perl programmer, and I just began learning Java several months ago. With my previous language and SE knowledge I blew through a tutorial without breaking a sweat, but then (and now) comes the hard part of building the vocabulary necessary to communicate fluently in the language.

      I had originally intended to buy the official Sun Java Series books, but I found that they were expensive and overly formal. To get all the current library specs requires three volumes at about $60 a piece. Plus the language spec which is written in very formal language, thus not very useful as a quick reference, and is available for free as a .pdf file should you require such formality to write a parser, for instance.

      The In a Nutshell collection is perfect for my needs. It is just the sort of comprehensive resource that I was looking for, both as a working reference and as a learning tool. As a learning tool it is almost self-contained. You can look at the 'Java Examples' (The Java Cookbook by Ian Darwin is also recommended - the examples are more up to date, and the scope is broader) and find some code that approximates what you are trying to do. Then you can look at the various API calls and object heirarchies and go to the other volumes to find a description of each class and interface (Another recommendation is the set of posters that you can get bundled with "Effective Java" - also an excellent book. The posters give a visual reference of the package/class hierarchies making it very easy to understand the relationships between the various classes, sub-classes, and interface specs. A word of caution: the posters are unusually tall. I had to turn them sideways to fit them on the walls of my cube.

      The reference material, typical of O'Reilly's 'Nutshell' books, is just right. Each interface is fully speced with just the right amount of verbage. You aren't left scratching your head (well, not any more that necessary) but at the same time you don't have to search endless paragraphs just to understand the syntax of one API call. It's the perfect substitute for online docs, which are never this well organized, and gives me the opportunity to pull my aching eyes away from the CRT for a moment without losing productivity.

      All told, it is a very good collection that seems ideal for what I - and a lot of other professional programmers I would imagine - am doing. I can't see how any Java programmer's book collection would not be enhanced by these books.

      5-0 out of 5 stars Good library for learning Java
      This set of books is really helpful for anybody to learn Java. It includes four helpful books - Java in a Nutshell, Java Examples in a Nutshell, Java Enterprise in a Nutshell and Java Foundation Classes in a Nutshell, they are all "in a Nutshell" series from O'Reilly. As a CS1 student, these books give me a very clear concepts in programming in Java. I think they are really useful books for you! ... Read more

      12. Java Power Reference: A Complete Searchable Resource on CD-ROM
      by David Flanagan, Paula Ferguson
      list price: $19.95
      (price subject to change: see help)
      Asin: B00007FYDM
      Catlog: Book (1999-05-15)
      Publisher: O'Reilly & Associates
      Sales Rank: 2938868
      Average Customer Review: 2.8 out of 5 stars
      US | Canada | United Kingdom | Germany | France | Japan

      Book Description

      David Flanagan and O'Reilly have taken the quick-reference style ofJava in a Nutshell one step further with Java Power Reference:A Complete Searchable Resource on CD-ROM.The Java API has become even more complex with the release of Java 2(TM). And although the official online documentation is complete, it can bedifficult to navigate. That's where the Java Power Reference comesin. This browser-based resource documents all the packages and classes ofthe Java 2 platform on a single CD-ROM. It includes synopses for:

      • 182 core and standard extensions packages
      • 3,900 public and protected classes
      Unlike the official documentation, the Java Power Reference groupsmethods functionally. Plus, the CD-ROM is searchable, so you can type inany Java class, method, or field and go directly to that material. Thepackage also contains a concise, printed overview of the newly releasedJava 2 platform. The Java Power Reference is a portable, easy-to-useresource that no Java developer should be without. ... Read more

      Reviews (5)

      5-0 out of 5 stars Great reference!
      I use this thing every day. It's fast.

      2-0 out of 5 stars So-so online reference
      It is a CD-ROM with an associated user's book that has a bare minimum of information.

      The CD-ROM is searchable and in HTML. It covers all the packages and classes of Java 2. It's style is very similiar to Java in a Nutshell. The search works by allowing you to type in the name of any class, method, or field. The CD-ROM will take you directly to the page covering that topic or give you a list of topics if there is more than one.

      This CD-ROM's major competitor is the Java Almanac. I prefer the almanac because it is paper.

      The CD-ROM has a nice browsing system, but given the fact that it does not have class/method descriptions, I think I will typically use the free HTML help that comes with JDK over this CD-ROM. The only time I envision using this CD-ROM is when I am working with a non-core API.

      5-0 out of 5 stars Excellent searchable reference guide
      I find this online searchable reference guide very helpful and can't live without it. The "copy protection" mentioned by another reviewer was a production problem, with a fix listed on the O'Reilly web site.

      1-0 out of 5 stars Don't buy this CD-Rom
      This "Reference" consists only of a CD-Rom with 130 MB and a very small booklet which concentrates on how to use the CD. The online reference on the CD claims to be a complete listing of all Java Classes and Packages, but without any example it's not as valueable as expected. Unfortunatly the surely required copy-protection causes a denial of service, when you try to copy all the files to your harddrive. This is a certain drawback, when you want the reference to be quickly available. No detailed reference, really.

      1-0 out of 5 stars This is not a good reference
      If you are in need of a good reference, do not buy this one. It contains a book (~50 pages) and a CD-ROM. The book contains no details at all. Just an overciew of Java2 news. You can download this info. from sun for free. The CD contains a searchable API reference. The organisation and the presentation of the information is really poor. All the helping comments are taken away. You just see the method name and what they return. I was hoping to get a good on-line ref. but THIS IS NOT IT. I recomend the on-line help that comes with IBM Visual Age for Java. The hole product costs under 100 dollars. ... Read more

      13. Enterprise Storage 2001 : From Back Office Afterthought to Strategic Buying Decisions
      by David Hill, Zachery Shess, Dan Tanner, Kristen Flanagan
      list price: $1,500.00
      our price: $1,500.00
      (price subject to change: see help)
      Asin: B00005N9C4
      Catlog: Book
      Manufacturer: Aberdeen Group
      US | Canada | United Kingdom | Germany | France | Japan

      Download Description

      The report outlines criteria for evaluating enterprise products and services based on necessary principles of availability, manageability, scalability, robustness, flexibility, breadth, and integration. ... Read more

      14. Java in a Nutshell (In a Nutshell (O'Reilly))
      by David Flanagan
      list price: $53.55
      (price subject to change: see help)
      Asin: 0613911768
      Catlog: Book (2002-03)
      Publisher: Rebound by Sagebrush
      US | Canada | United Kingdom | Germany | France | Japan

      1-14 of 14       1
      Prices listed on this site are subject to change without notice.
      Questions on ordering or shipping? click here for help.