Programming Books

This in-depth look into transaction processing provides a wonderful place to start when considering implementation in your application(s). Cover-to-cover, this is an EXTREMELY easy read and doesn't try to be "fancy" or use complicated wording as many other books on the topic do.

Before reading any other transaction books or jumping into API document, this is a MUST MUST MUST MUST read. When developing an application that has transaction support, this is wonderful as a reference in order to include data in presentations, summaries, position papers, internal documentation, etc.

No only will this benefit a general developer, but also benefit people not in the development environment. This allows for clarification of communication between departments without going into API-specific implementation details.

This book is excelent for who want to deep his knowledge in TP. Is very practical with many examples and tips. Funthermore include examples of of transacctions for commercials TP like a MTS (COM + today), Tuxedo, CICS, etc.
Is a book very very recommendable.
bye.

The title of this review is a quote from the book and it summarizes it very nicely. Indeed, the book provides a great deal of information in such a small volume, but many of the things that would have been nice to have are missing and many are just skimmed over.

The best chapters of the book explain in very simple words the principles of transaction logging (along with recovery from a failure), two-phase locking and two-phase commit.

The chapter on transactional communications is not as thorough as the just mentioned ones and pays most attention to transactional message queueing rather than synchronous RPC and peer-to-peer. On top of that, message queues are just transactional, period. No attention is paid to the message queues specifics.

The chapter on transaction processing monitors considers only the three-tier environment with presentation, workflow and transaction tiers.

Other problems ?

The whole chapter with an overview of the existing transaction processing software was useless. You see, product Foo has features A and B, and product Bar has features C and D, so what ? As you read it, certain architecture similarities show through, but it's up to you to analyze it, the book gives no cross-product comparison, no analysis, just a list of acronyms.

Samples in Cobol (duh !) or tangled C-like code. The pictures are less than perfect.

But the biggest problem to me was certainly the lack of real-life information. Specifically, I would better be interested in interaction between transactional and non-transactional systems. An acknowledgement of databases and message queues being the only transactional systems (or not) and the implications of that. Two-phase commit in heterogeneous environment. And so on.

A great introductory book.

Transaction processing is a daunting topic, and this is one of the few books that provides the basics in a clear, understandable manner without overwhelming the reader. Most of the book is focused solely on transaction processing, but it touches on queuing as well, which makes it the ideal first book for anyone who is seeking details that extend beyond pure TP.

I like the way that the authors use real products to reinforce key points made throughout the book. While some of the products are no longer mainstream (indeed, some were never mainstream), the fact that real world implementations are used makes the information realistic. If you are using CICS, MQSeries, Tuxedo or similar products this book will have even more value. I also like the way difficult topics, such as locking, high availability and database recovery are given entire chapters because these topics need to be thoroughly understood in order to completely understand transaction processing.

After reading this book you will be armed with sufficient knowledge to make intelligent choices in selecting the right approach for transaction processing in a system design, or to understand the nuts and bolts of any TPM that you are supporting. I also agree with Cem Kaner's earlier comments that this book is an ideal resource for software test professionals who need to understand the entire environment that they will be testing. If you want to go deeper into TP, I recommend "Transactional Information Systems: Theory, Algorithms, and the Practice of Concurrency Control" by Gerhard Weikum and Gottfried Vossen, which drills much further down into the details of both transaction processing and queuing systems.

This book was written in 1997 which is often considered ancient in "Internet-years" but it is still very relevant because it focuses on fundamental principles of transaction processing (TP) rather than the latest whiz-bang technologies that optimize TP.

For those of you who aren't TP experts, a transaction is a computer operation that meets the ACID test. ACID here stands for:

Atomic - the steps that comprise transaction succeed or fail as one, there is no partial success.

Consistent - the internal data structures of the system(s) remain consistent with business rules.

Isolated - the data read or manipulated by the transaction is not altered during the duration of the transaction's execution.

Durable - the results of the transaction are persisted

