5 comments about Reversing: Secrets of Reverse Engineering.

1. This book takes a tutorialistic approach to reverse engineering. It assumes you have a working knowledge of assembly language and C/C++. The author briefly introduces you to some of the programming languages in use, Windows Internals, gives an overview of some of the tools available, and then proceeds to walk you through some example reverse-engineering. The author spent alot of time covering Windows internals. The overview of Assembly language could have been a little more thorough before going into reverse-engineering, instead most of the appendix is devoted to this. More time introducing the debugging tools and the use of it's features instead of the brief overview would have been helpful too. Despite these shortcomings the book is very educational. If you are not up to speed on C/C++ and assembly would recommend reading Assembly Language Step-by-step: Programming with DOS and Linux (with CD-ROM) and The C Programming Language (2nd Edition) before reading this book.



2. This book is a dense collection of information about various aspects of reversing.
   
   There are a few factual errors, and so, while this book can be used for bed-time reading, I wouldn't count on it as a reference.
   
   Before people pounce on me for mentioning 'factual errors' and not substantiating them, let me draw their attention to the description of calling conventions in this book. This book mentions that cdecl and stdcall pass arguments in different orders (i.e left to right for cdecl and right to left for stdcall). This is just plain wrong. I wonder how this important detail could not be caught during editing, and technical review.



3. The book is put together very well and provides adequate explanations on the majority of everything it touches on, but if you've already been reversing for a while and want more in depth knowledge and/or advanced methods for reversing check elsewhere. For the audience it was written for, its great, if your a newbie to reversing it would be a good addition to your library.



4. This book includes a great deal of effective and practical techniques related to the subject. While reading this book it soon becomes very clear that the author is a highly experienced professional in the field. He does a wonderful job presenting the many relevant topics presented in the book. If developers want to discover vulnerabilities in their own applications, this book will give some excellent pointers. Security professionals will very likely draw some great benefits from it as well. This book is loaded with information which is generally easy to read, (more so if you are familiar with some high and low level programming languages), and remains right on topic. This book is definitely a "must read!"



5. I have only read about 1/3 of this book and I already know that it will be a great addition of "treasures" on my bookshelf. The author explains the material in a very clear way and also the way thing are presented to the user is very organized. Buy this book if you want to learn the techniques and how to approach the reversing problems. Do not worry too much about the technical inaccuracies mentioned by other reviewers. You can always write your own little experimental programs to verify those or if you are into reference manuals, you can always download those reference PDFs from Intel anyway. If someone like Russ Osterlund said it's a good read, you should listen.
   
   Understanding how the compiler convert the high level language into the machine code can help you become skillful in the technique of writing good and highly optimized code. It also allow you become a better debugging specialist even if you don't become a brilliant cracker.

5 comments about LEGO MINDSTORMS NXT-G Programming Guide (Technology in Action).

1. There's no other book out there that covers the NXT-G programming language. Jim Kelly covers the subject thoroughly, in a clear, friendly and encouraging style.
   
   The book not only covers NXT-G, it's also a primer on what programming is and how it works. With this book, teachers, students and beginners will have everything they need to understand how NXT-G works and how to use it. Advanced users will learn a thing or two as well, particularly with respect to some of the lesser known blocks within the NXT-G program.



2. When it comes to wanting to do Lego Mindstorm NXT-G, this is the first book you should get. The book shows the reader what different blocks are and how they work. The book also reads in terms that middle school students can understand and follow. Programming is the most difficult item that you have to do with a roboit. This book shows is a great resource for people that are in to lego roboits.



3. We bought this book for our nine year old son who had recently received the Mindstorms NXT for Christmas. He could not put the book down - read it from cover to cover and thinks it is a great book. Highly recommend.



