5 comments about Illustrated C# 2008 (Windows.Net).

1. This is the C# book that I always keep next to me. If I am unsure about some type of class, delegates, interfaces, etc. I open up this book and get right up to speed. While concise, Dan leaves nothing out in terms of details required for effective C# programming.
   
   The LINQ coverage is outstanding! It is so good that I hope Dan does an entire book on the subject. His mastery of informative graphics would be an ideal format for help to save us T-SQL hacks from having to stand on our heads to get at LINQ.
   
   I highly recommend this book.



2. Dan Solis's Illustrated C# 2008 is a pleasure to read and from which to learn, both with concise information and the easy to understand illustrations in it.
   The illustrations make this book unique in that they make relatively foreign concepts easy to understand. They are consistent, build one on another, and make sense. He takes the concept of the stack and the heap, explaining how temporary data is stored, right from the beginning. With each new data type, or type member, an illustration shows how it is different from the others, and therefore why that user defined type was developed.
   I strongly recommend this book for anyone wanting to learn the basics of a computer language, and especially C#, which is becomming the standard, as well as the language used my Microsoft in their program development.
   
   What a delight!



3. This is a reference that constructs ones understanding of C# one feature at a time in a one step at a time methodical manner. The liberal use of diagrams helped me visualise concepts more easily. I liked this approach when the author discussed delegates and events. Many books try to explain it but I was satisfied that I understood completely only after reading this book. e.g. I did not know that a delegate is actually a cillection of callbacks (not just one) before this. I also liked the friendly, usable and pallatable introduction to LINQ. Please note that this is a C# book and does not discuss dot net libraries. So you will have to buy another book for that.
   
   It's good for someone new to C# (not necesarily new to programming) and also for more exerienced programmers who may keep coming back to it to really dissect language details - e.g how do I make best use of bit fields?



4. I wish I had known about this book when I first started learning C#. In just a few words it makes concepts clear that others cannot make clear in twenty pages. The clarity of the book is not only due to the generous use of diagrams, helpful though that is, but also to well-thought-out English and a user-friendly layout. The book is a sheer pleasure to read, and even if you already understand C# you may find it a great book for relaxation. Among other things, the author studied English literature at the college level before going into computer science, and that may be part of the reason for his outstanding ability to communicate. Anyone thinking of writing or editing a book on a technical topic should read this one for inspiration.



5. This book could have been better if it covered even the basic database connection and data manipulation using ado.net, as well as XML. I know these two topics can well be covered by a separate book on their own, but I found some books which do cover these things while they try to teach the basic of C# programming. For one, try Jeffery Suddeth's book, nevermind the poor production (table of contents, index) but focus on straight-forward explanations and working examples which are simple and easy to understand, and you'll see what I mean.
   
   The two stars missing are for:
   - no coverage of XML and ADO.net basics.
   - too much illustration even for the very basic syntax which tends to confuse...
   
   Overall, this is better than "Learning C#" by Jessie Liberty...

5 comments about Beginning Joomla!: From Novice to Professional (Beginning from Novice to Professional).

1. As a web graphic designer, I want to expand my skills into CMS systems. I thought this book would be a good start, but after reading it, I learned little more than how to install Joomla and basic interactions. The book is states it's for "Novice to Professional," but a more accurate description would be "a getting started guide".



2. This is a very poor training book for anybody that not a complete beginner to Joomla. Dan Rahmel is an experience computer book writer and this is one of his worse books. it goes into number of subjects that don't really have anything to do with Joomla. The controlling editor obviously had no control over Mr Rahmel need to explain every type of open source program that you can use with jooomla!



3. This book is a great way to get introduced to Joomla if, like me, you are only used to creating static content websites. With the help of this book I got a site up and running in a really short time and was mostly pleased with the results. If there is one flaw with this book it is that it covers too much and falls short on some of the finer points of content management. I searched forever through the book to find out how to achieve a couple of things that were relatively simple, but on teh whole this book is a great product and I highly recommend it.



4. Utter garbage. Incomplete explanations & poor communication skills. You're better off installing JOOMLA using online instructions & then playing with it until you understand. Solutions for any problem you run into can easily be found with a Google search! Again - don't waste your money...



5. After reading the reviews, I was somewhat skeptical. How ever with a need for more info I made the purchase. I am glad I did, regardless of your skill with joomla. You will find everything you need to get to grips with this powerful CMS! Some of the reviews say the book is for pros. My dealing with joomla is this. If you want a CMS with power and need the ability to use it, you will have to come to terms with learning. No book will do the heavy lifting for you! Those of you who did not find this book well detailed and informative. Ether you did not read it, or are just to lazy to work through the program. I gave it five stars only because that's as high as I could go!