Why does this matter to the system user or stakeholder? The canonical example is that of the ATM machine (or the "handy bank" if you're Australian). When you withdrawl money from an ATM, it has to go out and validate you have enough funds to meet the withdrawl, reserve those funds, and dispense cash - all within the same transaction. If the ATM failed after your bank account had been debited but before you'd gotten your money, you'd be very upset; conversely if the cash was dispensed but the debit procedure failed, the bank would be very upset. Ted provides very amusing analogy for this using a wedding ceremony but you can read that in his book.

There's a whole lot more to transaction processing beyond ACID and the ATM example, including two-phase commit (TPC), high-availability, massive concurrency, and crash recovery. To find out about all of these topics, read the book. One thing to remember though is that most application developers will never have to deal with the extremely complex details of providing a working and robust transaction management implementation, but like any technology it's important to understand the technology's fundamental principles and mechanics to effectively use it.

The book itself is extremely dense. The content of the book is "only" 324 pages long but covers a large amount of ground in a good amount of detail. Definitely read in a quiet place free of interruptions with a strong cup of coffee.

One shortcoming of the book is that it was written in 1997 so it doesn't cover TP implementations in Java (e.g. JTA, EJBs, etc.) but it was nice to finally find out what the heck IBM's CICS and IMS products are.

Interestingly enough, I have never had to deal with complex transaction processing (i.e. two-phase commit) in my short IBM career. This is probably because I've worked on business-to-consumer (B2C) applications where only one data source is involved rather than a business-to-business system where multiple data sources are involved. I'll have to ask the B2B guys if they get heavy into two-phase commit or if it's not an issue.

The reason I read this book is because I've always been a bit mystified by Enterprise JavaBeans (EJBs). When I joined IBM, I knew the word, but I was not familiar with such topics as object-relational persistence, object remoting, and transaction processing, so to me EJBs were simply things that took four classes/interfaces to do what I could do in one simple POJO. Ted Neward, in a very interesting web interview on the Serverside.com mentioned that he used to think EJBs were completely worthless, but during the process of writing Effective Enterprise Java came to realize that they were not worthless but rather over-marketed. He said that they should have been called Transactional JavaBeans rather than Enterprise JavaBeans because transactions are what EJBs did very well. So, hearing this from Ted I decided to read a book on fundamentals of transaction processing, so that I could understand EJBs better. Now that I've read all about TP principles, I pick Richard Monson-Haefel's book again, and all of a sudden EJBs start to make a lot more sense.

I took the Microsoft exam 70-216 for network infrastructure today and all I can say is AMAZING! How did the writers know what was on the exam? There is so much obscure stuff on the exam that no other book I read covered the questons on the exam. But this one did. So much of the test was troubleshooting the network, so I guess a TCP/IP troubleshooting book would be the right one. But the similarity of this book to the test is amazing.

This book was good to read too and I am using it at my job and fixing some of the problems we've had with WINS and VPN based on what I learned. Great book and best study guide for the test.

This book is heads and tails above any other TCP/IP book I've read or own. Finally understand how DNS works, the RAS section helped me put together my Win2k VPN. Get this is you wnat to understand some of the weird stuff in Win2k TCP/IP.

We are in the process of moving from NT to Win2k and my boss made me the project manager. I had to get on top of Win2k networking fast. I bought this book on the recommendation of several of my co workers. Glad I got it. The book is informative and detailed in explanations and examples. A must have for the busy guy like me.

OK, I admit it. I learned my TCP/IP for Windows NT exams from reading Exam Cram. Needless to say, I passed the Windows NT TCP/IP test, but couldn't tell a subnet from a supernet. Now I have a job in the industry and I needed to actually learn TCP/IP, especially since we are moving up to Windows 2000 in our shop.

This book is unreal in how good things are explained. Great detail in describing RRAS, WINS, DNS, and the TCP stack. Using the information in the book I am now up to speed on TCP/IP. Enough to pass the 70-216 test! Not bad for a NT MCSE!

For Real, this book helped a lot. I owe the author's a beer on this one.

This book is fresh air to someone like myself who has read at least a dozen Windows 2000 books. I get the impression that a lot of the Windows 2000 books were written by people who write books and don't work with the technology. This book doesn't fall into that class. It was great to read this book, because it renewed my faith that a tech book could be written in a way that doesn't put me to sleep.

They cover Windows 2000 TCP/IP from top to bottom. WINS, DNS, DHCP, RRAS, IIS, routing and network devices. Its all there, and its filled with little known factoids that makes me want to keep reading and have another "aha!" experience.

This book also was the major reason I passed the Microsoft 216 exam so easily. Although I didn't buy it to pass the exam, they seem to cover all the material that the exam covered. A nice bonus. I wish they made the book longer, because I'm sure they could have said a lot more that I would like to read about.

This book isn't for beginners, but neither is Windows 2000. I think once the reader is ready to manage Windows 2000, they'll be ready to get the most out of this exceptional book.

This book is not only good for project managers but also an excellent read for developers. In the real world it is not uncommon that developers would confront a manager who likes to micromanage and everything the developers do have to be conform to something really bureaucracy and with little or no business sense or tech sense. In this book, the value of APM is well articulated in concise sentences. These sentences can be powerful tool when it is necessary for R&D people to discuss/argue with a manager about things like project plan/report, etc. There is also practical method of APM. I find this book very articulate and concise. Highly recommended.

This book is a thoroughly enjoyable read, from the emphasis on principles, the excellent job navigating the difficult territory of the line between prescribed process and anarchy, and the stages a team goes through as it embraces an agile style of development. I even thought that the hypothetical story added a nice element of repetition to each section that helped drive home the main points.

The one thing I would've liked was for this book to get off the fence and decide to be software-related. Almost every example is software related (except for the basketball analogy that got beaten to death...), but it goes out of the way not to specify software practices because this is about arbitrary project management. The book's in the "Agile Software Development Series" and the author is primarily a software consultant. I'd prefer it stuck to software rather than trying to go for broader appeal because there were several practice areas where detail was elided on that basis and could've really helped make the practices more concrete.

Also, it would've been nice to have a little grid mapping up common-day software development methodologies like Scrum, XP, FDD, and DSDM against the practices in the book. I tried to do it in my head, but once you get past 5x5, it's something that should've been provided.

I picked up Agile Project Management because I haven't done any agile projects in a while and wanted to update my knowledge to help with an upcoming project. I found the book a good combination of theory and practical activities that a project manager can use in an agile project. The book steps through each of the processes, explains the theory, then steps through tools that can be used for that process. I recommend this book for anyone new to agile project management, including experienced project managers looking to expand their toolkit.

This book is well-written and provides both a good explanation of agile software development and insights into how to manage such a project. My disappointment comes from fact that Highsmith emphasizes that one has to find the right people in order to succeed with this kind of project, and doesn't provide much info about how to identify the right people or how to train people with potential to work this way. Given the emphasis on the importance of the right team, more space in the book should be devoted to that aspect of management.

As someone who has managed large custom software projects and programs for 20 years, I was concerned that applying Agile to project management would simply mean burndown charts and the like. What I found in Highsmith's book is a perceptive understanding of how people think, feel and actually work on projects. Approaches that take human behavior into account, in my experience, are far more successful than those that don't.

The concepts covered here, if really absorbed and understood, can benefit any project. I found Chapter 7 to be the most valuable for my current product development team, and ordered copies of the book for all my managers.

When you're working with Group Policies or Profiles, it's simple: you must read this book. Jeremy Moskowitz learns you the tough parts of Windows in his own matchless style.

This book isn't for beginners but if you're a network or systems administrator it is an excellent source of group policy information for Windows servers and workstations (2000, XP, and 2003).

Great read and very informative. I've been using it as a reference ver since. Keep up the great work Jeremy!

Jeremy Moskowitz books are easy to read. He gives you great examples.

For managing GPOs for locking down servers, this is not a complete book. This is an excellent book for managing desktops or workstations, laptops and terminal servers. There are many user rights assignments and security settings that are left completely out of this book.

Updates:

Since the author commented, I feel it's only fair to elaborate on some of the items, either as a thought for a "Group Policy - locking down your servers" book or possibly a future update to this one.

Most of the User Rights Assignments are the most sensitive rights you can grant. Several of them provide the ability to impersonate other users, including the obvious ones (Impersonate client after authentication). Other rights don't actually provide the functionality that users likely think (Create permanent shared objects - you wouldn't believe how many application teams thought this would let them share folders and printers). At the very least, a detailed list of rights that should be granted per setting for complete OS functionality(changing Impersonate Client... without granting the right to the Service builtin object will break a server running Windows Server 2003 with SP1, but have no effect on other versions of the OS) would be very helpful - the defaults for Windows Server 2003 and Windows 2000 Server are completely different.