4. This book covers a lot of ground on NXT-G programming and is a must have resource for anyone serious about programming in NXT-G as the on line help included with the NXT set is not adequate.
   As a professional programmer and a robotics hobbyist, I would recommend that anyone wanting to bring out the full potential of their NXT creations move to a text based language like Robot-C instead. While NXT-G is good for simple programs, it is just to difficult to create anything of any complexity as the graphical elements and all those connecting lines distract you from what you are trying to accomplish.
   I am giving this book 5 stars because it does well at what it is, a reference / guide to the NXT-G programming language. It is NXT-G itself that I would only give 2 stars.



5. I was hoping to learn more about NXT-G. I didn't. There is nothing in this book that is not in the online help files that come with the software. There are a number of errors. The X/Y coordinate system on page 188 in wrong, half of the time in the discussion of the logic block he calls it the compare block. It expected much more from this book. In the discussion of the logic block he shows how to evaluate 2 things. That is very simple and covered in the on-line notes. He doesn't explain how to compare 3 things or 4 things. This is actually tricky to figure out. I did but an example in the book would have saved me a lot of time. As you know my now, telling the bot to turn 90 degrees will not turn the bot 90 degrees. He notes that--in the appendix--but doesn't tell you how to get accurate results. That would have been useful. It would have been useful if the author had shown how add to the number in a variable block. This is useful if you want your bot to keep a running tally of something, like keeping score. There are many more examples I could site but this will do. I did, however, discover some very useful tips in The Lego Mindsotrms NXT Idea Book. That book too has its flaws but is worth the money unlike this book.

5 comments about Java In A Nutshell, 5th Edition.

1. The book is by far the most comprehensive, plain english manual for java that exists. Great book, but anyone who see's it laughs at the title. I think it must be an intentional joke. With 1225 pages and weighing in at a hefty 1.5kg (3.3lb) it's by no means a nutshell. It's more like a bombshell. If it were ever to be divided into 3 books, I would buy it again, just so that using it wouldn't be so cumbersome.



2. This is a great book for those Java programmers who want a rapid reference. The only drawback of this book is its weigth: the large part of the book is made of a Java reference (very similar to the official JavaDoc) that in my opinion is not so helpful, as if I need the documentation for a specific class I can browse the official documentation online.
   Anyway, the first part of the book is well written and gives many examples that can help both new and experienced programmers to understand the main features of Java 5.



3. I very much like this as a reference, but at this point I feel like most of the back 2/3 of the book is unnecessary bulk. The front portion, however, is excellent.



4. I used to like this Nutshell book, but it seems to have grown a little too big for its bridges. Maybe it's not O'Reily's fault. Maybe it has more to do with Java growing so much. But earlier versions were quick and to the point. This is now overly verbose.
   
   This is no longer a sleek Nutshell. Its a back-breaking bomb shelter with 10ft thick walls.



5. I am a programmer, and in a programming language book, I expect to find syntactical diagrams of the language. Anyone can read those, we should not have to glean the diagram from the wordy explanation. It's fine to have all the verbiage, but head each section with the syntax diagram.
   Also, this book goes into lengthy explanations of what object oriented programming is NOT, as on page 104. This is a very bad practice in teaching. Only teach what is correct, not what some novice might ignorantly think. I have gotten better fundamentals in Java free on the w3c site.

5 comments about Perl Cookbook, Second Edition.

1. Very useful, well worth it. Getting a book like this and having it save you the time of working out how the (yes, come on, admit it, a lot of perl syntax etc. is quite arcane) actual program should be set out, formatted or whatever, is fantastic. Several times this book has done that for me, so one of the best computer book purchases I have ever made.



2. yummy perl recipes; easy to prepare! very helpful for working with date and time data.



3. Most O'Reilly Perl titles imply you'll learn something useful. Only Learning Perl and the Perl Cookbook fully come through in that regard.
   
   The Perl Cookbook features some very practical solutions to some very practical problems (in Perl).
   
   I find myself coming back to this one again and again - more so than Learning Perl, Programming Perl, Programming the Perl DBI, or Perl Best Practices. This is The One. The book to use to learn the Right Way to perform quite a large number of useful functions or tasks in Perl.



