3 comments about Hacking RSS and Atom.

1. The book is very logically arranged into 3 parts. For using feeds, making feeds and mixing feeds. Most readers will probably deal with the first part and maybe the third part.
   
   Using feeds is explained as being able to aggregate data from websites offering these using RSS or Atom methods. From which, you can see how to recast the output into HTML pages for your website. Or maybe send it to your mailbox. Actually and more realistically, to the mailboxes of those who visit your website and ask for this feed.
   
   Orchard deliberately does not go much into the fine distinctions between the different and incompatible RSS standards. Or likewise with the various Atom formats. More technical books can discuss these points ad nauseum. But Orchard is aiming this text at a programmer who just wants to put together a news feed, and does not really care about lower level details.
   
   Making a news feed is the second part of the book. Only a fraction of readers will head here. It's not easy to produce original content, after all.
   
   The last part of the book is essentially an advanced continuation of the first part. You are shown how to embed higher level logic into processing the feeds. With an extensive example on using a Bayesian to try to identify news articles that might be of interest to your readership. Be aware that the Bayesian method is not perfect. Occasionally, you might get an incongruous article.
   
   Definitely, Orchard has produced a nice programming book. (In Python.)



2. Rather than just read RSS feeds, would you like to *do stuff* with RSS and Atom? I received a copy of a really good book that goes beyond the nuts and bolts of RSS formatting... Hacking RSS and Atom by Leslie M. Orchard.
   
   Contents:
   Part 1 - Consuming Feeds: Getting Ready to Hack; Building a Simple Feed Aggregator; Routing Feeds to Your Email Inbox; Adding Feeds to Your Buddy List; Taking Your Feeds with You; Subscribing to Multimedia Content Feeds
   Part 2 - Producing Feeds: Building a Simple Feed Producer; Taking the Edge Off Hosting Feeds; Scraping Web Sites to Produce Feeds; Monitoring Your Server with Feeds; Tracking Changes in Open Source Projects; Routing Your Email Inbox to Feeds; Web Services and Feeds
   Part 3 - Remixing Feeds: Normalizing and Converting Feeds; Filtering and Sifting Feeds; Blending Feeds; Republishing Feeds; Extending Feeds
   Part 4 - Implementing a Shared Feed Cache
   Index
   
   This book starts with the assumption that you either already understand all the details of RSS/Atom formatting, or that you're willing to learn the details on your own as you go. This is *not* a reference book on RSS standards. Rather, Orchard answers the question "what can you *do* with RSS that's cool and useful?". Using a series of projects, he starts to get you thinking about how you might use RSS technology in ways you haven't considered. For instance, having your log files report things via RSS feed could give you immediate notice of unusual situations. Or perhaps having RSS feeds go to your IM client would allow you to react quickly to news and information. The possibilities are endless, and Orchard does a good job in getting you to think.
   
   The caveat here is that he assumes a particular software language and platform for building these hacks. Python is the language used, so this book would be most helpful if you already knew the language (or were willing to figure it out on the fly). Likewise, he writes for the Unix platform primarily. You can use Unix emulators like Cygwin to run Unix-like command in Windows, or you can mentally adapt the concepts to whatever hack you want to build. At first I was thinking that single focus might be a liability for the book. But after thinking about it, I don't think it's that bad. It maintains the focus on the hack instead of on how every different platform needs to be coded, hence the book is more concise. Also, his goal is to get you to hack and experiment, not to teach you a technology via a tutorial. Since hacking is experimenting, you may end up hacking these ideas on a couple of different fronts...
   
   Excellent idea and application book... If you're interested in going beyond simple feed readers and building stuff for yourself, this is a definite purchase you want to check out...



3. Often times there's information somewhere on the web that you want to use in your own computing. Perhaps you want to look at news stories and display the headlines of what's happening today with a link to the site of the story. In the early days of the web, when you wanted to do something like that you had to do it manually or do some kind of hard coding to parse the information you wanted out of the HTML. Tedious, and if they ever change their web page you're re-doing your code.
   
   This is the problem that RSS/Atom are intended to fix. These are standards that, when followed, present the information from a site in a standardized manner that makes it easy to parse.
   
   First, what this book is NOT. This book does not tell you all the details about how to put RSS/Atom information up on a site. Instead, this book is on taking the information from an RSS/Atom 'page' and getting into a form you can use.
   
   The book is broken down into three parts: Consuming Feeds, Producing Feeds, Remixing Feeds. In each part the author programs a few simple applications to show you what can be done. The programming is in Python, the operating system he uses is Linux.
   
   The only complaint I could make about this book is that it would help the newbie to have another chapter at the beginning that talked about some common feeds and the nature of the tags they use to encapsulate their data.

