Software Development Books

Many years ago I needed to learn ASP/ADO. I saw a lot of learning in front of me. But I was thrilled to find this book. It gave me the simple, clear explanations I needed to get rolling with ADO in short order. It's still one I keep handy, even thought I now use this technology to make my living. I have several big/thick ADO books, but this one is a quick reference that I still turn to often, as well as highly recommend to ADO (database connectivity) newbies for both web and Microsoft Office linking.

An excellent reference for the novise to advanced programmer. If you need a good overview of how to connect to a SQL Server or Access DB using VB, then you have got to get this book!

This was a very good book but it was not perfect. The code contained some coding errors, but what was worst was that I could not establish an internet connection to Rob's SQL server. Due to the connection problem I could not run those examples, which comprised about a third of the book. I e-mailed Rob, but Rob apparently is too good for his readers to reply back to. I would have given the book 5 stars if it weren't for these problems. The book certainly was not for beginners as it rightly claims. I actually had to read it twice. Any coding errors I was able to solve with some work. The book does offer a lot to learn though.

I bought this book looking for an introduction to ADO and DB programming in general with no prior ADO experience. I read the first 4 chapters for an introduction, and I have used the rest of the book for information on how to complete specific tasks. I have successfully created ADO applications using VB, Access, and ASP, using this book and online help as references. This is probably not the most complete book available for ADO programming, but if you have not used ADO in the past, you will not find a better introduction than this book!

This book is genuinely about ADO Programming without self promotion. Rob starts his book with the basic elements that lead up to ADO technology and steps up to very sophisticated programming procedures/techniques using ADO with Sql Server, MS Access 2000, Excel 2000, ASP and the Web in a very efficient and easy to understand manner. Of the features which set this book apart from others are the numerous runtime examples on Rob's website of procedures using ADO within VB/ASP scripts, and also the companion cd which includes all the of the programming code for each of the ADO examples on the website and all of the examples in the book. The information contained in this book has significantly enhanced my understanding of and coding abilities with ADO in a very short period of time, particularly in the web environment. I would highly recommend this book to any serious developer of data processing applications using ADO technology; especially for web applications.

I finally come across a very good ADO.NET textbook. The author has done an excellent job explaning everything that ADO.NET 3.5 has to offer. I really like the textbook structure. The problem/solution approch is awesome. that book is fully loaded with code sample, in which you face with a problem, and the next thing you know is your problem is solved. I highly recommend this book for any developers who need to deepen their knowledge of this great Data Access technology from Microsoft(ADO.NET). Thank you Sir.