4. Your first book on PERL should be "Learning PERL", now in its second edition. It takes you through the basics of PERL in a crystal clear fashion with lots of explanations, exercises, and examples. This should be your second book after you've learned to speak basic PERL. When you want to know the most efficient way to approach specific problems, no other book beats it. A concurrent purchase should be Programming PERL. That book is the definitive book on the language, but you could no more learn to program in PERL from that book than you could learn to speak English by using a dictionary as your textbook.
   
   Spread over five chapters, the first portion of this book addresses Perl's basic data types. Chapter 1 covers matters like accessing substrings, expanding function calls in strings, and parsing comma-separated data. It also covers Unicode strings. Chapter 2 tackles oddities of floating-point representation, placing commas in numbers, and pseudo-random numbers. Chapter 3 demonstrates conversions between numeric and string date formats and using timers. Chapter 4 covers everything relating to list and array manipulation, including finding unique elements in a list, efficiently sorting lists, and randomizing them. Chapter 5 concludes the section on basics with a demonstration of the most useful data type, the associative array. The chapter shows how to access a hash in insertion order, how to sort a hash by value, how to have multiple values per key, and how to have an immutable hash.
   
   Chapter 6, includes recipes for converting a shell wildcard into a pattern, matching letters or words, matching multiple lines, avoiding greediness, matching nested or recursive patterns, and matching strings that are close to but not exactly what you're looking for. Although this chapter is one of the longest in the book, it could easily have been longer still since every chapter contains uses of regular expressions. It's part of what makes Perl the language that it is.
   
   The next three chapters cover the filesystem. Chapter 7 shows recipes pertaining to opening files, locking them for concurrent access, modifying them in place, and storing filehandles in variables. Chapter 8 discusses storing filehandles in variables, managing temporary files, watching the end of a growing file, reading a particular line from a file, handling alternative character encodings like Unicode and Microsoft character sets, and random access binary I/O. Finally, in Chapter 9 there are techniques to copy, move, or delete a file, manipulate a file's timestamps, and recursively process all files in a directory.
   
   Chapter 10 through Chapter 13 focus on making your program flexible and powerful. Chapter 10 includes recipes on creating persistent local variables, passing parameters by reference, calling functions indirectly, crafting a switch statement, and handling exceptions. Chapter 11 is about data structures. Here basic manipulation of references to data and functions are demonstrated. Later recipes show how to create elaborate data structures and how to save and restore these structures from permanent storage. Chapter 12, concerns breaking up your program into separate files. The chapter discusses how to make variables and functions private to a module, customize warnings for modules, replace built-ins, trap errors loading missing modules, and use the h2ph and h2xs tools to interact with C and C++ code. Lastly, Chapter 13, covers the fundamentals of building your own object-based module to create user-defined types, complete with constructors, destructors, and inheritance. Other recipes show examples of circular data structures, operator overloading, and tied data types.
   
   The next two chapters are about interfaces: one to databases and the other to users. Chapter 14 includes techniques for manipulating DBM files and querying and updating databases with SQL and the DBI module. Chapter 15 covers topics such as clearing the screen, processing command-line switches, single-character input, moving the cursor using termcap and curses, thumbnailing images, and graphing data.
   
   The last portion of the book is devoted to interacting with other programs and services. Chapter 16 is about running other programs and collecting their output, handling zombie processes, named pipes, signal management, and sharing variables between running programs. Chapter 17 shows how to establish stream connections or use datagrams to create low-level networking applications for client-server programming. Chapter 18 is about higher-level protocols such as mail, FTP, Usenet news, XML-RPC, and SOAP. Chapter 19, contains recipes for processing web forms, trapping their errors, avoiding shell escapes for security, managing cookies, shopping cart techniques, and saving forms to files or pipes. Chapter 20, covers non-interactive uses of the Web, such as fetching web pages, automating form submissions in a script, extracting URLs from a web page, removing HTML tags, finding fresh or stale links, and parsing HTML. Chapter 21 introduces mod_perl, the Perl interpreter embedded in Apache. It covers fetching form parameters, issuing redirections, customizing Apache's logging, handling authentication, and advanced templating with Mason and the Template Toolkit. Finally, Chapter 22 is about ubiquitous data format XML and includes recipes such as validating XML, parsing XML into events and trees, and transforming XML into other formats.



