Recommended books about JAVA

Raves for the First Edition!

�|

�gI sure wish I had this book ten years ago. Some might think that I don�ft need any Java books, but I need this one.�h

�|James Gosling, fellow and vice president, Sun Microsystems, Inc.

�|

�gAn excellent book, crammed with good advice on using the Java programming language and object-oriented programming in general.�h

�|Gilad Bracha, coauthor of The Java�� Language Specification, Third Edition

�|

�g10/10�|anyone aspiring to write good Java code that others will appreciate reading and maintaining should be required to own a copy of this book. This is one of those rare books where the information won�ft become obsolete with subsequent releases of the JDK library.�h
�|Peter Tran, bartender, JavaRanch.com

�|

�gThe best Java book yet written.... Really great; very readable and eminently useful. I can�ft say enough good things about this book. At JavaOne 2001, James Gosling said, �eGo buy this book!�f I�fm glad I did, and I couldn�ft agree more.�h
�|Keith Edwards, senior member of research staff, Computer Science Lab at the Palo Alto Research Center (PARC), and author of Core JINI (Prentice Hall, 2000)

�|

�gThis is a truly excellent book done by the guy who designed several of the better recent Java platform APIs (including the Collections API).�h
�|James Clark, technical lead of the XML Working Group during the creation of the XML 1.0 Recommendation, editor of the XPath and XSLT Recommendations

�|

�gGreat content. Analogous to Scott Meyers�f classic Effective C++. If you know the basics of Java, this has to be your next book.�h
�|Gary K. Evans, OO mentor and consultant, Evanetics, Inc

�|

�gJosh Bloch gives great insight into best practices that really can only be discovered after years of study and experience.�h
�|Mark Mascolino, software engineer

�|

�gThis is a superb book. It clearly covers many of the language/platform subtleties and trickery you need to learn to become a real Java master.�h
�|Victor Wiewiorowski, vice president development and code quality manager, ValueCommerce Co., Tokyo, Japan

�|

�gI like books that under-promise in their titles and over-deliver in their contents. This book has 57 items of programming advice that are well chosen. Each item reveals a clear, deep grasp of the language. Each one illustrates in simple, practical terms the limits of programming on intuition alone, or taking the most direct path to a solution without fully understanding what the language offers.�h

�|Michael Ernest, Inkling Research, Inc.

�|

�gI don�ft find many programming books that make me want to read every page�|this is one of them.�h
�|Matt Tucker, chief technical officer, Jive Software

�|

�gGreat how-to resource for the experienced developer.�h
�|John Zukowski, author of numerous Java technology books

�|

�gI picked this book up two weeks ago and can safely say I learned more about the Java language in three days of reading than I did in three months of study! An excellent book and a welcome addition to my Java library.�h
�|Jane Griscti, I/T advisory specialist

Are you looking for a deeper understanding of the Java�� programming language so that you can write code that is clearer, more correct, more robust, and more reusable? Look no further! Effective Java��, Second Edition, brings together�|seventy-eight indispensable programmer�fs rules of thumb: working, best-practice solutions for the programming challenges you encounter every day.

�|

This highly anticipated new edition of the classic, Jolt Award-winning work has been thoroughly updated to cover Java SE 5 and Java SE 6 features introduced since the first edition. Bloch explores new design patterns and language idioms, showing you how to make the most of features ranging from generics to enums, annotations to autoboxing.

�|

Each chapter in the book consists of several �gitems�h presented in the form of a short, standalone essay that provides specific advice, insight into Java platform subtleties, and outstanding code examples. The comprehensive descriptions and explanations for each item illuminate what to do, what not to do, and why.

�|

Highlights include:

• New coverage of generics, enums, annotations, autoboxing, the for-each loop, varargs, concurrency utilities, and much more
• Updated techniques and best practices on classic topics, including objects, classes, libraries, methods, and serialization
• How to avoid the traps and pitfalls of commonly misunderstood subtleties of the language
• Focus on the language and its most fundamental libraries: java.lang, java.util, and, to a lesser extent, java.util.concurrent and java.io

Simply put, Effective Java��, Second Edition, presents the most practical, authoritative guidelines available for writing efficient, well-designed programs.

Greatest Java book ever written. In fact, it's beyond a 'java book', once many tips from here are 'universal tips'.

It's a great book for those who already have at least 4 or 5 programming years (code enough different projects), 'cause you'll notice several (apparently) minor mistakes that everyone make everyday.

Did you realize that enums can implement interfaces? That the simplest safe way to implement a singleton is using an enum? That it's possible to obtain an object reference to a private member using serialization? There are lots of ways to learn the language basics and figure out how to use the libraries. But nowhere do you have such a dense collection of non-obvious, yet important issues that any Java developer ought to be aware of. The book is written from the perspective of someone who creates public APIs, so there is a lot of obsessing over how to prevent users from doing things they shouldn't (intentionally, or not). But even if that's not a big concern for you, it's nevertheless important to be aware of the issues. Having read the first edition a while back, reading the second edition was more that a good refresher -- it's almost a different book. This is in part thanks to Java 5, which has made a lot of the original items (e.g. how create enumerations) obsolete, while introducing the need for a whole new set of items (e.g. regarding the use of generics).

This book is a must-read for all Java programmers. In fact, I think every programmer should read this book before they start programming Java. The book is full of good advice, best practices and guidelines.

Highly recommended

Absolute classic, definitely my favorite Java book. Every professional Java developer should have it on her/his desk.

It's not the easiest book and shouldn't be read if You are novice in Java, there better books to get started with Java, but for experienced developers, this book is invaluable.