Personally I think that another book about securing your servers via GPO would be nice. Not everyone should be securing their servers via GPO and it may add a certain level of complexity to an application environment that is not desired, but for larger environments that require an automatic mechanism to correct any security deficiencies or changes, GPOs are an excellent solution. A book that would cover Windows 2000 Server, Windows Server 2003, Windows Server 2008 (or whatever Longhorn ends up being called) and the differences between the OS versions, would be fabulous for a security/AD/GPO admin in any environment that is much more complex. Particularly in a complex environment, all 3 versions of Windows Server that GPOs apply to should be covered. Many larger companies are slow to adopt new versions of software or upgrade that which they already have (if it ain't broke, don't fix it!), so finding OUs that have Windows 2000 Servers and Windows Server 2003 machines in the same structure of your organization is definitely far from abnormal and providing the reference to effectively secure all of the GPO functional server operating systems (or at least the MS ones).

I understand that the intention of this book is to talk about basically the user environment portions of the GPO, but the name doesn't define that, so won't update my rating. Maybe if it had a companion for the machine-side security related settings...

This is a readable, practical, and deep book. It's one of those books which teaches or refreshes Java and OO theory and practice as you read. I am also reading it for pleasure!

This is a great book. It is directed at users of JUnit, the Java unit testing framework. But in my mind the book gives sound advice for solving your programming problems in general, not just for Java or JUnit testing. It stresses the importance of unit testing, programming to interfaces instead of implementations and just simple common sense. The author is clearly passionate about his field and extremely experiences. The combination of enthusiasm and experience comes through on every page.