3 comments about Accelerated SQL Server 2008 (Accelerated).

1. I've just finished reading the "Development in SQL Server" section of this book (i.e. 40% of the total book).
   
   I assumed the book related solely to SQL Server 2008. The book's introduction, forward, back cover content, and free downloadable chapter 1 led me to that belief.
   
   However, the book relates to both 2005 and 2008, and frustratingly it typically does not say what features belong to which database version.
   
   I wanted a book that showed me what was new in SQL Server 2008, I know what is in 2005, I have several books on it! I think the publishers etc have been very misleading with this book's title.
   
   That said, the content of the book is very good.
   
   The book is large (784 pages) and heavy. A book containing SQL Server 2008 only content would perhaps contain only 300 pages, and be more convenient to read and carry.
   
   The book's real title is "Accelerated SQL Server 2005 and 2008"



2. I needed to get up to speed fast with SQL 2008 as we are migrating our entire infrastructure to windows 2008 products, this book helped me do it. There are many changes in SQL 2008 from new data types, high availability improvements, admin scripting with powershell, my favorite is intellisence is finally in the query windows. This book explained the newly redone reporting services well. It is nothing like the Reporting services in 2005. Good explanations of the new policy management feature in SQL 2008, as well as the linq to SQL. As a first book out of the gate it is a good overview. It allowed me to get my SQL 2000 and 2005 servers up to 2008 with minimal headache. Now we can concentrate on exploiting the new features.



3. I saw this book come out, and had high expectations. The authors are all great guys who really know their stuff. What's more, Donald Farmer is _the_ guy for Data Mining, so I was hoping for a big section about the improvements in that area for SQL 2008.
   
   Looking through it though, it feels like a book that was written for SQL 2005 that just got updated a little for SQL 2008, and that wasn't what I was wanting. And to boot, there are things that are just plain missing. There's not a single page on Data Mining, and some of my favourite features just don't appear. For Xmpl, in the FOR XML section, there's no mention of FOR XML PATH at all - which has to be the best way of using FOR XML.
   
   However, I will still recommend this book. I will recommend this book to people who are moving from SQL 2000 and want to know what's new in both SQL 2005 and 2008, but there is a better reason again:
   
   It's really honest! It's written by Microsoft guys, and they give really frank opinions about things. There are times when they happily point out that one feature or another isn't really as useful as it sounds. It's the kind of thing that more books need.

5 comments about LINQ in Action.

1. The book covers a lot of topics that emcompass LINQ including LINQ basics, but also LINQ to SQL, LINQ to XML. I like that it starts out with a discussion of the problem and doesn't dive directly into the solution. In addition, I think it teaches the technology without resorting to starting with database applications as the example. Anyone who has heard me talk about LINQ knows that I can't stand that LINQ to SQL is the wrong way to teach it to new people...they didn't fall into that trap.
   
   In addition, I really like that there are lots of good examples and a great index. There was never an example I was looking for that the index didn't help me find. That's becoming rarer in books. I really liked their coverage of LINQ from both the consumer of LINQ and the provider of LINQ. Their discussion of the LINQ to Amazon provider provided quite a lot of good insight into how the inner workings of LINQ are put together.
   
   My only hesitation at completely loving this book is that all the examples are either in C# or VB. This lends the book to feel a bit schizophrenic. I would have preferred a more bloated book where all the example in print were in both languages. This is especially true of LINQ because the language integration of LINQ is very dissimilar between the languages.
   
   Overall, I would recommend the book to anyone trying to learn LINQ as a technology.



2. This was one of the best technical books I've ever read. It was easy to follow and understand. The examples were very clear and the section on the new features of VB and C# were wonderful and needed in order to understand the rest of the book.
   
   I was slightly disappointed that most of the examples in the book were printed in C# instead of VB. BUT, I downloaded all the example projects and utilities and those are excellent! ALL of the examples are available in C# and VB. They are correct and a great on-the-go blueprint for my routines.
   
   It was also very nice that they talk about (in easy-to-understand terms) the performance implications of different implementations.
   
   The cover is a bit dorky, but you shouldn't judge a book by its cover!
   
   A great buy for the novice LINQ programmer.



