Recommended books about object oriented

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.

Portable, powerful, and a breeze to use, Python is ideal for both standalone programs and scripting applications. With this hands-on book, you can master the fundamentals of the core Python language quickly and efficiently, whether you're new to programming or just new to Python. Once you finish, you will know enough about the language to use it in any application domain you choose. Learning Python is based on material from author Mark Lutz's popular training courses, which he's taught over the past decade. Each chapter is a self-contained lesson that helps you thoroughly understand a key component of Python before you continue. Along with plenty of annotated examples, illustrations, and chapter summaries, every chapter also contains Brain Builder, a unique section with practical exercises and review quizzes that let you practice new skills and test your understanding as you go. This book covers: Types and Operations -- Python's major built-in object types in depth: numbers, lists, dictionaries, and more Statements and Syntax -- the code you type to create and process objects in Python, along with Python's general syntax model Functions -- Python's basic procedural tool for structuring and reusing code Modules -- packages of statements, functions, and other tools organized into larger components Classes and OOP -- Python's optional object-oriented programming tool for structuring code for customization and reuse Exceptions and Tools -- exception handling model and statements, plus a look at development tools for writing larger programs. Learning Python gives you a deep and complete understanding of the language that will help you comprehend any application-level examples of Python that you later encounter. If you're ready to discover what Google and YouTube see in Python, this book is the best way to get started.

The authors of Learning Python show you enough essentials of the Python scripting language to enable you to begin solving problems right away, then reveal more powerful aspects of the language one at a time. This approach is sure to appeal to programmers and system administrators who have urgent problems and a preference for learning by semi-guided experimentation.

First off, Learning Python shows the relationships among Python scripts and their interpreter (in a mostly platform-neutral way). Then, the authors address the mechanics of the language itself, providing illustrations of how Python conceives of numbers, strings, and other objects as well as the operators you use to work with them. Dictionaries, lists, tuples, and other data structures specific to Python receive plenty of attention including complete examples.

Authors Mark Lutz and David Ascher build on that fundamental information in their discussions of functions and modules, which evolve into coverage of namespaces, classes, and the object-oriented aspects of Python programming. There's also information on creating graphical user interfaces (GUIs) for Python applications with Tkinter.

In addition to its careful expository prose, Learning Python includes exercises that both test your Python skills and help reveal more elusive truths about the language.

I just spent a few days going through this book and learned a lot. I've been working with PHP for years, but never did much complicated code. I studied Java about 8 years ago also and learned a lot about OOP from that. But never did any programming in Java. So it was all concept, no experience.

My reason for reading this book was to start using Python with Django. I wanted to learn Python first so I would understand the framework better.

This book covers in excruciating detail many of the finer qualities of just about everything you can imagine being in the language. I'm sure it doesn't cover everything the language can do. But somehow it spends 600 plus pages going over details that I wouldn't expect to find even if I was reading a 300 page book called "What I was thinking when I wrote this particular function on July 3rd 1991"

If something can be explained by 2 lines of example code and a three sentence paragraph about what's going on, the author does that -after 2 pages of explanation of how this code you are about to see might be a little like C, but it's a little different too, and how what you are going to learn is really powerful, and how some students might notice that the code is similar in structure to the code that you will see on page 400 later in the book.

If you think my review is way too verbose, read the book.

I give it 3 stars because it was in fact clear and well communicated information. It was just often hard to keep reading past all the unnecessary words to get to the useful content.

As a newcomer to Python, I find this book educational but somewhat inadequate for getting one's feet wet with a new programming language. Essentially all the sample code in the book is in the form of very short snippets run from the command line. There is almost nothing in the way of a full-blown sample Python program showing the reader what it's all supposed to look like in the end.

Python's strengths as a programming language are ostensibly its readability and ease of use, but you get no sense of that reading this book. All you get is bits and pieces that you have to glue together somehow. It's neither a complete technical manual nor a good introductory book for the novice programmer. The book is useful, but I would hope that there are better titles out there.