This review also appears on StickyMinds at http://www.stickyminds.com/s.asp?F=S767_BOOK_4

JUnit Recipes is a comprehensive tome of practical methods and techniques for the opensource JUnit tool to develop automated unit-tests for Java/J2EE applications. The book is split into four parts: Building Blocks, Testing J2EE, Additional JUnit Techniques, and Appendices. The Building Blocks cover the basics of using JUnit to create basic tests, organize and manage test suites and test data, running JUnit tests and reporting the results. It even includes a section on troubleshooting. Testing J2EE covers XML, JDBC, EJB, web components (including JSPs), and J2EE applications. Additional techniques include testing some well known design patterns, using JUnit add-ons and JUnit libraries (like GSBase). The Appendices include complete solutions (including code of course), some short and sweet essays on testing, and a modest recommended reading list.

The organization of the book flows very logically and the writing style is very clear and easy to follow. Along the way many insights into important design principles and testing techniques are revealed: the reader will learn about the "Hollywood principle", the Open-Closed principle, design patterns, POJOs, Mock Objects, Private and Parameterized Test-Cases, Abstract Test-Cases, Self-Shunts, and Spys. The book's coverage is very comprehensive and touches on many other popular Java/Enterprise projects and frameworks such as Struts, JBOSS, Prevayler, XDoclet, Tomcat, XPath, XMLUnit, HTTPUnit, Ant, Jakarta, and others.