This book seems to be one of the most critically acclaimed Java titles. What could I possibly add to what has been said? The acclaim is fully deserved. I had the feeling that I already learned something new and important as soon as I reached page twenty. This is something that I cannot say of very many books. Effective Java manages to be extremely useful and simultaneously extremely easy to read. However, "easy" doesn't mean simple in this case, since many of the discussed problems are subtly complex. Some are so complex, in fact, that Java beginners might not fully understand or appreciate them. So, it's probably not a book for beginners. On the other hand, the book is neither esoteric. The 78 items are general Java programming issues which one is likely to encounter in everyday work at some point, regardless of any specific domain. The book is written in a clear and concise language and each problem is exceptionally well reasoned. The author has a very deep understanding of the Java language, which is rather apparent and no surprise, since Joshua Bloch is one of the architects of the Java platform. Incidentally, this also means that the problems are discussed from the perspective of an API designer rather than from the perspective of an application programmer. This is useful, because it is primarily concerned with creating robust and high quality interfaces. Architects, designers, and application programmers benefit likewise from this. The items discussed in this book can probably be described as design and implementation level rationales. They are grouped by Java categories, such as generics, enums, annotations, exceptions, serialisation, as well as by more general concepts, such as object creation, classes and interfaces, methods and concurrency. Many of the individual topics are related; therefore the author makes ample use of cross references, which is helpful for reference use. The included code examples are a joy to read; they are clear, concise, and always illustrative. While discussing the intricacies of the above named topics, Joshua Bloch casually introduces the reader to a good number of commonly used design patterns, many of which are illustrated with code examples. However, design patterns are not themselves formally discussed. The book equips Java programmers with an arsenal of relevant best practices, from comparatively simple things such as creating objects, implementing "equals()" and "hashCode()" methods to more advanced topics, such as concurrency, mutability, and thread safety. In doing so, Joshua Bloch points out quite a few quirks and peculiarities of the Java language, and he does not only point them out, but explains their practical consequences in detail. Thus, the book has great didactic value, as the reader will end up with a higher level of familiarity with the language. Reading this book is time well invested for any Java programmer.

You're not alone.

At any given moment, somewhere in the world someone struggles with the same software design problems you have. You know you don't want to reinvent the wheel (or worse, a flat tire), so you look to Design Patterns--the lessons learned by those who've faced the same problems. With Design Patterns, you get to take advantage of the best practices and experience of others, so that you can spend your time on...something else. Something more challenging. Something more complex. Something more fun.

You want to learn about the patterns that matter--why to use them, when to use them, how to use them (and when NOT to use them). But you don't just want to see how patterns look in a book, you want to know how they look "in the wild". In their native environment. In other words, in real world applications. You also want to learn how patterns are used in the Java API, and how to exploit Java's built-in pattern support in your own code.

You want to learn the real OO design principles and why everything your boss told you about inheritance might be wrong (and what to do instead). You want to learn how those principles will help the next time you're up a creek without a design pattern.

Most importantly, you want to learn the "secret language" of Design Patterns so that you can hold your own with your co-worker (and impress cocktail party guests) when he casually mentions his stunningly clever use of Command, Facade, Proxy, and Factory in between sips of a martini. You'll easily counter with your deep understanding of why Singleton isn't as simple as it sounds, how the Factory is so often misunderstood, or on the real relationship between Decorator, Facade and Adapter.

With Head First Design Patterns, you'll avoid the embarrassment of thinking Decorator is something from the "Trading Spaces" show. Best of all, in a way that won't put you to sleep! We think your time is too important (and too short) to spend it struggling with academic texts.

If you've read a Head First book, you know what to expect--a visually rich format designed for the way your brain works. Using the latest research in neurobiology, cognitive science, and learning theory, Head First Design Patterns will load patterns into your brain in a way that sticks. In a way that lets you put them to work immediately. In a way that makes you better at solving software design problems, and better at speaking the language of patterns with others on your team.

Very good book with a very good concept. It takes your hand and follow you in understanding some important programming patterns which will make your life easier.

This was my first book from Head First, and i love it! The book uses an easy approach (besides the schema in each chapter) to make you understand the different patterns. I think the book is good for junior and mid senior people.

This book is like eating icecream. You expend Zero effort in learning valuable information about design patterns for oo development.

First, a little background: I have been programming since 1998 and my primary programming language is C#. My main area of development is ASP.NET websites.

For years I have been trying to get my head around software design patterns, but I kept running into road blocks. I tried learning about them from a combination of websites and books, but none of them seemed to communicate the practical reasons for learning design patterns. I decided to give up on learning them.

Several years went by and the gnawing question about the usefulness of software design patterns resurfaced in my head. I came across Head First Design Patterns, saw the great reviews and decided to take a chance. I am sure glad I did.

Not only is this easily the best design patterns book I have read, this may be one of the best books, teaching a complicated technology topic, I have ever read. This book was created with me in mind. The book is educational, entertaining, and does a good job of showing the practical side of the topic. The examples are all in Java, but I was able to easily translate them into C#.

If you want to learn object oriented design patterns, buy this book. I will definitely be checking out other Head First titles.

This is a book that I recommend to all of the software developers I work with, it is so much more than the gang of 4, it is actually readable. The unique format used to address the topics helps with retention and understandability. The only complaint that I would have about the book, and the reason I gave it 4 stars, is that the examples used are impractical and sometimes silly. The authors also could have alluded more to the usages of algorithms and efficiency of code.

Learning a complex new language is no easy task especially when it s an object-oriented computer programming language like Java. You might think the problem is your brain. It seems to have a mind of its own, a mind that doesn't always want to take in the dry, technical stuff you're forced to study.

The fact is your brain craves novelty. It's constantly searching, scanning, waiting for something unusual to happen. After all, that's the way it was built to help you stay alive. It takes all the routine, ordinary, dull stuff and filters it to the background so it won't interfere with your brain's real work--recording things that matter. How does your brain know what matters? It's like the creators of the Head First approach say, suppose you're out for a hike and a tiger jumps in front of you, what happens in your brain? Neurons fire. Emotions crank up. Chemicals surge.

