Computing Internet Books

Dummies books are written for the rest of us. On the DOS side of things. This book is a reference without spending a lot of money and without all the mumbo-jumbo. Just the stuff you need without the technical words. I have other Dummies computer books and ther great as well. Well worth the price.

I went to school for this sort of thing. I keep Dummies books handy for a quick reference. When I get a phone call 9 times out of 10 I'm reading a dummies book. With that said this and other Dummies books are great.

Not so long ago most people did not know how to use a computer. Dan Gookin's "DOS for Dummies" stepped us through the hills and vales of how to use one. For this alone the book deserves respect.

A very short while ago, a computer professional said to me, "For that I generally go to DOS and use 'XCOPY'." Anyone remember what that means? "DOS for Dummies" will tell you.

As usual, A book has been published by Wiley that seeks to add ease of use to a rather difficult subject. Dan Gookin has written many computer books for MS press and in other places.

This book is well-written and concise (silly comic sketches aside). It is a fair representation of what Wiley wants their books to be about. Except...

This book is not for MSDOS users, it is for folks who have tried their hand at using DOS box in Windows 95/98/XP and or Vista. I highly disagree with the subject matter of the book as to the absense of substantial coverage of MSDOS 6 and the dated coverage of the DOSbox programs. Don't expect to get support for either. Instead, I recommend using some of Gookin's earlier works actually written for MSDOS 5 and 6. Updated versions and documentation of DOS box is freely available on the web.

I really don't recommend this book to any reader who is serious about learning about DOS and DOS box. I gave it 1 star for its lack of substance and its value as a doorstop.

Do you have a friend that knows DOS, or an IT professional that is willing to teach you? Either way, do not buy this book, because if it may be useful to you he tells you to ask a friend or a professional. He is painfully not humorous or clever either, though he thinks he is.
You will learn more Google-ing DOS than you will from this book... which is not saying much. Look into Peter Norton's Complete Guide to DOS 6.22 if you want to know how to use DOS and or write batch files.

The concept in the "...for Dummies" series is to write in a friendly style and give the reader some substantial information along the way. What you get in this waste of paper is tons of useless unfunny attempts at humor with some passing references to DOS along the way.

Most of his book is just padding, and you get maybe one useful sentence per page. After reading it for awhile, I started to notice the phrase, "go talk to an expert to get this done..." popping up again and again. Well... I buy a how-to book in order to learn something new. I already know that I can pay to have an expert do just about anything for me. The writer telling me to just "go consult an expert" defeats the reason for buying a how-to book.

Save your money and buy something else.

I am a technical manager in the software industry. I am responsible for the SDLC, manage developers, and perform code reviews, while still occasionally contributing code - generally architecture and technical spikes. I mention this because I feel this gives me a good perspective on books like this, as I deal daily with the issues on 'both sides of the fence'. I bought this book sight unseen and without knowing who the author was because it was recommended to me as a 'timeless classic'.

To be honest, I couldn't read it in it's entirety and merely skimmed it. This is without a doubt the worst book I have ever seen on this subject. I read this with a stunned disbelief at what I was reading along with a growing sense of disdain for the author.

Okay, firstly the author has the most intense bias against engineers. In retrospect I realise it should have been obvious from the title (duh!).

Take these examples from the Chapter 3 - Feature List Bargaining:

"These feature lists allowed programmers to 'shift the blame' to management when the product failed to live up to expectations." [implies (a) blame belongs solely with the developers and (b) features lists are an evil plot of the developers. Apparently developers should read minds instead]

"There are far too many features to create in the time allotted, 'they claim', and many of them will have to be cut to meet the deadline." [implies developers are deceitful]

"The programmers 'draw a dividing line midway' through the list. Items above it will be implemented, they declare, while those below the "line of death" are postponed or eliminated." [implies unreasoned and arbitrary decision making by the developers]

"All of the analysis and careful thinking done by high-powered and high-priced executives' is made moot by the unilateral cherry picking of a programmer following his own muse or defending his turf." [Contrasts the 'careful thinking' of the managers with the 'unilateral cherry picking' of the developer. Sneakily implies 'high priced' = 'worth it']

Whilst reading this rubbish, I was trying to imagine what reality the author lived in. A google search told me that he was some sort of 'father of VB'. Oh. Well. That explains rather a lot. I suspect that the sort of developer that the author is railing against in this book is the sort of developer that the author was previously. My 15 years of experience in the software industry (C++,Delphi,Java) has been vastly different. I would not have hired a developer like the author was then, and I would certainly not engage his services as a consultant now.

