No comments about Semantics with Applications: An Appetizer (Undergraduate Topics in Computer Science).

5 comments about Kernel Methods for Pattern Analysis.

1. The book is divided into 3 parts. The theory is all in part I,
   the rest of the book is a cook-book with plenty of matlab code.
   The website contains most of the same code + data online. Readable, complete.



2. This work presents a coherent overview of an important field in machine learning. The unifying framework of kernel methods has proven state of the art results and the community has been waiting for a book like this to make both theory and practice of kernel methods accesssible for readers of all different backgrounds (researchers, students, practioners from both academia and industry, ...).
   
   It is theoretically well-founded, the resulting algorithms are well-explained and made accessible for practioners by providing pseudo-code and online, ready-to-use matlab code.
   
   This book nicely complements the previous, yellow book, written by the same authors. Indeed, after "getting into the field" by reading the accessible introduction to support vector machines (SVMs), it was clear to me that SVMs was only an example of a signifcantly larger framework, i.e., kernel methods. The blue book is the reference book about that larger framework I have been waiting for since then. I particularly like the way the book is set up, making clear the modular, flexible approach in kernel methods.



3. Well, at first I was petrified to find a book that sounded like it deeply explores the subject of kernel methods. But all in all, it did not quite achieve what I hoped for. As a practical approach, when it comes to implementation, it serves nicely as a reference. The deeper mathematical roots of kernels (especially when it comes to measure theory and functional analysis) are not dealt with at all or just scratched at the very surface. The notation is sometimes awkward, mentioning for example the representation of an object in a given vector space with respect to the basis. And: Too much copied and pasted from the former book about SVMs. Basically, reading papers of Carmeli, Aronszajn and others will give you a much deeper insight into the subject.



4. Sloppy language, sloppy definitions, sloppy proofs.
   Constant repetitions do not add any clarity either.



5. A very useful book and quite a nice read. I bought the book after reading a few chapters. Even now, an year after my grad school, I still read this. A good reference.
   
   Nice print, no mistakes, MATLAB code. You get everything on Kernel Methods, from theory to implementation. A perfect book and helped me a lot in my research.

No comments about Algorithms and Data Structures: The Basic Toolbox.

5 comments about Crackproof Your Software: Protect Your Software Against Crackers (With CD-ROM).

1. It's great that there's a book like this out to begin with, but I was disappointed to see the focus only on Windows applications and mostly on how to use existing tools to harden your software. It doesn't really cover as much as I would have liked to have seen on how to actually implement crack-resistant software. Much of the book's contents are FAQ-like and refer only to currently available tools (a very current practical approach versus a broader theoretical academic approach). If the exact problem you're trying to solve is explicitly addressed in this book, you're golden - if not, you're completely out of luck with regards to the book's information.



2. Before I read this book I knew very little about cracking software. After reading this book I still know very little. I agree with the author when he says that to protect yourself, you need a good understanding of what you're up against. It also helps when you apply a protection method if you can check it against something. The book falls way short of teaching you ways to crack software.
   
   However, I gave this book a good rating because I think it does a good job of giving the reader an overview of methods he can use against crackers. It covers disassembly detection, registration protection, use of dongles, CD copy protection, and compressing and encoding executables. It also provides a CD with several freeware/shareware programs you can use to protect your software. Keep in mind that the book deals exclusively with the Windows operating system.



3. As fast as developers and vendors can pump out new software the crackers of the world break the protection schemes. Rather than paying a fair price for the software many people visit underground cracker sites and warez FTP sites to download illegally cracked versions of software.
   
   This theft has a financial impact on the vendors and developers. Large companies like Microsoft lose tens of millions of dollars in revenue to pirated and illegally distributed software each year. Not that they are in the market of not making money, but losing $30 or $50 million is more or less a drop in the bucket to Microsoft and something they can absorb as the cost of doing business and simply write it off on their taxes. Joe Programmer sitting in his basement writing code 18 hours a day to create a fantastic new shareware program however might miss the money a little more.
   
   If you are a freelance software developer or even a small software company this book may be just what you're looking for. Crackproof Your Software: Protect Your Software Against Crackers gives you the inside scoop on the techniques and tools used by crackers to break into your software.
   
   Pavol Cerven helps the reader to understand the common errors developers make that make it easier for crackers to break in and shows a number of tips and hints to help the reader learn how to write crackproof code including how to thwart attempts to debug or disassemble the code.
   
   I highly recommend this book for software developers.
   
   (...)