That's how your brain knows.

And that's how your brain will learn Java. Head First Java combines puzzles, strong visuals, mysteries, and soul-searching interviews with famous Java objects to engage you in many different ways. It's fast, it's fun, and it's effective. And, despite its playful appearance, Head First Java is serious stuff: a complete introduction to object-oriented programming and Java. You'll learn everything from the fundamentals to advanced topics, including threads, network sockets, and distributed programming with RMI. And the new. second edition focuses on Java 5.0, the latest version of the Java language and development platform. Because Java 5.0 is a major update to the platform, with deep, code-level changes, even more careful study and implementation is required. So learning the Head First way is more important than ever.

If you've read a Head First book, you know what to expect--a visually rich format designed for the way your brain works. If you haven't, you're in for a treat. You'll see why people say it's unlike any other Java book you've ever read.

By exploiting how your brain works, Head First Java compresses the time it takes to learn and retain--complex information. Its unique approach not only shows you what you need to know about Java syntax, it teaches you to think like a Java programmer. If you want to be bored, buy some other book. But if you want to understand Java, this book's for you.

It has taken four years, but with Head First Java the introductory Java book category has finally come of age. This is an excellent book, far more capable than any of the scores of Java-for-novices books that have come before it. Kathy Sierra and Bert Bates deserve rich kudos--and big sales--for developing this book's new way of teaching the Java programming language, because any reader with even a little bit of discipline will come away with true understanding of how the language works. Perhaps best of all, this is no protracted "Hello, World" introductory guide. Readers get substantial exposure to object-oriented design and implementation, serialization, neatwork programming, threads, and Remote Method Invocation (RMI).

Key to the authors' teaching style are carefully designed graphics. Rather than explain class inheritance (to cite one example) primarily with text, the authors use a series of tree diagrams that clarify the mechanism far more succinctly. The diagrams are carefully annotated with arrows and notes. Also characteristic of the unique teaching strategy is heavy reliance on exercises, in which the reader is asked to complete partial classes, write whole new code segments and do design work. Though there's little discussion of why the exercises' correct answers are what they are, it's clear that the practice work was carefully designed to reinforce the lesson at hand. If you've waited this long to give Java a try, this book is a great choice. --David Wall

Topics covered: The Java programming language for people with no Java experience, and even people with no programming experience at all. Key concepts read like a list of Java features: Object oriented design, variable type and scope, object properties and methods, inheritance and polymorphism, exceptions, graphical user interfaces (GUIs), network connectivity, Java archives (JAR files), and Remote Method Invocation (RMI).

Although I have granted this book 4 stars -- a pretty favorable rating -- mine is another one of those dissenting opinions you will see in the current set of reviews.

I have given 4 stars because I think the Head First folks' aims are laudable; however (and this is a big however), for me the approach simply doesn't work, and I feel as though if I'd spent a little time with the book prior to ordering it I would have given it a miss.

My point here is that since it is the approach that is the real selling point here, it's worth your while trying to figure out whether the approach works for you or (as it did in my case) gives you a headache, and makes you wish for more traditional, meaning-bearing prose.

The harsh version of what I am fumbling towards saying here is that, for me, this book is the triumph of widgets. I recall a Perl 5 book from some years back that I used and liked ... but I recall detractors (the author, a really fine and well-known writer on Perl, included) saying that the book had been near-ruined with text widgets and icons and other such stuff. The Head First books, while not ALL widgets, tilt the scale massively in favor of the visual, tricky, goofy, funny [insert more terms here] approach, in a self-proclaimed effort to entertain you into learning.

There is a part of me that can grok that and applaud this, but when it comes down to brass tacks, it just doesn't work for me. And when I say "doesn't work," I am not even considering the question of whether the content is reasonably complete (other reviewers have pointed out that things may get dropped or glided over in th is process, with confusing results for learners). No, I mean "doesn't work," in the sense that I am not sure what to do with it. As an example, there are several "Code Magnet" sections in this book. The conceit is simple: mix and match these jumbled code fragments, as if they were "magnetic poetry" on a refrigerator, so that together they form a program that outputs the desired stuff.

This is a cute, attractive idea that a majority of readers can probably relate to -- but what is one supposed to do with a paper page of "code magnets." Is the reader supposed to tear the page out? type all the code in and mix it around? It doesn't appear to be in the downloadable code for the book ... OH, well it seems O'Reilly sells the code magnets, for $19.95 / set. Hmm.

Honestly, I didn't know that last fact until I started this review. I'm not trying to be awfully snarky here, but I think the whole thing would work better as an interactive CD-ROM. It's hard for the activities to reach out and grab you (crossword puzzles work okay, I guess, but their pedagogic value is pretty small) when they're confined to paper.

In short, try this thing first. If you like it, by all means go for it. I didn't like it, and I have reservations about whether it really works in its current form.

Pretty good book for those whom Programming is difficult to understand. You will be doing an excellent purchase.

I had to get this book for an Intro Java class I'm taking. The "teacher" is basically reading the book as part of his lessons. I've learned more from this book than I have from the "teacher". This book has a unique approach to teaching programming, and so far I think it's working. Other programming books I have read, are really dry and boring, this book is the opposite.

This is a good beginners' book. It is, however, 3 years old and does not cover the latest version of Java, 6.0. According the publisher, O'Reilly Media, the authors consider Java 6.0 to be similar to version 5.0 and thus not worth a new edition. The next edition is scheduled for 2010, when Java 7.0 comes out. On the other hand, the authors did not really cover all the new 5.0 features in this second edition. In particular, enum is relegated to the appendix! I am not sure how much update one can realistically expect in the 3rd edition.