5. If you are beginner to expert, this helps with simple methods that are tried and true. I find it most helpful in giving me ideas of how to address problems far beyond the scope of the book. Sometimes just simple reminders of cookbook methods stimulates thoughts in orthogonal directions that yield the best solutions to customer problems.

5 comments about Murach's SQL Server 2005 for Developers.

1. I am using "Murach's SQL Server 2005 for Developers" for a community college entry-level SQL class. It is a great book with nice prose and good examples.
   
   One drawback is that instead of identifying, say, Figure 8.3 above-or-below the image, the identification is listed at the bottom of the page with the image. That takes awhile to get used to and makes it harder than it needs to be to make sure I am looking at the correct code snippet.



2. I read Murach's SQL Server 2005 for Developers while looking for a book for teaching a class on SQL. Since the course is going to use SQL Server it seemed like an obvious fit. It is. This is a targeted book for the professional course on writing SQL for SQL Server 2005.
   
   I suppose it could be used for learning SQL for other databases but it does a pretty good job of hitting all the SQL Server specific variations in SQL that make up T-SQL. I also suppose that it could be used for self directed study. Like the rest of the Murach books, it has a side by side format with explanation and related examples. Since there's plenty of room for Lab work, it really fits the classroom well.
   
   Overall I'm happy with the book and don't have any real criticism. It is what it tries to be. A book for teaching SQL for SQL Server 2005.



