5 comments about The Object of Java: Introduction to Programming Using Software Engineering Principles (2nd Edition) (Visual Quickstart Guides).

1. The BlueJ IDE is less than impressive, and my copy (1st edition?) has plenty of errors (diagrams and/or codesamples have typos or are "wrong" with respect to the main text) ... however ... this book teaches OBJECTS using Java, not just how to program in Java. The excercises use problems that are optimally suited to object oriented solutions. The book was never boring or hard to understand. I love this book!



2. Let me say first: I love the BlueJ environment. It is by far and away the best environment I have ever seen for learning or teaching Java. I was facinated after reading the tutorial that comes with it (from www.bluej.org), and I got this book.

   This book is okay, and has some good points to it, but the 'BlueJ' tag on the front cover is a bit misleading. I got the impression that it was added as an afterthought, and does not make really good use of the BlueJ environment.

   BlueJ opens many fascinating possibilities (calling methods directly on an object!) and not much of this is used in the book. A bit disappointing. Otherwise the book is okay.




3. The Object of Java by David D. Riley
   
   This book is less than impressive. It exhumes the need for elucidated text in the field of computer science.
   
   I am compelled to correlate this book with the awkward ramblings of Vizzini to Westley in the movie, "The Princess Bride".
   
   Reading this book was more than a slight burden. Only one who is versed in reading the writings of such authors as Joseph Cambell or Henry David Thoreau can comprehend the confusion of word and sputter heavily peppering this book.
   
   Allow me to illuminate:
   
   1) This author finds it fit to include typos and syntax errors in the example code as to completely change the meaning of the code. Only one already experienced in programming will catch such errors. Others will wallow in confusion as to why the program is not working properly, after all, they copied it from the book word for word, it should be working, right?
   
   2) In several instances, the author uses programming syntax and variable naming methods in his text that has nothing to do with the code explaination at hand. He actively titles the beginning of each sub-section as if it were a class or variable. IE: DivisionOfRadians()
   NO THAT'S NOT A CLASS! :D
   This is a common practice of David D. Rileys throughout the book, and not only for chapter sub-sections. He uses such writing methods all too liberally.
   
   3) This genius author also uses an arbitrary library called aLibrary. Good for him, he designed his own library! Since this whole book is based on the aLibrary, any real world application have just been made void. I mean seriously, try convincing your co-workers that this aLibrary is the next big thing. What happened to the commonly used AWT and Swing libraries? Hmmm, oh, it's shoved in the back index. Right where you would expect commonly used every day libraries.
   
   4) His code snippets and actual text are seperated by font style. Only problem is, you can't tell at all. His method of referring to code, methods, arguments, classes etc in his text is extremely easy to miss without paying impossibly close attention. His text is filled with inconsistencies and problems. I DO NOT recommend this book. If at all possible, avoid it entirely. For those of you who are using this book as a college text, well, all I can say is, I'm very sorry.
   
   On the bright side, his explaination of objects and classes is ... decent.