I wanted to like this book. As a general rule, I give the benefit of a doubt to O'Reilly books, and rarely am I mistaken. But this was one of the rare exceptions. In my experience, there are two trains of thought when it comes to learning a programming language:
1) Start right in with a book, using it to familiarize yourself with the language while you use the language to start fleshing out stuff that you learn in the book -- let's call this the "synergistic" or maybe "complementary" approach: using the book complements the coding you try, which, in turn, lets you put stuff you're learning into a workable framework.
2) Read the whole book through, and then apply what you've learned.

Personally, I don't know anyone with a good enough memory to really be able to pull off #2. But, honestly, it's more about patience than memory: people get excited about a language, and want to start using it. Having to (pretty much) read a whole book before you can start digging in is a bit of an anti-climax. The problem is that that's what you have to do with _Learning Python_. For example, one of the fundamentals of almost all programming languages is how looping is accomplished. In _Learning Python_, looping isn't discussed in detail until you're almost *250* pages into the book. Instead, the very, very fundamentals of the language are gone over in excruciating detail. Honestly, if you'd never programmed before, this might actually be a helpful, good thing. If, on the other hand, you've had pretty much any other programming experience, the pace is slow and tedious. I found myself yearning to be *doing* something, and instead was just plodding along.

If you have had previous programming experience, and are relatively well-versed with how languages work, I have to recommend _Python Essential Reference_ by David M. Beazley. Just read its first chapter in the bookstore, and you'll find yourself becoming quickly enlightened.

Like my title suggests, if you have programming experience and you do not mind or have little trouble reading the Python documentation in a online fashion then its probably not absolutely necessary that you have to buy the book.

However, the author is very good in instilling the nature of Python programming and he's good at getting you to think about the concepts but this book is definitely not a cookbook. Last thing is that it doesn't concentrate on the GUI nor library usage etc as it's mission is simply to teach you about the core of Python

This book is great! Good writing, good exercises. Good for people who have some experience in programming. If you have never had any contact to other languages or logic, consider studying some introdutory topics before reading this book.

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.

*Capturing a wealth of experience about the design of object-oriented software, four top-notch designers present a catalog of simple and succinct solutions to commonly occurring design problems. Previously undocumented, these 23 patterns allow designers to create more flexible, elegant, and ultimately reusable designs without having to rediscover the design solutions themselves. *The authors begin by describing what patterns are and how they can help you design object-oriented software. They then go on to systematically name, explain, evaluate, and catalog recurring designs in object-oriented systems. With Design Patterns as your guide, you will learn how these important patterns fit into the software development process, and how you can leverage them to solve your own design problems most efficiently.

Design Patterns is a modern classic in the literature of object-oriented development, offering timeless and elegant solutions to common problems in software design. It describes patterns for managing object creation, composing objects into larger structures, and coordinating control flow between objects. The book provides numerous examples where using composition rather than inheritance can improve the reusability and flexibility of code. Note, though, that it's not a tutorial but a catalog that you can use to find an object-oriented design pattern that's appropriate for the needs of your particular application--a selection for virtuoso programmers who appreciate (or require) consistent, well-engineered object-oriented designs.

I thinks this is a great book for anyone wanting to learn or have a reference on design patterns. It does expect the user to know OO C++. It is definetly a book for software engineers to have on their collection.

The concept of design patterns transcends programming languages. If you wish to think "outside the box" yet be effective and efficient, either this book will provide the answer or help you think in ways that you can develop our own design. A must read.

I would say this book was a bit old school in it's approach and content, but was exactly what i needed to get a good starting point in understanding how to use design patterns in my software designs. The case studies it presented were simple problems but contained practical elements I could apply to my next big project.

This is the most recommended book on object oriented design. I can see now.what all the hype is about. I have been a developer for almost six years now. I have been using object oriented languages for some time. Despite the experience with the technologies, I didn't have a good working knowlege of how to effectively implement the technology and methodology in my own code. That is, until I read "Design Patterns". It has opened my eyes and I understand the concepts of polymorphism and code reuse much more clearly now.

"Design Patterns" is easy to read, easy to understand and has great code examples that facilitate understanding. It is my opinion that if you haven't read this book and you develop with OOP, you are probably working harder and not smarter. So do yourself a favor and pick up a copy.

I give this book a 3 because it was great when it was written. But now, it is not a very good book to read. Most people who read it acknowledge they can't understand it. There are two excellent books on the market that should be read if you want to learn design patterns.