4. i bought this book thinking it will teach me the techniques used in cracking so that i can apply it in my development.
   
   well, from that angle this book is a total disappointment. it doesn't even have a section that discusses the basic techniques, zilch!
   
   one thing it does tell you is the methods used by various tools but the discussion is too cursory.
   
   not worth buying this book. if you want to learn crackproofing or cracking, might as well scour the internet especially learning from the hacker sites.
   
   i also wrote to the author. he never replied.



5. Nutshell review - The book covers the basics of protecting software and covers some protection tools. However, the world has too many protection options and schemes and evolves too fast for one book to do it all. Will date quickly.

No comments about Understanding Practical Unix.

2 comments about Professional Ruby on Rails (Programmer to Programmer).

1. First thing I'd like to point out is this book is up to date with Rails 2.0.2 (released 12/07) which is important as many things have changed like script/generate scaffold, in-place-editing and auto-complete have been deprecated, etc. Essentially, enough to baffle and frustrate a relative newcomer unaware of these changes who is trying to get started on 2.0.2 with older tutorials.
   
   This book absolutely delivers on its promise to "fill the void" between beginner books and recipe/cookbook style books. It is the one-stop resource I've been seeking since Rails hit the streets.
   
   I bought this book hesitantly as there were no reviews yet. I've purchased at least a dozen books on RoR over the past 2-years, some good, some average, some not so good. I can honestly say this is the best coverage of RoR I've read - without hesitation! I've only written one other review here at Amazon which was for David Black's "Ruby for Rails" which was a great book a few years ago if you didn't know Ruby programming.
   
   I own AWDR I & II, Pick Axe, Recipes I&II, Cookbook etc. etc. Good books in their own right but I was still left not fully understanding key elements of building a solid, well tested enterprise ready site. This resulted in me making a ton of mistakes leading to endless hours of Googling to find others who had encountered the same problems, finding random tutorials, picking up a tip here, a tip there, etc. It was pure scattershot!
   
   My application design was not cohesive and lacked the fundamental building blocks and safeguards necessary for continued growth. For lack of a better analogy, the apps I've built with Rails have been nothing more than patchwork quilts temporarily held together with rapidly disintegrating stitches. Enter "Professional Ruby on Rails."
   
   I received "Professional Ruby on Rails" the other night and thought I'd spend an hour or two skimming chapters and hopefully picking up a couple tips. 7-hours later after fully reading through everything in several chapters I was stunned at how many things I was doing wrong. Noel has done an exceptional job of covering key details that are typically glossed over or go untouched in other books and tutorials.
   
   For example, how many tutorials have you seen where you get step-by-step intimate details on how to generate the models/controllers/scaffolds, run migrations, set up your associations, validations create a snappy View with some nifty AJAX....and then bang......the tutorial ends with "Now write your tests and check it into SVN". Hmmmmmm? Sounds pretty easy, okay...done.
   
   Building the AWDR bookstore was reasonably covered but testing and fixtures were an afterthought. There was a chapter dedicated to testing but was general coverage and did not comply with Rails best practices of test driven development. This book fills that void wonderfully.
   
   In the interest of full disclosure, I'm a hobbyist and don't make my living with web development. I'd rate myself with low-level intermediate Rails skills having built 3 or 4 "personal" projects, trivial in every sense of the word. In early 2007 I had attempted to start a non-trivial project, my "Big Idea". 6-months of agony later, I became so frustrated and lost, I walked away from Rails entirely. The biggest reason for my frustration, also my biggest weakness, was testing and it came back to bite me in the arse on more than a zillion occasions. In short, my app was hopelessly broken and the only solution was to scrap it and start over. Not fun!
   
   Having spent a few nights with the examples and advice in Professional Ruby on Rails, I've come to realize I was going about testing in a completely bass ackwards way. I was also not using SVN properly and missing opportunities left and right to refactor code that is now, in just a few short days of reading this book, so blatantly obvious. I also didn't realize how trivial it was to build your own rake tasks to automate tedious chores I had previously performed manually. And I'm really only halfway through the book!
   
   In short, no Rails book or resource I've read, and I've read a lot, has come close to teaching me exactly when, why, what, where and how to build a real-world application, step by step, like Professional Ruby on Rails. I give it my highest recommendation and feel confident that, thanks to Professional Ruby on Rails, my "Big Idea" now has a chance!