4. i had to get this book for a course i was taking at the college i go to. i cringe every time i read it because the title is a bit misleading. I thought i was going to be learning JAVA insted i'm learning how to take someone elses class files to apply them to completely meaningless projects that really dont teach anyone anything about how to program, let alone about the inner workings of the programs your working with. the teaching style is more of a top down approach rather than explaining whats going on at the lower level and you learn to program with classes to make programs at an upper level. This may work for some, it definately doesnt fly with me.
   I have read many books on C, and C++, and have paged through some promising java books (like Sun's own books on the subject).. if it werent for the requirement for this book in the class i would have passed it up INDEFINATELY!!! Peice of Krap!!!
   
   do{
   if(The object of JAVA==pickup){
   The object of JAVA = Leave it the hell alone!!!;
   else if(The object of JAVA == buy)
   {
   do{
   Beat head with stick && knock sence into head;
   burn book || return to store;
   }while(book==posession)
   }while(@bookshelf)



5. This book was a required text for my java class. In conversing with my classmates, we all agree that this book wasn't of any help. I would recommend any other book, this one is just too abstract for a beginner. It's difficult to apply the concepts, and the flow is jagged. With the addition of a teacher, and reading this book from front to back, my java class sucked hard because i didn't have that solid foundation I needed.

5 comments about Programming Microsoft ASP.NET 2.0 Applications: Advanced Topics.

1. Basics of .net framework is presented in a clear and lucid style. This book is a joy to read and . by the way there is not much difference in content wise between applied .Net framework programming and this book. My only worry is the speed at which microsoft is pushing .net versions as if there is no tommorrow! [Subsequently the catch up I have to do on reading all this!]



2. The two books of this series (Core Reference & Advanced Topics) offer broad and deep coverage of ASP.NET.
   
   All the important topics of ASP.NET web sites are covered in a mostly tutorial with a little reference fashion. The books are well researched. The coverage of what really happens during compilation, request processing, and expression evaluation is excellent. The books avoid being an MSDN rehash. By carefully pointing out which ASP.NET versions support which features, the books will be useful for working with any ASP.NET version. No matter what you're working on you'll find something useful in these books. Note that web services are not covered.
   
   The terms "core reference" and "advanced topics" (which MS press is using on all the non beginner books) make no sense at all with these books. If you're serious, you need both books. Think of them as volumes 1 and 2 of a single book.
   
   I do have some issues with these books. The biggest mistake was recommending the use of GDI+ (through the System.Drawing namespace). This is not supported. The System.Drawing namespace page in MSDN states "Classes within the System.Drawing namespace are not supported for use within a Windows or ASP.NET service. Attempting to use these classes from within one of these application types may produce unexpected problems, such as diminished service performance and run-time exceptions."
   
   I didn't enjoy Dino's writing style. It's verbose (at times), he uses odd words to describe things, and was boring even by tech book standards.
   
   The chapter on configuration was difficult. It would have better to cover configuration throughout the book, in the context of what was being configured, instead of a single all configuration and only configuration chapter.
   
   The section of asynchronous pages was confusing and didn't really explain why asynchronous pages improve scalability.
   
   Despite my reservations, there is much that's good about these books. Anybody who's serious about ASP.NET should consider getting both of them.



3. I bought this book specifically for the 100+ pages on creating custom web controls. That is the only portion of the book that I have used.
   
   The book does not come with a CD for the source code examples, and I have been unable to find them online.
   
   That means I have to type in the examples. I normally don't mind, as it helps me learn. But his sample control, SimpleGaugeBar, has code scattered across two chapters (#13 and 14), all in bits and pieces. The code is intermingled with alternate code examples that (I think) he isn't using in the class, plus code from other classes apparently unrelated to SimpleGaugeBar.
   
   The sample control is also buggy. Of course, it's my guess as to the code that is supposed to be contained in the control, because there is no single definitive listing of the code in the book. I suspect the sample code is simply buggy because the event sequencing the control responds to does not match the way the control was coded.
   
   He separated the creation of the internal list of control objects and the styling code into two routines. That's probably a good idea. But, and this is a killer, if you programmatically change the properties of the control, the internal list of control objects is created *before* the new property value is set, and applies styling after the property is set. This will cause the control to fail, because the styling code will refer to objects that were not created based upon the prior property settings.
   
   The styling code also refers to objects in the internal list of controls by array index number instead of by their id. That's bad form and very prone to error.
   
   I'm not a happy customer.
   
   That said, there is a lot of material on custom controls, and I learned a lot going through it. There are not a lot of resources out there that cover this topic in any depth, and this is one of the few. So, muddled, buggy and disorganized as it is on this topic, I would recommend it (until I found something better).



4. This book rocks! I cant find anymore words to say this :D
   
   I keep this book by my computer all the time. Dino has once again provided us with some great information.



5. So whilst you are waiting for the 3.5 version you can get this one second hand.
   
   It covers loads of usefull day-to-day tasks that most web devs have to search google for. Not sure that "Advanced" is the correct choice here, but its tasks that all my senior devs are capable of.
   This said, it's a must have for any web developers desk. All of the 2.0 stuff still applies to 3.5 cant wait till the new version that would be more complete.
   However, just using his examples expressed in Listview/Datapager controls using LINQ will yeild plenty till his new book comes out.
   I can understand why the 3.5 version is delayed (seeing 4.0 is due in December), there is plenty of 'advanced' issues in using MVC to content with, then add microsofts version of Spring/NHibernate to the mix (not stable yet where as the open source Spring/NHibernate is) then you can see why there is a delay.
   
   "ASP.NET 3.5 Applications: Advanced Topics" is a moving target and will be for 6 months(conjecture) or more(features in consenus use a >12months away?).
   
   So why get "ASP.NET 2.0 Applications: Advanced Topics"?
   It will make your life easier and get projects out the door faster.
   All that you learn in this book can be applied to your 3.5 projects (we just use VS2008 and VS2003 for legacy - VS2005 has no further use).
   Likewise if your are a commerical C# developer you would use the VSTS version of 2008 due to the productivity gains unless you work in a sweat shop where labour is cheap.
   
   Related:
   
   Using ReSharper4 Power Programming with ReSharper: Optimize .NET Development with the ReSharper Add-In to Visual Studio 2008 (Wrox Briefs) offer substantial benefits for C# 3.5 users this too will have you get quality code out the door faster.
   
   Programming Microsoft ASP.NET 3.5 is a welcome addition as Dino really knows his stuff (ASP.NET/AJAX/UI)

5 comments about C# Cookbook, 2nd Edition (Cookbooks (O'Reilly)).

1. If you are just coming into C# or have been doing it for a while - it doesn't matter - BUY THIS BOOK!!! Oreilly as we all know, makes very good tech/programming books and this one is one of the best I've had so far. This will be a book that will spend much less time on my shelf and much more time next to me on my desk.



2. I came across a project that had to do with XML, and I came to love this book. It has a lot of suggestions that helped me jump start my project.
   
   I wouldn't recommend this book to learn C#- (pick up John Sharp C# step by step for that.)



3. I'm an intermediate coder, familiar with programming and I have about 1.5 years programming C#. I've already used this book(C# Cookbook 2nd edition) to write C# code navigating in and around directories and files. The examples in the book regarding "Directory Info" and "File Info" were so clear and concise, I was able to complete my programming task with almost no lost time to the learning process. What I like most was that there was not one example, but many examples for the most used functionalities. This book has already paid for itself when I consider the time it saved me the first time I needed it!



4. This is a good intro book that eliminates the need for some of the first books I bought on C#. When compared to other "cookbooks", however, this book is incredibly weak (see: XSLT Cookbook, SQL Cookbook). If you have used C# for more than 6 months, you will know how to iterate over an array, to use String.IsNullOrEmpty, get the index of a value within a string, and use a generic arraylist. These are just some of the junior "recipes" you'll see in this book. The "recipes" just exercise the fundamentals (i.e. how to boil water) rather than how the fundamentals work together to solve complex problems in elegant ways. The easier the concept, the more information. There isn't really any analysis or best-practice justification present. I'd like to see some performance analysis of generics or at least some depth on partial methods. Nothing to see here for mid-level developers. Not written or organized poorly, just simple. If it were titled "Intro to C# by example", I'd give it a higher score.



5. [Reviewed by XPSD member Steve Grubbs]
   
   Summary
   
   I wanted to check out a C# cookbook after developing in C# for almost a year. I figured I should get a basic understanding of the language and the .NET framework by using it for awhile before I buy such a book. That said, I wish I could go back in time and tell myself to get the C# Cookbook the day I started developing in C#.
   
   Overall Review
   
   I see two main criteria for reviewing a programming language cookbook.
   
   1. The quality of each "recipe"
   2. The recipes chosen for the book
   
   The C# Cookbook handles each recipe very well, which we should definitely demand of a cookbook. It has a very simple 4-section format, Problem-Solution-Discussion-See Also. The problem is briefly stated first. The solution is almost entirely code samples, with minimal commentary. The discussion is usually short and sweet, with a few exceptions. The "see also" points to reference topics in the MSDN help, which is of questionable usefulness, since you can search the topics yourself; but, is short enough to skim over easily.
   
   The recipes chosen for the C# Cookbook range from very useful to trivial. One of the trivial examples would be something like, converting degrees to radians. The only language specific feature here is Math.PI, which I don't think is worth the page it's printed on. What I found surprisingly useful were some code samples that I spent time coming up with on my own before reading this book, like a custom trace class that outputs in XML. Fortunately, most of the examples were in the useful category.
   
   A few glaring topic omissions are remoting, ADO, and advanced object serialization.
   
   Per-Chapter Review
   
   * Numbers - somewhat trivial
   * Strings and Characters - good introduction to the C# string
   * Classes and Structures - good stuff on interfaces, casting, converting, COM interop
   * Enumerations - simple, but short and useful
   * Exception Handling - an underrated topic that I'm happy to see covered
   * Diagnostics - a surprisingly useful set of tools to help with debugging
   * Delegates and Events - very good intro for the new C# programmer
   * Regular Expressions - very good intro for the new C# programmer
   * Collections - a little simple, could have more useful samples
   * Data Structures and Algorithms - simple, but good if more advanced types are required
   * Filesystem I/O - very good examples of file I/O in C#
   * Reflection - a necessary intro to reflection, but a bit simple
   * Networking - biggest complaint: Why is there no remoting?
   * Security - a good survey of various security issues in C#
   * Threading - a good intro to threads and basic synchronization in C#
   * Unsafe Code - I tore out and burned this section
   * XML - good intro to reading/writing XML in C#

5 comments about Oracle JDeveloper 10g for Forms & PL/SQL Developers: A Guide to Web Development with Oracle ADF (Osborne Oracle Press Series).

1. This is an excelent book for begining web development, it explains you step by step how things work and "glue" together. The only reason for me to give it 4 stars is that, in the book it explains how to build part of an application (tuhra) and it tells you to look for the rest (of the app.) on the web site..... I looked for it but it is nowhere to be found... (they only have the parts of the app. that you develope while doing the books excercises).



2. Great



3. exellent Book
   
   Goods Tips for programming Oracle ADF
   
   greetings from Toluca, EdoMex, Mex.



4. Being a traditional pl/sql developer, I was drawn to the title of the book immediately. I know I need to eventually buckle down and learn Java, but what better way than by drawing parallels to pl/sql and Forms.
   
   I like the hands-on examples that has you build a fairly complete application from scratch. I say fairly complete because its only a 500 page book and it allows the reader to go out and research ways to improve it.
   
   One of my favorite parts of the book is a summary section that shows up after a large chunk of instructions called "What did you just do?" This sums up what the reader just performed - explaining in layman's terms what you actually just did.
   
   Although I'm sure you can get similar tutorials on OTN somewhere, having a book to flip back through is always nice.



5. this book is ok.
   just like all other oracle books, they just "talk too much"..
   to much junk and too little meat...
   almost feel like they are putting in too much filler to make it to a
   500-600 page book....
   if you get the class notes from oracle's classes...it's much more compact
   and to the point.
   Too bad there is not much other jdeveloper book out there.

1 comments about Windows PowerShell(TM) Scripting Guide.

1. This book looked really good at first. A lot of practical scripts included, however, they all appear to be basically the same with exception of a WMI call (query). Which brings up the point, that a lot this book is geared towards using WMI. A better title might be Using Powershell and WMI. There is very little in terms of concepts, efficient uses of Powershell, using COM or WinRM. Many of the concepts and techniques are spread through out the book and difficult to locate. If you have a basic understanding of Powershell, need some quick and dirty scripts and don't plan on getting to know it much more in depth this might work for you.

5 comments about Beginning Database Design: From Novice to Professional.

1. This book delivers what it promises. It give a object oriented approach to designing databases. The basic topics and design methodology are addressed. I have become a better programer having read this book
   
   Using several examples of data modeling (plants, argiculture testing, personal management) it tracks the process from use cases and data collection to modeling the information with UML, and presenting this informaotion in a useable format. She touches on a number of common issues, such as a 'fan trap', key generation and data types that need to be addressed early in a project.
   
   The style is light and fast paced. The impact of different techniques are illustated in a concise manner with sufficent detail to be understandable and not overwhelming. I see it as a good basic introduction, and will use it as a foundation for more in depth study.



2. The more I get into database design, the more I keep coming back to this book, as well as Database Design Demysified. The two books are oriented toward small to medium databases, and that's the best way to learn the fundamentals. In my work for the government, I've only seen one or two decently designed databases. The true examples in the book of databases gone wrong are amazing and oh so common. Some much needed humor enlivens a dry subject in both books, and neither throws a lot of jargon at you. Database Modeling and Design (T Teorey) could never teach me how to design a good database! It just never gets down to the nitty gritty details of what works and what doesn't, and why. The two good books are complementary- I reccommend you get them both. Good Luck!



3. This book is excellent for someone who is trying to get into learning databases. I like using a different form of ERD than mentioned in this book, but I couldn't find any errors with this book. I found this comforting since many database books use the author's interpretations of database design, rather than generally accepted practices. Awesome educational book!



4. I am about 1/2 way through this book and all the things that I thought I would get out of it, I haven't. It is a fast read, but it is lacking in content.



5. Clare Churcher is an excellent teacher! She can explain difficult things in a clear and concise way. This is e.g. the first book who explains table joins to me without getting a hazy feel in the head. Nice to have this book as a first introduction. For digging a little bit deeper in the subject I would reccommend Beginning Database Design (Wrox Beginning Guides) wich I also bought.

1 comments about Beginning Python: From Novice to Professional, Second Edition (Beginning from Novice to Professional).

1. To summarize, too cumbersome and rather difficult to find the exact information you are looking for. Magnus Hetland tries to be funny and assumes that it makes the book more readable. Unfortunately, nothing could be further from the truth. I'd rather have a serious book with all the information accessible, rather than something which reads like a boring college lecture. This book does not address the needs of experienced programmers in other languages who want to shift to Python(like myself), and is way too advanced for a beginner. That said, the only interesting things in the book are the projects described at the end.
   In place of Hetland's book, I'd recommend other books like the freely downloadable Python programming book in the "Thinking like a Computer Scientist" series by Green Tea Press. Besides this, there are also many websites which teach Python programming for free. Why buy a bad book?

5 comments about UML 2.0 in a Nutshell (In a Nutshell (O'Reilly)).

1. I bought this book recently to learn about the differences and new stuff included in this version of UML. I sincerely think this book was an excellent choice. The author describes each UML diagram in a focused way and in very simple words. I'm actually reading it and i am very pleased with this book. It fits all my expectations about a quick reference guide into the world of UML 2.0. Note this isn't a learning book about this language it's only like its title said UML 2.0 in a nutshell.



2. When searching for a very good UML reference book last year, I happened upon the book entitled "UML 2.0 in a Nutshell" by Dan Pilone with Neil Pitman. The book, which measures a mere 8.9 by 6 by 0.8 inches, is both lightweight and highly portable; which is one of the reasons that I decided to purchase a copy. However, it was ultimately the content of the book, and not its compact size, that convinced to me that this would a very useful resource. Condensed within 216 pages, "UML 2.0 in a Nutshell" lives up to its title, as the book is an extremely informative resource in understanding the various graphical elements that comprise UML with its nine types of diagrams.
   
   The book's 12 chapters and two appendices are divided into four main parts: an introduction, static diagrams, behavioral modeling diagrams and finally, extensions and applications of UML.
   
   First Part: Introduction
   
   chapter 1: Fundamentals of UML
   
   This chapter provides a short, but good introduction to the fundamentals of UML. If you have never used UML before, this will help to introduce several key concepts of UML; but you might want to consider purchasing a UML tutorial book, such as "UML Weekend Crash Course" by Thomas A. Pender, to obtain a more hands-on approach to learning UML.
   
   Second Part: Static Diagrams
   
   Chapter 2: Class Diagrams
   
   Class diagrams are one of the most important aspects of UML. With class diagrams, the relationships between classes can be thoroughly illustrated, including the strengths of the relationships between classes. This chapter provides a precise description of the various ways that class relationships can be defined within UML: dependencies, associations, aggregations, compositions and generalizations; as well as association classes. This chapter also discusses class members (variables & methods), whether a class might be abstract or an interface, and templates.
   
   Chapter 3: Package Diagrams
   
   Classes that are contained within a common package can be illustrated within UML using package diagrams. This chapter also includes relationships between packages and use case packages.
   
   Chapter 4: Composite Structures
   
   This chapter discusses composite structures that exist during runtime, including connectors and ports, as well as collaborations.
   
   Chapter 5: Component Diagrams
   
   Components (replaceable & executable pieces of a larger system whose implementations are usually hidden) can be used in UML as either a black-box or white-box view. This chapter discusses both uses.
   
   Chapter 6: Deployment Diagrams
   
   This chapter discusses how the deployment of an application (which may include many pieces) can be illustrated within UML, including artifact instances, manifestations, nodes, devices, execution environments and communication paths.
   
   Third Part: Behavioral Modeling Diagrams
   
   Chapter 7: Use Case Diagrams
   
   This chapter documents how an actor (a person or another application) interacts with applications and their internal components.
   
   Chapter 8: Statechart Diagrams
   
   This chapter discusses the two types of state machines that can be described in UML: behavioral state machines and protocol state machines. This includes states, composite states, submachine states, transitions, activities, pseudo-states and event processing.
   
   Chapter 9: Activity Diagrams
   
   This chapter discusses how activities and actions are illustrated within UML, including activity edges, activity nodes, object nodes, control nodes and more advanced activity modeling: activity partitions, exception handling, expansion regions, looping, streaming, interruptible activities and data store nodes.
   
   Chapter 10: Interaction Diagrams
   
   How UML is able to illustrate interactions between objects is accomplished through interaction diagrams. This chapter discusses usage of interaction participants, messages, execution occurrences, state invariants, event occurrences, traces, combined fragments, interaction occurrences, decompositions, continuations, sequence timing, timing diagrams and communication diagrams.
   
   Fourth Part: UML Extensions & Applications
   
   Chapter 11: Tagged Values, Stereotypes and UML Profiles
   
   This chapter discusses use of stereotypes, tagged values, constraints and UML profiles.
   
   Chapter 12: Effective Diagramming
   
   This chapter is essentially a "do" and "don't do" chapter that emphasizes the need to keep UML diagrams as simple as possible, though that is not always possible.
   
   The two appendices: Appendix A is about MDA (Model-Driven Architecture) and Appendix B is about the object constraint language (OCL), which is an extension of UML 2.0.
   
   Overall, I rate "UML 2.0 in a Nutshell" with 5 out of 5 stars and highly recommend it to anyone learning and/or using UML on a regular or infrequent basis. I have yet to see a book as well written as this in explaining the many aspects of UML in as a concise & easy-to-understand form as "UML 2.0 in a Nutshell".



3. This book is just a reference guide for UML 2.0. Well categorized, small examples for each UML concept but nothing else. If you want to learn UML from scratch this is not the first book you want or even need to read. If you are a proficient UML designer you won't need it. If you are in the middle path this book can help you a little, when you forgot something specific for example. Although you can easily find the same information googling elsewhere.
   
   I'm not telling you this is a waste of money. Just don't expect too much.



4. I am a software developer with 15 yrs experience, been a Java developer for the last 7. Never worked in a heavy UML environment but have been required to put together class diagrams and wanted to learn more about other UML features. This book is not a cookbook, a how-to, or a learning guide, so if you need to learn and use UML in a heavy-duty way this book is not the right one. However, this book is great as an overview and reference, and it allows me to speak intelligently about UML and understand diagrams. Certainly would recommend it for other developers who wish to have a working understanding of UML.



5. It provide enough "life" examples to permit you to understand the basic. It is a great complement to maybe a college book that provides limited examples.

5 comments about Foundations of GTK+ Development (Expert's Voice in Open Source).

1. A textview widget in python had me stumped, but no longer. Anyone wishing to tackle GTK+ programming should buy this well organized and excellent book. It is well worth it.



2. I got this book a few weeks ago and found it to be well written and to the point.



3. FINALLY... a great book on GTK+.
   Easy to follow and understand, great example, great explanations...
   
   Usually I dislike the writing styles in Apress publications, but this is a definite winner. For the first time I can say I actually understand and can effectively use GTK+.



4. I picked up this book to help me develop an application knowing absolutely nothing about GTK+ programming and it was beyond helpful. Excellently written, not to mention many code examples showing how to use the GTK+ library properly and efficiently. This book gives you the tools and the understanding for building your own applications and not just re-creating the examples given to you.
   I highly recommend this book to anyone programing in C and want to learn how to use the GTK+ library along with the GLib and Pango libraries. This is one book I'm not going to let go of.



5. I wanted to like this book, but unfortunately I cannot in good conscience give it 5 stars as the other reviewers have.
   
   I will say the book is well organized and is definitely useful as a starting point for studying GTK+ and the author clearly has a great deal of knowledge about the subject. But what should have been the main strength of the book that differentiates it from the mostly inadequate online tutorials is the author conveying to the reader straightforward explanations of important concepts and insider tips and tricks that can only come from extensive experience. He tries to do this, but I found many of his explanations ambiguous and confusing. Important terminology was left undefined or poorly defined which contributed to the confusion.
   
   The author dutifully plods through a presentation of most of the main widgets, providing essentially the same trivial example code each time with minor variations- basically just showing how to put the widget onscreen. But there was a frustrating lack of material devoted to how to use signals and events to perform any useful tasks. The vast majority of the functionality of any GUI application lies in its event handlers and callback functions. After reading this book, you will be able to prototype the GUI for your application, but you may be at a loss to make it actually do something.
   
   By Ch.3 and 4, the same example code has been replicated so many times that there is an increasing frequency of copy-paste errors that gradually becomes very annoying. Also, there are many typos in the text. The lack of editorial oversight and technical review on the part of the publisher combined with the author's lack of attention to detail and failures in exposition has created a book that I can only marginally recommend- mostly because all of the other books that have been published on GTK+ are either out of date or out of print, so this book seems to be the winner by default.

5 comments about Digital Signal Processing with Field Programmable Gate Arrays (Signals and Communication Technology).

1. This book is well written and covers many of the aspects of DSP with FPGAs. I run a business that specializes exclusively in high performance DSP designs using FPGAs. This book pretty much covers it all, in fact it closely parallels the material we present in our DSP for FPGAs seminar. I very highly recommend this book.

   The following are the contents of the book, which are not otherwise listed on Amazon:
   1. Intro, which goes over FPGA architectures, 25 pages

   2. Computer arithmetic. Covers computer arithmetic from the slant of hardware. Includes distributed arithmetic and cordic discussion, 46 pages,

   3. FIR filters 34 pages

   4. IIR filters 24 pages

   5. Multirate signal processing -- decimation &interpolation, polyphase decompositin, CIC filters, Multistage decimators, Frequency sampling, filterbanks, wavelets. 59 pages

   6. Fourier Transforms -- 42 pages

   7. Advanced topics -- Rectangular and number theoretic transforms, error control and cryptography, modulation & demodulation --76 pages

   8 . references and source code 76 pages

   -Ray Andraka, P.E.
   President, Andraka Consulting Group, Inc




2. "Digital Signal Processing with Field Programmable Gate Arrays" covers most of the popular DSP applications in good detail.
   Before you buy this book I would highly recommend reading "Understanding DSP" by Rick Lyons.

   Once you understand the fundamentals of DSP this book will help you decide on the best implementation
   of each algorithm using a step by step approach. The author also weighs up the pros and cons of each algorithm.




3. In this book Dr Meyer-Baese brings in his industrial/proffessional experience from the field of DSP using FPGAS. Lots of other FPGA/Hardware books just talk about the theoretical/concetual/abstract level DSP. Here the main focus is the practical implementation of the different DSP Components
   everything from Multipliers to the Discrete Wavelet Trasform.
   Each of these components are seperately discussed chapter-wise and is supplemented by applications and also source code in both VHDL and Verilog (mostly in the accompanying CD)
   If you just want to know what an FFT is then this book is NOT for you,but if you want to implement this in hardware then this is THE book.



4. I was so disappointed after I read the book. I had expected to get some practical examples about implementing DSP in FPGA.I regret I was attracted by the name of the book and some reviews definitely not from sillicon valley . Except in chapter1"introduction" there lists some basic FPGA concepts, I hardly say how this book was named as "DSP with FPGA".
   It does provide lots of mathemetical models, graphs for each DSP component, I believe it will be much more helpful to writing a PhD thesis rather than using as reference book in industry.
   If you are expecting to get some practical examples about implementing DSP in FPGA, this book might not be a choice.



5. Comes from the DSP hardware Stars. Actually the only book on DSP hardware design in the market as of 2007. So there isnt much of choice, if you are into this businees. Good value for money, a hefty, detailed treatment.