The author seems to be completely mired in the past and completely out of touch with the last decade of the evolution of the industry. One good book on Agile or Lean development will impart the reader with the context to look at the perspective the author displays in this book as dangerously antiquated.

This book reads like some sort of 'class-warfare' political *screed* from the managerial class to the engineering (working) class.

Let me share my experience. The IT industry is full of scams and cons, primarily run by large consultancy firms. Software development is hard, and the majority of those responsible for the success of failure of IT projects do not have enough understanding of the projects to feel comfortable in taking responsibility for their success or failure. They will obviously accept the accolades of success, but in an all too human manner - look for scapegoats for failure. By turning to outside consultants pushing the latest new technology, they can always blame the consulting firm if things go wrong. The consulting firms are completely on board with this as (a) they are paid well and (b) they know that when the next new technology is ready the cycle will repeat. This is not a secret. I have sat in board meetings with these consultants who have used exactly this as a sales pitch to us.

Now I don't know if the author is a 'true believer' in the idea's presented in the book or whether it is a cynical attempt to reinforce the existing prejudices of certain entrenched executives in order to secure for him more consulting work. In any case, this is the worst book I have ever read, bad enough to write my first negative review on Amazon.

I'd normally recommend reading books like this to get an idea on what to avoid, but in this case I can't even recommend that, it's actually too repulsive. Avoid like the plague.

The Inmates Are Running The Asylum starts off pretty well. It begins with some very good examples of poor design that lead to a bad user experience, as well as just how downright dysfunctional the software development process can be. There is also the beginnings of a thesis on how to solve these problems. From there however, the quality of The Inmates takes a steep nosedive. The deeper into The Inmates you go, the lower the signal-to-noise ratio becomes. Cooper's message gets buried progressively deeper under a heap of sand-kicking diatribes about software engineers, armchair quarterbacking of the designs of others, and thinly veiled plugs for Cooper's particular brand of interaction design consulting.

There are some good ideas in The Inmates, though nothing truly groundbreaking at this point in time. Cooper champions things such as goal oriented design, personae, and primacy of user friendliness. All of which are good things, but none of which are exactly new concepts in 2008. However, the actual useful information comprises maybe 75 pages of the 250ish pages in the book, and is reduced to little more than nuggets of useful information scattered throughout a sea of whining and self aggrandizement.

Cooper's armchair quarterbacking of certain technologies as 'dancing bearware' is particularly annoying. Cooper continually brings up example after example of software and technology that is breaking new ground, acknowledges the fact that the technology even exists as an amazing achievement, and then turns around and lambasts it for not magically coming equipped with the precise amount of polish and feature sets that he wants. The 20/20 hindsight through which Cooper views many technologies belies the fact that Cooper is just as blinkered when it comes to the 'big picture' issues of software engineering as the managers and programmers that he continually needles.

Cooper tries to keep the tone light, and his unique brand of humor kept me reading even as the tone of the book slid gradually into that of a polemic against all things Alan Cooper doesn't like. This book can be downright dangerous if taken as holy writ. Cooper continually takes shots at programmers, and in fact spends an entire chapter reducing them to a set of stereotypes and providing an 'animal handling' guide for the backwards, egotistical, smelly bullies otherwise known as 'programmers'. Taking Cooper's stereotypes to heart is pretty much guaranteed to cause rifts between design and engineering teams, as Cooper goes to great length to explain exactly how far beneath contempt programmers are, how they are not to be trusted, etc. The Inmates espouses a philosophy of design in which non-designer stakeholders are to be marginalized or even totally cut out of the design process. The concepts of business or technical needs influencing design are constantly sidelined, as business and technical concerns are never legitimate, but rather the result of inept managers or lazy programmers. This book should be subtitled 'How to have your design, business, and engineering teams at each others' throats in 3 easy steps'.

Overall I think that the book has some useful information, but much like Cooper does with his case studies, the reader must cherry-pick it to obtain any useful information. Coopers ideas are good (if dated), but they could have been presented in a far more concise fasion, and could have done without the extra 175 pages of masturbatory ego stroking, ranting, and poorly disguised plugs for his consulting firm.