2. Since this is one of the few Ruby on Rails 2.0 books it is just an okay book. You really need to know Ruby on Rails before even starting this book. It is very hard to follow and without the source code everyone would be lost by page 20. I guess he wanted people to learn by figuring out what he was trying to do.

No comments about Professional ASP.NET 3.5 MVC.

5 comments about Perl Medic: Transforming Legacy Code.

1. While the "medic" metaphor recurs throughout the book, most of the material isn't directly related to repairing old code. Instead, this is a collection of best practices for new code. (The author recommends rewriting existing code if at all possible.) It ends up resembling another excellent Perl title, Joseph Hall's Effective Perl Programming. Good company to keep. Perl Medic has the advantage of being newer, and of covering a bit more material. The writing style is very easy to read, and the order of presentation works well. An excellent title for any intermediate-level Perl programmer.



2. A quote on the front cover of this book says "if you code in Perl then you need to read this book". That's a pretty bold claim to make. It made me think of the hyperbole on covers of books that claim to teach you to program in Perl in just a few days. But this book is published by Addison Wesley, who are a well respected technical publisher of technical books and the quote is from Adam Turoff who certainly knows what he's talking about when it comes to Perl programming. So in this case the claim isn't hyperbole. The book really is one that I want every Perl programmer to read.

   Perl gets a lot of bad press from people who claim that it encourages people to write unreadable code. Whilst there's certainly a lot of very bad Perl code out there I think that's more a sign that it's used by a lot of people who don't know how to program than a reflection on the language itself. And that's where this book comes in. It assumes that you are familiar with the syntax of Perl but that you've never really been shown how to use it effectively. Which is a situation that many Perl programmers find themselves in.

   Perl Medic is actually targetted at people who have to maintain older Perl code written by someone else, but I think that the information it contains is just as useful to anyone coding in Perl. Peter Scott has a lot of experience in writing Perl and in training other people to write Perl and the distillation of that experience and knowledge into these 300-odd pages mean that there are few Perl programmers who won't pick up something useful from this book.

   The main emphasis in the book is on increasing the maintainability of code. The techniques are wide-ranging. I particularly enjoyed the examples of refactoring programs and the coverage of using modules from CPAN. Two other very good sections are the one on antipatterns in chapter 4 and the one on cargo cult programming in chapter 6. Together these sections give a programmer a number of easy to recognise quick wins when improving existing code and a checklist of things not to do when writing new code.

   There are a couple of niggles. I've already mentioned that I think the book has been slightly mis-targetted and that it should have been aimed at anyone writing Perl code. The other problem that I had was that the medic analogy that runs through the book gets a bit strained at times. But these are only minor and they shouldn't prevent you from adding this book to your library.

   In fact, all in all, the quote on the front cover is pretty accurate.