Head First Design Patterns (Head First) - is the best book to read on what patterns are as solutions to a problem in a context. Fun to read, useful, really wonderful *****.

However, if you want to learn what patterns really are - the thought process behind them, read Design Patterns Explained: A New Perspective on Object-Oriented Design (2nd Edition) (Software Patterns Series) *****

A related book that would also be a good read is Scott Bain's Emergent Design: The Evolutionary Nature of Professional Software Development (Net Objectives Product Development Series) *****

Let's give tribute to the acknowledged #1 classic in the modern software industry. But it is not the book to read to learn patterns anymore.

ActionScript 3.0 is a huge upgrade to Flash's programming language. The enhancements to ActionScript's performance, feature set, ease of use, cleanliness, and sophistication are considerable. Essential ActionScript 3.0 focuses on the core language and object-oriented programming, along with the Flash Player API. Essential ActionScript has become the #1 resource for the Flash and ActionScript development community, and the reason is the author, Colin Moock. Many people even refer to it simply as "The Colin Moock book." And for good reason: No one is better at turning ActionScript inside out, learning its nuances and capabilities, and then explaining everything in such an accessible way. Colin Moock is not just a talented programmer and technologist; he's also a gifted teacher. Essential ActionScript 3.0 is a radically overhauled update to Essential ActionScript 2.0. True to its roots, the book once again focuses on the core language and object-oriented programming, but also adds a deep look at the centerpiece of Flash Player's new API: display programming. Enjoy hundreds of brand new pages covering exciting new language features, such as the DOM-based event architecture, E4X, and namespaces--all brimming with real-world sample code. The ActionScript 3.0 revolution is here, and Essential ActionScript 3.0's steady hand is waiting to guide you through it.

I really liked Mr.Moock's book, as it goes from the fundamentals to crystal clear object oriented programming. As an AS2 programmer I filled gaps to make a succesfull switch to ActionScript3.0, and got a good grip in Flex also. Recommended!

I don't really like this book. Its way too descriptive and the result is that the subject matter is made to seem over-complicated. If you have some familiarity with OOP programming, you'll have to sort through lots of reading to get a few needed bits of information. If you're new to programming, the first 137 pages have no working code and so you'll have to understand deep and detailed programming basics without putting any theory into practice or having any working experience with the content. 'Not what I would want if I were a beginner.

I'm a huge fan of O'Reilly books, but this book should be avoided.

Good book as a code reference but in my opinion we need more real exercises for a better understand.

This book is brilliant. It's encyclopedic. It is a must-have to better understand AS 3 and to hopefully lower your frustration when coding. I am a designer fairly new to AS 3 and found this book gave clear, detailed explanations on every aspect of AS 3. Like an encyclopedia, each chapter breaks down specific core concepts, from Arrays and XML, into their basics. Information is laid out well and can be found quickly simply by looking at the book's table of contents. As a reference book, it fills in the "why" that other books on Flash or on-line tutorials don't have time or space to cover in easy to understand detail. Colin Moock avoids confusing jargon and de-mystifies ActionScipt.

I learned a good bit from this book; however I came into this with over 6 years for programming experience.

Part 1:

I found that this moved to slow for me. Much of it I already knew. So from an experienced perspective it was it was way to much info.

From a "I never programmed" it could be a good reference, but ultimately it would leave such a person with a shallow understanding of what is going on. I think he should have broke this book down into pieces. A good beginner would have been the first part of this book with some expansion on callback and closure theory combined with another book; Object Oriented ActionScript 3.0.

Part II:

The second part of the book was decent but had quite a few errors. For example in Screen Updates; his code for an optimized ellipse. In removedFromStageListener he adds the listener instead of removing it. He also never clears the redraw variable so it will always redraw when Event.RENDER is called.

This was so obvious to me that it was none issue. But for the intended audience I could see as being completely confusing and frustrating.

The good news is he does address both these issues in the Errata (but in two separate updates).

Part III:

They are there to support some concepts discussed in the book; they should have been before Part II and they are like a scholastic version of the content covered (not a bad thing; it is just what it is).