3. If you're new to SQL Server, the format of this book could not be better or reading it cover to cover. It's designed (as Murach's other books) in a style to indroduce a small concept per page and give you an excercise to try it yourself. I recommend this book to all beginners to the technology but not necessarily if you have a lot of experience in the field already.



4. The only thing I can find wrong with it is that it didn't come with sql server cd. Other than that it's just fine.



5. I'm a junior web developer, and I've found this book to be very useful. The explanations are concise and very clear. Great book for beginning-to-intermediate SQL Server 2005 development.

4 comments about Mastering Dojo: JavaScript and Ajax Tools for Great Web Experiences (Pragmatic Programmers).

1. Often when you're learning a new toolkit, you see an implementation detail and wonder, "Why does it work this way?" This book answers a lot of those "why" questions as it shows you the "how" of Dojo.
   
   I liked the way the examples were accompanied by lots of context and analogy to other programming languages. The high level of detail was helpful, too -- the fact that the authors are key Dojo contributors shows in the writing.



2. One line conclusion: Recommended for serious developers using Dojo.
   
   Comparing this book with the other two Dojo books (one published by O'Reilly and one by Addison-Wesley Professional), I feel the title of this book is justified. The contents of the other two are greatly overlapped with the free online documentation of Dojo [...]. If all you wanted is a Dojo book that resembles a print copy of the free on line book, then you can buy the other two. If you are asking for something more, like how Dojo actually works and how to customize Dojo build (a pivotal step to speed up your product) then this is the one you need. You will not find such detailed documentation from either the Dojo documentation or the other two books.
   
   I take one star out because the contents of the book does not fully cover the functionality of Dojo, which is somewhat understandable as Dojo itself keeps evolving.



3. To fully utilize this book, I suggest you read the Book of Dojo first. Then, for some few topics you still don't get, you need to read the blog of the authors. Compared to Using the Dojo JavaScript Library, I think this is more advanced. Of the 3 currently available Dojo books, this is the only book that discussed the Grid, devoting entirely one chapter in Chapter 14. It is also the only book that has an example of handling XML (handleAs: "xml").



4. I haven't read the other Dojo books so I can't compare them. They may be very good too. This book is well orgainsed and well written. My advise to anyone starting from scratch is not to bother with the free online documentation, "The Book of Dojo", which is a spotty and unsystematic and start with this.

5 comments about ASP.NET AJAX in Action.

1. Like many people who develop ASP.NET applications for a living, I was extremely interested in learning about ASP.NET AJAX. This is the only book I bought on the subject, and it has been extraordinary. I can't recommend it highly enough. Read this book and you'll be an expert.



2. Ok for me its a must have book.
   Why because I want to know all about what the micrsoft javascipt injection is actually doing, how I debug applications with it, how I make it leaner (versa using CSSQuery,JQuery and MooTools), how I wire up events and become articulate with this tecnology. You can use the MS Ajax framework on its own in say PHP.
   So this book is really all about the client side of MS Ajax. If you are familiar with javascript libs like prototype.js you can absorbe this book easy. If you are a UI/Frontend developer then this is a must have.
   If you are a PHP developer then why not use it to pick up a robust framework.
   If you are a C# UI developer this will allow you to go beyond stuff that all the other can only drag and drop from the toolbar.
   Worth while looking at writing control extenders in 3.5 as this would be the place to put the results of your ajax efforts (write one - use many).



3. WARNING: Examples are in C#
   I purchased this book due to the abundance of positive reviews. Unfortunately, the author/publisher fails to include in their description that the examples are based in C#. I was looking for VB. (Note to ALL publishers of technical books: Be VERY SPECIFIC in your Product Description as to what language your examples are based in. If you don't, then you are just pushing paper for the purpose of making a sale....) While I have some experience in C#, converting the examples to VB became a nightmare! And, even when I did try running the examples in their native C#, several failed.
   
   During the first chapter the author provides some quick and dirty examples of Ajax as implemented by Microsoft. In doing so, he gives you the code in well explained fragments, but, leaves out some key points. Mainly, the fact that the JavaScript (your code) to be used with MS/Ajax MUST come AFTER the asp:ScriptManager declaration. Which means that you cannot include your .js code in the "header" section of a web page (as many experienced JavaScript programmers would do...). When MS compiles a page, it adds it's own .js code AFTER it encounters the asp:ScriptManager tag. Therefore, any .js code you add, MUST come AFTER the asp:ScriptManage tag. This is a CRUCIAL point the author left out. If the author had mentioned this, I wouldn't have wasted an hour trying to figure out why his example kept blowing up on me. There are a number of examples that required you to add or include something that wasn't mentioned. Generally trivial things, but annoying to troubleshoot none the less.
   
   While the depth and coverage of the material is very good, giving plenty of under-the-hood information about AJAX and Microsoft's implementation of such, this is almost nullified by the fact that the code examples are continually presented out of order. A (very annoying) example of this is in chapter 5 where the author attempts to explain how to make cross domain calls to the Yahoo mapping API. The author provides the code to create a webservice (GeocodeService) that includes a reference to a class (Location) that isn't provided until later, which has a reference to another class (YahooProvider) that isn't explained until after that...(lather, frustrate, repeat, or should it be rinse, repeat, lather?) Had the examples been presented from inside-out it would have been easier to code and follow in a step-by-step manner. Instead, you are constantly required to read ahead, then code from back to front. Annoying to say the least.
   
   Had the examples been better organized, and more explicit on including that button, the onclick event, the assembly reference, etc., it would have been a four or five star book. Instead, the frustration factor made the attempt to learn-by-example impractical.



4. I really enjoyed this book. Not only does it explain things thoroughly but the author also gives very intelligent, practical examples to help flesh out the theory. It's really good.



5. I wonder why people who did not buy the book but are allowed to review the book. This opens the door for many dishonest reviews.

5 comments about C++ Primer (4th Edition).

1. yeah, may be it's primer, but it's definitely not the book to start learning about programming on the whole and about C++ in particular, because as I can see authors sometimes make assumptions they shouldn't have made (all of them are in the first part of the book). And for such a misleading title I should've given it 4 stars , but I can't.
   Pick up "C++ Primer Plus" by Stephen Prata as first programming book, as one of reviewers has already mentioned. I should say, that if I read this book instead of Prata's, I'd tear it to shreds and curse the authors (kidding).
   Plus I think the reader should take some time programming or looking at other people's code before reading this book, because only in this case 'notes' and 'key concepts' put in this book can be appreciated (the beginner just wouldn't consider them important and therefore wouldn't remember).



2. A great improvement over previous editions - presents a very good balance of introductory and advanced topics. It served my purpose extremely well as a refresher to C++ after several years. Certainly, Stroustrup offers better coverage of more complex topics - however, as a general purpose textbook, this is good. Indispensable to me, more so than the second edition that I was still using. If you are a beginner or an exprerienced C++ programmer looking for a refresher, this is a good book. If you rate yourself as an advanced C++ programmer, you can save it for that day when you start to forget things!



3. First, I own the 2nd, 3rd and 4th editions of this book. I originally learned C++ from the 2nd edition in the early 90's (it's out of date). Later I bought the 3rd edition when the C++ standards were updated. Now, after a few years away from C++, I find that I have to catch up with the latest and greatest C++ idioms, methods, convential wisdoms, whatever.
   
   I started reading the 3rd edition and after 300 pages it became very obvious the 3rd edition was very encyclopaedic in its coverage and with its examples. The 3rd edition is an excellent reference, but for learning you need a month or more to read through the 1100+ pages. I don't have that much time. I needed something more concise -- so I bought the 4th edition.
   
   The 4th edition is still 800 pages in length, but the information density per page is less. The examples are cut back, but they are still good, and tables are used to summarize different choices or variants to C++ syntax or libraries. These changes make the book vastly superior for learning C++ (relearning?). The examples demonstrate how to use the language and the tables convey the required information precisely. What a fantastic difference.
   
   The 4th edition does have a different organization, that is, the order the language is introduced has changed. The emphasis is on introducing templates and generic programming much earlier than before. The section on OO design and programming is excellent, but the emphasis on templates changes its relative importance.
   
   This may sound strange, but use the 4th edition to learn and use the 3rd edition as a reference.



4. In the last year i had two computer science exams about C++ programming.
   I had never seriously studied programming before, so i was surprised with almost infinite potentialities of this language.
   
   However, modern C++ is a lot different from the one most books try to teach: i've got a lot of C++ books like Deitels' and Schlidt's, but all they offer is a overview of a "pre-standard-like" C++: a lot of chapters and exercises on arrays, pointers, C-like-strings, just like this was the core of the modern C++ language.
   
   This book focuses instead on the things a C++ programmer should know today, his swiss-army-knife: the STL and the standard library. The book introduces vectors and strings first, then compares them with old-fashioned arrays/pointers and char*s.
   This is not a book about introducing "new stuff" into the C programming language, but about learning C++ like a whole new language, thus changing the way you approach programming (a lot of other books introduces STL only in the last 2 o 3 chapters!).
   
   The only thing i disliked about the book, funny to say, is that while not too long (the fourth edition is about 800 pages long), the book is so full of contents that a newcomer may probably find it overwhelming.
   Not only it introduces classes and STL in the first chapters, but it also goes in a much deeper level of detail than other books, so if you haven't any programming (and, maybe a little C++) experience, you'll probably be going "back and forth" searching for concepts and explaination you didn't care too much about (like the notions about constructors given in the first chapter, wich would seem rather abstract if you don't know how a data structure is realized).
   
   Anyway, this is one of the best programming books i've ever read: if you are a computer science student, a programmer who wants to learn C++ or a C++ programmer who wants to really understand "what's behind the scenes", you have to buy this!
   If you are a novice in programming, this book could make you started with programming in the best way and introduce you to the best programming practices, but it can also scare you in the beginning, so you'd probably want to start elsewhere (probably with Accelerated C++, or C++ Primer Plus).