As a computer science teacher I am always on the lookout for introductory texts that make Java less intimidating. Head First Java certainly fills the bill with a good mix of humor and content. My only objection (and it is very slight) is that it tends to get a bit "thick" in sections -- nothing a final edit couldn't easily fix.

On the whole, however, a very good job.

The Best Fully Integrated Study System Available--Written by the Lead Developers of Exam 310-065

With hundreds of practice questions and hands-on exercises, SCJP Sun Certified Programmer for Java 6 Study Guide covers what you need to know--and shows you how to prepare--for this challenging exam.

• 100% complete coverage of all official objectives for exam 310-065
• Exam Objective Highlights in every chapter point out certification objectives to ensure you're focused on passing the exam
• Exam Watch sections in every chapter highlight key exam topics covered
• Simulated exam questions match the format, tone, topics, and difficulty of the real exam

Covers all SCJP exam topics, including:

Declarations and Access Control �| Object Orientation �| Assignments �| Operators �| Flow Control, Exceptions, and Assertions �| Strings, I/O, Formatting, and Parsing �| Generics and Collections �| Inner Classes �| Threads �| Development

CD-ROM includes:

• Complete MasterExam practice testing engine, featuring: Two full practice exams; Detailed answers with explanations; Score Report performance assessment tool
• Electronic book for studying on the go
• Bonus coverage of the SCJD exam included!

Bonus downloadable MasterExam practice test with free online registration.

.

It helped me a lot! An excellent way to get SCJP! Thanks Amazon for the quick delivery!

Great preperation tool. This material is advanced, and a little hard to get through. However, it does a great job of preparing you for the SCJP exam. The sample tests and summaries at the end of each chapter are very helpful as are the full exam samples.

The book is ok. But the time I wasted waiting for it to arrive here was terrible. A friend bought the same book 2 days after me and it arrived 3 weeks earlier than mine and we chose the same delivery method. I just don't know what happened but it took from the 13th of september till the 31st of october to arrive... terrible delivering service. Take care if you need it in the estimate delivery time and specially if you live in another country.

I took the SCJP once before and failed. I had prepared only with online resources. But after reading this book thoroughly, and taking all the practice exams, I retook SCJP and passed! I found this book's questions generally harder than the real SCJP exam, but it was great preperation. My only complaint about this book is the "Two minute" chapter summaries should be a little more concise.

In addition to preparing for the SCJP exam, this is an excellent way for a rusty Java programmer who has been using other technologies to get their head wrapped around Java again. This book's content and presentation are both highly effective. The humor really lightens up the reading experience.

One strong suggestion for the authors is to include page numbers for each section of the "Two Minute" drills, providing a quick reference to that section's underlying discussion. I wasted a lot of time flipping back through the chapter trying to find/review the underlying (and often clever) example.

This Fifth Edition is completely revised and expanded to cover JavaScript as it is used in today's Web 2.0 applications. This book is both an example-driven programmer's guide and a keep-on-your-desk reference, with new chapters that explain everything you need to know to get the most out of JavaScript, including: Scripted HTTP and Ajax XML processing Client-side graphics using the canvas tag Namespaces in JavaScript--essential when writing complex programs Classes, closures, persistence, Flash, and JavaScript embedded in Java applications

Part I explains the core JavaScript language in detail. If you are new to JavaScript, it will teach you the language. If you are already a JavaScript programmer, Part I will sharpen your skills and deepen your understanding of the language.

Part II explains the scripting environment provided by web browsers, with a focus on DOM scripting with unobtrusive JavaScript. The broad and deep coverage of client-side JavaScript is illustrated with many sophisticated examples that demonstrate how to: Generate a table of contents for an HTML document Display DHTML animations Automate form validation Draw dynamic pie charts Make HTML elements draggable Define keyboard shortcuts for web applications Create Ajax-enabled tool tips Use XPath and XSLT on XML documents loaded with Ajax And much more

Part III is a complete reference for core JavaScript. It documents every class, object, constructor, method, function, property, and constant defined by JavaScript 1.5 and ECMAScript Version 3.

Part IV is a reference for client-side JavaScript, covering legacy web browser APIs, the standard Level 2 DOM API, and emerging standards such as the XMLHttpRequestobject and the canvas tag.

More than 300,000 JavaScript programmers around the world have made this their indispensable reference book for building JavaScript applications.

""A must-have reference for expert JavaScript programmers...well-organized and detailed."" -- Brendan Eich, creator of JavaScript

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.

This is I believe the best book about basic Javascript on the market right now.

Pros: Technically complete, solid writing style, understandable examples, no better intro books on the market.

Cons: Authors repeatedly show that they prefer class-based object systems, which Javascript is not. Authors do not effectively teach advanced Javascript prototype-based object usage and in fact seem to view it as a nuisance to be avoided. Authors don't regularly use closures except in section on closures.

I would recommend following this book up with "Javascript: The Good Parts" and making sure you fully grok how to use closures to avoid namespace pollution.

I've learned a lot of tech in my time, and this book does the best job explaining the fundamentals of a language that I've ever come across. Flanagan basically builds the whole language piece by piece, explaining the fundamentals of every aspect.

There are some more esoteric techniques he doesn't cover, but I hardly consider that a shortcoming; aside from those, he basically covers the entire breadth of JavaScript, both in its core design and in practical browser-based applications. This really is the definitive book on JavaScript, even if it is two years old (which is ages in Internet time).

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.

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.

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.

