Programming Books

This book is indeed a "Cookbook"; nice examples on how to do lots of stuff. It is nicely categorized and the explanations/discussions are easy to follow. The authors seem to have lots of experience, and are honest enough to even explain when NOT to use bash; when for example perl would do better.

Highly recommended if you want to get stuff done using bash.

Currently this is the only book that specifically covers bash 3.2, the version that contain new and interesting features like =~ operator for "normal" regular expression matching.

The main advantage of the book that it really covers a lot of ground and provides system administrators and users with a lot of good and difficult to find tips about customizing of the environment and making yourself more productive.

Chapters 5-6 which provide good overview of new features introduced in version 3.x including "normal" regular expressions pattern matching ( operator =~) and C-style for loop. One problem with shells traditionally use two completely obsolete notations for regular expressions (basic regular expression often known as DOS-style regular expressions plus quite perverse prefix notation ). Bash 3.2 did not fixes this problem as this is a problem of Unix in general (Unix can be called an Os that uses a dozen of different definitions of regular expressions :-) that but at least added a normal regular expression notion to the list.

After chapters 5 and 6 I recommend reading chapters 9, 17 and 19 and then the rest. While chapters are of very uneven quality, usually you can find at least one useful tip in each.

The spectrum of bash related tips and useful mini-scripts is quote substantial. The authors cover classic things like customizing prompt quite well. The book is not only about bash it covers a lot of ground including use of classic Unix utilities in scripting (most notably grep, find, sort, and date) along with related topics such as use of pipes and I/O redirection.

Of course for such a complex topic there are some shortcomings. It's a pretty difficult task to write a good cookbook but authors did an excellent job and provided many very valuable tips that can help to improve both system administrators and power users productivity.

One of the problems for a cookbook is a good organization and specifically a good starting chapter and here authors failed. Some chapters are half-baked. The Chapter about version control is badly written and very superficial. The authors just mention a couple of system without any details. And in this topic the devil is in details.

Some bash features are explained superficially. For example bash has horrible implementation of pushd/popd/dirs troika and it not that easy to use them productively. One notable deficiency is that there is no way to suppress duplicates which in essence make this feature almost unusable. The authors treatment looks like a baseless advertizing of a poorly implemented feature.

But I hope that the authors will improve the book in the next edition and I am reluctant to downgrade the book based on those flaws. After all, this is a cookbook and it should be judged by the best recipes not the worst.

Linux system admin is something I do as part of my job. I've been able to acquire the basics and get the job done, but I knew that there were better ways to get the job done. Nothing like having an expert to help learn the ins and outs.

This book allowed me to take it to the next level. There are many excellent examples on how to get it done, as well as advice on things that should not be done.

There is a good mix of newbie info as well as useful tips for the seasoned veteran. There's usually more than one way to get the job done, and this book showed me some new, better ways to accomplish the task at hand.

If you're working with bash, you'll find something useful in this book.

This book covers the GNU Bourne Again Shell, which is a member of the Bourne family of shells that includes the original Bourne shell sh, the Korn shell ksh, and the Public Domain Korn Shell pdksh. This book is for anyone who uses a Unix or Linux system, as well as system administrators who may use several systems on any given day. Thus, there are solutions and useful sections for all levels of users including newcomers. This book is full of recipes for creating scripts and interacting with the shell that will allow you to greatly increase your productivity.

Chapter 1, "Beginning bash" covers what a shell is, why you should care about it, and then the basics of bash including how you get it on your system. The next five chapters are on the basics that you would need when working with any shell - standard I/O, command execution, shell variables, and shell logic and arithmetic. Next there are two chapters on "Intermediate Shell Tools". These chapters' recipes use some utilities that are not part of the shell, but which are so useful that it is hard to imagine using the shell without them, such as "sort" and "grep", for example. Chapter nine features recipes that allow you to find files by case, date, type, size, etc. Chapter 10, "Additional Features for Scripting" has much to do with code reuse, which is something you find even in scripting. Chapter 11, "Working with Dates and Times", seems like it would be very simple, but it's not. This chapter helps you get through the complexities of dealing with different formats for displaying the time and date and converting between various date formats.