Extra Content:
His source download is one of the most horribly organized "extra" content downloads I've ever ran into. He lists everything by name not chapter. Some code is included some is not. Both combined I find my self spending extra time trying to find content never knowing if is just labeled funny or just not documented at all. Over all your best bet it to purchase this as a pdf book so you can just copy and paste the examples.

Bottom line:
These writers need to stop trying to create these "everything covered" books. Ultimately they are rushed, shallow and alienate their intended audience.

I would still recommend this book as really I've found no other resource except for the language reference that goes over the material that is discussed in this book. Just be sure that you have the Errata handy!

Product Description
In this book, authors Rich Shupe and Zevan Rosser share the knowledge they've gained from their years as multimedia developers/designers and teachers. Learning ActionScript 3.0 gives you a solid foundation in the language of Flash and demonstrates how you can use it for practical, everyday projects. The authors do more than just give you a collection of sample scripts. Written for those of you new to ActionScript 3.0, the book describes how ActionScript and Flash work, giving you a clear look into essential topics such as logic, event handling, displaying content, migrating legacy projects to ActionScript 3.0, classes, and much more. You will learn important techniques through hands-on exercises, and then build on those skills as chapters progress. ActionScript 3.0 represents a significant change for many Flash users, and a steeper learning curve for the uninitiated. This book will help guide you through a variety of scripting scenarios. Rather than relying heavily on prior knowledge of object-oriented programming (OOP), topics are explained in focused examples that originate in the timeline, with optional companion classes for those already comfortable with their use. As chapters progress, the book introduces more and more OOP techniques, allowing you to choose which scripting approach you prefer. Learning ActionScript 3.0 reveals: New ways to harness the power and performance of AS3 Common mistakes that people make with the language Essential coverage of text, sound, video, XML, drawing with code, and more Migration issues from AS1 and AS2 to AS3 Simultaneous development of procedural and object-oriented techniques Tips that go beyond simple script collections, including how toapproach a project and which resources can help you along the way The companion web site contains material for all the exercises in the book, as well as short quizzes to make sure you're up to speed with key concepts. ActionScript 3.0 is a different animal from previous versions, and Learning ActionScript 3.0 teaches everything that web designers, GUI-based Flash developers, and those new to ActionScript need to start using the language.

Praise
"The best ActionScript book ever written."
-Lee Brimelow, Creator of The Flash Blog

I think the book does a great job explaining all of the intricate details of OOP for experienced Actionscript users. I have used AS2 for a long time and I was very frustrated how so much had changed in AS3 and I never seemed to find a good book to explain each change. This book does that and more.

In addition to spelling out the advantages of using AS3 and OOP in general, it even takes things a step further by actually DEFINING programming design methodologies that are using in most development based work environments (i.e. Agile, XP, Waterfall, etc.). You know, all of those acronyms and other garbage that people through into job descriptions to intimidate newbies.

I'm inclined to agree that this book may not be suited for beginners to Actionscript, I would strongly recommend that anyone who is learning AS for the first time should grab a beginner's book (maybe a cheap one) and then use this as your professional reference guide. Everything is categorized and color coded for you: Need to attach a sound? Chpt. 13. Need to read XML? Chpt. 14

john

This book is great. I am starting off with AS 3.0 and its a great reference. I feel though sometimes it gets too complicated. Also it does not have many pictures, but the good thing is that the code is color coded. According to my professor who is very into finding books, its the best one out there for AS. I haven;t had a ton of time to look through the book yet, but so far what I see is helpful, just a really boring read.

I'm starting from scratch to learn Flash AS 3 and this book seems to be a very good starting point. I haven't read it through yet, but it's yet been very understandable and there's not too much technical jargon (I have 5+ years of PHP-coding to start with).

I have worked with Action Script in the past on many projects but I never took advantage of the real programming capabilities that Action Script 3 has to offers, so I wanted to find a book to help me take the next step and this is the one. I got this book and I was immediately hooked because it was written in a way that makes you feel comfortable and relaxed instead of intimidated.

This book offers simple easy to understand tutorials accompanied with the basic start files already designed so that you can focus on the programming.

If your looking for a great book for beginning or intermediate Action Script 3 porgramming then this is the one for you.

EXCELLENT BOOK.