"I was fortunate indeed to have worked with a fantastic team on the design and implementation of the concurrency features added to the Java platform in Java 5.0 and Java 6. Now this same team provides the best explanation yet of these new features, and of concurrency in general. Concurrency is no longer a subject for advanced users only. Every Java developer should read this book." --Martin Buchholz JDK Concurrency Czar, Sun Microsystems "For the past 30 years, computer performance has been driven by Moore's Law; from now on, it will be driven by Amdahl's Law. Writing code that effectively exploits multiple processors can be very challenging. Java Concurrency in Practice provides you with the concepts and techniques needed to write safe and scalable Java programs for today's--and tomorrow's--systems." --Doron Rajwan Research Scientist, Intel Corp "This is the book you need if you're writing--or designing, or debugging, or maintaining, or contemplating--multithreaded Java programs. If you've ever had to synchronize a method and you weren't sure why, you owe it to yourself and your users to read this book, cover to cover."--Ted Neward Author of Effective Enterprise Java "Brian addresses the fundamental issues and complexities of concurrency with uncommon clarity. This book is a must-read for anyone who uses threads and cares about performance." --Kirk Pepperdine CTO, JavaPerformanceTuning.com "This book covers a very deep and subtle topic in a very clear and concise way, making it the perfect Java Concurrency reference manual. Each page is filled with the problems (and solutions!) that programmers struggle with every day. Effectively exploiting concurrency is becoming more and more important now that Moore's Law is delivering more cores but not faster cores, and this book will show you how to do it." --Dr. Cliff Click Senior Software Engineer, Azul Systems "I have a strong interest in concurrency, and have probably written more thread deadlocks and made more synchronization mistakes than most programmers. Brian's book is the most readable on the topic of threading and concurrency in Java, and deals with this difficult subject with a wonderful hands-on approach.This is a book I am recommending to all my readers of The Java Specialists' Newsletter, because it is interesting, useful, and relevant to the problems facing Java developers today." --Dr. Heinz Kabutz The Java Specialists' Newsletter "I've focused a career on simplifying simple problems, but this book ambitiously and effectively works to simplify a complex but critical subject: concurrency. Java Concurrency in Practice is revolutionary in its approach, smooth and easy in style, and timely in its delivery--it's destined to be a very important book." --Bruce Tate Author of Beyond Java "Java Concurrency in Practice is an invaluable compilation of threading know-how for Java developers. I found reading this book intellectually exciting, in part because it is an excellent introduction to Java's concurrency API, but mostly because it captures in a thorough and accessible way expert knowledge on threading not easily found elsewhere." --Bill Venners Author of Inside the Java Virtual Machine Threads are a fundamental part of the Java platform. As multicore processors become the norm, using concurrency effectively becomes essential for building high-performance applications.Java SE 5 and 6 are a huge step forward for the development of concurrent applications, with improvements to the Java Virtual Machine to support high-performance, highly scalable concurrent classes and a rich set of new concurrency building blocks. In Java Concurrency in Practice, the creators of these new facilities explain not only how they work and how to use them, but also the motivation and design patterns behind them. However, developing, testing, and debugging multithreaded programs can still be very difficult; it is all too easy to create concurrent programs that appear to work, but fail when it matters most: in production, under heavy load. Java Concurrency in Practice arms readers with both the theoretical underpinnings and concrete techniques for building reliable, scalable, maintainable concurrent applications. Rather than simply offering an inventory of concurrency APIs and mechanisms, it provides design rules, patterns, and mental models that make it easier to build concurrent programs that are both correct and performant.This book covers: *Basic concepts of concurrency and thread safety *Techniques for building and composing thread-safe classes *Using the concurrency building blocks in java.util.concurrent *Performance optimization dos and don'ts *Testing concurrent programs *Advanced topics such as atomic variables, nonblocking algorithms, and the Java Memory Model

Having recently required to use Java in my work I needed a book to help explain the use of concurrency in Java. I have used C++ and Ada extensively in the defence environment for many years working on many multithreaded systems. For concurrency concepts, the book Concurrency in Ada by Burns and Wellings is still the bench mark, however while this is a Java book many of it concepts apply to any multithreaded language. This is a superb book.

The authors correctly point out that this topic, once the realm of advanced programming specialists, is now of concern to all programmers. Technology and the Java language both demand that software artisans understand concurrency and building thread-safe applications. The authors begin with some basics concerning concurrency and defining terms. This is essential since it seems an area where every software engineer seems to have their own definitions and assumptions. With the ground work complete, the authors continue on with various approaches to thread-safety and design considerations.

Included is a discussion of GUI development considerations, performance considerations, and testing strategies. Within an advanced topics section the authors cover explicit locks, custom synchronizers, and the Java memory model with respect to concurrency issues.

The writing style is clear, concise, and readable. Well worth the investment for the beginner or advanced student and sure to be referred to again and again in the future.

As others have written, this is the best book out there on Java concurrency. I am a decent journeyman coder, not a guru, and this helped me wrap my head around what is involved with concurrency. Concurrency is in many ways orthogonal to the rest of Java programming, so it's good to get a clear and authoritative guide. I still avoid multi-threading whenever possible, but if I have to go there, I reach for this book.

This is a very nice book to get to know all the tools of Java 5 for concurrency support.

This is the very best book available on concurrency. It covers all the Java 5.0 paradigms and goes from the explanation of volatile/final/mutable/immutable to advanced topics like re-entrant locks.
The best part about the book is Mr Yuk an icon to denote really bad thread unsafe code examples and comparison to different implementations that are correct -you will see from the first day onwards the mistakes that you have been making in your existing code. Very practical; Good explanation, lots of sample code.

Close your eyes look no further and get this book -you will not regret it.

Regular expressions are an extremely powerful tool for manipulating text and data. They are now standard features in a wide range of languages and popular tools, including Perl, Python, Ruby, Java, VB.NET and C# (and any language using the .NET Framework), PHP, and MySQL.