This a classic book that anyone who build computer systems should read. Some of the specific examples are dated, though many caused me to nod in acknowledgment, especially his observations about alarm clocks and TV remotes, Inmates describes goal directed design, the concept of Pesonas, ideas which, whether they make sense for your project are not, are ones that you should be aware of. This book also explains what "polite software" is and emphasizes the market advantages to good interaction design. Even if this book doesn't change the way you work, it will help you think about the relationship between interaction design and programming. Among the interesting points Cooper makes are Customer Driven isn't aways the best model (customer influenced is better), and neither is Engineering Driven; software designers should go beyond customers say they want and help them to understand what they need. There were a few things towards the end of the book that struck me as just wrong. For example Cooper says that most developers don't believe that they are the best people to test their code. Most Agile software developers would challenge that point. Agile developers would also challenge the recurring theme that the engineering team can't make the leap to understanding the customer enough to build good interaction design. He ignores the value of a specializing generalist, which is an important concept in today's projects. It's for these points that I gave this 4 rather than 5 stars. Regardless, this is a book that anyone building software systems should read, if only to understand the concepts underlying interaction design.

Alan Cooper gives the reader insight into why so many of today's technological products frustrate and confuse users. Yet he goes past this to discuss a methodology for keeping it simple and designing for the user i.e. avoiding cognitive friction. This book has changed the way I will develop products and should be a must read for product managers of application developers. Just learning Mr. Cooper's vocabulary is worth the read. The ideas such as personas, keywords, and designing for an individual push the book way above average. This is an easy read that should be done in your spare time if you want to avoid cognitive friction with your users. It has changed the way I view technology and brought a new awareness to thoughtless technology implementation which often cause failure or misuse. The only reason I gave this book a 4 out of 5 as I feel it could have been reduced a little bit more, certain points I felt like the author was rambling about personal fustrations.

Cooper's argument in this book is simple: you have to know your users, and you have to understand what they're trying to accomplish with your software. The method that he puts forth for achieving this understanding is personas, richly-described archetypical users.

The book is easy to read and understand. He begins with a detailed description of the problem with software design as carried about by programmers who can only imagine themselves as the users of their software, resulting in software that makes really difficult things possible but doesn't bother to make easy or common things quick and easy.

After making the argument that programmers shouldn't design interfaces and making the case both for usability and interaction design, he lays out the personas concept. Cooper's guidelines for creating personas and using them are well-written and well-thought-out. However, his examples of applying them to some of his own customers are rather repetitive, and sometimes come across as somewhat whiny.

Now that it's time for my group at Microsoft to revisit our personas and determine what needs to be tweaked for our next version, I decided that I should revisit the book that first advanced the idea. It has stood up well to the test of time (something that not many computer books can do). I highly recommend it, both to usability and design professionals, as well as programmers.

I can see that a lot of work went into this book and it does a pretty good job of explaining Business Objects at a high level. This is a good book for you if you are tentative about working with computers and don't expect to do intermediate or advanced work with Business Objects.

The notion that this book is a 'reference' or can replace a manual is completely off base. This book is a 'primer' not a reference. Any topic that is easily addressable through discussing the GUI is handled, but only for obvious cases. The function reference is incomplete and poorly documented. Insightful examples that make you think, "Oh, that's how you do X (where X is anything nontrivial)" are not found in this book. The kind of situations you will likely encounter if you want to create reports for a real business, are not handled. In these cases you are left to your own devices.

If you are new to Business Objects and need a good understanding of what Business objects does and can do then this is an excellent book. Where I work we have purchased several copies of this book. Doesn't go into tremendous detail on how to do some of the more complicated concepts of Business Objects but is more than enough to get you started.

I've been implementing and supporting BO since version 4.0.3, so I've read a few BO manuals over the years. It's difficult to encompass all the functionality of BO XI R2 into a single manual without turning it into a multi-volume text. This is a very good reference covering the major ground work of the new BO version. I recommend it as the starting point for all old and new users of BO, especially given the fact that they've totally rewired our favourite BI tool. And didn't it need it!

It is a great book to give you an overview of the product from a user's perspective. Recommended for universe designers. Although it doesn't go in detail on best practices. This coupled with reading the business objects documentation online (which is REALLY good) shoulg get you pretty far.

I bought the book hoping to get a sound overview of BusinessObjects - what it is, how it works, and how to use it. Instead, I found a combination of marketing gibberish and user documentation that has been recycled and updated so many times that it no longer makes any sense.