Chapter 12, "End-User Tasks As Shell Scripts", shows you a few larger though not large examples of scripts. They are meant to give you useful, real world examples of actual uses of shell scripts beyond just system administration tasks. Chapter 13, "Parsing and Similar Tasks", is about tasks that will be familiar to programmers. It's not necessarily full of more advanced scripts than the other recipes in the book, but if you are not a programmer, these tasks might seem obscure or irrelevant to your use of bash. Topics covered include parsing HTML, setting up a database with MySQL, and both trimming and compressing whitespace. Chapter 14 is on dealing with the security of your shell scripts. Chapters 15 through 19 finish up the book starting with a chapter on advanced scripting that focuses on script portability. Chapter 16 is related to the previous chapter on portability and is concerned with configuring and customizing your bash environment. Chapter 17 is about miscellaneous items that didn't fit well into any other chapter. The subjects include capturing file metadata for recovery, sharing and logging sessions, and unzipping many ZIP files at once. Chapter 18 deals with shortcuts aimed at the limiting factor of many uses of bash - the typing speed of the user and shortcuts that cut down on the amount of typing necessary. The final chapter in the book, "Tips and Traps", deals with the common mistakes that bash users make.

All in all this is a very handy reference for a vast number of the tasks that you'll come across when scripting with the bash shell along with well-commented code. Highly recommended.

These O'Reilly Cookbooks should be on every sysadmin's shelf. The Bash Cookbook is no different. Incredibly useful book. I didn't read it cover to cover but have gone back to it at least 15-20 times to pull out nuggets of info. The real-world, practical examples and solutions offered in this book provide the sysadmin with a virtual swiss army knife when working with bash.

Book was so useful, I bought two extra copies and sent them to coworkers.

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 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.

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.

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!!!

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.

I am using this text as the basis for a university-level business web application development course. It is a better introduction to ASP.NET 3.5 than any textbook I have found. The chapters unfold logically, each new skill building on the last. The prose is clear and relaxed. The code examples are correct and clearly presented. Imar has used the same organization and logic skills needed for good programming to produce an excellent book!

This is a good hands-on tutorial. The author will walk you through an operation, and then explain how it works. I like that approach.

The online resources provided to accompany the book have been very helpful to me. When you start working through a new chapter, you might find it a good idea to start with the official source code provided for the previous one, instead of relying on the results of your own work, especially if you skip some of the exercises.

There is an online forum for the book, and the author and the editor do a great job of answering questions.

To fully benefit from the code-intensive examples in the book, you may want to study C# or VB in its own right as well. If you have no knowledge of programming languages at all, you might find the book a little hard to understand.

The book could benefit from some more editing, which is why I have only given it four stars. Nevertheless, I highly recommend it for anyone who wants to learn ASP.NET 3.5.

Recieved book in excellent condition! The book is very organized and very constructive in teaching me what I need to learn in a step-by-step manner. I very much recommend this book!

I think this is a great start for anyone looking to get into ASP.NET. The entire book takes you through creating a professional-looking website. The book was very well thought out and I have yet to see any errors. I've found the author to be very responsive on the WROX website, as well.

I've picked up copies of Beginning ASP.NET 2.0; Build Your Own ASP.NET 2.0 Web Site Using C# & VB; Beginning ASP.NET 2.0 E-Commerce in C# 2005 From Novice to Professional; and Microsoft ASP.NET 3.5 Step by Step (the only one I can recommend). With all of these, I struggled to read them and didn't feel as though I learned much, or in the case of the last, failed to get much more than an overview of ASP.NET (albeit a good one).

However, with Imar Spaanjaars' book, I finally feel comfortable with ASP.NET 3.5.

In this book Imar works through the steps of creating of an actual, fully-functional, ASP.NET 3.5 Web site, that's actually not that bad (ignoring some questionable design).

Unlike other books, Imar covers both the Express and commercial versions of Visual Studio, in a very unobtrusive way. In addition, Imar doesn't rely solely on the ASP.NET components, but gives a good deal of actual programming, in both C# and VB (in a very clean, comfortable, way).

While it's true that he references a number of other Wrox books, such as Professional ASP.NET 3.5: In C# and VB (Programmer to Programmer), there is very little that needs to be examined to get a site up and running, that would suit the majority of business needs.