If you don't use regular expressions yet, you will discover in this book a whole new world of mastery over your data. If you already use them, you'll appreciate this book's unprecedented detail and breadth of coverage. If you think you know all you need to know about regular expressions, this book is a stunning eye-opener.

As this book shows, a command of regular expressions is an invaluable skill. Regular expressions allow you to code complex and subtle text processing that you never imagined could be automated. Regular expressions can save you time and aggravation. They can be used to craft elegant solutions to a wide range of problems. Once you've mastered regular expressions, they'll become an invaluable part of your toolkit. You will wonder how you ever got by without them.

Yet despite their wide availability, flexibility, and unparalleled power, regular expressions are frequently underutilized. Yet what is power in the hands of an expert can be fraught with peril for the unwary. Mastering Regular Expressions will help you navigate the minefield to becoming an expert and help you optimize your use of regular expressions.

Mastering Regular Expressions, Third Edition, now includes a full chapter devoted to PHP and its powerful and expressive suite of regular expression functions, in addition to enhanced PHP coverage in the central "core" chapters. Furthermore, this edition has been updated throughout to reflect advances in other languages, including expanded in-depth coverage of Sun's java.util.regex package, which has emerged as the standard Java regex implementation.Topics include:

• A comparison of features among different versions of many languages and tools
• How the regular expression engine works
• Optimization (major savings available here!)
• Matching just what you want, but not what you don't want
• Sections and chapters on individual languages

Written in the lucid, entertaining tone that makes a complex, dry topic become crystal-clear to programmers, and sprinkled with solutions to complex real-world problems, Mastering Regular Expressions, Third Edition offers a wealth information that you can put to immediate use.

Reviews of this new edition and the second edition:

"There isn't a better (or more useful) book available on regular expressions."
--Zak Greant, Managing Director, eZ Systems

"A real tour-de-force of a book which not only covers the mechanics of regexes in extraordinary detail but also talks about efficiency and the use of regexes in Perl, Java, and .NET...If you use regular expressions as part of your professional work (even if you already have a good book on whatever language you're programming in) I would strongly recommend this book to you."
--Dr. Chris Brown, Linux Format

"The author does an outstanding job leading the reader from regex novice to master. The book is extremely easy to read and chock full of useful and relevant examples...Regular expressions are valuable tools that every developer should have in their toolbox. Mastering Regular Expressions is the definitive guide to the subject, and an outstanding resource that belongs on every programmer's bookshelf. Ten out of Ten Horseshoes."
--Jason Menard, Java Ranch

Regular expressions are a central element of UNIX utilities like egrep and programming languages such as Perl. But whether you're a UNIX user or not, you can benefit from a better understanding of regular expressions since they work with applications ranging from validating data-entry fields to manipulating information in multimegabyte text files. Mastering Regular Expressions quickly covers the basics of regular-expression syntax, then delves into the mechanics of expression-processing, common pitfalls, performance issues, and implementation-specific differences. Written in an engaging style and sprinkled with solutions to complex real-world problems, Mastering Regular Expressions offers a wealth information that you can put to immediate use.

This book is great if you want to learn about what you can do with regex, how they work, how you can improve them (efficiency & accuracy) and what kind of pitfalls there are.

My only gripe is about the Ruby reference on the cover. In the top right corner it says: "For Perl, PHP, Java, .NET, Ruby and more!" Perl, Java, .NET and PHP each get their own chapters (together 200 pages). Ruby, however, only participates in feature comparisons and benchmarks. If I had checked the ToC I would've known this, so I won't hold it against the book that much.

The Ruby thing is a bummer, but since the book is great, it will get all five stars.

The book is robust and goes into alot detail. I liked the comparing and contrasting between the various RegEx implementations. I had a difficult time digesting some of the detail. In particular, the analogies confused me and I felt the author went overboard with them. Many times, I had to backtrack to understand what was being discussed. However, regular expressions is a complex topic and the author did a good job easing into the concepts. An additional plus was with inline page citation - this helped to find the page corresponding to the topic being discussed.
I would have liked shorter chapters with chapter summaries and more diagrams in place of analogies. Ultimately, Mastering Regular Expressions is a good book referencing a complex topic.

I went through several books and online tutorials and never found anything that did a good comprehensive job of explaining regular expressions. This book does. If you are having trouble "getting it", I highly encourage reading this book. You will be extremely enlightened even after the first few chapters.

Quite a comprehensive guide to regular expressions. Gets very detailed in the areas that it covers. However, definitely not a 'beginner's guide'. I highly recommend that you are already comfortable with the basis of regular expressions before picking up this book. You will get way more out of it if this is not your first introduction to it. Comfort and proficiency with Perl would also be a big help. Title is correct though, this is a guide to 'mastering' regular expressions, not learning them from the beginning.

How deep down the rabbit hole do you really NEED to go? I had a serious need to get on top of regular expressions to solve one particular problem. I looked at several online tutorials which didn't take me where I needed to go, so I ordered Mastering Regular Expressions after reading the Amazon reviews. I always look at the negative reviews first. In spite of the negative reviews I ordered the book with an open mind.
When the book arrived I began reading it with enthusiasm. In the preface there is a small section on "How to Read This Book". I bought into the author's suggestion to read the book's first six chapters first. I was captivated through the first three chapters, and then somewhere in chapter 4 I began to get very weary with information overload. After putting the book down for a couple of days I decided to skip the rest and use what I needed to write the one regular expression I had need of. The book did successfully help me accomplish this, so I gave it 3 stars. Not only did it give me the information I needed that the online tutorials didn't, it also gave me the confidence I needed. For that, which I am grateful, I would have liked to have given it more stars. I think many of those in need of learning about regular expression could be well served by a "lite-edition" of this book. Perhaps someday when I have the time and the need I may try to wade through the rest of the book, but as it is now Mastering Regular Expressions took me far farther down the rabbit hole than I really needed or wanted to go.
If you need to get on top of Regular Expressions, I would recommend this book, however just be ready to be taken far deeper than the average coder probably needs to go.