3. I wish I read this book earlier...
   In fact it's my only regret about this book...
   
   This book is an absolute "must have" for every Perl beginner.
   Teaching how to program safely, and to maintain/debug/clean Perl code is not an easy goal, but the author
   (who is obviously someone who loves and knows Perl)
   manages to do it in a simple and pragmatic style.
   
   A lots of subject are covered too many to mention here
   (you HAVE to read this book anyway ;-) )
   but I'd like to point the chapter about "cargo cult programming" which will be highly useful to beginners to my mind
   (So sad the cargo cult constructor isn't described too (you know the one using : my $class = ref $proto || $proto; ))
   
   While oriented to the beginners (IMHO), the experienced Perl coder will also probably find some useful tricks.
   (Useful modules, uncommon options or other pieces of code that increase your productivity...)
   
   In short this book is pure "Perl Packaged Experience", save you hours of trial&error frustration and buy this book, you won't regret it...



4. Like author Peter Scott's previous book (co-written with Ed Wright), Perl Debugged, Perl Medic is rather inaccurately titled. Both books are collections of advice and tips on best practices and idioms in Perl, like Effective Perl Programming and Perl Best Practices. You can think of Perl Medic as a sequel to Perl Debugged. You definitely don't need to have read the former, but if you have, you should have a good idea about the format and contents you can expect here.
   
   There is more advice on code style, low-level stuff like brace indentation and choosing decent variable names. Additionally, tracing, profiling, benchmarking and logging are again introduced. Some of this is admittedly rather reminiscent of what appeared in Perl Debugged. Happily, also present is the clear writing, which is informal without ever talking down to the reader.
   
   Perl Medic, however, has a more agile flavour than Perl Debugged. Again, there is a chapter on unit testing, but it's much more fleshed out in this book, featuring far more modules, and providing an entire Test Driven Development example of a bounds-checked array.
   
   Also, some refactorings are introduced, such as inlining temporary variables and extracting subroutines. The final chapter of the book is a refactoring example on some ancient Perl 4 cgi code, that pulls together most of the themes of the book.
   
   There's also an in-depth discussion of what the strict and warnings pragmas entail, beyond that provided by most books. Also worthy of note is the chapter on 'cargo cult' Perl, where the author's pet peeves about non-idiomatic Perl code are explored, from practices which are merely pointless to the downright wrong.
   
   Much of this material is general good practice. However, there are some chapters that help to justify the 'legacy code' approach. Chapter 7 provides a potted history of the different versions of Perl from Perl 4 onwards, and how to spot which version a program was targetted at. There is some mention of legacy code in the unit testing chapter, but not much.
   
   In general, I think a lot of the suggestions will be obvious to anyone with experience with Perl, or experience with another modern programming language: use new modules from CPAN where you can, use lexically scoped (my) variables and localise global access and, of course, turn on strict and warnings. Overall, I wasn't much convinced with the 'legacy code' aspect of the book and the strained medical metaphor renders many of the chapter names nonsensical.
   
   Another slight problem I had is that, like Perl Debugged, there can be a lack of flow between (and sometimes within) chapters. Chapter 10, nominally about maintainability, starts with assertions and Eiffel-style contract programming, and then goes onto logging, tieing, overloading, POD and version control integration. It's hard to see this as a cohesive whole.
   
   If you're looking for a book on dealing with legacy code, Michael Feathers' Working Effectively with Legacy Code provides more bang for your buck -- although it's not Perl-specific (in fact, I'm pretty sure there's no Perl code in it at all). However, if you're a budding agilist looking for Perl-based examples of refactoring and TDD, then this is a good choice. Less experienced Perl programmers should definitely consider this, especially alongside Perl Debugged, as it provides both a good grounding in best practices, and more advanced development skills such as profiling and code coverage.



5. When Perl Medic came out, we received a review copy. It was the first review book we got, and I was pretty excited. I took it to (of all places) the gym with me, and read it while I ran. A lot of Perl People were raving about how it was the awesomest book in a long time, and I just couldn't get that excited about it. Despite that, I find myself recommending it to more and more fellow programmers.Here are the things that I find especially useful in the book:
   
   Tests
   
   I am all for testing. I like testing. Testing helps me code better. Testing helps me figure out what badly documented features should do, and helps me notice that my patches are going to break in production. It's just the right thing to do. When reading, I thought the coverage of testing was a too long, but that was because I was already at home with it. Really, it's the right length for someone who's not already testing, and Peter Scott should be applauded for writing one of the first Perl books to really explain and encourage testing. Moreover, he stays true to the book's "for maintenance programmers" nature and talks about the troubles with writing tests for code you didn't write, including testing traditionally hard to test things like CGI scripts.
   
   perldelta
   
   The book walks through historical versions of perl from version 4 (!) to 5.8.3. The authors tells you what changed, and what you should probably do if you upgrade the platform your old Perl code is running on. (Moving to 5.6? Now you can use C. Moving to 5.8? Restricted hashes!)
   
   Cargo Cult Perl
   
   The author devotes almost a whole chapter to pointing out stupid things that people write because they don't really know what they're doing. open without checking the return, symbolic references, three part for, and (argh!) return undef.
   
   I hear Dominus is working on a book on this topic. Until then, this should help people write code that will be less of a pain to maintain.
   
   *other stuff*
   
   Perl Medic offers a concise explanation of scoping and variable types. It's no Coping with Scoping, but it's quite clear and covers C. While a lot of Perl Medic is really for experienced folks maintaining old code, this section is something every new Perl hacker should read.
   
   There's a nice section on figuring out WTF existing code /does/, suggesting modules to benchmark, profile, deobfuscate, and otherwise dissect the horrible code you're handed.
   
   In the appendices, there's a few pages on "How to Ask Questions that Get Answered." There exist many of these guides, but I don't care. If every technical book spent two or three pages on this, it would be a blessing. Somebody who knows how to ask a question is going to get help, and is going to quickly be received into the community where he asks it.
   
   *the down side*
   
   I guess the biggest down side for me was that I just didn't learn many new things from this book. A number of things were well stated, and I recognized that this book would be useful for many people, but for the most part I didn't have many "A-ha!" moments.
   
   There's a section on "how to use the CPAN," and I felt it was out of place. This might be, though, because I find the idea of Perl without CPAN (for non-tiny projects) to be insane. I guess there must be people who do have to deal with "anti-CPAN policies," though.
   
   This book is definitely a good buy for anybody who's going to be taking over someone else's code, especially code that's old or just lousy. (Even if it's good code, this book can help.) Whenever I leave my job, I will make sure they pick up a copy for the new guy.