If your new to actionscript 3 or just new to actionscript period , this book will help you catch up with it. You will feel confident as you go through the book and practice examples.

What I really liked is that while the book is showing you how to code with actionscript 3, the examples will even apply to actionscript 2 or 1 ( with different coding of course, but the principle idea is great)

I would really recommend you pick up this book.

Programming in Objective-C is a concise, carefully written tutorial on the basics of Objective-C and object-oriented programming. The book makes no assumption about prior experience with object-oriented programming languages or with the C language (upon which Objective-C is based). And because of this, both novice and experienced programmers alike can use this book to quickly and effectively learn the fundamentals of Objective-C. Readers can also learn the concepts of object-oriented programming without having to first learn all of the intricacies of the underlying procedural language (C). This approach, combined with many small program examples and exercises at the end of each chapter, makes it ideally suited for either classroom use or self-study. Growth is expected in this language. At the January 2003 MacWorld, it was announced that there are 5 million Mac OS X users and each of their boxes ships with Objective-C built in.

This is an excellent introductory book on Objective C programming language as used for the Apple Macintosh and Apple iPhone. It is very clearly written, with good examples, and good exercises that help reinforce the concepts that need to be learned. I used this book to become proficient in Objective C in less than 3 weeks.(Note I have previous experience with C language and the Macintosh programming language so your learning rate may vary) I highly recommend this to those seeking to learn or review Objective C.

Don't waste your money on this book like I did. It too out of date to be of any use. Mac Xcode has changed too much since this was published.

Excellent!

I got this almost by accident in a bundle of books I picked up on eBay and it is the single best written 'how to learn a language' book I have ever encountered.

Clear, concise and just so well written. Quite complex issues are handled with great skill and deftness.

I have pre-ordered the 2nd edition just to give Kochan the credit he deserves and didn't get from my second-hand purchase.