This book might be useful for folks who already know some version of BusinessObjects and are looking for a refresher. But if you're trying to learn what BusinessObjects is all about, this book is a very expensive waste of money.

Game programmers receive an in-depth, advanced guide to getting the most out of the Torque Game Engine, and comes from a long-time Torque programmer and trainer who knows his stuff. Discussions and descriptions of the components of the program teach how to make better games - and even how to modify the engine and source code itself. Computer libraries strong in gaming will know of Torque - and will value this important guide.

This book grate start torque game engine programming. I like it. If you want to learn deeply Torque Game Engine you should buy this book.

I would suggest this book anyone dealing with STL. It provides extensive best practice input for the experienced C++/STL developer.

What a great book! Helped me get past mental blocks on using the STL.

The man Meyers has worked his magic on the STL. If you've read Effective C++, then you know what to expect, and should invest accordingly. Meyers is on top of his game, finding the right balance of sage advice and dry wit as he guides you through the complexities of the STL. If you haven't read Effective C++, you really ought to before reading this one.

A wide range of advice is dispensed, including: advice on what containers to use, range member functions, avoiding loops, erase-remove, auto_ptr, associative containers, equality vs equivalence, gotchas like const keys in sets and maps and references to reference problems, efficiency in sorting, searching and inserting, iterators, functors and adapting them.

Phew. A lot of ground is covered. You will want to be familiar with the structure of the STL, I don't recommend learning the STL from scratch from this book, and you may want a good STL reference. But those aren't half as much fun to read as Scott Meyers.

I really enjoyed to read this book as it contains very good tips. The only detail that annoys me a little bit is the amount of cross references between the items. The author first 2 books were a little bit like that but it seems to me that this one is too much. I would have prefered to have items more self contained. If you want to refer to a particular item, this one will refer to 2 other items that will refer to some more items and so on to the point where if you would like to close the open loop, you would need to consult all the items.

Except for this small annoyance, this book is very good. You should read it or have it.

I tought I knew STL but Dr. Meyers showed me how little I knew. His in-depth analysis and numerous examples gives new insight into STL and how to best implement solutions using it. This is a must-have for every C++ programmer/software engineer.

This is a very good treatment of Vista, and in the paperback version I have found it helpful. The Kindle version, however, does not handle the illustrations well. I could not read the diagrams. Perhaps in an update of Kindle it will be possible to magnify and move the figures, but at present it is hopeless.

This product was in excellant condition upon arrival and arrived before expected.
I have used Que Books by the same authors previously. I find these are excellent reference books.

Now I have not read the book all the way through. I only use it as a reference when I can't figure something out on my own.

It has had the answer every time I needed it, so I am very impressed so far. Also bought the book on the new version of Office by the same authors and have the same thing to say about it.

Good Stuff

A very comprehensive treatment which lives up to its title of the only vista book you need.A real bargain at the price.

I have read and put to work about half of this book and I'm impressed with its thorough coverage. However be aware that to fully benefit from this book you must have intermediate to advanced prior knowledge of the Windows OS. This new edition includes SP1, but I found several remnants of references to pre SP1 Vista features that were not corrected or edited. For example, the Search link was deleted from the Start Menu by SP1. Yet the book refers to this link as if it was still present. If these minor problems had been corrected I would have rated this book 5 stars.

The book states that it's goal is to provide a user (or admin) view of TCP/IP in Win2k8 Server and Vista. It doesn't do a good job. Routing and NAT are hardly covered.

Examples:
* Do you want to know what `netsh routing ip autodhcp` does? Or maybe what `show rtmdestinations` does? You won't find out in this book.
* The discussion on SWS (silly window sindrome) is pretty confusing. Wikipedia does a better job at explaining it.