Even though JUnit is often associated with "Agile" development and much of the wisdom apparent in the book applies to agile Java development, the book is useful to any Java developer on any Java project (agile or otherwise). The book also goes into considerable detail, with working code examples, to spell out exactly how to perform and apply the techniques it describes.

The book's primary audience is Java developers. Java Tester's will still find some good nuggets of information but it's quite clear that Java programmers and developers are the target audience. This isn't some high-level theoretical book mostly of concepts and ideas. This is an imminently pragmatic guide that not only conveys a great deal of highly practical wisdom but also clearly and comprehensively walks you through the explanations and the code to accomplish and apply the techniques it describes. The book is also not a "How To" for coming up-to-speed on setting up and running JUnit.

Another book from the same publisher, "JUnit in Action" is a great overview on learning more about the basics of running and using JUnit and on using JUnit to tackle a number of basic challenges with unit-testing Java and J2EE code. JUnit Recipes has some overlapping material but pretty much "picks up" where "JUnit in Action" leaves off, and JUnit Recipes goes into much more breadth and depth of coverage of JUnit methods, practices and techniques and use with other Java projects and frameworks.

I would say JUnit Recipes should probably be required reading for anyone attempting to use Java, J2EE and JUnit in the real-world.

This isn't necessarily the best introduction for absolute beginners (I would recommend /Pragmatic Unit Testing/ for that), but it is required reading for server-side Java, as most other reviewers have pointed out. But it's more than that--it's one of those rare computer books that transcends its subject matter. Why? Because it can make you a better programmer. While some of the credit can rightly be given to unit testing and Test-Driven Development in general, Rainsberger's book makes you /see/ better ways to write and refactor your code. The breadth and depth of examples is astonishing--he convincingly shatters "but it's too hard to test that" arguments with well-researched, non-trivial examples. In fact, I'd say that this is almost a better J2EE tutorial than most books about J2EE proper.

I'm withholding a star for one reason: the book doesn't cover GUI testing tools like Jemmy, JFCUnit, or Abbot/Costello. These JUnit extensions are ripe for a book with this depth; it's just too bad that this couldn't be that book. Other than that, I find that I turn to Rainsberger's book far more often than any other testing book or online reference.

Rainsberger does a very good job of detailing the techniques to unit test difficult code; including xml, ejb, servlets, jsps etc.

did you really write this book have not read it yet but it's being shipped to my house.

The value of this book is not in the number of documented designs, but how it teaches you the process to come up with your own designs. It even does it in a much more entertaining way then my engineering classes did. Understanding the design process allows you to create any number of robots that do what you want them to do and this is an invaluable life skill. That is what this book teaches you. It allows you to try to come up with the solutions on your own, or build the solutions the author came up with. My son and I plan on going through the book a second time and using the processes taught come up with our own solutions. This book is definitely worth having.

I bought this to introduce my grandchildren to science projects. Their ages are 7 and 10. We have no special contest or competition to enter. Not sure exactly what I expected but I was not disappointed. This has awesome potential for learning. Actually, my grandkids were impressively advanced in what they could accomplish. The suggested robot to build was fairly complicated. My 10 yo took charge, with the 7 yo taking his turn. When completed I could not get close to the control computer. They took over!!! The kit could use some better instructions. I recommend one of several additional books to get a better feel for it. Next we will try the programming. Good way to spend lots of quality time with your kids. Just make sure you have big blocks set aside! Love it!

This book is a wonderful introduction into program and design with the NXT, and yes, we've been using the RCX as well. The book is well laid out. The story is engaging and gives the tasks purpose.

I really like the templates provided in the book. It gives anyone a method of organizing their thoughts, so they can go ahead with the building and programming and know they're headed down the right path.

I bought this for my children because I have no interest in robotics or programming, and I've enjoyed it as much as they have.

AB FAB! I'm really trying to addd something to the reviews posted already. So much goodness has already been posted about this wonderful book.

My sons are very young and I cannot wait for them to have this book to read and enhance their knowledge while having fun in the process. Melting together reading, technology, problem-solving, and programming could not produce a better combination for building a great education.