Overall, my faith in the ability of Web developers to write good books has been restored by this tome (and at over 700 pages, tome it is). A Web developer Imar is, and to us, as equals, is to whom he speaks. This is clearly seen in his summaries and tips, at the end of each chapter.

I give this book 5 stars of 5. If you've read the other books and been left sad, confused, and/or angry, this is the volume to pick up.

Note: I will be reading this book twice, once I've finished with Professional ASP.NET 3.5: In C# and VB (Programmer to Programmer). There is so much in this book that bears repeating, and many things that I'm sure I missed in my first read, since it's so full of (valuable) information.

Kayden Gray, a half-vampire, hunts the things that go bump in the night with her annoying partner, Micah. The pair fight each other, vying for the upper hand in their relationship, as they hunt evil. Their sexual tension is palpable, even though they both deny it--at first.

The story starts with the pair arguing. As they engage in their spat, they are overcome by a succubus. One, two, three, the pair find themselves in bed. As fun as the sex is, there's a downside. The succubus feeds on their sexual energy and plans to use it to become human and acquire a soul. On top of all this, Kayden's Ex, Jullian, comes to town ready to re-claim her.

The characters are interesting and keep the reader engaged. It is erotic, funny and action-packed. Check it out, it is a fun read.

Kayden is a demon hunter, with a vampire ex-lover, and now has a partner who is a pain in her backside.
Micah is a demon hunter with a dark past that he can't get over and now finds himself looking out for Kayden who he seems to hate for all the feelings she makes him feel.
While out demon hunting the two come across a succubus, now they can't keep their hands off each other. With the help of family, they are trying to find the succubus to remove whatever kind of magic she has put upon Micah and Kayden before it kills them. But that isn't their only problem. Kaydens ex, the vampire, is back in town causing problems. Can Kayden and Micah pull through all the supernatural bull**** and remain in love, or is it too much to overcome.
Bending to Break was my first AJ Hampton book, but it is definitely not my last. I look forward to future reads from her and I would suggest checking out her other titles.

I absolutely love this book! I was a fan of AJ Hampton before this book, and I'm a fan now. I've read fantasy books where I can't relate to the characters at all, or everything seems impossible, but AJ makes her characters so real and relatable. Once I started reading, I couldn't put it down. I can't wait to see what else AJ comes out with!

I am a junkie for good vampire romance stories. This was a new, interesting and very successful approach. Well developed characters. Good writing. Erotic without going nasty. The ending came too soon. I hope there will be more with these characters.

A blend of humanity and the vampire that changed her, Kayden Gray spends her nights hunting creatures similar to herself and the other demons that haunt her small town. Forced to pair with Micah Mckenzie, another warrior in the battle, at the urging of her uncle, she's not had a moment of demon hunting peace since. Micah isn't sure if he wants to kiss Kayden or strangle her from one minute to the next, but an encounter with a succubus takes the decision out of his hands. Thrown together in a mad haze of wantonness, Kayden and Micah are mindless with lust as their family members attempt to break the hold the demon of desire has over them. The problem lies in their true feelings, a bond built not only by passion but also their love for one another. A love that threatens the hold Kayden's sire wishes to have on the beautiful hybrid he sees as his perfect bride--a position Kayden has no desire to occupy.

In a story filled with dramatic action sequences that were only icing on the cake compared to the frenzied mating of Kayden and Micah, Bending to Break was just what I needed to break my reading slump. Boredom was a thing of the past as I was sucked into a world where fighting demons is as normal as taking your next breath. Kayden and Micah are a breath of fresh air, their constant bickering kept me in stitches, hot with anger one minute and falling over their flying clothing the next. A.J. Hampton did a great job with her supporting cast, from Kayden's baby sister and her sweet talented cousin to Micah's younger brother who I think will need counseling from all the peep shows he was subjected to. That is why I'm Joyfully Recommending Bending to Break for the month of February. I pray that this is only the beginning and we will see more from this family of fighters because I can't imagine that there won't be a sire or two coming for revenge in the future!

Indy
reviewed for Joyfully Reviewed