3. This book is a well-written tutorial that is generally easy to understand. The logic is straightforward and the language is much better than in most of the other books I have been studying on ASP.NET 3.5 and C#. My only complaint is that I would have liked to see more depth in some sections. To fill in some of the gaps I have found "C# 3.0 in a Nutshell," from O'Reilly Media, to be very helpful, but I wouldn't consider it a replacement for this book. There is an online forum that goes with "LINQ in Action," and two of the authors and some other contributors are very responsive to questions. There are also some files of source code that can be downloaded from the Internet.



4. Most of the reviewers have given high marks for this book. No issue with that, as long as the first six chapters of this book are concerned. It gives the best intrduction on subjects such as lambda expression and various Linq syntaxes. But the most important chapters should have been those dealing with Linq in N-tier architecture - chapters 7 and 8. But those were written in such a confusing manner that, at the end of those two chapters, you are left wondering why you spent money and time on this book. It is a pitty that almost all internet articles, including those on MSDN, deal with Linq as if it is an add-on to Microsoft Access programming and show pages and pages of "drag-and-drop and voila it works great!!" approach. I don't think anyone could write a successfull n-tier Linq code with that approach. Although this book goes little further than the drag-and-drop gimmic, it could have avoided so much fluff and concentrated just on what is needed for a real world n-tier programming using Linq. But unfortunately I don't know whether there is any better book treating Linq as a serious enterprise development tool.