5. Although the pace may not be easy for someone completely new to programming, this an exellent book for learning the C++ language. It now introduces the C++ standard library early in the book, before getting into object-oriented programming and C++ class design and implementation. This makes it easier to start writing useful programms sooner. Organization, clarity and style are outstanding.

5 comments about Visual Studio 2008 All-In-One Desk Reference For Dummies (For Dummies (Computer/Tech)).

1. I haven't read the entire book yet, but my initial impressions are that it is an excellent beginning book for Visual Studio 2008. It also touches on some topics not immediately related to Visual Studio, such as modern programming practices, which I found valuable as a junior programmer.
   
   If you are a veteran Visual Studio user, this book is probably too basic for you.
   
   Most of the chapters are overviews, rather than in-depth coverage of any one topic. However, the content is very practical and concise, and contains a lot more useful information per chapter than some more poorly written books would.
   
   From what I can tell, this book is very similar to the previous edition for Visual Studio 2005, with much of the same text. This new version includes mostly the same chapters, with a few new chapters on new features - notably AJAX and LINQ. The new JavaScript debugging does not appear to be covered, which would have been nice.
   
   The new book is missing a few chapters that were in the 2005 edition - one on SQL Server Reporting Services and another one on Using Enterprise Library.
   
   The omission of Reporting Services is unfortunate, since that is a popular alternative to Crystal Reports. (The 2008 edition still has the Crystal Reports chapter that the 2005 book had.) However, if you are going to use Reporting Services you'll probably get a separate book for that anyway. And perhaps the RS chapter was left out of this 2008 book in anticipation of SQL Server 2008 (scheduled for release later in 2008).
   
   All in all, this is an excellent overview and introduction to Visual Studio 2008. If you have a little .NET programming experience and want to learn more about the basics of Visual Studio development, this book is for you.