I purchased this book based on Amazon's information and the reviews. My purposes in doing so are different than most who would / should consider it -- to audit and assist US FDA-regulated companines in compliance, including the requirement for validating software in medical devices, or in manufacturing and data systems used to manufacture FDA-regulated products (devices and drugs). Given that caveat, Rodger's book is an excellent resource. He supplements his narrative with numerous diagrams which he defines as describing a process and a "set of tasks that can be used to implement or improve a formal testing program".

His stated assumptions (a pre-existing formal system in place at a company; specifically defined by the Capability Maturity Model / CMM 3-4+; with a separate reporting structure -- or, as he stated, "the full blown model described in this book details a full-featured formal testing process that is applicable to large programs and that would fully support programs deliverable to state and federal governments, or on programs delivering safety-critical systems or having significant impact on corporate profits" ). What he describes would fit well with the FDA's GMPs(Good Manufacturing Practices), a quality system similar to but more stringent than ISO 9001 / 13485, and various FDA /Agency guidance documents on software validation (a series of structured documentation and testing requirements).

Although presented for / geared to a large corporation w/ greater resources, I would argue that the basic principles he discusses, and the systems approaches recommended, are adaptable, and 'down-scaleable' to any size company. It also provides a model / target to aim for by any software developer / provider, including (especially) the small shop, a requirement trend that will probably only increase, and globally -- and providing such companies a competitive advantage, and enhance the Intellectual Property (IP) value of the resulting product. His strategic level and test level discussions also provide the basis for input to software portions of a company's documentation -- the Quality Manual, SOPs (standard operating procedures), and WIs (work instructions) for both engineering and testing / QA.

Certainly, the recommendations, systems, documentation and efforts outlined in this book, if followed in principle, would greatly reduce the problems experienced in software / hardware implementation projects, including some recent failures / delays receiving nationwide publicity.

As such, it has proven to be a valuable addition to my consulting library, and a useful reference in conducting audits, making recommendations, and developing validation protocols.

Testing large software projects is a very difficult task. Testing can only reveal the presence of bugs, not their absence and it is impossible to cover all possible pathways that the software can traverse. Furthermore, and what is the worst, "simple" changes made in software can cascade across many modules, requiring the re-testing of all affected modules. Therefore, any testing plan must incorporate repeating tests based on feedback. Finally, testing is something that must be done, so there is no choice in the matter.
The practices described in this book are all modeled using Input-Process-Output (IPO) diagrams, which are labeled state diagrams. The states in the diagrams are partitioned into three sections, input, process and output. Inputs are represented as labeled arrows, which can originate from another state, but do not have to. The process section describes what is to be done at that stage and the output section has labeled arrows exiting the state that then go to the next state. Multiple inputs and outputs are possible and the flow can loop back to a previous state.
Each state is described in the text, where the inputs for the state are explained in detail. Applicable feedback from all persons with a stake in the operation is discussed as well as feedback that this state can give to previous states. The process is described and then the outputs that the state will send to later states are explained. Feedback that may be received from states later in the sequence is then described.
What is most impressive about these modeling diagrams is the extensive allowance for feedback. The complexity of the testing process and the consequences of the results means that testing can form a feedback loop that exhibits many of the characteristics of chaos. A loop is chaotic when small changes can cascade into very big changes. The way to prevent this in any process carried out by humans is to incorporate damping mechanisms. These features reduce the impact of any result so that they do not grow beyond the bounds of the system to handle them.
When faced with impossible tasks, something that software testing has now become, the best that you can do is examine a subset composed of the most likely scenarios. By applying the models in this book, it is possible to raise the level of your testing quality to the point where you can be confident in your software