5. I think the expression is "don't cry over spilled milk...", well when my son spilled milk on this book I almost cried. Why would you cry over a book you ask? There are many reasons. Not only does the book go into LINQ in depth (I know there is a C# in Depth book) but the authors cover all of the parts of the .NET framework that were created and needed for LINQ to function. In addition, all of the samples provided are both in C# and VB.NET. These samples are not your basic "Hello World" samples but useful reusable code snippets that get the point of the book section across.
   
   The book starts of with an introduction to LINQ and the different versions of LINQ to xxx, more than enough to wet your whistle. The authors then go into the prerequisites of the .NET framework required, generics, anonymous types and lambda expressions. This chapter was so good I read it twice. The third chapter discusses how LINQ is made up. After this, the authors go in depth in describing the different types of LINQ, including LINQ to SQL, LINQ to Objects and LINQ to Amazon with useful examples.
   
   This book will be a reference book on my book shelf. I expect to refer to this book constantly.

5 comments about CMMI(R): Guidelines for Process Integration and Product Improvement (2nd Edition) (SEI Series in Software Engineering).

1. Much like the King James Bible and the Anarchist's Cookbook this book is dangerous in the wrong hands. When used properly the Model is a highly effective tool for measuring organizational maturity and for developing an organizational maturity roadmap. In the wrong hands it can actually hurt an organization. Typically this harm is manifested either by process wonks who zealously accept the Model at face value rather than interpreting it for their organization or by senior management and sales reps who don't understand the model and see maturity levels only as a means for business winning. I think this is a great Model, just remember, if you are going to use it, make sure your organizational needs drive your interpretation of model and not the other way around. And for all that is good and Holy, please read the entire book (specifically the section on Process Components)!



2. i bought this product and it was exactly as mentioned in the product description before buying this product. the shipping was fast too and care was taken to ship the product carefully.
   
   all in all a good and a trustworthy deal.



3. I disagree with some of the other reviewers. Not only am I leading a project to set-up a CMMI Quality Program, but I am teaching a "newbee" to the quality world. The spec that SEI publishes is great and the notes included in this book are very informative to the new folks. I have the V1.1 and V1.2 texts and use them both on a regular basis when training and when working. Yeah to Mary Beth, Mike and Sandy!!!



4. Having read many reviews of the book, I was concerned as to whether it would meet my needs. It was just what I needed. Our organization is doing a gap analysis for an assessment in the near future. Although the book re-iterates the SEI web page texts, it also has very useful tips in the margins and throughout the book. I was able to quickly go through our gap analysis using the book as my guide (hey! maybe that's why "Guidelines" is in the title).



5. Had to buy this book for CS course at the university. Zero usefulness. All the info is available online.
   By the way, if you are not in the business of CMM or apraisals, curb your curiosity - it is nowhere near Computer Science or software engineering, it's about basic management. Tedious and annoying stuff.

5 comments about C# 3.0 Design Patterns.

1. I bought several copies of this book to teach my development team design patterns. I have a copy of and like the Head First design patterns book, but my guys wanted to learn some of the new C# 3.0 features and judging from the other reviews I thought this would be a decent book.
   
   Boy was I wrong. Do not trust the positive reviews. The examples and coresponding code samples are flat wrong. I don't mean code won't compile, I mean they don't teach the purpose of the design patterns or blatently defeat the pupose of them. I am only up to chapter 3 and I am having to create cheatsheets that show how the patter REALLY should work. If anyone is reading this and really wants to learn the design patterns, I would recommend the Head First or the original Gang of Four books. Beware, if you don't know design patterns and use this to learn you will be shooting yourself in the foot.



2. As with all books on patterns, I had high expectations from this book. I was really hoping that the author would have introduced new patterns utilizing new 3.0 language features that I have not yet thought of on my own, but was disappointed to see that the book is mostly another poorly written book on design patterns that happened to use C#.
   
   After realizing that the book was what it was, I was hoping that she would have done something a bit on the cutting-edge side of things by fusing new C# 3.0 language constructs and design patterns, but again, disappointed. The application of C# 3.0 features throughout the book seemed to be more of a showcase ("hey look what I can do") as opposed to practical or necessary.
   
   If you understand that this book is just another patterns book and doesn't introduce new patterns or really take advantage of new C# 3.0 language features, this book is ok. On a positive note, the book is a simple read. But if you're looking for a really solid book on patterns for the bookshelf, the gang of four patterns book (1994) is still the way to go.



3. This book was poor. The source code has errors. It does a poor job at explaining the issue a pattern is attempting to address. Made me very sleepy. If you want a good primer get "Heads Up Design Patterns", if you want more get the GOF book.



4. Lets face it design patterns are something that we have to have but at the same token are usually difficult to understand where it should be used and how to create it. With design patterns C# 3.0 By Judith Bishop we have a little more help.
   
   From structural patterns to Behavorial we can all feel a bit better in designing our tiers for robustness and making things just a slight more easier on ourselves. When i had to create a protected class for an application that i was working on. I had difficulty creating protecting it from instantiation with the guidance in this book i was able to complete the application in less time and focus on other areas of code that needed improvements. I also found use for the decorator pattern, while i will admit some patterns in the book seem like a lot of work to include in an application Bishop makes the case for each one and also describes situations where patterns may be become anti pattern for example using the Singleton pattern to hold static information as a global variable.
   
   Overall, the quality of this book is top notch (figures since it is a O'reily book) and offers many sections on how to enhance your coding practices to make best of your limited time and also of your program. The examples in the book are superb and offer a introduction to what i feel is one of the more complex ways of designing a program. It also has a fair bit of UML diagrams and is "decent" practical guide to also adhering to UML based designs.
   
   Something though i wish they had in this book were more samples, at times there seems to be decent coverage on some of the easier patterns (singleton) and not so much on the more convoluted patterns like Model View Controller. While she does try to create a balanced ground sometimes, i have to re-read the section because she gets to technical sometimes. I guess with time and over the years her thoughts should become more clear.
   
   - Mike



5. Overall, the book seemed pretty useful. Some of the patterns covered in the book are probably rarely used in the real world, but others are design patterns that we use as software developers pretty constantly without realizing it. Getting a formal definition of what those are, and all the different parts involved ... as well as when it is a good idea to use it or what other pattern might be a better fit really offers some value. It was a pretty short book, so I thought it was worth the investment of time to read it.

4 comments about Practical Prototype and script.aculo.us (Expert's Voice in Web Development).

1. Prototype and script.aculo.us are influential and widely adopted. It's not surprising that book publishers are rushing to cover them. What is surprising is that most of the titles currently available are of such poor quality. This is the good one.
   
   Practical Prototype and script.aculous is well-organized, easy-to-read, covers the feature set well and includes a wealth of non-fluffy background material that beginners and journeymen alike will appreciate. The book easily paid for itself in time savings. Use it with the API reference at prototypejs.org/api and you'll be all set.



2. Andrew does an excellent job introducing developers at all levels to the power of these great frameworks, providing an easy way for those new to JavaScript to get started as well as the important information required by the experienced. Add in a dash of Andrew's dry humor and direct experience building Prototype as a part of the core team and you've got a hell of a great resource for Web developers.



3. It's the best book in the field yet, though it would be best if it has come out earlier, the samples are easy to understand, and to incorporate in any other snippet. Great!



4. I would have liked a bit more on script.aculo.us, especially the Droppable, Draggable, and Sortable, but it's very good, easily understood.

5 comments about More Joel on Software: Further Thoughts on Diverse and Occasionally Related Matters That Will Prove of Interest to Software Developers, Designers, and ... Luck, Work with Them in Some Capacity (Pro).

1. If you're a fan of the website Joel On Software, you will enjoy having so many of his postings in a single volume. More Joel on Software: Further Thoughts on Diverse and Occasionally Related Matters That Will Prove of Interest to Software Developers, Designers, and ... Luck, Work with Them in Some Capacity by Joel Spolsky takes a number of his blog postings over the last six years and presents in a context that was unavailable as they unfold over time. This aspect of book over blog allows him to consolidate thoughts or explain the evolution of concepts that he's experienced as one of the A-list bloggers in the tech community.
   
   Contents:
   Part 1 - Managing People: My first BillG Review; Finding Great Developers; A Field Guide to Developers; Three Management Methods (Introduction); The Command and Control Management Method; The Econ 101 Management Method; The Identity Management Method
   Part 2 - Advice to Potential Programmers: The Perils of JavaSchools; Talk at Yale; Advice for Computer Science College Students
   Part 3 - The Impact of Design: Font Smoothing, Anti-Aliasing, and Subpixel Rendering; A Game of Inches; The Big Picture; Choices = Headaches; It's Not Just Usability; Building Communities with Software
   Part 4 - Managing Large Projects: Martian Headsets; Why Are the Microsoft Office File Formats So Complicated? (And Some Workarounds); Where There's Muck, There's Brass
   Part 5 - Programming Advice: Evidence-Based Scheduling; Strategy Letter VI; Can Your Programming Language Do This?; Making Wrong Code Look Wrong
   Part 6 - Starting a Software Business: Forward to Eric Sink on the Business of Software; Forward to Micro-ISV: From Vision to Reality; Hitting the High Notes
   Part 7 - Running a Software Business: Bionic Office; Up the Tata Without a Tutu; Simplicity; Rub a Dub Dub; Top Twelve Tips for Running a Beta Test; Seven Steps to Remarkable Customer Service
   Part 8 - Releasing Software: Picking a Ship Date; Camels and Rubber Duckies
   Part 9 - Revising Software: Five Whys; Set Your Priorities
   Index
   
   The thing that either resonates with or infuriates you about Spolsky is that he has very strong opinions that don't always mesh with the "common practice" of our industry. For instance, he has some extremely defined ideas about what all programmers should be able to do, and most of them are only possible as the result of a computer science degree. He only wants "great developers", and these developers are only going to come out of high-end college programs. While he might only hire those who fall into that classification, the reality is that the industry is far more populated with solid and competent developers who don't work on code for software products that are designed to be released as saleable products. He would consider a development job in a regular company a life of hell. On the other hand, some of us like it. :)
   
   But not all the topics are controversial. Some articles shed light on common industry problems, like "Martian Headsets" (backward compatibility) and "Why Are The Microsoft Office File Formats So Complicated?". It's easy to bash Microsoft for bloated and buggy software, but you start to understand a bit more after reading that last one. With popularity comes legacy, and with legacy comes compatibility and general nastiness. "Martian Headsets" also explains the "no win" situation Microsoft is in when it comes to IE8 and "standards". They're raked for not supporting strict standards, yet most existing sites would fail to render under a browser that adhered to strict standards. So do you bow to reality and accommodate quirks, or do you stick to ideals and break sites? It's not an easy argument...
   
   More Joel on Software is a book that will challenge you on a few things that you thought you probably already knew. You won't agree with him on everything, but it's always good to be forced to think...



2. Since I've been reading joelonsoftware for the past two years, a lot of this was already familiar to me, but it was well worth rereading. Some of the essays were old enough and I hadn't come by links to them so they were new to me, but not many. Most of the first part Managing People was already published in Joel's Smart and Gets Things Done.
   
   Anyone even considering working on shrink-wrap software, especially in a small company, should read this book. (Anyone considering consultingware should especially read the last chapter; it will convince you not to, unless you are a masochist.)



3. This is cut and paste from the Joel on Software Blog.
   I just finished reading "Smart and Gets Things Done" by the same author and about a quarter of that book is in here.
   What a waste of money! If you think this guy has good ideas, save your money and read the blog instead.
   I felt ripped off buying this book after just reading "Smart and Gets Thinks Done" as it's a cut and paste from that book into this one.



4. I have been subscribing to his email list for quite a while, and he always entertains you *and* makes you think.
   
   This book is composed of his collected writings from his website. I'm posting this review mostly to counteract the "1" rating given by the person who didn't realize that, even though it says so in the description of the book......



5. 
   "More Joel on Software" is exactly what it says. It's a follow-up on "Joel on Software", a collection of blog posts from Joel Spolskys well-known blog "Joel on Software". I thoroughly enjoyed the first collection of Joels posts and thus was looking forward to this. And... I was disappointed. It IS good, Joel is an excellent and funny author and his posts are interesting, but... it was not as good as the first collection of posts :) Is he running out of ideas? We'll see in "Even More Joel on Software" which ought to be ready in four years...
   
   Slight disappointment, but still enjoyed Joels latest collection of posts. Let me point out a few of his posts to give an idea what he covers.
   
   The first post "My First BillG review" was a great story in which Joel tells his experience with Bill Gates reviewing his spec for MS Excel (many years ago) and how Bill reacted to the spec and what impression it led to him. It's a nice post and gives an insight to the working of MS during that time.
   
   "The Perils of JavaSchools" criticized the universities that uses Java as main languages for teaching computer science. Joel argues that developers do not learn "the hard parts" about programming when using a language like Java.
   
   In "Why are the MS Office File Formats So Complicated" Joel takes a look at the insanely large file format spec for Office files and explains why they became the way they are. Then he gives some advise on what to do when you want to read Office files (not write it yourself)
   
   In "Hitting the High Notes", Joel explores the productivity difference between developers from many different perspectives and argues that great developers are absolutely essential for great products. This was his main idea behind setting up his own business. He looks at productivity and quality from different perspectives.
   
   All in all, More Joel contains 300 pages with Joel blog posts. It's worth reading and I enjoyed it a lot. Joel has an "interesting perspective" on certain topics. Worth reading, but if you haven't read "Joel on Software" then I'd recommend to read that first.

5 comments about More About Software Requirements: Thorny Issues and Practical Advice.

1. Karl Wiegers is the person I recommend all my employees to read. This book is even better than 'Software Requirements, 2nd Edition' by Karl. He gives practical advises together with theory and important references. This book could be used as a tutorial for requirements engineers. One of the best books in this subject area.



2. This book addresses specific topics related with software requirements and the section "10 cosmic truths about software requirements" alone is well worth the read. The definitive book on software requirements remains the "Software Requirements" by the same author.



3. This is an excellent book which discusses the practical aspects of requirements engineering. Is a good companion to the original Weigers book.



4. I found it easy to read and very quickly full of my own highlighted pages and sticky notes for reference. This book will be in my must reread shelf at my desk. Since gathering requirements is a huge part of any quality product this book will help you get your hands around the task.



5. This book is easier to read than the book that it is the sequel to and has specific topics. They may or may not add value to your life, but does add value to the original book to get a little more insight into how real life works on software projects.

5 comments about Software Engineering: (Update) (8th Edition) (International Computer Science Series).

1. I bought this book as a required textbook for my grad course. I've learned a lot from my past misconception and misunderstanding between software science and software engineering just after reading a few chapters from the book.
   
   The book covers wide aspects of engineering a software, both technical aspects and non-technical aspects (social, laws, ethics) although not in deep-breath details.
   
   I highly recommend this book for any students who want to know about software engineering, pracicing software engineers who want to enhance their engineering ana managerial capability in developing a good software or for self-study for anybody who want to jump into software business.



2. This is a good high-level book for a first software engineering course. It mentions things like critical systems, object oriented programming, and real -time systems, but at a very high level; so it should not be used for a specialized course. It provides many helpful examples and diagrams. My only complaint is that the chapters are very long, and a lot of things are repeated several times. I think this book could easily be 75% shorter without loosing any important information.



3. This book is a good book to learn from, it can be a little boring at times but in general it is a good study tool that keeps subject matters seperate where they should be



4. it feels like this book goes out its way to stretch easily understandable concepts into a huge 900 page book.



5. I used this book as the text in my software engineering class in the spring semester of 2008. When I was evaluating it for potential adoption, I did not read through it in detail, I looked over the chapter titles and subtitles, read the first few chapters and examined the exercises at the end of the first few chapters. As the semester progressed, I found myself wishing I had read further into the text.
   As I moved through the chapters, I found myself mentally noting over and over again that topics are repeated. When the class was over, I asked the students their opinion of the book and they were unanimous, with no prompting from me, in saying that there is a great deal of repetition after the first chapters.
   I have no complaint about the quality of exposition or the coverage of software engineering in this book. My reason for not continuing to use it in future classes is solely due to my belief that the size could have been reduced from the current 840 pages to around 600 pages with no real loss of content of flow.