I know that this book has gained some significant recognition in the LEGO MindStorms world and the education field. LEGO Masters and Edu Teachers all agree it is a very good book.

If you are looking for a book that will entertain and teach your MindStormer (young or old) in a very pleasing way...this book is a fantastic starter.

Chris
MDP, MCP
USA - NASA

This book should be considered required reading for anyone designing and developing sites.

Most of the websites online do not follow the practices outlined in this book and would be better off if they did.

The book is filled with clear examples and shows bad content and then the ways to improve it.

Great book!

From the moment I started reading this well-constructed, excellently researched book, I couldn't put it down and wanted to know more. The pages are reader-friendly, and lots of good examples make all the author's advice come to life on the page. "Letting Go of the Words" clarifies so many gray areas of writing for the web. I highly recommend this book to anyone who ever has to write anything that will appear on the web, and also to designers who are responsble for setting up websites. Once you read this book, you won't be able to look at any website in the same way again.

This is one of the best books you can buy if you creating a website, looking for ideas on how to make your site better or just need simple easy to implement ideas. Ginny has created an easy way to focus on your "audience" make any site practicle with simple solutions. Tips and trick that any one can do without functionality. This is a best value!

This book is an absolute must read for anyone who develops websites. Ginny Redish provides great examples of web pages and how the visitor is affected by the arrangement of the content. I love the way she presents a website user and allows you to "think" like a visitor.

I'm a big fan of technical communication texts. This book is exceptional, and stands apart from others in many ways:

- Many technical communication texts repeat the same rote guidelines. Although this book does not ignore the "classic" rules (e.g., "Write in inverted pyramid style"; "Use space effectively"), many of the rules are unexpected or even contrarian (e.g., "Use a sans-serif font"; "Long lists are o.k. for familiar items"). All rules are backed by examples that demonstrate their effectiveness.
- The book provides clear examples of real-world Web content, including many "before" and "after" images that demonstrate the book's principles.
- The production of the book is excellent. The color printing and rich layout help to make the book attractive and approachable.

Although the focus of this book is Web communication, the rules, principles, and guidelines are relevant to any form of written communication. The number of examples and diversity of the book's guidelines make this an ideal text for technical communicators and Web content developers of all levels of experience and proficiency.

I've read a lot of these type of books. A lot of similarities and a lot of contradictions between books. This books is the most comprehensive one I've read. I've reread it several times and get something new out of it each time.

a great book to read before your weight loss journey. Very well written and it has a good progression of all facets of a weight loss approach minus the recipes.

Through my life I have wanted to change from being an out of control eater to a well controlled person. Eating has been my biggest down fall and I have turned to food for many hiccups through life for comfort.

Jeremy has written this book to talk about his struggles through live and how he learned to over come them. He is transparent with his thoughts and his writing.

It has been encourgaging to read a book that puts the prospective of our mind set in the forefront of our struggle of life. It is our mind set that allows or disallows what we can or cannot achieve in life; and the mind set is choice by each of us as Jeremy helps us see.

The book is easliy read, full of tons of information, inspiration, and truths that we can all use on our journeys through life.

It was also encouraging that when you get on Jeremy's website and you ask a question. . . . he writes! Thanks Jeremy!

This IS THE BOOK ladies! It is not just for men only. If you want to be encouraged and seek the key to transfomation, Jeremy Likness hands you everything you need in his book. I am 49, mother or two, an RN for 27 years, gained 70 lbs and should have known better. This book has given me hope and encouragement and KEYS to getting fit and healthy again. YOU WILL LOVE THIS BOOK. I intend on reading it again and again. It is THAT GREAT of a book!

KAREN S.