Rodger Drabick has written a comprehensive and practical guide to formal software testing process. Everyone involved in software testing will benefit from his years of experience and his revealing insights. I've been in the testing field for more than 10 years, and I'm learning a lot from this book! This is a great textbook for new testers, a step-by-step cookbook for new managers, and a great reference book for everyone in the testing world. Rodger takes what can be a difficult and elusive process and explains it thoroughly, using graphic models as well as real-life examples. The best part is that he explains how to adapt the testing process in various situations, even Extreme Programming projects. He gives specific advice to testers at every level, most valuably for new testers and new test managers. Just a few of the things you can learn from this book: How to apply IEEE standards to your project, how to break a project into testing tasks, how a process model can be used as a training tool for new test engineers, how to apply the model to achieve a specific CMM level. Rodger's aim is to help the reader improve the testing process, thus improving product quality. He emphasizes that the testing and development organizations must work together throughout the software development life cycle - not a new idea, but not done nearly enough either. Don't be thrown by the technical-looking IPO diagrams and formal terminology - this is a common-sense approach that can be applied just about anywhere. Rodger doesn't expect you to run out and implement this entire model - he just wants to help you improve on what you do. What if your a tester who gets code to test but no requirements? Pretest and posttest meetings wouldn't be hard to implement, and they'd improve your process. This is the type of advice that makes this book golden. The appendices add even more value, with info on CMM, preferred practices, a way to evaluate your current practices, and a primer on test execution. The book's references to other works will let you explore other areas of testing.

Rodger Drabick has written a useful book for those working on test efforts in formal environments. By "formal environment" I mean a CMM level 3 or above, SPICE, or ISO registered program, or one regulated by a government agency like the Federal Aviation Administration or the Food and Drug Administration in the US. There have been plenty of templates and standards floating around for years on what to write down for such tests, but precious little describing how to manage the formal testing process. This book fills that void.

The book has the following strengths:

1. Rodger provides a clear, complete roadmap for those new to testing in a formal environment. You could follow this roadmap, with the tailoring advice he provides, and do a competent job your first time working on such a project.

2. Rodger manages to cover a dry topic like formal processes in an engaging fashion. He includes useful "stories from the trenches" and lessons learned from his experiences, which bring the topic to life.

3. Rodger transcends and complements the IEEE 829 test documentation standard by harnessing a formal process model to the templates. Rick Craig's book, *Systematic Software Testing*, does this, too. However, Rodger's book is a good complement to Rick's in a more formal environment.

4. Finally, Rodger's book is browseable. You can skim sections, get the gist, and return later for a more detailed read.

The book has a few minor weaknesses, which I should mention:

1. The bibliography is a bit thin. The body of useful and interesting test knowledge extends well beyond what's shown there.

2. Rodger is careful to note that the processes he describes are for formal environments. So, the brief section on Extreme Programming struck me as somewhat of a non-sequitor. However, readers will probably simply skip this section if they aren't using XP or other agile approaches. If readers are using XP or some other agile approach, I'd recommend a different book on the testing process first.

In the domain and user community Rodger is addressing with this book, neither concern should dissuade someone from buying the book.

Anyone testing in a formal environment will likely benefit from Rodger's book. If you are testing in a formal environment for the first time, reading Rodger's book might well go from a good idea to a survival requirement. Formal environments are the world Rodger has worked in for decades, and no one else has brought his wealth of experience in that world into writing a book about the testing process.

First, this book is not primarily for software test and QA professionals who are working in 'typical' organizations. As noted by others, the approach this book provides is best suited to organizations that are at least at CMM level 3. Moreover, unless software engineering practices across the organization are mature the approach will probably fail. However, that does not prevent even a Level 1 organization from selecting best practices and tasks set forth in this book and applying them. The net result will be an incremental improvement, and may be the catalyst for larger improvements with a small win.

That said, this book is invaluable to mature organizations that are committed to software engineering at the defined, managed or optimizing levels of maturity. It distills formal test practices drawn from a variety of sources and the author's experience into a succinct, process-oriented guide. The model itself is presented in IPO (Input-Process-Output) diagrams that start at a high level to describe the process itself, and drill down into successive levels of detail in level 2 and 3 IPO diagrams. This process-oriented structure gives a great deal of clarity to a complex set of processes that touch all milestones in any SDLC.

I like the fact that the model proposed is not rigid, but can be tailored to development life cycle approaches ranging from waterfall to agile approaches. Chapter 8 gives advice on how to accomplish the tailoring without breaking the integrity of the process. I also found the appendices useful, especially Appendix B (preferred practices) and the plans and templates provided, and Appendix C (testing processes evaluation questionnaire).

If your organization is pursuing CMM level 3 or above, or are contractually required to have a formal software engineering process or process capability, this book will address the software testing process areas of a larger initiative. However, do not overlook some of the small wins a chaotic organization can achieve by using many of the ideas in this book.

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!