2. This is exactly what you need to get started with Visual Studio 2008. Whether you are a novice programmer or an experienced developer this book has something for you. It is a very easy read and has a basic step by step approach throughout. For anyone interested in programming with Visual Studio 2008 or if you just want a good reference guide, I would highly recommend this book.



3. This book has been a great reference and learning aid. From start to finish it gives you a great insight of Visual Studio 2008 and the versatility of this program. There are many step by step examples of the many uses of Visual Studio 2008 as well as many tips and web site references. From building application programs (such as smart client and web applications) to accessing data(by using XML or SQL Server) this is a great reference for any programmer. I would strongly suggest that this book become a part of any programmers library.



4. This book is good for a first overview of what and how do to with VS 2008.
   The reader should have minimum programming skils, not a dummie at all.



5. Many people like the style of the "Dummies" books, but most will find this one tries to cover too much. It aspires to be the Swiss Army Knife of anything you could want to do with Visual Studio but that would take 5000 pages so it falls well short.
   
   VS 2008 for Dummies is arranged into 7 "mini books" (not 6 as the cover artwork here on Amazon shows). And while each book has some great information, it typically covers too little to do much real development. Overall, it's biased towards web development (asp.net) using databases but also includes desktop applications, smart phone apps, deployment, unit testing, extending Visual Studio, etc. Unfortunately, unless you just want an overview, most of the mini-book topics really needs its own book.
   
   There's a reason most beginning books on say just C# or Visual Basic are around 1000 pages. This book tries to cover both languages in only 163 pages.
   
   Trying to cover so much information with relatively few pages creates problems. For example, Book 5 is titled Coding. Likely to save space, C# and Visual Basic examples and descriptions are intermixed on nearly every page. So the C# programmer is confused by all the Visual Basic examples and text, and visa versa. It's far from ideal unless you really do want to learn two complex programming languages at once, which seems like a bad idea for a beginning programmer buying an intro "Dummy" book.
   
   So few pages per topic means a lot of important things are not covered at all. If you want to go much past useless "Hello World!" applications, a lot of what you'll likely need is just plain missing--i.e. basic file I/O using FileStream, ReadStream, etc. Many windows forms controls and other common .NET resources are also not covered.
   
   I can imagine a few sorts of people for who might want to buy this book. The first is someone who wants an overview of the capabilities of VS 2008 but doesn't need to actually develop anything. An example might be someone managing a group of developers using VS 2008.
   
   Another target audience might be experienced developers coming from a different or older development environment (such as Linux/Eclipse, VB 6.0, etc.) who only want to get up to speed on VS 2008. They would still likeley need to know (or buy another book on) the current .NET framework, however.
   
   If someone just wants to play around and develop a few "Hello World!" examples, this book will get them there. In the "Dummies" tradition, it holds your hand fairly well through the basics.
   
   If you're the sort of person who likes to read 2 or 3 different books on the same topic, this book may also prove useful. Visual Studio 2008 is a very complex product and this book presents some good information I've not seen elsewhere. And it presents information found in other books in new ways.
   
   If you want to do some serious application or web development you either already need to know what you're doing, or you'll almost certainly need another book that covers your particular development area in more detail. This book will not, for example, teach you object oriented programming, or the full syntax of Visual Basic, ASP.NET or C#. It also doesn't cover the .NET framework and libraries in sufficient detail to do much more than play around.
   
   In summary it's a useful overview, but unless that's all you need, you're probably better off with a book that targets the particular area of Visual Studio development you're most interested in. Many beginning books on C#, Visual Basic, ASP.NET, etc. do a good job of also covering Visual Studio 2008. So if you only want to buy one book, this might not be the best choice.