[Also posted on my blog: http://msmvps.com/blogs/luisabreu/archive/2008/06/11/book-review-ado-net-3-5-cookbook.aspx]
After several days, I've finally finished reading this book. This is really a very complete book wit lots and lots (and lots!) of examples. It's fair to say that it covers most (if not all) ADO.NET related scenarios (I'm an SQL Server user but if you're into Oracle then it also has several examples that show how to use ADO.NET and Oracle).

I do have one complaint though: chapter 8. Currently, I'll personally "hurt" anyone that is working on the same project as me and that uses ADO.NET objects on window forms or ASP.NET front ents! Ok, I'm not violent, so I wouldn't really hurt anyone :) serioulsy, don't use ADO.NET objects on your UI.

Having said this, I still recommend it (specially if you're working with ADO.NET).

The 'ADO.NET 3.5 Cookbook' is a great resource for every .NET database developer out in the world. With 950+ pages of content you will not be reading thin, as this goodies book comes with 222 tidbits of information that will help you in your everyday work.

Subjects covered include:

- connecting to a variety of data sources
- working with disconnected data objects (datasets)
- querying data
- executing functions and stored procedures
- using LINQ
- searching and filtering data
- adding and updating data
- copying/transferring data
- database integrity
- binding data to web forms
- XML data
- optimizing .NET data access
- debugging stored procedures
- doing batch updates
- enumerating SQL servers
- SQL Server CLR integration

I feel that is an outstanding companion book for .NET database developers that are looking for a resource that specifically outlines tasks into a neat, organized manner. Instead of thumbing through a book to figure out a particular way to do something, these common tasks and questions are broken up for ease of use and efficiency. If you are a .NET DB developer you definitely owe it to yourself to add this great book to your collection of technical books immediately.

***** HIGHLY RECOMMENDED

I received a copy of this book from the publisher for a review by a "technical expert". I really liked how the book was laid out with a problem-solution-reasoning approach (known as a recipe). Each one was generally useful for those unaware of how to do things in ADO.NET. The examples were short and too the point. The topics were quite varied so just about everyone will find something in this book. In particular the recipes on getting schema information programmatically will really benefit a lot of people because it is neither common nor easy.

I had only a few complaints about the book. The first complaint is with the title. It says ADO.NET v3.5 but in reality almost all the recipes cover any version of ADO.NET from v2 on. This might cause some people to shy away from the book. This book is really for anybody using ADO.NET.

This leads me to the second complaint. There really was no 3.5 content mentioned. LINQ and SQL 2008 were mentioned a few times but they aren't specific to ADO.NET v3.5. LINQ itself seemed out of place for the topic.

The final complaint I had was that the recipes are mostly designed to be copy and pasted into working code. The code samples don't really follow what I would consider an appropriate pattern for professional code. Therefore simply copy/paste will cause more problems than not. It really would have required no additional lines of code and would not have complicated things to have "done it right". Still this seems to be standard practice for most technical books so I can't harp too much.

Overall I recommend this book for anyone who works with (or will) ADO.NET of any version.

(Full Disclosure: I was a tech reviewer for this book and received a free copy)

I've been using the various incarnations of Microsoft data access technologies for quite some time and have been using ADO.NET for a few years, so I wondered whether I was going to learn anything new from this book. It covers all of the territory to get started (connection strings, basic usage of ADO.NET classes, etc.), but what I really appreciated was that it topics that advanced ADO.NET users would find useful and I certainly learned a few new tricks.

The topic on writing provider and database independent code (Section 10.22) which covers how to do it right if you are targeting .NET 1.1 (which we do) was particularly useful to me. Chapter 10 (Optimizing .NET Data Access) is just generally a good chapter no matter what your level and covers asynchronous SQL calls (executing and cancelling), ASP.NET data caching, paging queries, SQL Server stored procedure debugging and more.

Since my job was to actually run every code snippet, I can vouch for their quality. Most are built off the AdventureWorks sample database that comes with SQL Server Express, so they are ready to run. The rest come with full DDL to create what you need (databases, stored procedures, etc), and the code and SQL is available online so you don't have to type it in.

Hey they are right; it covers Oracle 7 perfectly but there is Oracle 8 and now Oracle 8i. But for the basics, well this is a great starter. It will explain how to tune Oracle and why; after that get another and explore

When I used to work at Oracle, these books were our bibles. I had to learn a great deal about Oracle in a very short time (I knew extremely little about technology, and didn't know a database from a ring ding). These books are remarkably thorough, and go into a lot of detail. The added benefit is that they are extremely widely read by Oracle developers (both working for Oracle and not), that they get TONS of feedback, so any inaccuracies, development or new ideas/tricks get back to the publisher and often get incorporated in new editions. The Oracle series is general is a great foundation to start with for Oracle knowledge. The thick white Oracle PL/SQL guide is also extremely good, and comes with the server software. I believe that it is more easily available in soft copy, as Oracle is trying to limit the documentation that they distribute with their software.

This book offered a complete look at high performance computing for an Oracle7 database. It covers everything about Oracle7 server and hardware tuning. It the best high performance Oracle database book I've ever seen. I've used this book quite frequently when dealing and planning for performance issues. If an Oracle8 version of this book comes out - I will be one of the first to buy it.

No DBA's bookshelf is complete without this book. The authors covered some of the most important topics in oracle tuning and administration. This book gives the most complete and up to date information about underlying concepts and practical ways of using those theoritical concepts in day to day operations in oracle database tuning and administration.

The book is aimed at those interested in DBA issues however I recommend developers to shell out for the book just for the chapters on EXPLAIN PLAN and SQL Tuning Tips. My investment quickly paid back when I put the info to use recently for a major client.

How often have you presented--or been presented with--an extensive table of raw data only to hear the question "what does it all mean and how can we leverage it?"

There is a wealth of useful data hidden within our own raw data. This book presents the statistical methods required to transform these data into useful information, in the form of mathematical equations (e.g. Cost Estimating Relationships).

It is simply one of the most important texts for Decision Support and Knowledge Discovery you can find. This book is an excellent value and is an absolute must-have for Program Managers, Project Managers, and Parametricians.

The book provides a solid approach towards dealing with software development project data. It is also written in an easy to understand style although the subject itself is far from easy.
This should provide software development managers with a well founded handle to get more grip on development efforts.

This book has a powerful format that blends practical "how to" and common sense with the power and rigor of statistical analysis. I will use this book as a "primer" when implementing software metrics in the corporate arena. This book is a "must have" for anyone implementing a corporate software measurement program. I also wish I had this book in my graduate offerings for Software Development and Design. Existing software curriculums can be sadly lacking the foundations and fundamentals for software measurement and statistics. This book literally makes statistics easy, sensible, and straight forward even for the complexities of software development and technology.

If you're working in SQA or managing software development projects this book is an excellent introductory text to statistical analysis. Although I found "Measuring the Software Process" by William Florac and Anita Carleton to me a more in-depth book that book assumes that you've established a metrics program and that you already have a working knowledge of statistics.

What I like about this book is that it's a tutorial on the statistical skills and knowledge that you'll need, and it combines this learning goal with the basics of software metrics and how they can be employed to measure productivity, estimate projects, and manage costs and organizational quality. The core approach is data analysis, and the main tools that the book employs are multi-variate techniques, regression analysis and correlation and sensitivity tests. The author has a talent for clearly explaining a dry subject, and while it will take a good deal of effort to master the material because of its nature, the excellent writing and illustrations will make it easy to quickly grasp statistical fundamentals and put them to use.

The lessons are taught within the framework of four case studies that are realistic and apply to the real world. The case study topics are: productivity analysis, analysis of time to market factors, development cost analysis, and maintenance cost drivers. These cover the full range of both internal development and product-line software engineering. I especially like the inclusion of maintenance costs as a topic of study because this area contributes significantly to total costs of ownership, but is often overlooked.

As of the date of this review there are two primary books that address measurement from a statistical perspective: this one and Florac's and Carleton's "Measuring the Software Process". Deciding which is better is a matter of assessing your needs. The key strengths of this book is the tutorial nature and the wide range of case studies that are used to reinforce the learning. The key strengths of "Measuring the Software Process" is that it goes much deeper into analysis and also includes statistical process controls and other techniques that are present in highly mature development organizations. Regardless of which book you choose (or if you choose both), the information and knowledge to be gained is the foundation of SQA and best practices in project management.

Being a researcher in software metrics, I am really pleased to see a book that is suited for software managers with the correct level of detail in statistics. I particularly enjoyed reading the 4 chapters with case studies. Its a must have for anyone in the field of software metrics and measurement.

First Edition of this book 1-59059-468-1 was a step by step tutorial of how to build sites. At the end, you get a decent working model of a balloon website. Thus, the title Novice to Professional. This book doesn't do this. The book is more laid out like other books. Chapter by Chapter, it covers a big topic like State Management, Error Handling, and others. This book is just like other books out there. I am bit disappointed that the publisher thought that previous book was not in an optimal format. There is really nothing wrong with the content or the information. This just isn't the Novice to Professional Book. It's as if you were reading the Harry Potter. On first edition, you know how Harry Potter is like. On second edition, he is gone or he doesn't do the magic tricks anymore. Instead, he cooks or sings. This book is like that. I can see Harry Potter Singing and Cooking. But that's not the Harry Potter series. He does magics...

This book is good but it's not in the original format.

I have purchased (what feels like) hundreds of computer related books from Amazon.com (including other ASP.NET books), and this is the first one that I have ever felt the need to comment on.

This is just a great book, in my opinion! I found the book to be very easy to read, and logical to follow - Matthew MacDonald's writing style is very effective in communicating technical information in a way that made it easy for me to understand.

I've been developing Windows client applications (VB/C#) for close to 10 years, and have "played around" with ASP.NET 2.0. I knew how to make some basic web apps work, but didn't really understand what was going on underneath the covers. I had a lot of questions that were answered and now have a lot more confidence going forward with creating ASP.NET apps.

As I mentioned, I had purchased ASP.NET books by different authors (for 1.1 and 2.0). Maybe I never gave those books a chance, but this is by far the best that I have come across.

Usually technical books are very booring to read. I buy many books as I tend to easily get trapped with reviews about book. But this book is one of the best book on C#. Every chapter is in detail and all it needs to get concentrations is to start reading it. The examples and the flow of topics are well planned. This is the book one should have if you are in to C#.
This is my first review on any book although I have purchased many books from many website. I felt a book which is soo good needs to be acknowledged.
Mark my words...this book is worth buying ...!!!!

I don't read many 900 page books cover to cover.. It's an accomplishment for both finishing this tome, and for the author of this great read.

The first sections gets you up to speed on C# quickly.. You should know some programming before diving in. Then each area of ASP.NET is covered at a healthy pace. Useful samples, and explanations and recommendations throughout. He first covers the manual ways of doing things, then goes into the slightly narrower scope of productivity shortcuts that turn days of development into hours. He's given me a new respect for it.

There are so many books on each tech subject, it's hard to know where to go. You find a few authors you like, and read their books. I'll pick up another one of his books soon.

Great read, highly recommended.

ASP.NET 3.5 is the latest version of the .NET Framework from Microsoft. C# is the defacto standard programming language for Microsoft programmers. Although there are more VB.NET programmers out there, C# is considered the more "professional" language and hence forth there are more job opportunities for C# programmers.

This book is huge (800+ pages) and really covers everything you need to know about C# and ASP.NET 3.5. Of course there maybe a few database topics it did not go into detail as much, but for the money it can't be beat. The author (Mathew MacDonald) really explained all the topics very well and assumed no prior knowledge of .NET knowledge. You really can be a `novice' and learn a lot from this book.

The great thing about the .NET framework from Microsoft now, is that there are so many free programs to learn before you invest any money (apart from the book of course).

The author explains the C# language first (great choice and wish more authors did it that way), in the first few chapters before getting into web forms and ASP.NET objects. C# is a professional language and definitely should be learned first before getting into anything else.

Starting at chapter 5, the author starts to explain what a web form is and how ASP.NET works. Covering everything from how sever and web controls work, to the web.config customizations, WAT, web control classes, etc. The following chapter focuses in detail about web controls (what ASP.NET is really all about) and probably is the meatiest of all the chapters. The chapter 7 goes into state management which is a very important and goes hand-in-hand with how web controls work.

Error handling (chaper 8) and deployment (chapter 9) is next on topics covered and then in the next sections of the book the author goes back into web controls with lots of examples of using the validation controls and master pages. Master Pages have grown a lot in this version and it is the core of how you will design you own ASP.NET 3.5 web site. There are 3 chapters dedicated to web site design and development and I have never seen a book with so much detail on the subject. Well done!

The rest of the book goes into database topics such as SQL, ADO.NET, Data Bindings, etc. I can't describe how impressed I am with how many topics are covered in this book and how well they are covered. You really only need this book for 80-90% of you ASP.NET development work.

A great buy!!!

This is really a good book to learn PL/SQL. I had intermediate skills on SQL and was able to grasp the Pl/Sql quickly reading the book. The author explains the sample Pl / Sql code in nice, relaxed and organized way. I have one small advice for the author as well, `If possible please give the chapter name related to the contents'. After reading the book I was able to write some good Pl / Sql code with Package, Body and Stored Procedures. Author was successful to communicate with the reader in `Easy Mode'. I highly recommend this book if you some knowledge of SQL and 0 knowledge on Pl / Sql. Currently I am reading a book "SOA Using Java Web Services" by Mark D Hansen, which is completely opposite style of writing, I feel like author Hansen is dropping me off of an airplane without a parachute when its flying 50,000 feet above the ground.

Tazim Khan (SCJP SCBCD SCWCD SCEA)

As an Oracle developer for over 10 years, I have read many Oracle books on a variety of topics, and this book is definitely one of those that stands heads above the others. As the title suggests, Beginning PL/SQL: From Novice to Professional covers a range of PL/SQL topics, both foundational and advanced. From the fundamentals such as triggers, procedures, packages, the book moves into the more advanced operations of Bulk Collection, Objects and even one of the more neglected but no less important areas in PL/SQL, unit testing. The topics in this book are delivered to the reader from a professional point of view in that all examples of the PL/SQL in the book are approached and designed as quality, production ready code. Topics such as design patterns, best practices and even some of the more insidious Oracle "gotchas" are discussed in this book, making it a wealth of information available to both the new as well as seasoned developer looking to update their PL/SQL knowledge. As a final bonus, this book packs all of this pertinent information in an refreshingly compact size with a breezy, fresh writing style. As one who has many a weighty computer tome where maybe 50% of the book has pertinent information and the rest is fluff, finding books where the fluff is removed are books to be treasured. If you are a PL/SQL developer of any level, beginner or veteran, this book is definitely one that should be turned to for information.

A friendly and well-written book recommended for anyone ready to learn PL/SQL. This Beggining PL/SQL well-written and well-organized introduction to the PL/SQL programming language. It uses a careful, example-based, easy to understand approach.
Thank you

The author did an excellent job covering novice PL/SQL concepts and building those concepts into more advanced topics such as information modeling and object orientation. Each chapter is filled with easy to follow, step-by-step coding examples. Each chapters also contains exercises where you create and execute code. I found this most useful. There is no better way to learn than actually doing it yourself.

One thing that impressed me is how the author stressed the importance of testing code during the application development process. An entire chapter is dedicated to application code testing and documentation and rightfully so. Every PL/SQL programmer should own a copy of this book!

As a Information Technology professional with little expertise in PL/SQL I bought this book as a replacement for a PL/SQL training course. It has taught me much and is a very good reference. I feel confident about attending the future Oracle training courses without having attended the pre-requisite PL/SQL training course after reading the contents in this book. I can see that the information in this book will still be useful for years to come as it covers fundamental information. I recommended ut as it lays a good foundation. It is not one of those books that states the obvious or is so simple that you to wonder why you purchased it (and we have all done that before, haven't we).

Better Software Faster provides an excellent, clear and pragmatic approach to developing complex systems. Not only is the book the most useful tool companion that I have ever read, it also identifies and explores the key issues that face software development teams today without overloading the reader with academic process.

BSF challenges each unit of process to prove it's value before it is accepted into the team's software development environment - following the school of "build it up" with the essentials, rather than "strip down" that many process users are accustomed to.

Along with a truly in-depth guide to using Together, and a pragmatic development process, BSF explores issues of domain modeling, requirements modeling (functional and non-functional), cost estimation, and quality from a base of practical experience.

A true informational heavyweight, each chapter is littered with experiential pop-ups where the authors share some great insight. Clearly a lot of thought has gone into this - a sit-down read.

I had great pleasure and interest reading "Better Software Faster". The great value and uniqueness of this book is that it presents in a comprehensive way a development process, the tool that supports it and the main techniques to accomplish each step. The presentation is made easy to read through an example which is clear, complete and which works.

The book also addresses some key technical points that I have never seen addressed elsewhere.

It should be the reference book of each system development team.

I have read good books about how to develop software, but this one goes to another level. It gives a lucid explanation of the principles that are needed to understand and manage the reality of iterative and evolutionary software development. That's right - this book doesn't ask you to learn some new methodology for software development. Rather it gives you principles that will make sense whatever process you are working.

While identifying key ideas behind good software processes, it is also eminently practical - the authors obviously enjoy making software that works. The book includes a significant application, complete with requirements model and a full suite of tests. This is an example that teaches.

As an added bonus the book demonstrates how to put these principles to good use with Together ControlCenter. As far as I know, it it is the ONLY book out there to deal with the single-source, single model approach that Together allows.

Finally, as an experienced Together user I was pleased to find the book uses side bars and appendices to share plenty of advanced tips and tricks too.

This book felt like a fresh breeze on a subject that has been dragged ad infinitum through a morass of books on this methodology or that process. It is not another methodology, nor is it merely a process (though there are solid roots in proven methodologies and processes).

The book impresses most with its down-to-earth practicality. Developers should quickly recognize the authors as two of their own who have spent a lot of time out there in the trenches. I helped review the manuscript for the publisher, and I found myself constantly distracted from the task of looking for problems in the text because I kept on highlighting interesting stuff that I wanted to go back to. I learned much then, and I am still learning.

The work is jam-packed with highly pragmatic advice, based on long experience, on how to tackle object-based, distributed development projects using a readily available development environment. (TogetherSoft's Together ControlCenter is the authors' weapon of choice... as far as I know it's the first third-party book to focus on this killer development platform. For TCC users, the book is probably worth it's price for the expert tips and tricks alone.)

Example abounds. The authors have built a reasonably robust distributed application (for an auto servicing shop), with both local and internet-based clients, around which the text revolves. (You can download the source code free from the book's website.) The language is Java, and the focus is on building distributed applications in a team setting.

Anyone relatively new to distributed apps (as I am), especially corporate developers and project managers, will probably benefit most from this book, though I think even the most seasoned veterans could find some interesting tidbits (artifact management and ControlCenter tips, for example).

This is a great book. Ever since I first evaluated the Together case tool I have thought it was a powerful tool, but this book has shown me many other useful features it has and practical ways to develop top quality software.

In the recent past, CASE tools have received a bad name because their return on investment has seemed poor. Project managers see the developers discarding the detailed UML diagrams painstakingly developed by the analysts and have, by default, encouraged a hack and slash methodology where the resulting code may be rapidly developed but is poorly tested and ultimately disappoints the end users who have to use it. The maintenance team is also horrified with the lack of quality and documentation.

Many companies are slowly discovering Together's big advantage over other CASE tools; that the source code is always fully synchronised with the UML Model. This means that the class diagrams and other UML diagrams used by the analyst never get left to gather dust on the shelf and the documentation will never get out of date. No longer is there a Chinese wall between the architects and analysts and the developers who write the code. The authors demonstrate the power of this code synchronisation feature with their case study.

You have to download the case study available from the accompanying web site. It's very detailed, more detailed in fact than many similar models that I've come across for other tools. There is much to be learnt by following the discussions, examining the code, running and testing the application. It's like suddenly finding yourself in the middle of a real project.

It's all too common to find object-oriented development projects managed by project managers who are not familiar with the iterative and incremental approach that is used. They often fear the continual changes and refactoring of the same classes over several iterations, especially when they thought the class coding was 'one and done'! This book will help them understand what the authors call the 'Perturbation Change Model'. The word perturbation is a bit of a tongue twister, but the authors make the principle simple and elegant. I've always wondered why every software project doesn't already do this. Project managers will be convinced that quality software doesn't cost money but will actually save money and time in the long run.

The focus on making evolutionary changes to the code so that a fully tested and high quality application emerges is described in detail in the sections on the built in Patterns, JUnit testing framework, Metrics, Audit reports and documentation.

In the appendix, the authors describe many useful modules they have developed to extend the functionality of the Together tool. I can't wait to try these out. The only feature the authors haven't written about is the new User Interface Builder that is now part of Together version 6.0. I guess this will be covered in their next book.

I recommend you read this book and be inspired.

As an IT Project/Program Manager, senior IT executive and fellow-author for more years now than I care to remember, I found Marsha Lewin's new book, "Better Software Project Management", a pleasant and informative surprise. Ms. Lewin has distilled her obviously vast experience into a highly practical "how-to" book which will prove invaluable to Project Managers and all other managers with IT connections. Her advice and suggestions throughout this well-written book vibrate with hard-won experience and a strong aura of "been there, done that". Newly minted project managers will find a wealth of tips and templates to get them started and to provide project deliverables with the aplomb of seasoned veterans. Veterans will themselves find plenty to learn and re-learn from Ms. Lewin's hard-nosed, yet humorous approach. The author dispenses with the usual theoretical approaches to the subject but illustrates the best of the available theory with practical and thoughtful "cases".

If you have one project management book to read this year, read this one!

This is a short and easy to read book that is packed with practical advise. Marsha gives detailed examples that can be adapted for other projects. She discusses the role of tools for project managers but also discusses the unquantified problems that cause projects to fail such as personnel turnover, changes in scope, and defining the end of a project. She has obviously managed some large projects and is speaking from experience. I must contrast this with "Extreme Programming Explained" which might work for very small projects but which does not work for a large project.

Whether you are an experienced project manager or just starting out, this book should be on your shelf. For the beginner, it covers all of the basics...and much more. For the experienced project manager, much of it will be familiar, but you will find many opportunities to improve your techniques.

Better Software Project Management goes beyond the oversimplified approaches that confuse project management tools with project management. Real project management means dealing with people as well as tasks, schedules and budgets. This book offers insights into them all.

I have been engaged in the management of software projects for more than 30 years. This "primer" is, by far, the best and most concise book that I have ever read on the subject.

Of particular note, it is written by an experienced project manager to meet the needs of real life project managers. The author offers practical answers and presents usable examples that clearly show how her methods may be applied.

One of the hardest things for a new project manager to do is to sort out all of the acronyms, buzzwords, means and methods spoken of when describing the management of a project. The author cuts through the professional fog that obscures the subject and makes clear what is entailed in this art/science. Even after 30 years I found myself learning from her.

I strongly recommend this book.

As an IT Project/Program Manager, senior IT executive and fellow-author for more years now than I care to remember, I found Marsha Lewin's new book, "Better Software Project Management", a pleasant and informative surprise. Ms. Lewin has distilled her obviously vast experience into a highly practical "how-to" book which will prove invaluable to Project Managers and all other managers with IT connections. Her advice and suggestions throughout this well-written book vibrate with hard-won experience and a strong aura of "been there, done that". Newly minted project managers will find a wealth of tips and templates to get them started and to provide project deliverables with the aplomb of seasoned veterans. Veterans will themselves find plenty to learn and re-learn from Ms. Lewin's hard-nosed, yet humorous approach. The author dispenses with the usual theoretical approaches to the subject but illustrates the best of the available theory with practical and thoughtful "cases".

If you have one project management book to read this year, read this one!

Books that improve my technical communication skills are few and far between; either the advice is too general or it is simply repeating something Gerald Weinberg once said. Still, being able to explain something to a colleague without sounding authoritative is difficult. My belief is that conversations with a colleague should be collegial, and one thing that can set us on equal footing is checklists.

Bug Patterns in Java provides you with a checklist for code reviews and software defect disputes. The best thing about these checklists is that they are non-authoritative. A checklist is just a general static analysis tool. It cannot prove there is a defect or corner case awaiting to be discovered by the end-user. It can, however, non-authoritatively point out patterns in code that appear to be programmer mistakes. What's more, since a checklist is really just a general static analysis tool, you can implement these checklists using automated tools like FindBugs. These tools help provide you with The 2 Minute Answer about the health of your code base.

Now, if you can just run a program to find these mistakes, should you still read Bug Patterns in Java? Absolutely. Just as Martin Fowler's Refactoring is still read by many who love their push-button refactoring features in IDEs, Allen's book should still be read by programmers who use static analysis tools to locate and correct mistakes. The correction half is where Allen shines. He explains exactly what program transformation to do. Moreover, in talking you through the correction, he makes you realize how valuable code reviews are in catching mistakes before they become part of a forward-facing, published API. Allen provides a fantastic vocabulary for describing common bugs in Java, and my belief is that this vocabulary can be cross-pollinated and benefit users of other languages. In particular, Liar View, Dangling Composite, Run-on Initialization and Sabateur Data are phrases I regularly use outside of Java.

Last but not least, most of the chapters are based on an IBM developerWorks series written by Allen. You could read the developerWorks articles by typing in the names of each bug pattern in a search engine. However, if you are not strapped for cash, then it really is worth it to get the book. In my opinion, the format is easier to read, the ideas flow well from one chapter to the next, and Allen definitely spent some extra time sequencing the chapters in the most pedagogical order possible. You are paying for a finished product and world class presentation quality.

Two side notes:

(1) Others have since built upon Allen's work. Sai Zhang published a paper titled "On Identifying Bug Patterns in Aspect-Oriented Programs". It is a really good paper that explains some pitfalls to watch out for, whether you are a programmer or language designer. Templight, a Template Metaprogramming Debugger for C++, was the first effort to provide a way to identify defects in C++ code that takes full advantage of the Turing Complete template system. Problems like infinite recursion and so forth were shown to be identifiable using an automated checklist of sorts. There are many more examples, but these were just the first two I encountered after reading this book. Do your own exploration!

(2) Eric Allen claims he invented the term "bug pattern". Although I don't have any reason to believe he plagiarized the term, Google Book Search suggests that W. Lewis Johnson's book, Intention-Based Diagnosis of Novice Programming Errors (Research Notes in Artificial Intelligence), was the first appearance of the term in the programming field. Thus, credit appears to be owed to Johnson. I just hope that this "bug pattern" term isn't one of those notions that gets lost and re-invented every decade.

The author presents a different way to look on bugs and the debugging process. I could recognize most of the bug patterns as regular acquaintances from my daily work. What I liked most was the way he made clear how Java's type system can be used to eliminate certain kinds of bugs but that there's a trade off between static typing and duplication in code. In other words, to remove some sorts of duplication you sometimes have to forgo static typing in Java.

Time is a very valuable resource on every project, and this book can help conserve that resource. The first six chapters of the book present defect management within the larger concept of Agile development methods. Chapters 7-20 detail various bug patterns with symptoms, causes, cures, and preventions. The remainder of the book provides some nice resources like a diagnostic checklist, a glossary, a reference list, and an index.

I recognized some of the patterns from the author's column on developerWorks, but the book does a solid of pulling them together to present debugging as a rather orderly and scientific process. The author relies on his real project experience with the DrJava project to illustrate his examples. Various tables are available to link concepts with potential bug patterns or problems to a bug pattern that could be related.

The patterns are explained and depicted with code with each chapter having a summary of the concepts at the end. Tips and variations on the patterns are sprinkled in the text. I found the glossary of particularly helpful. The text is easy to read and the examples are clearly explained. This book and "Bitter Java" may have a good "ROI" as required reading for Java developers.

A great Java resource for programmers of widely varying experience levels. Author found the perfect balance between theory and practical application. There is a wealth of useful information in the chapters devoted to detailed descriptions of the symptoms and cures for the most common and/or most troublesome Java bugs. The book is organized in a very friendly way, making it an excellent reference. I plan on keeping this book very handy.

Bugs. All code has them to one degree or another and they always seem to take twice as long to fix as the original code took to write. This book boils thirteen of the most common bugs down to their root causes and formulates them as 'bug patterns'. Each bug pattern describes how to identify the bug by the symptoms it exhibits, why the bug is occurring, and gives one or more suggestions to fix it and prevent it from occurring again.
If the bug you are searching for isn't among one of the thirteen bug patterns covered, the author also covers a methodical approach to tracking down bugs effieciently and quickly. Suggestions on how to prevent bugs from occurring in various stages of the development cycle are also presented, which are helpful even if you aren't currently searching for a bug in your code. Most of the suggestions are based on the XP development model, but the practices that are important are pointed out so they can be incorporated into any other style of development.
Even though debugging doesn't sound like a fun topic, the author has a very readable style and is able to get you excited about preventing and fixing bugs. The chapters have been very well thought out and the book is broken into topics very well. You can read a chapter in about ten minutes or less and feel like you have a good grasp of the topic covered.
This is a great book to partner with a 'best coding practices' type of book, like 'Practical Java' or 'Effective Java'. Those books are really good at describing how Java should be coded. This book gives examples of why those practices should be followed, and how to quickly get back on track when they aren't and something goes wrong.

Well, you know it's a winner b/c it's in Addison Wesley's Microsoft .Net Development series. Like their Hejlsberg title, this is pure reference. However, there's a lot to it (almost 900 pages in total) and EVERYTHING in the CLS is covered here. It's very technical, and definitely not a cover to cover read, but there are many good examples and if you need a quick reference for any topic in the Framework, this book is a must have.

.NET, unlike Java, is an implementation of an ECMA and a ISO standard.
This book, from the Microsoft employees that created .NET and with input from members of the standards bodies, annotates the standard with comments that provide insights into the reasoning behind the standard. If you are in one of these categories, you should seriously consider buying this book:
1. advanced .NET developers
2. language designers
3. tool designers
4. those interested in understanding virtual machines
5. developers of libraries
6. Java developer (wondering what a standard looks like, just kidding. As an intermediate-advanced Java developer, the book is very interesting though.)
7. developer who wants insight into current software architecture
Otherwise, the book is still a useful guide to help you grow as a developer if you even browse it sporadically, and unlike many programming books, it will not be obsolete in a year.

When Microsoft released its .NET platform, it attempted, and is attempting, something quite audacious. It is putting forth a programming environment whereby you could combine modules written in different languages, without recompiling, let alone rewriting.

Arguably, Microsoft set itself a harder task than did Sun with java. Along this road, as the book describes, a standard arose - the Common Language Infrastructure. It describes a Virtual Execution System and what type of executable code can use it. So a version of Pascal, say, that wanted to run on a VES would need to pass the compilation rules of a Pascal compiler that adhered to CLI.

An analogy might help. In some rough way, you might consider CLI + VES to be like a java virtual machine, and the choice of a language to use atop CLI to be like running java under its jvm. Granted, this is crude, but many readers are probably unfamiliar with CLI, whilst having more acquaintance with java.

Warning. The book may be heavy sledding for most. The main audience is compiler writers and language developers. Daresay that even experienced developers may not usually deal with a language at this level.

A slight irony is that CLI is meant to decouple programmers from any specific platform, which is why Microsoft pushed it over to a standards body. But the most developed instantiation currently appears to be .NET, which is inextricably interwoved with Microsoft's operating systems.

Excerpt from C# Online.NET Review (wiki.CSharp-Online.NET):
"...this book goes beyond the online documentation to clarify and amplify the original standard and describe its implementation.... the single source programmers, language and tool designers, and library and VES developers need to render the CLI and the CLR fully comprehensible."

This is not just a reference guide (although it is a very good one). It is also (due to the annotations, often funny) that give you insight into the 'why' behind thing like naming, design decisions, things that were internally debated that we would not normally know about, and in general you come away feeling like you were there creating .NET. I find it required reading and often use it as a reference. 5 stars. An amazing read.

Kind Regards,
Damon Carr
(...)