This work by Larman shares some commonalities with Balancing Agility and Discipline, a work by Boehm and Turner (see my review for that book) in which a wide range of methodologies are compared side-by-side to determine the best fit for teams. However, rather than serving as a guide to determine best fit from a wide assortment of methodologies, Larman's work is limited to a discussion of Scrum, XP, Unified Process (i.e. RUP/UP), and Evo, within the broader context of what the author categories as iterative and incremental development (IID). In my opinion, this book is probably the best organized text on this subject currently available in the marketplace. Although the subtitle for this work categorizes itself as a manager's guide, the content Larman has included here will prove beneficial for anyone involved in software development. And this is the case even if one does not read the four methodology-specific chapters. After a thorough explanation of iterative and evolutionary development, the author discusses its relationship to agile development and the motivation behind adopting such methodologies. The subsequent chapter on the evidence behind the effectiveness of IID is the most concise listing of research findings I have come across. While this chapter begins with a warning that "exhaustive data can make for exhaustive reading" and that it is "probably best spot-read as a reference", at only about 30 pages in length it is well recommended. While many in technology recognize the benefits of IID and have used the ideas brought to the table by various IID methodologies to some extent, the author reminds the reader that not only do many technology shops simply remain paralyzed by waterfall methods that view software as a predictive process, but that IID has been around for decades. David L. Parnas, a software engineering pioneer who developed the concept of module design, is quoted by Larman as follows. "Q: What are the most exciting, promising software engineering ideas or techniques on the horizon? A: I don't think that the most promising ideas are on the horizon. They are already here and have been for years, but are not being used properly." I found the following sections within the specific methodology discussions to be especially beneficial: common mistakes and misunderstandings (or how to fail with a particular methodology), signs that one has not understood a particular methodology, sample projects, process mixtures, and adoption strategies. In addition, the reader might be interested in knowing that the last chapter consists solely of questions and answers summarizing many of the main discussions presented elsewhere in the preceding eleven chapters, serving as a quick reference by pointing to specific portions of the text where ideas are elaborated upon.

Unlike many of the books out there, this book covers iterative development techniques in general. The book is well organized and structured and gives a good framework for thinking about different ways to manage a project and develop software. Agile, Scrum, Extreme Programming, Unified Process and Evo are all covered and compared which is invaluable in deciding which one to use or, more likely, which elements can be used for your projects.
Finally, some practice tips and a FAQ are provided to help you succeed in applying these methods to your project as well as answering the questions your team may come up with.
I found this book easy to read and understand and now feel well equipped to apply these techniques.

This book tries to provide an overview of several different "non-Waterfall" techniques for managing and organizing projects. The authors are pretty scrupulous about not really advocating one method over another, and as such, I did not find it particularly helpful for my own situation with my software team. Reading about Evo, XP, Scrum, RUP etc. all in one place with key characteristics and comparing their "levels of ceremony" might be interesting to project management/methodology researchers, but there aren't very many professionals out there who are sold on iterative development but are wondering which one they should use.

The book also is fairly technical, with lots of grids and charts trying to explain which levels of critical projects should be considered for a methodology, how levels of effort of different tasks change over time, who the stakeholders are and what to label them, and so forth. I got practically zero out of this.

On the positive side, now that I've read it I am armed to discuss the different methodologies much more, in case a new person arrives advocating a methodology I disagree with or something. I can use this overview knowledge to also pick and choose some terms or approaches which might be helpful in my situation at work. The part of the book which was most interesting was a chapter in which a typical Scrum project was described in narrative form. I think more of that, such as perhaps a narrative illustrating each methodology, would have been more helpful to those trying to decide which methodology to follow in future work.

For the audience of PMs who don't want to know the ins and outs of every IID methodology since the 70's, though, and just want to know how to run their projects better, I don't think this book will fill their need. Or if it does, it will be from the readers picking and choosing little bits across the book--something the authors recommend against.

What caught my eye on seeing this on the bookshelf were the color of typography, the small notes near the edges of the page that summarized a paragraph, the good graphics and diagrams. It looked like a quality book. After seeing how long was the discussion on "proving" that waterfall methodology was too long, "heavy", slow, and projects that used it more prone to less-than-satisfying end results, I understood why this book is titled for managers. In fact, one of the sentences it mentions that the step-follow-step process of the waterfall was popularized in the 70's and 80's, age during which today's managers got their education. On the CMM of SEI, a brief mention on it was that it resembles the heavyness of waterfall. Wished I had a bit more on it, but did learn from it anyway. The very last paragraph of the book had information I wanted: it was about Fitnesse, but it was just too little.

The book is very informative and presents both previous (EVO, XP) and current (UP, Scrum) methodologies. I am a project manager and this book helped me understand enough of Agile methodologies to apply it in my work environment. Good detail about each method and how it provides benefit. Before attempting to deploy Scrum or RUP/UP, read this book to understand the larger context and get other ideas for things to incorporate into your framework.