No comments about Pro ASP.NET MVC Framework (Pro).

2 comments about Object-Oriented Programming via Fortran 90/95.

1. This is a great book for any Fortran programmer (new and old). The author does a fantastic job of introducing OOP for Fortran 90/95. I had no idea that all kinds of neat OO concepts could be implemented in Fortran. I almost want to go back and rewrite my big FEA code using these concepts.

   What I like most is that the author contrasts implementation details between Fortran, C++, and MATLAB to futher enrich the topics being discussed. Obviously, with this style, the author knows his audience (engineers and scientists).

   I HIGHLY RECOMMEND THIS BOOK!




2. This book requires that the reader already knows about object-oriented programming. It gives little information on the subject. Instead, it gives details about how to use Fortran to implement those concepts. The details it gives will already be familiar to Fortran users, though not for that purpose. I was hoping for a book for the many scientists and engineers who have learned and used Fortran well, but who have not learned about object-oriented methods. This book isn't it. The only audience for which it is useful is the opposite: an experienced object-oriented programmer who wishes to switch from another language to Fortran.

   The above occupies about a third of the book. Another third consists of elementary material that is not particularly relevant even to that audience, such as memory management, linked lists, and linear algebra. Object orientation is mentioned only peripherally in that material.

   The last third consists of appendices that are mostly padding. There are language tables that are available in the manual with any compiler, and source code which repeats with variations examples in the main text.

No comments about Programming with Alice and Java.

5 comments about Design Patterns CD: Elements of Reusable Object-Oriented Software (Professional Computing).

1. unlike the last pattern book i reviewed (see my other reviews), this one has an attractive cover. i like blue.



2. This book doesn't contain any Java hacks or UML 2.0 up to date notations, it contains the core concepts of software design patterns. The 23 GoF Patterns are described by their four inventors. A must have for software engineers.



3. Overall a good book. In my opinion it is better suited to be a textbook for a software engineering course than a 'self help' kind of book. Can be a bit too theoretical for my taste, but it is an interesting read.



4. This book is a classic and doesn't require any further presentations. It is THE Design Patterns bible and every OO programmer should read at least a couple of times.
   
   The samples are in C++ and sometimes Smalltalk but that really doesn't change anything even if you are a Java or C# guy.
   
   If you are looking for a quick way into patterns I'd recommend Head First: Design Patterns as your 1st reading, but buy both and get ready to start reading this one right after.



5. I give this book a 3 because it was great when it was written. But now, it is not a very good book to read. Most people who read it acknowledge they can't understand it. There are two excellent books on the market that should be read if you want to learn design patterns.
   
   Head First Design Patterns (Head First) - is the best book to read on what patterns are as solutions to a problem in a context. Fun to read, useful, really wonderful *****.
   
   However, if you want to learn what patterns really are - the thought process behind them, read Design Patterns Explained: A New Perspective on Object-Oriented Design (2nd Edition) (Software Patterns Series) *****
   
   A related book that would also be a good read is Scott Bain's Emergent Design: The Evolutionary Nature of Professional Software Development (Net Objectives Product Development Series) *****
   
   Let's give tribute to the acknowledged #1 classic in the modern software industry. But it is not the book to read to learn patterns anymore.

5 comments about C And The 8051.

1. It seems like on every other page of this book, half of the page is footnotes. Gives me a headache with my eyes jumping up and down the page. If the author can not seamlessly weave his ideas into one continuous narrative, or doesn't know when to leave out irrelevant information, how can you expect to be educated?