It has been said that the way to make money quickly in the book industry is self-help or weight loss fitness books. This book does not really fall into that category. It is written with a passion for a subject and based on personal experience and transformation. There are a number of factors that make this an exceptional book, and even more so an extraordinary fitness book. First is the way it is written - each chapter is written in two parts. It begins with the meat of the matter, the teaching about, health, fitness, wellness ... the second part of each chapter is the personal narrative of Jeremy's journey from being unhealthy to healthy. Mr. Likeness gives numerous examples from his own fitness journey and some from those he has helped to move along that path. In the same way that Sylvester Stallone did in his book Sly Moves : My Proven Program to Lose Weight, Build Strength, Gain Will Power, and Live your Dream.

This book is in part written around the philosophy from the book Body for Life: 12 Weeks to Mental and Physical Strength by Bill Phillips, yet it goes into much greater depth on some of the non-physical factors of health and weight loss or weight management. It deals with issues of stress, family life and work factors that can either help or hinder the physical transformation a person desires to make. This book has a very holistic approach to health and fitness. It presents the argument that in order to make lasting changes in your life, those changes must begin from the inside; transformation starts in the heart and in the mind and then works out in the body. Jeremy states: "Physique transformation is about more than simply losing weight. You will find that your life changes in many ways, too. You adjust to new clothing, a new image in the mirror, even a new sense of energy that allows you to achieve more during the day. Spiritually and mentally, you may change as well. Although these changes are almost always positive, change itself can be something that we fear. For this reason, it is important to understand what changes to expect to better prepare yourself as the process unfolds." Once the physical changes start to become more evident, you will have both positive and negative comments from people in your life. Likeness helps to provide some tools for dealing with both types. An example he gives is that if you have been over weight for a long time, you might not be accustomed to compliments - you will have to learn how to receive them and take some of them to heart.

This book, as the techniques in it are applied, can be a great tool for helping a person achieve greater health and wellbeing. This can be a factor in a longer and happier life. If these goals are things you have been thinking about, or have started working on, pick up this book to help boost your resolve and efforts to make your lifestyle changes.

(First Published in Imprint 2008-05-30.)

I have actually used this reference for years as needed for ActionScript. I still had a good use for this text in ensuring compatibility with Flash MX until the lack of features became too overwhelming. This is in the face of newer versions of Flash such as CS3 (9.0) that use ActionScript 2.0/3.0. All in all, this book was wonderful until the release of Flash 8.