If you have a Mac and think you want to understand programming (even if you aren't going to really write any programs) get this.

Whatever OS you have go get Kochan's book on C Programming which is nearly as good. Unfortunately C is simply more obtuse so even Kochan's great writing can't make it much easier than he does because it just is closer to the metal with all the power and complexity that that means.

Anyway it's a great book and if you want some of the best coverage of Object Orientated Programming you'll read anywhere it's easily worth the price (especially at the insanely cheap Amazon price).

If you are new to Objective-C and are teaching yourself, do the following.
A. GET THIS BOOK.
B. Get the Objective-C Pocket Reference.
C. Get programming.

In short, this book is a perfect start developing form Mac and also iPhone, the title is a bit misleading as it only mentions ObjectiveC but the fact is that it takes you in a very coherent and well written fashion to C and also Cocoa framework.
Great book, buy it.

Designing a good interface isn't easy. Users demand software that is well-behaved, good-looking, and easy to use. Your clients or managers demand originality and a short time to market. Your UI technology -- web applications, desktop software, even mobile devices -- may give you the tools you need, but little guidance on how to use them well.

UI designers over the years have refined the art of interface design, evolving many best practices and reusable ideas. If you learn these, and understand why the best user interfaces work so well, you too can design engaging and usable interfaces with less guesswork and more confidence.

"Designing Interfaces" captures those best practices as design patterns -- solutions to common design problems, tailored to the situation at hand. Each pattern contains practical advice that you can put to use immediately, plus a variety of examples illustrated in full color. You'll get recommendations, design alternatives, and warnings on when not to use them.

Each chapter's introduction describes key design concepts that are often misunderstood, such as affordances, visual hierarchy, navigational distance, and the use of color. These give you a deeper understanding of why the patterns work, and how to apply them with more insight.

A book can't design an interface for you -- no foolproof design process is given here -- but "Designing Interfaces" does give you concrete ideas that you can mix and recombine as you see fit. Experienced designers can use it as a sourcebook of ideas. Novice designers will find a roadmap to the world of interface and interaction design, with enough guidance to start using these patterns immediately.

This book is by far the best book that does for the User Interface world of computing what Edward R. Tufte's series of books does for the writer's of technical reports and their needs to present and represent many varied types of data and data interaction. Need to show the effects of miles marched, time required to cover terrain, and temperature on Napoleon's armies march on Moscow and show the number of troops he has left alive at every point along the journey? Tufte shows how the French engineer Charles Minard did so. "Designing Interfaces" does exactly the same thing by showing how various UI pioneers have done the same for the Man-Machine interface. Want to see which issues are getting the most reporting in Google News and how fast or slow those issues are fading from the landscape? Check out the marumishi "Treemap" described on page 205 of Designing Interfaces. Highly recommended.

Nutshell review - If you design interfaces for any software project you should read this book. It covers all the bases, is extensive, comprehensive, well written and easy to use as a resource or refresher in interface design techniques.

Designing Interfaces catalogs UI design patterns in use and provides guidance in using them, with plenty of examples. It takes a consistent approach to describing each pattern: What it is, when to use it, why to use it and how to use it. The book is both a good overview and a reference. If UI design is an area of interest to you, then read through this book and then keep it available as a reference.

For many years now, I have been coding web sites and applications. Through all that time, nothing has ever been as tough for me as coming up with a design that I am truly happy with. Attempting to create an optimized and stable algorithm or coming up with the answer to a problem that requires non-conventional coding practices; these are always challenges, but ones that are most often eventually solved. Creating that mythical eye catching never-been-done-before layout is something that I have attempted and, sadly to say, usually fell short on. I suppose you'd consider this a case of a programmer wanting an application to not look like a programmer designed it. This was my reason for picking up the Designing Interfaces book.

The first chapter talks about how users think. However, as I finished the chapter introduction, I realized that the author and I are definitely coming from two very different places. In my experience, I get very little hands-on with the user base, or the client that the application is being built for. Even if I do talk to the client directly, instead of going through the levels of proper channels, they usually have a set design in mind, limiting my choices. That's not to say, however, that a good designer couldn't be creative given these design constraints. On the other hand, the author mentions that building a user profile is something that eats up a lot of time though it is always worth it, and while I agree whole-heartedly, sometimes a deadline approaches too quickly or it's just not in the budget to give this the time it truly needs. Past this quibble and reading on, the patterns of human behavior in the first chapter give an almost checklist of things to keep in mind when designing, and even though you read and probably think, "common sense", it is very helpful to have in one place.

As the chapters passed one by one, I found the same patterns in my reading emerge. Read the introduction to the chapters the first time you pick up the book to get an idea behind why that particular chapter is important, or, at the very least, for posterity. After that, just skip to the section in each chapter marked as "Patterns" when you need them. These patterns are where the book really shines. Each of these patterns are laid out in a similar way letting you quickly see what it is, when you would use it, why it is used (as in why it is beneficial to your user), how you create the pattern, and then some examples of its use. Considering that there are nine chapters, each with about ten different patterns, this book contains a wealth of information.

I was originally hoping for more of a design lesson; color theory, placement with a hint of golden ratios, maybe a small college art class packed into 331 pages. Though I did not get much of that, at least until the last chapter or two, I definitely found an excellent reference to keep by my side. For example, if I'm building a layout, I'll open the book right up to chapter 4 to see what the common options are; for showing hierarchical data, I'm opening up to chapter 6 to see when and for what reason I might want to go with a tree map over a normal tree. I couldn't recommend it more to someone wanting a helpful component pocket guide of sorts for interfaces, but if you are looking for theory, I'd go with something more geared in that direction.

While I don't own a physical copy of this book, I had used an electronic form of it in the course of my studies.

I will first forewarn those who are interested in Human-Computer Interaction (HCI) that this text does not heavily focus on the science of Psychological principles such as Gestalt Perception, nor does it concern itself with techniques/methodologies such as Threading and Model-View-Controller (MVC) to improve the performance of programs. The focus of this text falls strictly on the layout and/or graphical design in regards to interfaces and web pages.

As well, each principle has certain uses depending on the medium used, which the text does a good job of elaborating (for example, cell phone programs would not be designed the same as a full Windows Application).

A word to the wise though: Requirements must come before Design. There are certain design principles outlined in this text that cannot be realized if the very requirements of the program do not allow for it - For example, Microsoft Office 2007 has in many ways disregarded the principle of habituation/familiarity (as it looks much different from typical Windows Applications in general). One will still need the skill of compromise in order to apply the information presented here effectively in the real world.