'The Book of Visual Basic 2005: .NET Insight for Classic VB Developers' by Matthew MacDonald is another fantastic book written by the busy author Matthew MacDonald. Presented in a very entertaining and fun format thanks to the No Starch line, this book will cover Visual Basic 2005 from top to bottom and show you why it's one of the most popular and easy languages to develop in. With ~500 pages of material and 14 chapters, this book doesn't skimp on any of the good stuff (plenty of whip cream and jimmies for everyone).

If you are a VB programmer and want to learn about how far it's come and why the .NET framework makes RAD ever more RAD than ever before, pick up this book, read it, and enjoy it.

Easy to read and even easier to recommend, this is a solid best buy.

***** HIGHLY RECOMMENDED

Very well written and organized. I've read it once and am re-reading it again. Highly recommended.

This is definitely not a complete work on VB or .NET. It does serve as a good walkthrough of the features of .NET and their use through Visual Basic. So as long as you know what you are buying you will likely be pleased.

The writing is solid, and the graphics are used effectively. This is not one of the screenshot heavy tomes so often seen in the VB world.

The focus of this book is to take a traditional Visual Basic developer who is already experienced writing Visual Basic programs and use that as a base to move them to the .NET platform. One of the problems of the traditional Visual Basic program has been that it has its own way of doing things and is built on a platform that is different from other object-oriented languages such as C++ and Java. Of course this is not the only problem but if you program in more than one language then Visual Basic's dlls would often replace and create problems for the other language and vice-versa. The vision of .NET was to create a common language runtime with common classes that can be used for all languages. The problem is that this meant a complete rewrite of Visual Basic and many of the expressions used before no longer work. This need to relearn how to do so many things has slowed the adoption of the .NET framework for Visual Basic. This book comes to the rescue by providing a convenient learning pathway that starts with the familiar for the Visual Basic 6 programmer and moves them from there to the correct use of the .Net framework to accomplish the same goal. For the Visual Basic programmer making the move to the .NET platform The Book of Visual Basic 2005 is highly recommended.

Are you a Visual Basic 6 developer? If you are, then this book is for you. Author Matthew MacDonald, has done an outstanding job of writing a book about Visual Basic 6 developers who want to shed some of their current habits and start learning more about how the .NET platform works and thinks.

MacDonald, begins by showing you why Microsoft decided to create a whole new framework for programming and what it threw in. Then, the author provides an overview of the design environment. Next, he looks at the .NET world, with an overview of language changes, an exploration of the class library, and an introduction to namespaces. The author also provides an overview of Windows Forms. He continues by showing you the basics of object-oriented development, the most modern and elegant way tosolve almost any programming problem. Then, the author explores VB 2005's object oriented features and advanced class construction techniques including interfaces nd inheritance, the most anticipated Visual enhancement ever. Next, he shows you how to make your own components and get the essentials you need to know in order to transfer your applications to other computers. The author also describes debugging in the IDE, outlines some tips for making bug-resistant code, and introduces structured exception handling. He continues by showing you how to deal with Data: Files, Printing and XML. Then, the author presents an overview of databases and ADO.NET. Next, he provides some advice about when to create threads and how to use them safely. The author also describes the basics of ASP.NET, Microsoft's all-in-one solution for creating web-based applications. He continues by showing you how to create web services and, best of all, let .NET take care of all the plumbing. Finally, he shows you how to deploy your application: the streamlined web-based ClickOnce model, and the more comprehensive Visual Studio setup project.

Throughout this most excellent book, the author strives to give you the essential facts and insights. More importantly, the emphasis here isn't on becoming a "language nerd," but on gaining the insights you'll need in order to understand .NET development and to continue learning on your own.

I just bought the book and will start learning it immediately. The book is amazing in its illustrations and quality. I had a complaint about another book by Tony Mullen. He responded to my complain in a matter of hours. I will let more experienced reviewers evaluate the book, but I will highly recommend any author who cares so much for his customers.