No comments about Microsoft .NET for COBOL Programmers Third Edition.

2 comments about You Can Program in C++: A Programmer's Introduction.

1. Francis Glasborow is one of the most frequent problem solvers on comp.lang.c++.moderated. And he has done a wonderful job authoring the book.
   
   I can recommend this book to anybody who knows basic programming (in any language) and wants to learn C++. In addition to the coverage of C++ basics that you find in many other C++ primers, you will find invaluable caveats and tricks.
   
   There are a few typos in the example programs in the later chapters. In spite of those, I still rate the book 5 stars as I could learn more C++ from this book than most others. After going thru 388 pages of this book, I find myself capable of taking on advanced C++ books -- like Modern C++ Design.



2. This C++ text is considerably less verbose than most, as it makes some significant assumptions about the reader's prior programming knowledge.
   
   These knowledge assumptions are the book's primary weakness for beginners. Early on the book presents concepts that many readers, even those with prior, but non-C++, programming experience, will not have previously encountered. For example, the author presents the term side-effect without explanation. As early as page 31 basic exception handling is presented in a small program. Iterators are first mentioned without an adequate discussion of what iterators are. Other items from the STL are also presented with explanations so limited that most novice C++ reader's will find the presentations very difficult, if not impossible, to follow.
   
   The author spends too little time providing details for a reader completely new to C++ or object-oriented methods to properly understand many of the new concepts presented, and too little time presenting well-coded exemplars. In chapter 3, e.g., the author states, "I deliberately leave some of these problems in my code because I want you to check code rather than taking my word for it." For beginners, this approach seems fraught with problems. I would have preferred to see programs correctly coded in the presentation sections, with code demonstrating poor practices, explicitly identifying what those poor practices are and providing examples correcting those weaknesses. Otherwise, code with potential problems should be left to the exercises. What reader's need are appropriate examples of good coding practices that they can emulate, not poorly written code examples. Snippets of code can be an excellent approach to presenting key concepts, but fully coded examples should demonstrate appropriate coding practices.
   
   Concepts are "fleshed-out" in later chapters, but "newbies" may find this book does not provide the solid understanding of the basics that they seek.
   
   Additionally, the improved and updated software does not always respond in the same way the earlier software versions used by the author did. For example, in the author's first floating point program, he deliberately leaves off an #include statement and comments that the user will see the compiler complain about this. However, my version of the updated C++ compiler, which is a later release of the one used by the author in preparing the text, accepts this situation without a problem and successfully compiles and runs the program.
   
   Many, in my opinion, unnecessary sections of the book relate to the author's inclusion of a graphic software package he developed called Playpen. This package provides extremely limited capabilities, and simply takes too much time and effort to learn. The package has essentially no value beyond the course. The author would have been better served to provide basic explanations of how to use the built-in graphics capabilities of the major OS systems currently in use. Perhaps he could have selected one, e.g., Microsoft's OS, and as he did for the IDEs mentioned earlier provided additional information on other OSs, e.g., Apple's, presented on the CD. This would have been far more helpful to readers, and have had real value beyond the course. I hope this approach will be followed for latter editions of this work, thus allowing the Playpen package to be removed. This package's limited educational value takes time away from important topics that could otherwise have been covered.
   
   However, in spite of, or because of, the author's conclusion about his readers knowledge level, many readers with some, even limited, background in C++ will appreciate this book's "get to the point quickly" approach. The author is also excellent in presenting appropriate C++ idioms, and showing where idioms carried over from other programming languages, even C, are inappropriate for C++. The author also takes time to explain why they are inappropriate.
   
   In summary, although the book indicates that it is appropriate for those with knowledge of another programming language, I don't concur. However, for those with prior C++ experience or knowledge gained from prior self-study of C++ basics, this is quite a nice book. It gets the reader programming from the start, and provides lots of short, complete, and easily understood programs illustrating key C++ concepts. It provides clear and appropriate short programming exercises throughout. It successfully brings many important advanced features of C++'s together in an authoritative manner.
   
   Thus, although it is not recommended as a first C++ book, it is definitely recommended as a good choice for those with some prior C++ knowledge or experience.