Spring in Action 2E is an expanded, completely updated second edition of the best selling Spring in Action. Written by Craig Walls, one of Manning's best writers, this book covers the exciting new features of Spring 2.0, which was released in October 2006.

Spring is a lightweight container framework that represents an exciting way to build enterprise components with simple Java objects. By employing dependency injection and AOP, Spring encourages loosely coupled code and enables plain-old Java objects with capabilities that were previously reserved for EJBs. This book is a hands-on, example-driven exploration of the Spring Framework. Combining short code snippets and an ongoing example developed throughout the book, it shows readers how to build simple and efficient J2EE applications, how to solve persistence problems, handle asynchronous messaging, create and consume remote services, build web applications, and integrate with most popular web frameworks. Readers will learn how to use Spring to write simpler, easier to maintain code so they can focus on what really matters-- critical business needs.

Spring in Action, 2E is for Java developers who are looking for ways to build enterprise-grade applications based on simple Java objects, without resorting to more complex and invasive EJBs. Even hard-core EJB users will find this book valuable as Spring in Action, 2E will describe ways to use EJB components alongside Spring. Software architects will also find Spring in Action, 2E useful as they assess and apply lightweight techniques prescribed by Spring. and learn how Spring can be applied at the various layers of enterprise applications.

Overall, Spring in Action (SIA) is an excellent book, well worth buying. Here are my impressions after having studied (in a group) several portions of the book a little while ago:

---------
Pros are:
---------
- SIA contains many memorable source code examples that help the concepts stick in one's mind.
- Very much in the tradition of books from Manning publishers, the print quality is pleasing, and the book lays flat nicely for easy reading. In this aspect, it's right up there with the book "Code Craft: The Practice of Writing Excellent Code" by Pete Goodliffe (Publisher: No Starch Press), which, by the way, is another eminently readable, useful book. This is in stark contrast with the book "Eclipse Distilled" by David Carlson (Publisher: Addison-Wesley Professional). While the content quality of "Eclipse Distilled" is very good, the print quality is poor (I'm all for printing on recycled paper, but not on shoddy recycled paper) and the binding inferior -- Try keeping the book "Eclipse Distilled" lying open on a flat surface, and it'll spring [sic - no pun intended in connection with the book I'm reviewing] shut like a steel trap; so much easy reading :-( But SIA is not like that at all and, in sum, excels in this respect.
- The basics are covered very well -- Dependency Injection and AOP, solving persistence problems, handling asynchronous messaging -- It's all in here!

---------
Cons are:
---------
- In more places than I care to count, SIA tends to have a rambling style.
- Hand-in-hand with the rambling style -- while an excellent tutorial that's worth studying and owning -- SIA is not eminently suitable as a reference. But for that we can always go to the ubiquitous online Spring API.

I've managed to get through the first six chapters in two weeks. Although the writing style is readable for a technical book there is a glaring lack of examples other than dangling code snippets that show how to actually use Spring. The code I downloaded from the book's web site is largely incoherent and undocumented.

I did manage to find several online tutorials that have been a lot more help. I recommend finding one that you like before attempting to wade past the first four chapters.

I am a great fan of struts framework and have been looking out for Spring Framework from quite some time. Did lot of search on internet but was not able to find much information.

This book gave me exactly what I needed and it helped me in understanding n appreciating the concepts and simplicity of Spring Framework.

I enjoyed the first edition and this one is equally good. I would like more information about MVC (or a Spring MVC in action book) but anyway it's highly recommendable. I hope they update it soon to Spring 2.5.

This book is exactly what you would expect from the In Action Series. The book is thorough and comprehensive. I even thought it had a slightly more personal writing style than some other In Action books.

Creating robust software requires the use of efficient algorithms, but programmers seldom think about them until a problem occurs. Algorithms in a Nutshell describes a large number of existing algorithms for solving a variety of problems, and helps you select and implement the right algorithm for your needs -- with just enough math to let you understand and analyze algorithm performance.

With its focus on application, rather than theory, this book provides efficient code solutions in several programming languages that you can easily adapt to a specific project. Each major algorithm is presented in the style of a design pattern that includes information to help you understand why and when the algorithm is appropriate.

With this book, you will:

• Solve a particular coding problem or improve on the performance of an existing solution
• Quickly locate algorithms that relate to the problems you want to solve, and determine why a particular algorithm is the right one to use
• Get algorithmic solutions in C, C++, Java, and Ruby with implementation tips
• Learn the expected performance of an algorithm, and the conditions it needs to perform at its best
• Discover the impact that similar design decisions have on different algorithms
• Learn advanced data structures to improve the efficiency of algorithms

With Algorithms in a Nutshell, you'll learn how to improve the performance of key algorithms essential for the success of your software applications.

This new book on algorithms from O'Reilly is a breath of fresh air. Most books on the subject fall into two categories: very dense tomes full of math and heavy on sometime unintelligible pseudocode, or books that basically just give you recipes without much understanding. The second category is the "give a man a fish" type, the first type is the "teach a man to fish, but use ALGOL to do it". Even the author, in his preface, recognizes that this is not the one book on algorithms you'd need if you were on a desert island. On a desert island you have plenty of time and you can carefully digest Cormen's Introduction to Algorithms. However, you're not on a desert island, are you? Thus this book is the link between Cormen's careful theoretical approach that takes time, and books that amount to code dumps.

The first six chapters amount to supplements on the basics of Theory of Algorithm courses: mathematics foundations, sorting, searching, and graphing algorithms. The mathematics here is somewhat lacking, but then the author is assuming you have other books on the subject - this is a book for ramping up quickly. The rest of the book is rather specialized, considering specific families of algorithms that are topical in these times such as path finding in AI, computational geometry, and network flow. They fill in the blanks missing in the standard textbooks. Plus there is plenty of code - real code, not pseudocode - that you can put to work quickly. The product description lacks the table of contents, so I list that next:

Part I: I
Chapter 1. Algorithms Matter
Section 1.1. Understand the Problem
Section 1.2. Experiment if Necessary
Section 1.3. Side Story
Section 1.4. The Moral of the Story
Section 1.5. References
Chapter 2. The Mathematics of Algorithms
Section 2.1. Size of a Problem Instance
Section 2.2. Rate of Growth of Functions
Section 2.3. Analysis in the Best, Average, and Worst Cases
Section 2.4. Performance Families
Section 2.5. Mix of Operations
Section 2.6. Benchmark Operations
Section 2.7. One Final Point
Section 2.8. References
Chapter 3. Patterns and Domains
Section 3.1. Patterns: A Communication Language
Section 3.2. Algorithm Pattern Format
Section 3.3. Pseudocode Pattern Format
Section 3.4. Design Format
Section 3.5. Empirical Evaluation Format
Section 3.6. Domains and Algorithms
Section 3.7. Floating-Point Computations
Section 3.8. Manual Memory Allocation
Section 3.9. Choosing a Programming Language
Section 3.10. References
Part II: II
Chapter 4. Sorting Algorithms
Section 4.1. Overview
Section 4.2. Insertion Sort
Section 4.3. Median Sort
Section 4.4. Quicksort
Section 4.5. Selection Sort
Section 4.6. Heap Sort
Section 4.7. Counting Sort
Section 4.8. Bucket Sort
Section 4.9. Criteria for Choosing a Sorting Algorithm
Section 4.10. References
Chapter 5. Searching
Section 5.1. Overview
Section 5.2. Sequential Search
Section 5.3. Binary Search
Section 5.4. Hash-based Search
Section 5.5. Binary Tree Search
Chapter 6. Graph Algorithms
Section 6.1. Overview
Section 6.2. Depth-First Search
Section 6.3. Breadth-First Search
Section 6.4. Single-Source Shortest Path
Section 6.5. All Pairs Shortest Path
Section 6.6. Minimum Spanning Tree Algorithms
Section 6.7. References
Chapter 7. Path Finding in AI
Section 7.1. Overview
Section 7.2. Depth-First Search
Section 7.3. Breadth-First Search
Section 7.4. A*Search
Section 7.5. Comparison
Section 7.6. Minimax
Section 7.7. NegMax
Section 7.8. AlphaBeta
Section 7.9. References
Chapter 8. Network Flow Algorithms
Section 8.1. Overview
Section 8.2. Maximum Flow
Section 8.3. Bipartite Matching
Section 8.4. Reflections on Augmenting Paths
Section 8.5. Minimum Cost Flow
Section 8.6. Transshipment
Section 8.7. Transportation
Section 8.8. Assignment
Section 8.9. Linear Programming
Section 8.10. References
Chapter 9. Computational Geometry
Section 9.1. Overview
Section 9.2. Convex Hull Scan
Section 9.3. LineSweep
Section 9.4. Nearest Neighbor Queries
Section 9.5. Range Queries
Section 9.6. References
Part III: III
Chapter 10. When All Else Fails
Section 10.1. Variations on a Theme
Section 10.2. Approximation Algorithms
Section 10.3. Offline Algorithms
Section 10.4. Parallel Algorithms
Section 10.5. Randomized Algorithms
Section 10.6. Algorithms That Can Be Wrong, but with Diminishing Probability
Section 10.7. References
Chapter 11. Epilogue
Section 11.1. Overview
Section 11.2. Principle: Know Your Data
Section 11.3. Principle: Decompose the Problem into Smaller Problems
Section 11.4. Principle: Choose the Right Data Structure
Section 11.5. Principle: Add Storage to Increase Performance
Section 11.6. Principle: If No Solution Is Evident, Construct a Search
Section 11.7. Principle: If No Solution Is Evident, Reduce Your Problem to Another Problem That Has a Solution
Section 11.8. Principle: Writing Algorithms Is Hard--Testing Algorithms Is Harder
Part IV: IV
Appendix A. Benchmarking
Section A.1. Statistical Foundation
Section A.2. Hardware
Section A.3. Reporting
Section A.4. Precision

For too long, developers have worked on disorganized application projects, where every part seemed to have its own build system, and no common repository existed for information about the state of the project. Now there's help. The long-awaited official documentation to Maven is here.

Written by Maven creator Jason Van Zyl and his team at Sonatype, Maven: The Definitive Guide clearly explains how this tool can bring order to your software development projects. Maven is largely replacing Ant as the build tool of choice for large open source Java projects because, unlike Ant, Maven is also a project management tool that can run reports, generate a project website, and facilitate communication among members of a working team.

To use Maven, everything you need to know is in this guide. The first part demonstrates the tool's capabilities through the development, from ideation to deployment, of several sample applications -- a simple software development project, a simple web application, a multi-module project, and a multi-module enterprise project.

The second part offers a complete reference guide that includes:

• The POM and Project Relationships
• The Build Lifecycle
• Plugins
• Project website generation
• Advanced site generation
• Reporting
• Properties
• Build Profiles
• The Maven Repository
• Team Collaboration
• Writing Plugins
• IDEs such as Eclipse, IntelliJ, ands NetBeans
• Using and creating assemblies
• Developing with Maven Archetypes

Several sources for Maven have appeared online for some time, but nothing served as an introduction and comprehensive reference guide to this tool -- until now. Maven: The Definitive Guide is the ideal book to help you manage development projects for software, web applications, and enterprise applications. And it comes straight from the source.