2. That is not the problem. The problem is that the autor is not precise. Many of the calculations are experimentaly made or don't match reality.
   I haven`t finished to read the book and I have found unconcluded text in at least two pages.
   On the other hand, the book is a good guide and give you some tips that are dificult to find in other place.



3. Product is great, and a good read. However, I ordered overnight shipping in mid morning and did not receive it until 2 days later.



4. One of the most confusing, unhelpful books on C programming for microcontrolers. The examples are ambigious and just plane impossible to decipher



5. This book is a good starting point for individuals that have C/C++ programming experience and have been exposed to some form of Assembler coding. It teaches by example more than theory. Many concepts presented in this book are fundamental to those who have written device-drivers or other real-time software. I was able to read the first 140 pages in approximately 3 hours. However, I am 22 year veteran of mixed-signal IC design and write about 20k lines of code a year to develop and test my products. I have never programmed with an 8051 before and I quickly came up to speed and program an 8051 using the Keil compiler. I use the book more as a reference manual for C constructs unique to the 8051. This book was a good tool for jump starting me on how to work with the 8051.

1 comments about SQL Server 2005 Reporting Services in Action: Revised edition of Microsoft Reporting Services in Action (In Action).

1. There are several reasons why this book only gets three stars.
   
   First, it's full of silly little mistakes. Some are trivial but some are very frustrating especially when they occur in the examples. For example page 127 has a screen print at the bottom and page 128 has exactly the same screen print at the top; different figure number and subtitle but exactly the same screen print. Trivial to be sure but indicitive of poor editing. A little later on page 130 the text states 'drag the Territory field ... and drop it onto the data fields section'. The author means the category fields section. If you follow the instructions exactly the example doesn't work. This kind of error is unacceptable in instructional material. That's two errors I found just a few pages apart. The rest of the book so far has been similar. I have to ask myself who checked this book?
   
   The second reason I only give this book three stars is that important features are glossed over. The author himself states that to properly explain charts would take an entire chapter so he points us to the documentation and spends less that five pages on them. I think he got lazy. So it would take an entire chapter? So take a whole chapter and do the job we paid you for! Don't fob us off into Microsoft's tender clutches. We read the documentation and found it wanting, that's why we bought this book! Again, the book feels rushed.
   
   The third reason is that the examples are not adequately explained. When introducing new concepts it is important to take the reader by the hand and walk them through step-by-step. Just because you've already explained how to do grouping for a table control doesn't mean you can just show us the dialog box for grouping list controls. What did you click on to get there? Similarly for charts, you can't just tell us to drop a field onto a region of the chart. Why are we doing it and what are the implications? What about the series field section? Just because you didn't use it in the example doesn't mean you don't have a responsibility to explain it to us. Again, the book seems to be rushed.
   
   Perhaps it isn't possible to cover SQL Server Reporting Services in one book. Quite frankly I'm sure it's impossible. So let's call this the 'Introduction...' and remove the later chapters on report management. Then you can expand the chapters on report authoring so that they are clear and unambiguous. Take the removed chapters and expand them into an 'Advanced...' book. While you're at it you can fix all the silly errors.
   
   I do need to say one good thing about this book. The examples are well crafted and explain the point at hand succinctly. They are also examples of what the average developer would want to do and not the contrived examples that so many books have.
   
   Final update:
   I give up. I'm dumping this book. Two examples in a row have had such major errors I refuse to spend my time figuring out the correct solutions. On page 175 there a report to demonstrate the use of the Previous function to report percentage changes by month. Problem is the author doesn't realize the iif function always evaluates both objects that could be returned which means you are guaranteed to get a #Error for the first row because there's an implicit divide by zero. The example does work as shown.
   
   But wait, it gets worse! The next example is a drill down. One of the reports that gets drilled down to uses a stored procedure (book doesn't mention this little fact). The stored procedure .sql file is in the code I downloaded from the site, but it creates a stored procedure with a different name and function. Yes, the actual stored procedure required by the example DOESN'T EXIST so you CAN'T RUN THE REPORT! I'm banging way too hard on my keyboard right now so I'll sign off here and go get some decaf.
   
   Do not buy this book, it is a complete waste of money.

2 comments about Web 2.0 Security - Defending AJAX, RIA, AND SOA.

1. Are you a security- professional or developer? If you are, this book is for you! Author Shreeraj Shah, has done an outstanding job of writing a great book that explores Web 2.0 hacking methods.
   
   Shah, begins by covering real life Web 2.0 applications that offer a better perspective on the overall infrastructure. Next, the author focuses on the overall Web 2.0 changes and their impact on security. Then, he discusses Web services footprinting and identifies access points for SOA as well as an understanding of application discovery and profiling to identify internal Web 2.0 resources. The author continues by discussing the XSS attack vector and its security implications for Web 2.0 applications. In addition, the author explores the security concerns growing around RSS, mashup, and widgets. He also provides an overview of SOA and the security concerns associated with it. Next, the author takes a look at ModSecurity for Apache and IhttpModule for the .NET framework, as well as some tricks with which you can identify Ajax-based requests and act upon them on the server side. Finally, he covers some interesting tools, techniques, references, and cheat sheets.
   
   This most excellent book addresses several critical aspects of Web 2.0 security/. What's most important though, is that this book addresses in detail both tactical attack vectors and defense strategies, while focussing on web 2.0.



2. Buy this book if you want to have decent information on tools to use for testing and defending your applications against various Web 2.0 security-related vulnerabilities. I deducted one star because I felt that some parts of the book were redundant and some concepts were not explained well, but overall I am quite happy with this book!

5 comments about Writing Compilers and Interpreters.

1. I bought and examined this book thoroughly. There are so many old concepts I wonder whether the author has ever re-read its current second edition. It is supposed to have been written for C++ programmers but of what generation? I understand that the current 2nd edition was written after the release of MS Visual C++ 4. So, the source code still assumes that C++ doesn't have the true and false Boolean constants since the author #defines them, which causes an error in both Visual C++ 6 and later. In fact, the use of #include and void main()indicate that the book is not ANSI compliant. The web site that supports the book provides source code, for MSVC 4 (only after I bought the book, which is extremely expensive, did I find out on the 4th page that it was released in 1996; but the current C++ Standard is from 1998). I tried compiling them in MSVC6 and MSVC.NET. None of the programs compiled (none at all). Even after re-creating the programs by adding files manually, I received many many errors. I tried to fix them and also tried compiling from the Command Prompt, to no avail. It is true that we don't have that many books on compiler development but just as these books are rare, this particular one will be to no help. It is (very) old and its programs don't work. The only things you might get are the authors comments that may help you with some suggestions or guidance, which will be little.



2. This is a down'n'dirty book on how to create a complete Pascal compiler. The book is heavily loaded with massive amounts of code, code which is at times very repetitive, since the author keeps improving on his classes time after time, writing the complete class code each time. If you can read C++ code as well as english, this is a great book to learn every detail about creating a compiler.
   
   The book also cover alot of interesting off-topics, such as programming technique and code management. It is quite obvious that Roald Mak is a very gifted programmer.
   
   I would not recommend this book to anyone who hasn't been doing regular C++ programming for at least 2-3 years. But then again, who else would care about creating their own compilers? ;)



3. This was really my 'practical compilerbook' winner (bought in 1999), until I discovered in 2004 "Programming Language Processors in Java: Compilers and Interpreters" by David Watt, which I like more.
   
   If you're looking for a theory book about compiler design I would recommend 'Engineering a compiler' by Cooper et al.
   
   This book offers a nice compiler (including x86 code generator and debugger!!), for a simple language.
   
   The problem is that the compiler is written in C++, and if you are more familiar with Java you could better buy the book I recommened above.
   
   An advantage of this book is that it also covers rare topics, such as debugger implementation.
   
   A disadvantage is that this book show a lot of code. Actually, all code is printed in the book (as far as I know). That's why it's a big bibble.
   
   The greatest disadvantage of this book is that it doesn't introduce new concepts. It offers a recursive descent parser (difficult to maintain), instead of much faster table driven parsers, or recursive descent parsers made by a generator (ANTLR).
   
   However, this is a great starter for C++ people new to compiler design. Java people would I recommend to buy the book of Watt as recommended above.



4. I am amazed at the positive reviews I have read about this book. Unfortunately, I took their advice and bought it.
   
   The book tries to follow the approach of teaching by example by developing compiler/interpreter components and utilities in C++. Unfortunately, the book reads more like a computer program printout, and rapidly becomes too boring to follow.
   
   There is very little theoretical background to the concepts behind creating compilers and interpreters. Attemping to learn from the C++ code will rapidly confirm that the code is of very poor quality, and seems to be a bodged conversion from C rather than a native C++ development.
   
   Avoid this book at all costs. It is especially dangerous for C++ novices as following the code will teach bad practices and lead you to believe that C++ is just C with classes. It is useless for experienced C++ programmers who wish to learn about compiler/interpreter programming techniques.



5. I read this book in my freshman year long back (2001) -- might have been a previous version. Book is awesome if you know *nothing* about compilers, interpreters, languages etc. I did not know Pascal, had just learnt C++ and (was forced to learn) FORTRAN, knew basic concepts of assembly language and how computers work etc. I enjoyed the book. I never wrote a line of code while I was reading it, but for the rest of my life through college, I have never been afraid about writing my own parser/interpreter/compiler. I had borrowed the book from the library, so for those of you who actually pay for this book, YMMV really.

5 comments about C++ from the Ground Up, Third Edition.

1. I learned C++ programming from the first edition of this book, and browsing through the 3rd edition it seems that the quality is just as high as that first edition from which I learned the language years ago. Schildt excels at teaching by keeping the concepts simple and straightforward. If you hope to learn object oriented programming from this book, by the way, you will not. This is strictly a book for learning the language. The only negative thing I can say about the book is that the last three chapters that have been added since the first edition on more advanced topics are rather thin and seem tacked on. Regardless of that, I would highly recommend this book to anyone thinking about learning C++. I notice that the table of contents is not shown by Amazon, so I show that here for the purpose of completeness:
   1: The Story of C++
   2: An Overview of C++
   3: The Basic Data Types
   4: Program Control Statements
   5: Arrays and Strings
   6: Pointers
   7: Functions, Part One: The Fundamentals
   8: Functions, Part Two: References, Overloading, and Default Arguments
   9: More Data Types and Operators
   10: Structures and Unions
   11: Introducing the Class
   12: A Closer Look at Classes
   13: Operator Overloading
   14: Inheritance
   15: Virtual Functions and Polymorphism
   16: Templates
   17: Exception Handling
   18: The C++ I/O System
   19: Run-Time Type ID and the Casting Operators
   20: Namespaces and Other Advanced Topics
   21: Introducing the Standard Template Library
   22: The C++ Preprocessor
   A: C-Based I/O
   B: Working with an Older C++ Compiler
   C: The .NET Managed Extensions to C++



2. The book was easy to read and the examples were clear. Came in a very timely manner



3. In my quest to find a really good teaching guide to learn C++ from scratch I was quite attracted to the title of this book. I checked out the author's credentials and thought this book would be an excellent way to get started. I wanted to "Learn C++ from the Master", as is written on the top right corner of the book for me to plainly see. I personally do not think that the title "C++ from the GROUND UP" is an appropriate one by any means. I found it hard to learn the basics of C++ programming using this book. I didn't find much in the way of detailed teachings to go along with the code examples. As an example, when writing my first program it would have been nice to know something about "headers" other than just the fact that they are necessary or useful for the program. Many more pages of explanations are needed for this book to be "beginner friendly". After all, this book boasts on page XVII that no previous programming experience is required. Now, I have had prior experience albeit many years ago, with C and Pascal. I found this book quite tedious to work through. I think many essential explanations / examples were lacking before advancing to, and running, various types of program code. After struggling through this book all the way to chapter four I got frustrated and invested in C++ Primer Plus, Fifth edition after checking several reviews. It would have been helpful to have more practice exercises with answers. The cost of this book is too high for what you get, ( I paid $59.95 CDN on the date of my purchase, although I see the price has diminished ). There is much, better value out there for your money if you investigate. On a positive note, I think the code examples do demonstrate excellent programming syntax and structure. I also believe that the book's description is correct about the fact that the author is a Master Windows Programmer, etc. I will use the examples of code shown in this book eventually. I would like to get some more use out of it. To sum it all up in a sentence: Had I known back then what I know now about this book, I would never have purchased it.



4. Programmers-in-training have this nasty, nasty tendency to purchase a slew of books only to leave half (or more!) of them virtually (if not literally!) untouched.
   
   I am such a culprit -- I bought quite a few C++ books, including this one, when I started out, but left it collecting dust on my bookshelf. However, when I'd been away from programming for a while and wanted to relearn C++, I decided to give this book a read. I'm glad that I did.
   
   The book is geared toward those with some conception of programming and how programming languages are used (I still remembered a bit o' C++, but nothing quite fancy), so I didn't find myself bored out of my mind when reading the initial 10 or so chapters on the C subset of C++ (which, I may add, are extremely well written and have practical examples -- like a bubblesort!) Then when I got to the chapters on OOP (of which I recalled almost nothing), I found myself in for a real treat. Everything was lucidly explained coupled with an ample number of full example programs to aid in understanding.
   
   I particularly liked the sample programs because they tended to be serious and were overall very, very useful and facilitated learning rather than obstruct it.
   
   If you're just coming off of a language like BASIC, Java, or C#, then I reccomend this book wholeheartedly -- you'll be programming C++ like there's no tomorrow within a reasonably short time. If you're a programming neophyte, you can probably go through the book and be fine -- but be prepared to work, experiment, and practice (although you'd do that anyway -- just moreso if you're a newbie).
   
   So, yeah, excellent book; definitely worth buying.



5. 
   Many of the reviews of this book mention the background of the reviewer.
   If you are considering learning C++ from this book, I suggest you consider
   carefully the reviews by those with a background close to yours. Pay
   less attention to those with a substantially different background. But.
   read this review because I will try to offer several different perspectives.
   
   I earned my living from 1960 to my recent retirement programming digital
   computers of many kinds, in many languages, and for many applications,
   including about 15 years using C. I used this text in a just finished C++
   course as part of my "mind rot delay program." I knew some things about
   C++, but had not used it.
   
   The instructor has taught the course for many years, and I believe has used
   the same text for several years. It seems to have passed the test of time
   for that environment. The second sentence of the preface states "No previous
   programming experience is required." The school requires either a two
   semester sequence of C programming, or a one semester C course for those
   with previous programming experience. The instructor said those without
   a solid background in C would be lost. I do not know anything about the
   other students in the class, but almost half were gone by the final night.
   
   One of the good things about this book is the large number of complete
   sample programs. These illustrate and demonstrate features of the language.
   You don't even have to type them in; you can get them from the publisher's
   web site. One of the bad things about this book is the large number of
   complete sample programs. Often the portion of interest is two or three
   lines out of a page or two. The book is much larger than it could be.
   
   There are a few questions in the text, but not many. There are no problem
   sets or review questions to test your understanding. At the end of a few
   chapters there is a suggestion to review certain topics. There are frequent
   suggestions to play with a program, make changes and understand what
   happens.
   
   Almost all the provided programs are complete in one file. Real C++
   applications are usually file intensive, even more so than applications
   written in C. Even toy homework problems from my class often involved
   five or seven files.
   
   The book is remarkably complete for a work aimed at novices. There are
   omissions, but most are minor. Some reviewers, and my instructor, said
   the coverage of member initialization lists is particularly weak.
   
   The Standard Template Library (STL) is one of the newer features of the
   language. It is covered in the longest chapter of the book, 46 pages.
   Other reviewers have complained that the coverage is scant. They are
   right. It is scant. The chapter is called "Introducing the Standard
   Template Library." The book explains a few of the container classes
   and a few of the operations you can do on them. The explanations are
   at a level similar to the rest of the book. It is enough to get you
   started. Similar operations on other container classes have similar
   names. There are several lists of function names with very brief
   descriptions. For an introduction, it is adequite.
   My instructor said it would take more than a semester to cover the
   entire STL. I think that would be a very dull class. Look through
   the STL from time to time; perhaps you will notice something that
   seems useful. Then learn the immediately useful parts.
   
   Here is a tip that I learned the hard way. The functions listed in
   the ALGORITHMS section of the STL are not member functions. You can
   tell if you study the sample program closely enough, but it is not
   clear from the main text.
   
   The preface promises you (the novice) will be an accomplished C++
   programmer when you finish the book. I disagree. You may know a lot
   about details of the language, but the book will not help you design
   a solution to a problem. Not recommended for a novice.
   
   If you have some experience programming in some language, the book
   could be useful. Read it while you rework the problems from your
   old text, using C++. Warning: I'm not a teacher; this is just my
   suspicion.
   
   The current edition is the Third Edition. Some of the reviews here seem to
   be of an earlier edition. The Third Edition was published in 2003. That is
   long ago for many computer books, but the C++ standard has not changed since
   1998, except for some corrections in 2003. Most of the changes for the next
   version of the standard are expected to apply only to the library.