Because of the new Filters that have come out with Flash 8.0 and the features of ActionScript 2.0 to support these and other enhancements, I would instead recommend Flash 8 ActionScript Bible if one is concerned with cross-compatibility in their ActionScript code and wishes to still be able to use AS with newer features such as Filters (but not as new as Transitions or other CS3 exclusive features - for that, I'd recommend ActionScript 3.0 Bible or something similar).

As far as who I could possibly recommend this book for: It's good for somebody who is still working with Flash MX 2004 and below to Flash 5 (much of the text is compatible with Flash 5), however, I don't know that there are many of those sorts of individuals.

This book is a great resource for when you're looking for that specific line of code. Its terrible to read from front to back, but its an excellent way to find exactly what you're looking for. Its so much code, it'll make your eyes bleed.

One of the few comprehensive actionsctipt titles on the market. The first half of the book boasts a large variety of tutorials and examples that skillfully lead the reader through both the syntax and use of actionscript. Personally I found the text clear and practical. The chapters on OOP were of particular value as they went beyond actionscript basics into application, bordering on philosophical.

The second half is an invaluable reference of the entire actionscript dictionary with a comprehensive CD full of .fla example files and bonus chapters on the XML Object. As a qualified teacher I found it hard to fault the methodology employed by the various authors.

Well worth the purchase.

I am a former programming teacher and I have a style to teach my students the most UNDERSTANDABLE way to do something not just how to do it. This text/reference achieves that purpose. If you have an understanding of Flash (which you should have before getting into scripting see Weinman books) then this book will serve you well. There are other books on scripting - great books - such as Moock's books but they are more so for the programmer. This book is for the novelist programmer that desires to learn about action scripting.

5 stars if you know Flash well.
1 star if you haven't had any experience with it at all.

I was a beginner once, who couldn't figure out Flash at all. I'd like to help you build a bridge between where you may be now, as a beginner, to where you may find yourself aspiring to go.

If your only experience with Flash is to have seen the many wonderful and breathtaking Flash movies on the Internet and just had a look at the authoring tool, I strongly recommend that you leave this book until much later. It has its place in the learning curve but it isn't, in my opinion, the first book to see.

There are understandings to possess that this book doesn't cover sufficiently well enough for those whose minds work in particular ways. This is a programming book, for using the phenomenon of programming to create great design and animations. Whilst the focus is on design, you aren't using the design tools on the interface. With this book, you are using the Actionscript language and you have to have a logical mind for this activity (as well as keeping your strong creative one).

I began my steep learning curve with Flash by watching others and watching video tutorials, especially those by George Pierson. In this way, I can ask questions that are tailored for me and I get tailored responses. Books aren't always able to do so well here.

What is great about this book is the MX Actionscript reference in it and the seemingly well designed theory tutorials. I can't find a fault with the reference. The theory is quite good. In the reference, all Flash MX commands are covered. There are examples of how to use them, but the coverage may not be enough for some. Brill. Just BRILL. I can be excited but because I can follow Actionscript.

Approach this book when you are successfully making Flash movies on your own. Yes, on your own. For me, this book is an aid for when I am going to where I haven't gone to before. It helps me make judgements on ideas I get.

I'm still working through the book but was pleased to FINALLY find an author whose style is clear without being boring. An enjoyable book which has already cleared up some confusion I had before. I have a couple of comments for other reviewers, though:
(1) The title is a play on words. It doesn't mean that the book is supposed to be
entirely about pointers, as a couple of reviewers seemed to think. I think its a great title! (2) The book IS expensive, probably because it is widely used as a textbook. Textbook publishers have been gouging students for years, and in this case it affects more than just university students. (I'm a prof myself.)

As before I bought this book I have problems about advance pointer like a pointer to function, array of pointer to function, pointer to structure or other topic like this. The author explain this topic very well.
By the way, the purpose of buying this book is to solve reading C language code on embedded linux which involve pointer and hardware. The author do not give enogh information about this topic.
However I still rate this book five stars for the topic Pointer on C.

This book is an excellent book on C for people who have previous programming experience. Although the title might be a little deceiving - does not cover just pointers - the author does dedicate the better part of the book discussing. The book has many excellent explanations that are not covered in books that I have read such as a whole chapter pertaining to lists (linked lists, and binary trees) using pointers. The main disadvantage is that the examples in the book are incomplete, thus you are not able to type them in and see the results. Beyond that disadvantage the book is great and offers answers to all the questions (on the website) which is something that I felt to be lacking on many books that I have read so far.

When programming in C you must use, love and own pointers. Look at the function templates for the standard C lib. What do these functions return? POINTERS! If you don't want to learn pointers, or think about solving problems using pointers, then please go drive a truck or program in Basic or some other half-wit language. C will frustrate you to tears if you insist on using subscripts. It's not how the language approaches problems.

I am having to use C# right now and want to gag. Any language that claims to be "C" but doesn't support pointers is an oxymoron. Have a glass of dry water while you try to swallowing that load of bull. Thanks MicroSlop for ruining two languages, Basic (who cares) and C, the language that built the computer revolution (punishable by death in a better world). Arrrghhh. Thanks Ken for a great book for the strong and the brave amongst us.

As others have noted, this book is exremely expensive. I was lucky enough to get a used copy for about half the retail price here on Amazon and I intend to keep it. I haven't read every book on C, so I may be ambitious to say this, but this is the best explanation of pointers I've read to date. The author doesn't assume anything and this is helpful when learning something as tricky as pointers for those new to the concept. The author explains concepts with clarity while being concise. I don't develop software for a living, but need to write the occasional program here and there. I thought this book accurately described the methodology of writing the most compact, yet readable code, for the problems presented. I'd reccommend this book despite the price. Those new to the C programming language won't be disappointed.