I ordered this book without much hesitation, once I discovered Tony was writing it. Having read his past book "Introducing Character Animation with Blender", I ordered this one without thinking twice. Now that this book is in my hands, I can't regret for my choice. The overall quality of the publication is impressive. Not only for the contents but also for the technical production: fine paper with color quality images. It's not common these days. The book is composed of 400 pages (7 chapters) plus an appendix and they are:

Chapter 1 - Re-creating the World: An overview
This chapter describes those tools and techniques that are not well explained elsewhere by the Blender literature. It covers topics like material creation with nodes, transparency, subsurface scattering, sky maps (sphere maps and angular maps) and those tools that can be used to fake physics, when accurate simulations are not necessary at all but you still need a "quick and dirty" method to achieve an effect efficiently and with sufficient speed (an example: water simulation with surface tension displacement or cloth simulation using a displacement modifier). Obviously, these techniques are useful for everyone involved using Blender. No doubt. Much appreciated.

Chapter 2 - The Nitty-Gritty on particles.
The first thing I thought after reading this chapter was:"WOW". *ALL* the latest development on Blender particles is covered here: emitters, reactors, positioning particles on a grid, chained physics systems, various types of visualizations, force fields (harmonic, magnetic, vortex, spherical, wind, etc.)
You will be guided through the creation of a convincing fire material using clouds and stencils textures! All is explained gradually and with great style. Highly informative.

Chapter 3 - Getting flexible with Soft Bodies and Cloth.
As you can expect, all that has been developed is covered here: baking, how to animate a spring, force fields and collision, using curves with softbodies (it will teach you how to animate a chain using an empty), stress maps, how to produce a fantastic cube of gelatin using lattices, simulating clothes. It will even explain how to use the demolition plugin to produce a window breaking in a spiderweb pattern!

Chapter 4 - Hair Essentials: The Long and Short of Strand Particles.
How to produce hair, fur and grass. After covering the basics, this chapter will guide you through the creation of an hairstyle on top of a practice head. One of my preferred chapters.

Chapter 5 - Making a Splash with Fluids.
One of the most interesting part of Blender: the fluid simulator. All is covered here: domains, resolution, inflow, outflow, fluid object intersection, kinematic viscosity, obstacles (considering animation, of course).

Chapter 6 - Bullet Physics and the Blender Game Engine.
One of the less undestood parts of Blender is certainly the game engine. So I was favourably impressed when I have seen an entire chapter dedicated to it. This chapter describes all the tools needed to produce hard bodies simulations, using the game engine and the powerfullness of the Bullet Physics Library. Actors, actuators, IPO curves, rigid body simulations with IPO curves, joints, ragdolls ... This is material that will be probably new to most Blender users.

Chapter 7 - Imitation of Life: Simulating Trees and Plants.
This chapter explores a few tools that can be used for creating trees and vegetation in general, like the L-System, ngPlant and Ivy Generator.

Each chapter is independent, so you don't need to read the book from the first page, with the exception of chapter 4, who strongly depends by the two previous chapters. This book is of course not intended for beginners. This book is completely updated with the latest Blender development and it covers the actual stable release. This is the documentation Blender needs. I highly recommend this book. It is well written, well presented, well structured and, most importantly, it's definitely fun!

I purchased this hoping to learn to use Blender, and open-source program available from blender.org. The book is very well written, very informative, and an excellent reference, but definitely NOT for beginners; the author even says so. If you, like me, are a beginner, either buy this AFTER getting "Character Animation With Blender" or "The Essential Blender," buy it WITH one of those, but if you are serious about learning 3D imaging, animated or not, this is a definitive must for your library.

I must say, I'm biased... I started liking this book the first time I read the title! The book is very impressive, it is full-color, lots of images, and the chapters are nice and modular so you can jump to the section the topic you're interested in. Tony Mullen did a great job in making the complex straightforward. The tasks in the chapters are clearly written in step-by-step style. He gets right to the point of the chapter and has you work through the material. Another nice touch is seeing pics and blurbs on various Blender artists/developers.

I recommend this book to anyone who wants to learn and/or master physics in Blender 2.46. This book has great tutorials. Unlike Tony Mullen's other book Introduction to Character Animation you are not working on one project, you work on lots a bit like the Essential blender. There are pictures to help you on every page and there ar .blend files on the CD.

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.