5 comments about Behind Closed Doors: Secrets of Great Management (Pragmatic Programmers).

1. First, let me say that I have read many books off the Pragmatic Bookshelf. Many of the best books I read during 2006 were published by these guys. With that said, this is by far the worst book I have read in recent memory. It is very simplistic and not very engaging at all. It's like a Fischer Price introduction to management. I did read most of it, but only because I was trapped on an airplane to Norway. Incidently, I left the book on the plane. It wasn't worth the shelf space in my library.



2. Having gone through a recent re-org that calls itself "new" 6 months after the fact, a 2-hour reading of this book was able to bullet point a good many ways the new management chain is screwing up. Nothing in this book is actually "secret" (it's all pragmatic) and very little happens "behind closed doors" (by the time you're there, something's gone wrong), but it's a good primer to read for a new manager or a good primer to pummel a pointy-haired boss with when they're doing nothing right. The fictionalized case study running through the book didn't appeal to me, but the drawn out points and sidebars were well (that is "concisely") written.



3. This is an excellent work that guided me though my first formal management experience. The book weaves its lessons into a story which helped you to understand how to apply what you learned. Like many important books, it explains some simple rules that can be difficult to execute in practice. The downside of reading this book is that you may realized that you're not being managed well (or have not been in the past) and you can no longer live in blissful ignorance. All technical managers at all levels should have read a copy of this book. The section on having one on ones by itself is worth the price.



4. I am very skeptical of most business improvement books and one size fits all methodologies, but I can tell you that this book absolutely shines as a glint of hope in the sea of business improvement noise. As opposed to trying to force a given technique that will apply to everyone in every business, this book provides some very "real" examples that exist in the software development world and some very simple concepts and techniques that can be used. This book is not written like an academic book of problems and solutions, but more of a story based book on a "real world" scenario, which truly solidifies the pragmatic name of the publisher. This pragmatic approach makes the book very easy to read, understand, and ultimately use. I think if you use at least one or two of the techniques presented in this book such as One-on-Ones and Big Visual Charts (BVCs) that the book will have more than paid for itself in terms of the time you will have spent reading it and of course the money!



5. Practical approach to management. This book shows the application of good management practices using real-world scenarios. It is easy to read and written in such a way that you can instantly start applying its concepts in your environment.