No comments about Practical API Design: Confessions of a Java Framework Architect.

5 comments about Mastering Algorithms with Perl.

1. As a guy ( engineer not computer expert ) who uses computers everyday to help his research, I would steer you away from using Perl for any task involving mathematical concepts more complicated than addition/subtraction/multiplication and addition.

   I heard this same advice before buying this book and ignored it, I really wish I had listened back then.

   While MAP has some nice pictures which broadly describe the essential concepts, it will give you no idea as to how to actually implement those ideas. Further, all the code is available in CPAN ( If you don't know CPAN, check it out before going any further - at the very least install a module ) and much ( at least what I attempted to use ) appeared to be broken.

   Authors of computer books are usually good about answering e-mail but these authors did not deign to respond to mine.

   If you are out there, struggling to learn algorithms, I would suggest taking a good computer course on the subject. I'm 99% certain the course will be taught in C/C++ or similar language -these languages have tremendous advantages over Perl when it comes to data structures and, believe me, even as a novice I've come to appreciate them...

   If you really know algorithms and wish to write a few in Perl, you can do without this book. Pick up Deitel & Deitel's 'Perl: How to Program' instead or O'Reilly's basic book ( which is good, but I prefer Deitel and Deitel ) ....besides D&D answer their e-mail.




2. This book is a great book, not only on the subject of algorithms, but also on how to implement them in Perl. A huge number of topics are covered, from Data Structures, to Searching/sorting, to cryptography, and much more. And what I found to be among the most useful additions was that for every subject, they give you a full implementation on the subject. I've read a few books on algorithms, but this is one of the most easy to read, and definitely one of the most practically useful. Recommended for any Perl programmer, regardless of skill.



3. Klowledge of algorithms and data structures is vital for effective programming, and Perl is one of the most popular programming languages around, so this book fills a long-needed niche.
   
   If you've ever looked at "Introduction to algorithms " by Cormen et al (CLR), this book will look familiar. It covers many of the topics covered in CLR, though not in such theoretic depth. It does, however, have mountains of Perl code implementing those algorithms.
   
   This book can seemingly have two purposes - one is to learn algorithms (as the title suggests), and the other is to understand the implementation of algorithms in Perl.
   
   IMHO, the authors fulfilled the second part quite well. For the first part, CLR is a excellent book and is hard to better. I don't think "Mastering algorithms" explained the topics in a clear enough way to compete with CLR, but it can indeed be a terrific companion to CLR (get the first edition, used copies cost pennies). Read about the algorith m in CLR, understand it from the pseudo-code and diagrams, then take "Mastering algorithms with Perl" and learn the Perl implementation of the algorithm.



4. If you have ever studied algorithms and data structures, then balanced trees and O(N) notation may still be a painful memory. Also, part of Perl's strength is in its built in parsing and sorting features so why would you need to know other ways of doing the same job? If your work does not challenge Perl's features then you probably do not need this book. However, if you have no computer science background and Perl is your language of choice then this book requires serious consideration.
   
   The book is concise and the advice given in concepts like choosing an appropriate data structure or in benchmarking your program is actually quite sound. It covers a wide number of topics such as sorting, searching, sets and matrices together with material you may not find in a data structures book like geometry, cryptography and statistics.
   
   Your choice depends on the task at hand. If you're looking for a Perl book where you can find routines to encrypt a string or find the maximum distance between two points then this book will not disappoint. Indeed, I believe that anyone serious about programming would benefit greatly from some of the Computer Science subjects discussed and implemented in Perl that are offered in this book.



5. This is a very accessible introduction to data structures and algorithms in Perl. It doesn't go into a lot of theory, it isn't going to answer your computer science homework, but it does give a good feel for the various applications of algorithm research.
   
   Plus, the code is all in Perl, which is not as unreadable as received wisdom asserts. It's certainly more accessible for the interested Perl-savvy amateur than the pseudocode in Introduction to Algorithms.
   
   Obviously, you're going to have to move onto the likes of Cormen et al, if you're really serious about this stuff. And practically speaking, yes, most of this can be found in CPAN without you having to worry your pretty little head about the mechanics. If just getting something done is your main concern, then this is not the book for you.
   
   Plus, it must be admitted that the level of detail varies across the chapters, and some of the explanations can be opaque, even for the simple stuff. I felt I had to work unnecessarily hard to comprehend some of the material: the discussion of the A* algorithm, some of the tree-related algorithms and the section on compression all suffered from this to varying degrees. This is the sort of book which requires concentration (plus copious scrap paper for scribbling down arrows and boxes) to get anything from.
   
   But to complain that Perl doesn't need you to write these data structures from scratch, and it isn't a suitable language for this sort of thing anyway, is to miss the point of at least part of the book. It's about communicating the intellectual pleasure of wrapping your head around these fundamental bits of computer science, and in that respect it succeeds admirably. If you're looking for an introduction to the area, this is definitely worth getting hold of.

5 comments about Building Automated Trading Systems: With an Introduction to Visual C++.NET 2005 (Financial Market Technology).

1. Unlike some other comments about this book, the intended readers are serious developers who have not started or just begining to use .Net 2005 framework. That is why some readers do not like this book.
   
   A pure programmer do not need to read this book.
   A pure quant strategist do not need this book.
   A network specialist do not need this book.
   
   It is only good for the intended readers.



2. I wish there was slightly more explanation of the code. 1 small paragraph doesnt cut it for me. I have ran the code merely as a puppet of the author and really dont 100% get a grasp on it. I dont think this book is for beginners, you should have a decent knowlege of c++ (pointers especially) already before getting into this book. The ony intro involved in this book is a slight .net informational. Title should be "Building Automated Trading Systems with Visual C++ .NET 2005, featuring slight intro to .NET framework". Probably an awesome book for people w/ good working knowledge of c++ and want to tie in with .net and financial systems programming. I have put the book down for now and am going to hit the programming gym before I pick it back up. Maybe I will make a follow up post at that point.



3. If you want a very practical introduction on how to design and implement your first trading system, this book is for you.
   The initial chapters cover all the C++/CLI concepts needed to understand the detailed case studies of two actual trading systems. The reader is assumed to have some general understanding of OO languages, preferably C++.
   
   Be realistic. As the author points out in the book, the algorithms driving these trading systems are well known, so they probably will not make you a millionaire. But the software included with the book will give you a head start to try out your own ideas in a simulated environment.
   
   People interested in running a hedge fund are advised to read the chapter on development methodology. It will help you get a handle on the software development side of the business.



4. Hands down this is the most useful financial-programming guide on the market. I would question the capabilities or intellectual capacity of any person who thinks anything less.
   
   Step-by-step, it shows the user how to take the concepts of object-oriented programming and apply it directly to the financial markets, ultimately yielding an automated-trading system designed to trade futures through Trading Technologies' XT_API.
   
   The book is thorough, yet simple to follow, descriptive, but not drawn out.



5. Waste of paper.
   I've started reading this book a few times but find myself paging through it trying to find something worth reading.
   As an introduction to Visual C++ .NET it might be useful but most chapters cover the matters in about two pages and I have a sneaking suspicion this is just a copy of MSDN with new code examples.
   As for Automated Trading systems it has about 10-15 pages on the subject and of that probably 8 are just code (could have been omitted and just put on the CD).
   If you don't have access to the internet this book will come in handy. Otherwise go for Practical .NET for the financial markets instead.

3 comments about Murach's Mainframe COBOL.

1. The collaboration of COBOL experts Mike Murach, Anne Prince, and Raul Menendez, Murach's Mainframe COBOL is a tutorial, guide, and reference especially for anyone charged with developing or maintaining COBOL programs. Explicit examples and sample code spell out COBOL syntax in the clearest possible terms, and much of Murach's Mainframe COBOL is divided into individual sections that teach the reader how to complete any given specific task, such as "how to code select statements and FD statements" or "how to join data from two or more tables". An easy-to-follow guide for anyone learning the ins and outs of COBOL.



2. As a longtime mainframe programmer I have used Murach books for the times when I need a quick reminder of what COBOL statement to use and how to use it. Mike Murach has recently published a new "Mainframe COBOL" book. The Murach books feature a paired page format that has statement syntax and notes on the right hand page and detailed descriptions on the left hand page. With this format the book is useful for both the "seasoned" programmer and the newbie just getting started in writing structured COBOL programs. A new COBOL programmer can get good detailed instruction on how a structured program is designed coded and tested, the veteran can quickly access information on statement syntax and usage.
   
   This book differs from Murach's "Structured COBOL" offering in that it has no mention of Personal or PC COBOL platforms. Those references have been replaced by chapter (17.) describing mainframe architecture, input/output devices, basic mainframe operating system features and IBM mainframe OS' that are currently used. Another new chapter (19.) gives a brief basic introduction in (AMS) Access Method Services necessary for working with VSAM files.
   
   All in all, this book should be a good starting point for the mainframe COBOL programmer looking for a solid reference for writing batch programs. Programmers needing instruction or reference for CICS and DB2 application development should read the (also brief and basic) chapters on those subjects and then seriously consider investing in Murach's "CICS for the COBOL Programmer" and excellent "CICS Desk Reference" along with their two DB2 manuals. They also have a solid VSAM manual.



3. This book is written in an easy to read and understand format. A good refresher for anyone that needs it and will serve as a good future reference book. Very good simple examples.

5 comments about Python For Dummies (For Dummies (Computer/Tech)).

1. If you have programmed at the level of Visual Basic, or perhaps Excel macros, then this book is perfect for you. It's a pleasure to read -- with its variety of visual aids. In many books, the graphics just clutter the page. Not here. The concepts pop out at you and burn themselves into your memory.
   
   I doubt you can become productive in Python any faster than with this book.



2. From the Dummies title I expected that this was for beginners. The book itself claims that it is suitable for someone who wrote a few Basic programs at one time. I wrote a few Basic programs and it is not. An example: On page 20 it starts a discussion that turns on objects. This is a somewhat advanced topic by most accounts, but the chapter that deals with objects is hundreds of pages later.
   This book that claims that it is suitable for beginners, claims a few pages later that it is more of a reference, really. But it is very poorly organized, as the previous discussion illustrates. Strange stuff like the explaination of Scheme as a functional programming language: In Python for Dummies this is explained as using functions to write programs. Really! It;s that bad.
   The only audience I can imagine for this book is people who know something about Python, but prefer reading about it to programming. Reading it, they could pick up a fe pieces of information they hadn't seen before.



3. This is a pretty decent book for those with some previous programming experience, but is definitely not for beginners (or Dummies) to programming. The first 2 chapters contain terms and concepts that assume an existing knowledge base.



4. I agree with some of the reviewers here, it is definitely disappointing to see a bad seed among the good "... for dummies" series. I have previous experience with programming languages, although this is not my everyday task. I got interested in Python and wanted the book to guide me through the basics. After reading the first 7-8 chapters I started asking myself whether I missed something in the previous ones, as I lost track (and interest) in the book.
   I found the examples parsed in the chapters rather useless, and not practical. Since, I have found several useful on-line tutorials on www.python.org, where the user is taken through the chapters in a gradual, progressive way. The examples and exercises in a beginner's book should be based on what is learned in the previous chapters, giving the reader the idea that what is learned is put in practice, thus easily assimilated.
   
   I don't recommend this book for a complete novice, as she/he will lose interest in Python programming very easily! This book has the advantage of presenting the main and most important features of the Python programming language, but it sues a more advanced audience.
   
   The low rating is indeed due to the non adequacy of the book for beginners and for not following the good standards of the "...for dummies" successful series.
   
   Sacha



5. I have read a couple dummies books and usually they are more of an introductory baby steps type of book. This was not the case. It feels they tried to offer more and it ended up coming across as babble.
   
   I found myself getting bored at times. I can program in Perl and I started this book knowing I might be above the topics at times. I was looking to this book as an introduction to Python. The examples given were not as good as I would have liked. Overall, I don't think the presentation of topics were not good. For example, I thought two chapters on OOP was overkill for this type of book and probably should have been reduced to a chapter on the bigger things you may do.
   
   I mention the examples again as I usually like to enter them for the fun of it. However, they really don't give a good feeling for the power of python.
   
   I did like the spider example but it was lightly discussed.
   
   The last two chapters I think were most useful for the links and other modules that were mentioned.
   
   I should say glob was mentioned and I think the book should have talked about it more then just a passing mention.
   
   So will I suggest this book? Probably not. It really depends on the person. I think it has to be a person that is between beginner and somebody who knows how to program.

4 comments about Software Configuration Management Strategies and IBM(R) Rational(R) ClearCase(R): A Practical Introduction (2nd Edition) (Visual Quickstart Guides).

1. As a long-time ClearCase user, consultant, Rational field rep, and all-around proponent of SCM, I found this book to be a wonderful update of Brian White's first edition. Tom and Dave have an extremely readable style of writing that you don't often find in technical publications. For the uninitiated, this book will serve as a great introduction to SCM concepts, ClearCase and the Unified Change Management process. For the experienced SCM administrator, this book is full of tips and practical "how-to" based on Tom and Dave's decades of experience in the SCM field.



2. Was the first edition mostly a repeat of the UCM manual that comes with the installation, this second edition brings more valuable, strategic information about SCM and ClearCase UCM. It is a must-read for SCM practitioners working with UCM or considering a step towards UCM. In fact, the SCM strategies covered in this book are a must-read for any SCM practitioner. Issues like quality promotion, parallel development and composite configurations are becoming quite common to modern software development organizations.
   Subjects that I am missing are activity management (as part of project management), reporting and audit trails, customizations (e.g. role based permissions, automation, triggers) and integration with other development tools (e.g. requirements and test assets).
   
   It is very difficult to find just the right book about SCM, with the right balance between theory and practice. Well, this book is it for Unified Change Management.



3. I purchased this book as a new Configuration Manager to the Rational suite of tools. I have used other 'big' CM tools in the past, but was unfamiliar with ClearCase. The book is very well laid out, has very good information and definitions that I have used in other presentations as I prepare to roll out a ClearCase solution to my team. After reading the first 1/2 of the book, I felt very versed on the tool, and was able to refer to my knowledge in conversations with other team members about how ClearCase is to work. I recommend that if you are new or even experienced with ClearCase, that you purchase this book for yourself. You will find in no time that you will mark many pages with yellow sticky's and highlight passages that you'll refer to many times!



4. I've a long history with CC, and SWCM. This is a good book for simpler projects, and it has some good tips I had learned, but hadn't seen in print. I wish it worked a bit more on the successful patterns that scale to really big projects, but that's not where the market is for books, right?

5 comments about SAP Planning: Best Practices in Implementation.

1. Whilst an excellent book for its broad treatment of the IT related issues in planning and implementing SAP this book does not address "Best Practices" - in particular the stage of ASAP titled 2.Blue Printing.
   
   Yes, in the TOC you will find Blueprinting mentioned but in this title these topics are addressed from an IT sizing perspective and not the business process oriented planning or implementation perspective; the latter is required to address alignment with strategic goals and to realize ROI.
   
   Why do organizations role out SAP? In fact why do organizations expend on IT? For the same reason they invest in any of their shared service; to support their business objective of course. In order to plan and implement major IT infrastructure then it is an imperative that it is done through IT and organizational strategy alignment and the most obvious route to alignment is via support for structured business processes management. Companies arguably role out SAP for (customer driven) process oriented reasons with IT & cost benefits a supplemental or bi-product outcome. To successfully plan and implement in the absence of business process management structure is to miss this key imperative. SAP realise this, they have it in ASAP, but its absent from this book.
   
   So if you are looking for a book that treats the entire planning and implementation process this is not the book but it does provide the most comprehensive IT treatment I've come across. My rating of three stars therefore reflects this deficiency.



2. I got this book and I was dissapointed to find that it is mostly talking about the technology part of the implementation ( landscape, High Availability, system HW,....) but it almost did not go through the functional (business) part of SAP, i.e. IMG activities are not discussed, building a company oraganizational chart and structure is not discussed, financial and controlling Baseline configuration is not discussed and so on.
   Although I am a certified SAP basis and XI consultants I do not find this book reflecting it's title, it can be very good for an IT / IS manager from the customer side.
   
   Regards.



3. This book focuses almost exclusiveley on the technical side of an SAP implementation. Not much regarding all the other aspects of an SAP implementation.



4. If you want to know more about SAP Implementation best practices. Just go ahead and GRAB it ! Well written and lucidly explained.
   
   Easy to understand, good look and feel of the content layout.
   
   Looking forward to the next edition.



5. I was looking for PP-MRP book with strategy/configuration/integration instructions/advice. My mistake, this is not a functional book. I agree with other buyers regarding the poor title selection. The title "R3 Implementation Planning" would more accurately describe the book. As a PP-APO consultant it does not help very much. Perhaps if Amazon would have allowed us to browse inside the book, the table of contents would have saved some of us some time and money. SAP Planning: Best Practices in Implementation

5 comments about Advanced Compiler Design and Implementation.

1. Ok, let's be fair. This book provides a broad coverage of useful optimizations and it will be useful in case you work writing compilers AND have some experience.
   
   However, for learning the concepts, it is a very bad material. At the end you end up confused under a pile of thousands of lines of pseudocode in a weird notation (invented by the author) called "I CAN" (yes you can write a very bad book Mr. Muchnick) instead of reading useful explanations of the topics. The author also assumes that you already know some concepts and that's why he does not explain them as he should. If you want to really understand this book, first review Chapter 10 of the Dragon Book. I thought that the Dragon book was not so good because you have to re read some things in order to fully understand, but with Muchnick's book that is not always possible.
   
   You can also take a look at Morgan's book (unfortunately, out of print) or just read the papers (as the first reviewer suggested). This book is not enough, and sadly, a lot of "teachers" think of it as a kind of "bible" and as a very bad excuse to teach very poorly. Some of them even don't master all the concepts presented there and have to use other books (their "dirty little secret") but they don't tell you which ones and continue praising this bad piece of work. If you are a CS student who really wants to learn, be warned that this book is not for you (it has at least three erratas and still has errors!)



2. I've seen chapter 14 of this book referenced (by a university professor giving suggestion to his students, not by a random guy) as:
   
   "Another conventional approach to strength reduction. 35 pages of the same kind of confusing crap we've all come to expect from this book."
   
   This could not sum it up better. A confusing book at best, presenting basic material so as to make it look "advanced", and without any covering of even relatively new techniques. A good source of references to papers that you should read, but not at all a valid reference on its own.



3. Compiler development is more of a craft than a science, although there's plenty of science involved. It involves huge numbers of tradeoffs in features, optimizations, and use of the underlying processor. But, as long as people keep coming up with new computing platforms (and not just instruction set processors), new languages, and new performance demands there will always be need for new compiler developers. If you can't apprentice yourself to masters of the craft, or even if you can, this book is a great introduction 2000-era compiler development.
   
   Muchnik does a clear, thorough job of laying out the basics, starting with the intermediate representation used. (If you get that wrong, nothing else is going to work.) He then moves on to the basics of symbol table structure - an issue that can get immensely complicated in systems like Microsoft's CLR. He also discusses run time support briefly. Although that discussion is good as far as it goes, it skips past a lot of the complexities of dynamic loading, debug symbol tables, simulation support, and related issues. They aren't strictly part of the compiled, executable code, but responsibilities of the compiler developer nonetheless. Next comes a brief description of code generation, crucial in normal environments but tangential to my own needs.
   
   That's just the first quarter of the book, though. The rest is the real meat of the topic: code analysis and optimization techniques, over 600 pages of discussion. It's way too much to summarize here, but even that just an introduction to a huge technology. Still, you have to start somewhere.
   
   By this point, you may be asking "But what about tokens, lexemes, and grammars? Isn't that what compilers do?" Well, yes, but it's done. Tool developers have made lexical analysis a commodity. The easily automated tasks are not where modern compiler distinguishes itself. This book addresses the semantic levels, getting the reader into the shallow end of the industry's huge pool of specialized compilation knowledge.
   
   If you have to self-teach compiler development - good luck. Start here, though, and luck will have a lot less to do with the outcome.
   
   //wiredweird



4. It's the bible of compiler data-flow analysis. The author had the experience of building an industrial strength compiler. One tip: skip books authored by those who haven't implemented an industrial strength compiler by themself.



5. This is a very good intermediate/advanced text for codegen & optimization.
   
   Having spent nearly 15 years working on compiler development, with most of it spent on codegen & optimization in compiler backends, I was very happy to see this book published ten years ago when I was relatively new to the field and hungry for more information.
   
   The good: Coverage of many important topics, and a better discussion of the phase ordering issues than I've seen in other texts.
   
   The bad: The writing style is okay, but not great. Little insight is typically given for the problems discussed. A very annoying aspect of the book is that the author sometimes goes into great detail about one technique, and then later mentions another (often superior, IMO) way to solve the problem at hand, without going into much detail. As a working compiler writer, I would have preferred it be the other way around.
   
   The very very bad: The ICAN notation used throughout the book is verbose, unintuitive, and ultimately takes away from the presentation. Compare the complicated detail-filled ICAN listings in this book to the simple, elegant algorithms in the Dragon Book or Cooper/Torczon's text.

5 comments about Java Examples in a Nutshell, 3rd Edition.

1. Just type these in and learn, learn, learn. Good examples across the board.



2. While writing this I can already imagine the shock and dismay of the Fan crowd with my review. I don't have much time so let me get to the point.
   The 1 star I've given it (bcs I had to, preferable I'd rate it 0 stars) mostly pertains to the GUI section of the book. Instead of providing the reader with abundant and clear examples, this author wants to impress the Java geeks by writing an 'smart' generic class that shows all the different aspects of the java GUI elements. Aside from just lame, this is also done most likely because of laziness. I can imagine it's not very exciting to write up the core program structure for every GUI example. But that's just the way a decent author would go about. No need to waste pages by explicitly mentioning everything more then once. Such things can be saved for the example source right ? But mr Flanagan does not share that view. He sits back with his (admittedly entertaining) 'showcomponent' program that loads in all the gui program code (classes) and displays the material. So, again, his 'Java examples' are merely small files with therein declared a certain class without any(!) surrounding program code. (basically similar to what you'd see in the Swing lang spec). All these compiled examples need to be read in (from the command line no less, by his showcomponent class which then actually does all the work of creating the frame, displaying it etc etc etc.
   
   And then cometh the reader, . . . . The moment you have to incorporate some of these lay-out en control components in you're own program this entire structure is obviously useless. Hence you have to struggle to get every component to work after all. The exact thing one is trying to avoid by buying a book. (No, you can't just copy & paste several separate sources together :) ). Basically you end up doing all the work yourself in the end anyway. Henceforth this book, particularly the part of GUI's , dialog's and event handling is of little practical use. I guess it would qualify as some sort of java coffee table book. Interesting functions, a clever introspective class here and there, things you can sit back and debate about with you're friends.
   Not with you're collegue(s) when you fighting the deadlines.
   While I'm not very proficient in Java, I've coded in c/c++ for far too long. Hence I don't need trivial lectures on what a ip port is. I just need to see some _completed_ (as in finished) programs, to get up and running with particular Java idiosyncrasies & components. If you are in a hurry, and simply have to get something up and running, keep running. Away from this piece of trash.
   Go with "Core Java" or some of the Swing books. it'll get you there much much faster.
   
   Edit: Took the flames out of the review. I was rather disappointed with this title at first. (now it's just collecting dust, but at least it doesn't aggravate me either).
   If you're a programmer, (like me) you can read the spec by yourself. It's the little things on the outside of the program (event & message que's ,window trickery etc.) that differ from platform to platform. Those are the exact things the author glosses over with this text.



3. This book should not be expected to substitute as a tutorial for people looking to learn the Java language. Instead, it is a book full of short programs that each illustrate specific concepts in the Java language. If you are needing a tutorial on the Java language in general, I suggest "Head First Java", which is also published by O'Reilly and Associates. You can either read the appropriate chapters of this book in parallel with that one, or look through this book after you finish the Head First Java book. If you already know Java, keeping an updated edition of this book around as a reference is a great idea.
   The first four chapters of this book cover the basics of Java, objects, classes, interfaces, input/output, and threads. Thus these chapters remain largely unchanged from the previous edition. Chapter 5, on networking, has been updated to reflect the changes in the language since the last edition, and contains examples of a simple network client, an HTTP client, and a POP client in addition to the programs of the previous edition. Chapter six is a new chapter on The new I/O (NIO) APIs introduced in version 1.4. These provide new features and improved performance in the areas of buffer management, scalable network and file I/O, character-set support, and regular-expression matching. The NIO APIs supplement the I/O facilities in the java.io package, and this chapter does a good job of demonstrating the APIs in action. The next chapter that has had a major overhaul is the chapter on printing. Printing in JDK1.4 was updated considerably and allows you to list specific printers with specific capabilities, query printer status, spool text or image files directly to a printer, and convert image files to Postscript files. There are examples of all of these upgrades in this chapter. The chapter on data transfer has largely been rewritten to reflect that Swing has added support for data transfer between applications. When adding data transfer support to Swing, the goal was to make it easy for developers using Swing components to add clipboard transfer as well as drag and drop to an application. The examples in this chapter demonstrate these concepts very well. There is a completely new chapter on the Java Sound API reflecting the capabilities of that API. In addition to simply playing sounds and sequences, the chapter demonstrates synthesizing MIDI and also real-time MIDI. Finally, the last part of the book on the Enterprise API's has been completely rewritten to reflect all of the changes that have taken place in those API's since the last edition due to the popularity of the Java language in enterprise applications.
   Currently, this book is two years old, which is getting a bit long in the tooth for a computer book. This is especially true if you consider the fact that JDK 1.5 has been released since this book was published with its own set of upgrades and nuances, and that JDK 1.6 is scheduled for release in the fall of 2006. I don't know if a fourth edition is planned for the immediate future, so if you can get the 3rd edition used for a low price it might still be worth the investment. If you are a Java novice, it is definitely worth your time and money.



4. Great overall summary of Java with examples. Replaces short surveys, tutorials and cookbooks of Java.



5. This book rocks. I started learning Java about 2 months ago with the Head First Java book, which is AMAZINGLY helpful (even if you know absolutely nothing beforehand). Once I got through that all that I began writing small apps on my own, but found in many cases that the API (Javadoc) was hard to understand because my limited Java knowledge leaves me with no context in many cases. I would think, "ok, it says this class can do this using these methods, and that's what I want, but how exactly do I put this into practice." Java Examples in a Nutshell fills this need perfectly with excellent examples(!), explanations, and clarifications. There's only so much that it can cover, but what it does cover, it covers really well.
   
   I might also add that I bought this book after *returning* Java In A Nutshell because for me it really just seemed like a $50 printout of the API you can read for free at [....].
   
   What I want to say is that, from my own experience, if you are pretty new to Java, and you are clicking well with it, and want a boost to propel you forward even faster, this is an excellent book to buy.

5 comments about The Rational Unified Process: An Introduction (3rd Edition) (Addison-Wesley Object Technology Series).

1. Target Audience
   IT professionals who need to learn about the Rational Unified Process (RUP)

   Contents
   This book is a relatively high-level overview of the entire RUP process.

   The book is divided into the following chapters: Software Development Best Practices; The Rational Unified Process; Static Structure: Process Description; Dynamic Structure: Iterative Development; An Architecture-Centric Process; A Use-Case-Driven Process; The Project Management Discipline; The Business Modeling Discipline; The Requirements Discipline; The Analysis and Design Discipline; The Implementation Discipline; The Test Discipline; The Configuration and Change Management Discipline; The Environment Discipline; The Deployment Discipline; Typical Iteration Plans; Implementing the Rational Unified Process; Summary of Roles; Summary of Artifacts; Acronyms; Glossary; Bibliography; Index

   Review
   The Rational Unified Process, or RUP, is a software engineering methodology that attempts to map out and document all parts of a software development project. It's extremely comprehensive, but it's also adaptable to whatever level of effort is appropriate for your situation. This book, The Rational Unified Process - An Introduction, is a good start to begin your understanding of RUP.

   First off, let me say this is not an easy read. It's a good book with all the information you need to know to start using RUP, but the information is dense and highly detail oriented. Like most developers, I'm more oriented towards coding and testing. But realistically, you need to know what the system should do before you get to the coding piece. RUP helps to put all that into a formal framework so that the necessary things will get done in the proper order.

   While the entire RUP framework might feel overwhelming, the author makes sure to let you know that you can adapt the RUP to meet your situation. If you are adding a function to an existing system, you will be more focused on use cases, development, and deployment processes. The author does a good job in segmenting the information so that you can more easily focus on your needs.

   You should also not consider this the end-all volume on RUP that you will ever need. Kruchten doesn't try to detail specific techniques like use cases or UML. You will learn where they fit in to RUP, but you will need additional information on how to implement use cases or UML diagrams. Consider this the volume that allows you to place everything in a mental framework so that you can figure out what you will need to know going forward.

   Conclusion
   If you are considering or in the process of implementing RUP, this is a book you should be studying. It's not an easy read, but it will give you the overview you need to understand the process and concepts.




2. This book introduces the logic behind Rational Unified Process (RUP). RUP is a novel idea. It puts several good practices in a consolidated package. What makes RUP useful is the fact that Rational provides all the necessary software tools to support this. This book does an average job in explaining the RUP. It over stresses obvious and well accepted concepts like "iterative development"; which makes the first half (6 chapters) of this book a bit boring. For a professional with software development and management experience, I found the first sixe chapters are best read at a cursory glance. The second half of the book introduces the workflows - and it is this half that I found more interesting. I finished this book as bed time readoing over the weekend - so this book is an easy reading. However this book is not about teaching how to use Rational Products. This book only gives an overview of the basis of origination of RUP. You would need another book to become an expert in using RUP.



3. It's an introduction, all right. The trouble is, it's such a high level introduction that there's almost no useful information whatsoever. The entire time I was reading, I was waiting for the author to get to the meat, only to discover at the end that there was none. It was like ordering a double cheeseburger, and getting two buns with ketchup and a pickle, and no beef patties.
   
   I can only assume that Rational paid the author for his time in the hopes that people, after reading this book, would purchase their entire software suite just to find out what the RUP actually involves.
   
   Despite my severe disappointment (and relief that I didn't have to pay for it myself), I can't rate it any lower than two stars. It's well written, and it could quite possibly be useful to managers and other business types who have no idea how software development works. The second star is for Rational's sheer chutzpah in getting a respected publisher to put out a $30 marketing pamphlet for them.



4. "The Rational Unified Process, An Introduction" offers readers a concise and strong introduction to the topic of the Rational Unified Process (RUP). Stressing the role of RUP in unifying the entire software development process, this book underscores the importance of efficient and effective software development.
   
   The book is structured in a logical and easy-to-follow manner and makes good use of descriptive graphics. For those with an interest in optimizing their software development processes, this is a good addition to your library.



5. After starting a few books in this series, this is the one I ended up finishing because of its readability. As an introduction to RUP, this book did its job. My only reservation is that it might be a bit too formal for those unfamiliar with the RUP jargon.