Product Description
Software engineering leads to better software products. This book teaches readers how to develop games according to a design and follow a standardized approach to game development. It provides a multitude of exercises that show just how software engineering practices can improve your game. All the basic categories of software engineering are covered. Programmers, designers, architects, generalists, software engineers, and game developers seeking knowledge about standard frameworks for games and their relative merits will find this text more than satisfying. Three frameworks (function, object-oriented, and patterned) are presented, contrasted, and fully described through design documents. ... Read more

Customer Reviews (5)

Good deal
I am totally happy with this text. Other students in the course purchased it through the school bookstore and they are missing an entire chapter. Arrived in good condition. Took a little longer than I had hoped, but given that everything including CD and all chapters were present... =)

Excellent, Professional, Formal Engineering Approach to Games!
The author takes all of the traditional software engineering principles and practises and provides logical, practical examples of their application within the domain of commercial game development.Not an easy task but one at which the Author excels.

Academia or anyone involved in games and/or software engineering should have this book as a reference text.

Excellent work.

Exactly what I expected
I got exactly what I expected, the book was new and showed up within the expected time frame.

Nice book for beginners
I like the fact that the author got out of his way to actually create a game to illustrate the software engineering methodology. Also, all the code and documents of the game are on the CD.

The only CON I would give to this book is that it keeps referring to things that have not been explained. So, if you are on Ch. 1 you have to quickly go and read a section on Ch. 3 to understand what the author is saying on Ch. 1 (Obviously Ch. 1 is an introduction to the whole book and it is supposed to talk about everything. This is just an example)

I would seriously recommend anyone interested in game developing and software engineering to get this book. Unlike other books in the Xtreme game developing series. Most of them are misleading.

The professional approach
This book takes a very interesting (and possibly unique) approach to game developing. It's a detailed discussion on the development of a real game (30,000 lines of code) by a small team of game developers.

The book starts with the development of a set of requirements for the game. What's the game all about, what tools are going to be used, what is the scope of the project? Indeed, what makes a good set of requirements in the first place. From there it goes to modelling the game using UML. This step helps to visualize the system that constitutes the game. Why model, how to model? From here the next step is the basic software design. What's the structure of the program going to be? Why? ?What are alternatives? Then on to the next step and the next.

This is not a description of how the play the game, this is an introductory to intermediate (maybe even advanced) book on Software Engineering. It is oriented to gaming, but it covers the basic rules of any major software project. The approach that it uses leads you through the process one step at a time, it gives you the way professional developers approach the business. ... Read more

Product Description
This innovative software/worktext package is the only product that offers you affordable, take-home pharmacy management software training. Case studies and exercises in the worktext teach you how to use the software and help you learn essential tasks such as inputting patient, prescriber, and prescription information into a pharmacy computer system.

• The full version of DAA Enterprises' Visual Superscript pharmacy management software program lets you explore all aspects of the program and work through realistic practice scenarios.
• Worktext activities provide real-world experience for the tasks you will perform in the pharmacy setting, preparing you for career success.
• A large database of provided patient records corresponds to worktext exercises that teach you how to determine if previously dispensed drugs pose an adverse reaction risk when combined with new prescriptions; determine if prescribed drugs contain ingredients listed on the patient's allergy profile; handle refills; examine a patient's prescription history; and much more.
• The software gives you the ability to add new patients, helping you learn to navigate and modify the patient database.
• Visual Superscript user tips offer helpful advice on the most effective and efficient ways to use the software.
• Various exercises familiarize you with HIPAA guidelines for patient privacy and confidentiality in the pharmacy setting.
• Key terms, learning objectives, and chapter reviews help you focus on the most important information.

Product Description

Customer Reviews (10)

good book
This book is one of the best books i've ever read. it has lot of good information, not only related to Microsoft way of testing, but also general concepts and guidelines.

Microsoft Testing Only
This book was good but it obviously focuses on technologies that are specific to Microsoft. In my case I thought it was a great book since most of the things I work on are Microsoft so no major loss there. I do recommend it for those that work with .NET technologies and are wanting to look into testing and all the tools and practices that Microsoft has made available.

Good not only for testers
I would recommend this book not only for testers, but anyone involved somehow on development process.

For managers, would help them to realize their own mistakes and compromises towards a decent final product and for developers, their own piece of guilty on the Q&A process.

It is not a "Microsoft book" sharing only "appraisals" to Microsoft itself, but good on identifying several parts of the Q&A process.

A good start if you want to stop creating "software on demand", like a fast foode counter order.

Highly recommended for all current and would-be testers.
In "How We Test Software at Microsoft", Alan Page, Ken Johnston, and Bj Rollison provide a terrific mix of insight into Microsoft, along with in-depth explanations of practical test processes.

From the introduction:

"This book is for anyone who is interested in the role of test at Microsoft or for those who want to know more about how Microsoft approaches testing.This book isn't a replacement for any of the numerous other great texts on software testing.Instead, it describes how Microsoft applies a number of testing techniques and methods of evaluation to improve our software."

I would also add that this book is for anyone who wants to learn some extremely useful, real-world approaches to both typical and complex testing situations.

This is a very good book - one I highly recommend to all current and would-be testers.

Good book on Software Testing
This book is one of my favorities on Software Testing. I would recommend this book to every one who wants get a fresh perspective on software testing/SQA. My best pick from the book is the chapter on "A practical approach to Test Case design", Authors have tremendously succeeded in explaining the principles with great real life examples in a very lucid style. Personally, it helped to improvize the test planning efforts at my work place and also to explain &emphasize the need for desigining "practical" test scenarios to my students. Chapter on "Test Automation" provides very good insights on how to take best advantage of automation tools. Book is neatly organized and will be a great reading for beginners and for experienced QA professionals as well. ... Read more

Product Description

Customer Reviews (70)

Altight
It has some easy concepts, but it will not help if you actually need to do a realproject. It will be a good book for a starter.

For Experienced Java Programmers Only Please
I am currently taking a Programming Concepts in Java college course.This is the required text and I would have to say that it is one of the most frustrating technical textbooks that I have every used.Java is not easy to learn - there is A LOT to the language and can be complicated.I like to have examples from which to draw when working on projects well, like a Java program.I think that examples help you to apply the concept you are trying to learn.This book had a great opportunity to provide "rich" examples; however, the authors preferred to use the simplest of examples.At times, no examples at all.As an example on page 119 is a list of "some" of the methods of the String class - are there more methods?Who's to know, the text doesn't address that either.There are 10 methods listed, the authors opted to only show an example of the use of 4 of the easiest methods to understand.I find String methods pretty easy to use now...but when I first turned to that chapter I had no clue.I had to search the Internet for examples of the methods that I needed to use...why did I pay $100 for this book?This is just an example of how the entire book has been written...very vague on the use of the material.I would say that this book would be good for someone who already has a decent grasp of the structure of Java programs...then the material in this book may be useful.

Good for starting to learn Java
Instead of just giving an opinion I'll give you the facts of my use of this book.I bought this book because it was to be used for my intro to programming course using java.I bought it 2 months before the class and decided to start going through it (I know, overachiever).I had no prior programming experience what so ever.I found it very easy to go through.Sure some parts were difficult, but that was because this was new to me.Before class even started I had a decent grasp on the basics and was able to do my own program experimentation using the Java API.Then the class just reinforced all that I had learned and went very smoothly.True the book is not exhaustive on the java language, but it is great for learning the foundation.

I felt the examples were very helpful and specific to what they were trying to express.I was able to better understand new concepts just by tracing some of the examples.

So if you just want someone to tell you what to type to make something happen or just be able to write quick apps for fun in a short amount of time, this is not for you.This book is for those who want to pursue programming and computer science in education or career and want a good foundation on java and/or OOP.

Java Book
It was in good condition like it said. I came quickly and was a great purchase.

very good
I'm very pleased with my purchase as in spite of being used this book arrived in a very good state and it didn't take a very long time. thanks ... Read more

Product Description

Since the release of the bestselling title Joel on Software in 2004, requests for a sequel have been relentless. So, we went back to the famed JoelonSoftware.com archives and pulled out a new batch of favorites, many of which have been downloaded over one million times. With Joel’s newest book, More Joel on Software, you’ll get an even better (not to mention updated) feast of Joel’s opinions and impressions on software development, software design, running a software business, and so much more.

This is a new selection of essays from the author’s web site, http://www.joelonsoftware.com.

Joel Spolsky started his web log in March 2000 in order to offer his insights, based on years of experience, on how to improve the world of programming. This web log has become infamous among the programming world, and is linked to more than 600 other web sites and translated into 30+ languages!

Spolsky’s extraordinary writing skills, technical knowledge, and caustic wit have made him a programming guru. With the success of Joel on Software, there has been a strong demand for additional gems and advice, and this book is the answer to those requests.

Customer Reviews (8)

Learned something new!
I loved the 2nd book in the serious: "Joel On Software" and wonder what can he possible say this time. Apparently, Spolsky did a good job. I read it cover to cover and couldn't stop laughing when reading 'Camels and Rubber Duckies'. Just for this I gave it 4 starts.

Having said that (or writing that); he did paraphrase from his previous book. But the bottom line is this: if you are a programmer/software-entrepreneur or a student in the computer-science world, take this book and read it. It has some great tips. I would surly use his interview questions the next time I need to hire someone...

Dror Guzman

Good, but the first was great
Good book, but not as great as the first. But still it has a ton of good information, and its written very well.

Second verse, same as the first
More Joel on Software continues where the first left off - great advice on software development from an in the trenches practioner.You wont agree with all of it, but you'll spend a lot of time thinking, and that's the first step.

The book that every software developer needs...
in short... Joel on Software and More Joel on Software are essential for every software developer. When I interview a software developer from now on I will ask if he or she read these books and if not ... you know!

Oh no more Joel.

"More Joel on Software" is exactly what it says. It's a follow-up on "Joel on Software", a collection of blog posts from Joel Spolskys well-known blog "Joel on Software". I thoroughly enjoyed the first collection of Joels posts and thus was looking forward to this. And... I was disappointed. It IS good, Joel is an excellent and funny author and his posts are interesting, but... it was not as good as the first collection of posts :) Is he running out of ideas? We'll see in "Even More Joel on Software" which ought to be ready in four years...

Slight disappointment, but still enjoyed Joels latest collection of posts. Let me point out a few of his posts to give an idea what he covers.

The first post "My First BillG review" was a great story in which Joel tells his experience with Bill Gates reviewing his spec for MS Excel (many years ago) and how Bill reacted to the spec and what impression it led to him. It's a nice post and gives an insight to the working of MS during that time.

"The Perils of JavaSchools" criticized the universities that uses Java as main languages for teaching computer science. Joel argues that developers do not learn "the hard parts" about programming when using a language like Java.

In "Why are the MS Office File Formats So Complicated" Joel takes a look at the insanely large file format spec for Office files and explains why they became the way they are. Then he gives some advise on what to do when you want to read Office files (not write it yourself)

In "Hitting the High Notes", Joel explores the productivity difference between developers from many different perspectives and argues that great developers are absolutely essential for great products. This was his main idea behind setting up his own business. He looks at productivity and quality from different perspectives.

All in all, More Joel contains 300 pages with Joel blog posts. It's worth reading and I enjoyed it a lot. Joel has an "interesting perspective" on certain topics. Worth reading, but if you haven't read "Joel on Software" then I'd recommend to read that first. ... Read more

Product Description

Eric Sink on the Business of Software is a selection of the best and most popular essays from the author's website. This insightful collection of essays explore the business concerns that programmers face during the course of their careersparticularly those programmers who are small independent software vendors.

Sink also covers issues like starting your own business, and then performing the hiring, marketing, and financesin a style that programmers understand, sprinkled with a touch of humor.

Customer Reviews (35)

Interesting book
I've read a number or articles from Eric's website and found them useful. I'd recommend this book to anyone involved in the software industry.

Lets stereotype software
Interesting and thought provoking ideas.

But at its heart this book is a manual about how to stereotype software people.

So if you are a lazy hiring manager with no personal skills and no personal agility or intuition about people, this will help you maximimize the probability of hiring the right people.

It would probably be better to get someone on your team with some people skills, though, since your stereotyping is going to give you the people who play the game best, not the best.

Some common sense and some good advise
If you like to read dead trees and you are interested in the Business of Software, than this book is a gook buy.

You'll find a lot of good advise, some common sense and some very interesting tips given by someone who actually create an ISV.

But if you enjoy reading weblog, well, the content of this book is mainly taken from Eric Sink blog (a very nice blog that you have to follow if you are interested in the Business of Software) and you'll find there a lot of the content you have here, including some classic like the micro-ISV one. What you loose are the intro comments that Mr Sink added to every chapter and some annotation.

My choice? bought the the dead tree version and read it cover-to-cover.

As valuable today as it was when it was first published!
I'm a Windows-based software developer who has for years dreamt about starting my own software company. I picked up a copy of Eric's book and found it to be one of the best decisions I could make in regards to learning more about becoming an Independent Software Vendor (ISV). It's one of two books that I have actually read cover-to-cover without skipping a single page. Very well written.

The content/advice Eric provides is just as valuable today (2009) as it was in 2006 when the book was published. An excellent book for anyone considering starting their own software company. Very inspirational.

Must Read for a Chief Geek!
This is a great book! A must read for any Geek interested in business, especially those interested in starting their own business.Eric's writing style is so honest and real.He doesn't "Sugar Coat" anything and isn't afraid to share his mistakes with the reader.Eric is honest, brave, and quite funny.

I love Eric's Suggestion to "Double Your Failure Rate." ... Read more

Product Description

How to Find and Fix the Killer Software Bugs that Evade Conventional Testing

In Exploratory Software Testing, renowned software testing expert James Whittaker reveals the real causes of today’s most serious, well-hidden software bugs--and introduces powerful new “exploratory” techniques for finding and correcting them.

Drawing on nearly two decades of experience working at the cutting edge of testing with Google, Microsoft, and other top software organizations, Whittaker introduces innovative new processes for manual testing that are repeatable, prescriptive, teachable, and extremely effective. Whittaker defines both in-the-small techniques for individual testers and in-the-large techniques to supercharge test teams. He also introduces a hybrid strategy for injecting exploratory concepts into traditional scripted testing. You’ll learn when to use each, and how to use them all successfully.

Concise, entertaining, and actionable, this book introduces robust techniques that have been used extensively by real testers on shipping software, illuminating their actual experiences with these techniques, and the results they’ve achieved. Writing for testers, QA specialists, developers, program managers, and architects alike, Whittaker answers crucial questions such as:

•  Why do some bugs remain invisible to automated testing--and how can I uncover them?

•  What techniques will help me consistently discover and eliminate “show stopper” bugs?

•  How do I make manual testing more effective--and less boring and unpleasant?

•  What’s the most effective high-level test strategy for each project?

•  Which inputs should I test when I can’t test them all?

•  Which test cases will provide the best feature coverage?

•  How can I get better results by combining exploratory testing with traditional script or scenario-based testing?

•  How do I reflect feedback from the development process, such as code changes?

Customer Reviews (4)

An excellent pick for any software developer's library
Learn how to find and fix software bugs that evade conventional testing with a title from a software testing expert who discusses the causes of today's best-hidden bugs in James A. Whittaker's EXPLORATORY SOFTWARE TESTING - and introduces new 'exploratory' techniques for fixing them. These bugs may prove invisible to automated testing and demand manual testing techniques: EXPLORATORY SOFTWARE TESTING tells how to implement test cases and choose the important areas to test. An excellent pick for any software developer's library.

a fun view on the perspectives of software testing
"Exploratory Software Testing" was a very enjoyable read.It is geared towards testers, but I think developers and informal testers can benefit from it as well.

My favorite section of the book was the "tours."This extended analogy compares vacation and testing.It points outdifferent types of testing in a creative and memorable way.Examples
"morning commute" = startup
"arrogant American" provides silly inputs
"tourist district" differences between experienced/novice users

The author then provides case studies of how the tours were used at Microsoft.I really liked how he showed the importance of focusing on a completely different point of view in different tests.

The first 136 pages provide enough reasons to buy the book.The rest is the author's background, newsletter type posts from university and his Microsoft blog ([...]).While I'm not a fan of blog posts verbatium in a book, it was in an appendix at least.

If I could change three things about the book:
1)A list or table of the tours in one place
2)More consistency in the format of each Microsoft tester's description
3)Order the blog posts by topic rather than chronologically.Posts in a "series" should be together in printed form

As you can see, my biggest "complaints" about the book are quite minor.
---
And to make the FTC happy: I received a copy of this book from the publisher in exchange for writing this review on behalf of JavaRanch.

Not much of value here
A few years back, I read "How to Break Software" by James Whittaker.I liked it.It wasn't wonderful, but it had a good batch of practical, useful tips.Then I read "How to Break Software Security" and "How to Break Web Software".I liked them as well, but not as much.Still, I figured I'd read James Whittaker's newest book "Exploratory Software Testing".Sadly, the downward progression of his writing continues.This book is by far the worst of the bunch.

Chapter 1 - "The Case for Software Quality" is nothing more than "software is terrific, but it has bugs". That's it, nothing more here.

Chapter 2 - "The Case for Manual Testing" talks a bit about testing, and tries to define exploratory testing.Whittaker's definition has apparently caused some controversy among some well-known practitioners of exploratory testing, so here is his perhaps unique definition:

"When the scripts are removed entirely (or as we shall see in later chapters, their rigidness relaxed), the process is called exploratory testing."

Whittaker then divides exploratory testing into two sections.Exploratory testing in the small is that which guides the tester to make small, distinct decisions while testing.Exploratory testing in the large guides the tester in how an application is explored more than how a specific feature is tested.

Chapter 3 - "Exploratory Testing in the Small" was, to me, the only useful chapter in the whole book.Here Whittaker offers practical advice with examples for thinking about constructing test data, software state, and test environment.

Chapter 4 - "Exploratory Testing in the Large" is where Whittaker dives into what appears to be the point of the whole book - his Tourist Metaphor.Apparently this is a big hit at Microsoft, but I found it pointless.Think about every type of testing you have ever performed.Now try to torture it into a phrase that ends with the word Tour.There you go - that's the chapter.

Just to give you a flavor, here's a list of all these Tours, and their variations:

The Guidebook Tour
Blogger's Tour
Pundit's Tour
Competitor's Tour
The Money Tour
Skeptical Customer Tour
The Landmark Tour
The Intellectual Tour
Arrogant American Tour
The FedEx Tour
The After-Hours Tour
Morning-Commute Tour
The Garbage Collector's Tour
The Bad-Neighborhood Tour
The Museum Tour
The Prior Version Tour
The Supporting Actor Tour
The Back Alley Tour
Mixed-Destination Tour
The All-Nighter Tour
The Collector's Tour
The Lonely Businessman's Tour
The Supermodel Tour
The TOGOF Tour
The Scottish Pub Tour
The Rained-Out Tour
The Couch Potato Tour
The Saboteur Tour
The Antisocial Tour
Opposite Tour
Crime Spree Tour
Wrong Turn Tour
The Obsessive-Compulsive Tour

Perhaps the idea of calling UI Testing a Supermodel Tour appeals to you, and will make for a richer, more productive set of tests.I don't get it.I just don't see any value here.Doesn't testing have enough variation in language and definitions already, without adding this silliness?

Chapter 5 - "Hybrid Exploratory Testing Techniques" tells us that it's acceptable to combine scenario testing with exploratory testing.Then it spends time rehashing each of the tours from Chapter 4 and tries to suggest a side trip for each.

Chapter 6 - "Exploratory Testing in Practice" presents essays written by several Microsoft testers describing how they each used one or more of the tours in a testing situation.It appears as if Whittaker instructed his charges to write a "What I did this summer"-styleessay, in the form of "How I used Tours to do my testing".

Chapter 7 - "Touring and Testing's Primary Pain Points" tries to tell us (in a few paragraphs) how to avoid five pain points - Aimlessness, Repetiveness, Transiency, Monontony, and Memorylesness.There's little real instruction here.For example, we are told that in order to avoid repetitiveness, we must know what testing has already occurred, and understand when to inject variation.Uhm, ok.

Chapter 8 - "The Future of Software Testing" has nothing at all to do with the other chapters, or exploratory testing.It's basically Whittaker's gee-whiz vision of what might be possible (some day) in the future.Perhaps.Whittaker has given this talk in several webinars - it's simply rehashed here.

Since these chapters take up only 136 pages, and obviously aren't enough to fill out a real book, three unrelated appendices are bolted on.A few pages about Testing as a career, and a bunch of pages lifted directly from Whittaker's blogs fill out the book to over 200 pages.

If you really want to learn about Exploratory Testing, this is probably not the place."Exploratory Software Testing" is fluff - stretched and tortured out barely to book-length.There's not much in the way of learning here.

And if Microsoft testers are really instructed to "Tell me what kind of testing you did today, and make sure it ends with the word Tour", then I feel very sorry for them.

A must read for all testers
I happened to review a copy of the book pre release. All I could say is that this book is full of new ideas regarding exploratory testing. The concept of tours is a revolutionary one, and provides a well defined structure to how we test. These concepts form a basic building block for a extremely comprehensive and solid test plan, paving way for automation. What is also impressive is the simplicity of the book. Easy and interesting to read, this book fills your mind with new ideas, which will change the way you think on approaching a test problem. 5 stars. ... Read more

Product Description
Everyone has a role to play in software testing -- even people outside a project team. Testers, developers, managers, customers, and users shape the process and results of testing, often unwittingly. Rather than continue to generate stacks of documents and fuel animosity, testers can cultivate rich opportunities and relationships by integrating an effective testing mentality into any process.

Jerry Weinberg, author of The Psychology of Computer Programming and more than forty nonfiction books, sets out to disprove destructive notions about testing and testers in Perfect Software And Other Illusions About Testing. With a blend of wit, storytelling, and jaw-dropping insight that has won him fans around the world, Weinberg deftly separates what is expected, significant, and possible in software testing. He destroys fallacies and steers readers clear of common mistakes.

We test because people are not perfect, and simply testing more does not guarantee better quality. This book guides test strategy development that's scalable for any project.

Topics include:

- Why Not Just Test Everything?
- Information Immunity
- What Makes a Test Good?
- Major Fallacies About Testing
- Determining Significance
- Testing Without Machinery
- and much more. ... Read more

Customer Reviews (12)

Excellent on humanity, weak on what is perfectable
Like many who follow Jerry Weinberg's works, I love the humanity of this book. The ineraction and people seem like many I work with, facing these same challenges.


I love the book... and don't wish Jerry to change it.

I would like readers to consider these thoughts ....

Nevertheless there is a gap between this book and the realities of verifying the correctness of software. This area is one many software developers and many testers and quality leads are unaware of.


1) Proof: For example, It is a profound truth that like some logic, software logic can be proven correct. Some software can be proven correct mathematically (and indeed must be). The approach to prove correctness (or the lack of incorrect properties) is called formal methods. Some software developers write proofs of linear time logic which is converted to c or java. Software that meets all necessary properties and has no undesirable states could be considered "perfect" when proven so. (Example a dishwasher control program could be proven correct for all time, and meet all requirements for that system.) The barrier to reach perfection (satifaction of all requirements and the application cannot attain states).

2) Types of verification : What should the tester know about profiling and instrumenting software for reliable software.

3) Where the numbers are and where does software break: What in software systems provide metrics of performance and correctness in testing! Example testers should know that databases keep statistics on query performance. Testers should know that developers and tests can validate the lack of memory leaks and deadlocks. Testers should know how to keep performance history.

4) Tools for software quality: What are the types and how are they used. (Example what are static analysis tools (e.g. PMD for java). What are dynamic analysis tools.

5) Defending the test environment and test harnesses: Testers should know how to present the benefits of maintaining the testing environment and test tools.

6) When can something be tested. What is maturity in software.When does the many eyes model fail.

A good introduction is The Spin Model Checker by Holzmann.
The SPIN Model Checker: Primer and Reference Manual

Thanks

A Book for Testers and their Managers
As a software testing consultant, I have had the same mentoring session about one thousand times (or at least it seems) with different IT, development and testing managers. These conversions are on the same topics as Jerry covers in this book and the insights he gives are ones I will be adding in my consultations. The value of this book in my view is that it concisely cuts to the key issues in getting software right. Too many people in decision-making capacities hold misconceptions about what it takes to have a successful software project and/or product. The biggest misconception, which is why the book is titled as such, is that perfect software is possible.

Companies hire testers to "find all the defects." When they don't, the testers get blamed and perhaps fired. This book explains the reasons why we don't have perfect software, but gets much deeper. It's funny that when people want "to go deeper" in their understanding of testing, they want to learn about tools and techniques. This book beautifully explains the deeper issues of software testing by how we think and communicate about this very important aspect of software development. My copy is now tattered after carrying it from trip to trip, but I keep finding the gems of wisdom. It is easily readable, but will make you think about what we do in testing - and why we do (or don't do) things. I highly recommend it to testers and the people who manage them - all the way up to CIO!

Not a "How To" Book - More of a "Why" or "Why Not" Book
Perfect Software is a high-level look at some of the "big picture questions" about testing, such as: Why do we have to bother testing?Do we have to test everything?What makes testing so hard?Is perfect software possible?Why can't we just accept a few bugs?

It's a small book (under 200 pages), and a quick read.

Here's an interesting example that will give you a flavor of the book.

In chapter 3 "Why Not Just Test Everything?", Weinberg has a section called "There are an infinite number of possible tests."He talks about a backdoor placed into a highly secure program whereby the ordinary password protection could be bypassed by typing W followed by three spaces, then M followed by three spaces, then J followed by exactly 168 more keystrokes without once using the letter L.Then he writes:

"Do you get the point by now?If you didn't guess that the number of tests required to exhaustively test software is infinite, or at least "a number greater than I could run in my lifetime", you didn't understand the point of this chapter.Now you do."

If you are looking for a "how to" book, you should look elsewhere.If you are looking for a "why" (and sometimes "why not") book, this might be for you.

The quest for perfect software
Yes, generally software can't be considered perfect. But do we need to write a book about that? Isn't that common knowledge? Software development is an art and instead of striving for perfection the goal should be customer satisfaction, security, and safety. Software perfection is a lofty goal.

Excellent - for the right audience
If you've been in testing long, you've probably heard the standard impossible questions:

"Why didn't you find that?"
"Why would we hire a human to test when we can automate our testing?"
"This NEEDS TO WORK.And we need it next week.Period"

If you drank the deep draught of testing, if you've struggled with it, wrestled with it, and gotten good at it, I have only one thing to say:

This probably ain't the book for you.

This book is for the people who are asking you the impossible questions.

Seriously. This is a nice evening read and will provide an executive,manger, or developer with enough information about testing to (A) understand some of the challenges of the role, (B) set appropriate expectations, and (C) communicate those expectations clearly.

In other words, it can be the difference between a sane life and an insane one - if only you can get the right people to read it.

Now, the style of the book is plain prose and folsky story - it's the kind of thing you can read in an comfortable evening, or perhaps, two.It doesn't have fancy metrics and graphs, but we all know what Mark Twain said about that.

So if you are a seasoned tester, this book might not be for you - it's for your boss, your bosses boss, the customer, the CEO, and The New Guy.I wanted to get my management team the book as a Christmas present, but somehow all those folks had read it before Christmas ... I suspect a co-worker.

Absolutely great for it's niche.Top Flight.Buy two copies to give away today! ... Read more

Product Description
This new book provides a total solution for learning and teaching embedded system design based on the Freescale HCS12/9S12 microcontroller. Readers will learn step-by-step how to program the HCS12 using both assembly and C languages, as well as how to use such development tools as CodeWarrior, ImageCraft ICC12, MiniIDE, GNU C, and EGNU IDE.Supportive examples clearly illustrate all applications of the HCS12 peripheral functions, including parallel port, timer functions, PWM, UART port, SPI, I2C, CAN, on-chip flash and EEPROM programming, external memory expansion, and more.New sections on C programming style, software development methodology, and software reuse have been added in theis revision. A back-of-book CD contains the source code for all examples in the book, several groups of reusable utility functions, and complimentary freeware development tools for improved learning. ... Read more

Customer Reviews (1)

Good Book for Those New to Microcontrollers
I would recommend this book to anybody new to microcontrollers or the HCS12 family.The book does a great job of covering programming of the HCS12 in assembly and C.There are plenty of examples in the book and included on the CD-ROM to guide you along.Additionally, the book provides a basic guide to the C language and the use of several different compilers.Out of all of the microcontroller books and textbooks I've used, I can say with confidence this one is the best. ... Read more

Product Description
In such a business climate that demands a heightened understanding andkeen ability to leverage essential technologies, one must understandevery element of an agreement as critical and essential as thesoftware user/vendor contract. As there has long been a disconnectbetween the express interests of the end user and the objectives ofthe vendor party in the developing, drafting and executing of suchcontracts, Software Agreements Line by Line serves to bridge thisgap. Taking a standard agreement and breaking it down clause byclause, explaining the nuances of the language and the implicationsinherent there within, authors Michael Overly and James Kalyvas(partners at Foley & Lardner) present a comprehensive overview of acontract, detail how it can be manipulated, offer practical solutionsto prevent against this and suggest ways in which it might be adaptedto meet the needs of the end user. A never-before offered glimpse intothe often daunting world of these highly-technical agreements,Software Agreements Line by Line highlights the often overlooked,unnoticed and even hidden aspects of authorizing, purchasing andleveraging such business-critical assets. The ability to understandand develop user-friendly software licenses and agreements offersunparalleled advantages for any company invested in, or makingdecisions around, purchasing software. This book will proveinstrumental in rendering any reader an informed user, a morestrategic thinker and above all, an empowered consumer. ... Read more

Customer Reviews (9)

Typos
This book is pretty expensive and seems to have promise from my reading of the first few chapters. However, at Chapter 1 the authors present a model agreement. There are various typos including improper use of defined terms where there is no definition provided (e.g., Charges, Services, Purchase Price, etc.), improper cross references (see article 12). These are mistakes even a new associate would not make so I am surprised they made it into this book. At such a high price I expected more care from the authors.

Software Licensing Toolkit
There are a number of reasons this book is an excellent resource for both the person who is just starting out reviewing software license and related agreements and those who have experience.

The first, and probably most important reason, is that it's clearly written. Although it has to contain legal terminology and jargon it doesn't contain unnecessary legalese and where it does it explains the concepts concisely and clearly.

It provides excellent examples in a before and after format so that's it is very clear what the author intends.

It contains checklists at the end of most of the sections so that, for both new and experienced reviewers, you can make sure you don't miss any of the important issues in the contract you're reviewing.

This is clearly a summary book and while you probably should read it cover to cover at least once, it's one of those books you should keep handy as a quick reference.

If you're just starting out reviewing software licenses I'd recommend this Line-by-Line book and a more comprehensive overview book Software Licensing Handbook, Second Edition. Both will provide the what, why, and how of software license reviews and negotiations.

Great breakdown of license terms
I found this book to be extremely useful when working on vedor agreements.The author breaks down the license agreement and providesreasoning on why certain terms should be changed as well as proposed language that is suitable.this book is a great tool when you find yourself on the procurement side of the fence.

Book very informative- don't buy the digital version if you want to print
This book does have a lot of great information in it both for an experienced software contract negotiator as well as a new software contract negotiator.The sections are easy to find so you don't need to read the entire book to find the information you need, for example information on software infringement. However, even though I read from the print reviews that the type is small and not easy to read, I do recommend you NOT order the digital version.You have to download special Adobe software to read it (not just Adobe reader which most people have anyway) and it will not allow you to print more that 5 pages EVER.So if you are like me and want to have a hard copy of a page to compare to a contract you are negotiating, you are out of luck.So content I would give a 4, but usability, a zero.

Not alot you don't know but good food for thought
If you've been around software much you won't really learn alot of new facts or specific details of legal terminology but Overly does have some good suggestions for how to conduct negotation over specific contract areas - indeminification, support, adding additional users - that were very valuable.

For large firm buyers Overly has some interesting ideas about standardizing the contract process and developing enterprise-wide "best practices" for writing re-useable software agreements. ... Read more

Product Description
Recipient of the 1997 Jolt Award.

The developer of the acclaimed Eiffel programminglanguage comes through with one of the clearest and most informativebooks about computers ever committed to paper. Object-OrientedSoftware Construction is the gospel of object-oriented technology andit deserves to be spread everywhere. Meyer opens with coverage of theneed for an object-oriented approach to software development, citingimproved quality and development speed as key advantages of theapproach. He then explains all the key criteria that define an object-oriented approach to a problem. Meyer pays attention to techniques,such as classes, objects, memory management, and more, returning toeach technique and polishing his readers' knowledge of it as heexplains how to employ it "well." In a section on advanced topics,Meyer explores interesting and relevant topics, such as persistentobjects stored in a database. He also offers a sort of "Do and Don't"section in which he enumerates common mistakes and ways to avoidthem. Management information isn't the main point of Object-OrientedSoftware Construction, but you'll find some in its pages. Meyerconcludes his tour de force with comparisons of all the keyobject-oriented languages, including Java. He also covers thepotential of simulating object technology in non-object-orientedlanguages, such as Pascal and Fortran. The companion CD-ROM includesthe full text of this book in hypertext form, as well as some toolsfor designing object-oriented systems. If you program computers, youneed to read this book.Amazon.com Review
The developer of the acclaimed Eiffel programming languagecomes through with one of the clearest and most informative booksabout computers ever committed to paper. Object-Oriented SoftwareConstruction is the gospel of object-oriented technology and itdeserves to be spread everywhere. Meyer opens with coverage of theneed for an object-oriented approach to software development, citingimproved quality and development speed as key advantages of theapproach. He then explains all the key criteria that define an object-oriented approach to a problem. Meyer pays attention to techniques,such as classes, objects, memory management, and more, returning toeach technique and polishing his readers' knowledge of it as heexplains how to employ it "well." In a section on advancedtopics, Meyer explores interesting and relevant topics, such aspersistent objects stored in a database. He also offers a sort of"Do and Don't" section in which he enumerates commonmistakes and ways to avoid them. Management information isn't the mainpoint of Object-Oriented Software Construction, but you'll findsome in its pages. Meyer concludes his tour de force with comparisonsof all the key object-oriented languages, including Java. He alsocovers the potential of simulating object technology innon-object-oriented languages, such as Pascal and Fortran. Thecompanion CD-ROM includes the full text of this book in hypertextform, as well as some tools for designing object-oriented systems. Ifyou program computers, you need to read this book. ... Read more

Customer Reviews (46)

The source
Single best book on software development I have read. Keep coming back, it repays study.

Classical book, but obsoleted.
The author is famous in OO and the book is recommended from another book,however, the programming language used in the book is no longer used in the market.

Should be titled: "Object Oriented Programming in Eiffel"
After reading the first couple of hundred pages, I felt something was not right. The notation the author used to explain his OO theories seemed like I was actually being forced to learn a computer language syntax. Before buying, I remember reading through some of the Amazon reviews that mentioned this book was an advertisement for Bertrand Meyer's Eiffel language. So I got online to find some Eiffel syntax and programming examples. Sure enough, Meyer's had me secretly learning his OO language, Eiffel!

The first big clue comes in Chapter 36. Meyer's writes, "the language is the notation that we have devised in part C and applied throughout the book." The Epilogue is the epiphany moment. It's entitled, "Epilogue, In Full Frankness Exposing the Language." In the last paragraph he thanks the reader for "patiently" following along, unveiling that the "anonymous language" used throughout the book is actually Eiffel! He concludes, "welcome to the world of Eiffel." BTW, this is on page 1,163!

I give it 2 stars because 4 of the 36 chapters (~120 pages) are actually worth reading and have very little cruft. These chapters are included in Part B, "The Road To Object Orientation." They cover some very key OO topics, such as modularity, reusability, decomposition, genericity, and abstract data types (ADT). I especially liked the contrast of functional and object-based decomposition in chapter 5. Meyer's argument really gives you a sense of the power of OO languages in application development environments compared to functional or structured languages, such as C or Ada.

However, I bought the book believing it was a language independent study of OO methods. I made this assumption from the title, table of contents, and the book's back cover description. I feel very cheated and would not recommend this book to anybody who is looking for an in-depth read of OO analysis, design or programming. It wastes time introducing the "anonymous" Eiffel syntax, evolution, and implementation when the reader doesn't quite understand the big secret yet.

The better book you can get about OO
There's no way someone can get to know about objects without reading meyer's book. It's huge but worth

highly recommended as a first introduction to OOP
When writing a treatise on computer programming one has to strike a balance between providing a book that is both useful (which usually means writing within the context of a compilable programming language), but general enough so as not to oversimplify or truncate parts of the theory because it is not represented by the chosen language. In OOSC2 Meyer does just this, by providing a sound and general introduction to object-oriented programming, while using the Eiffel language for purposes of notation and practical programming examples.

Meyer has a very engaging writing style: very clear, with lots of good (and humorous : ) examples. And the Eiffel language itself seems quite simple, readable (it was obviously influenced by ADA) and brilliantly designed (think of Java, but with multiple inheritance, generics, and without the run-time inefficiency of the java virtual machine).
But whether you program in Eiffel, Java, C#, or C++, OOPSC2 has alot to offer in terms of OO software design, and a good understanding of the issues behind inheritance, polymorphism, the importance of static typing, and dynamic binding.

For example, I program in C++, and this book has helped me clearly understand the object-oriented features of the language, because in clearly explaining the principles, it helped me understand the intentions of the C++ language designers.

May be my only complaint, at perhaps half a star, is the fact that Meyer often weighs in heavily against other languages for their shortcomings, while going easy on his own Eiffel language. For example, he failed to give an objective analysis regarding the run-time costs of garbage collection. Indeed, the chapter on garbage collection seemed more of handwaving defense of the fact that Eiffel uses this technology. A presentation of run-time empirical studies for various applications would have been much more welcomed. However I believe that the benefits of this book far outweigh the occasional partisanship shown towards Eiffel. I truely believe that Meyer favors Eiffel because he believes in it more on the basis of principle than on profit (he does own a software company that supports Eiffel development tools). ... Read more

Customer Reviews (4)

Medisoft version 14
The software - Medisoftv14 arrived quickly, packaged safely and in brand new condition. I had no trouble at all with installation and it is working great. Thanks!

great delivery time, but product was not as advertised
I was thrilled to receive the textbook in plenty of time to use for class, but imagine my dismay when I realized that the textbook was missing more than 20 pages. Unfortunately they are ones directly relating to assignments, so this leaves me having to purchase another. I do not remember the description including that there were pages missing as the rating was very good, and only containing some writing.

Hard to install with Vista
This software is great if you found a book online that did not also have the accompanying software. If you have Windows Vista be prepared to spend a few hours with tech support. It took me 5 hours and 4 attempts to get this software installed on my Vista computer.

Medisoft Software
Make sure you select the advanced installation for this software when you first install it or it will mess you up when you get so far in your class my laptop cd drive quit working and I couldn't reinstall it so I got to chapter 8 in my book and couldn't finish my class and failed the class for the semester and had to retake the class again but other than that the software is good and at a cheap price. ... Read more

Product Description
“This book fills a huge gap in our knowledge of software testing. It does an excellent job describing how test automation differs from other test activities, and clearly lays out what kind of skills and knowledge are needed to automate tests. The book is essential reading for students of testing and a bible for practitioners.”
—Jeff Offutt, Professor of Software Engineering, George Mason University

“This new book naturally expands upon its predecessor, Automated Software Testing, and is the perfect reference for software practitioners applying automated software testing to their development efforts. Mandatory reading for software testing professionals!”
—Jeff Rashka, PMP, Coauthor of Automated Software Testing and Quality Web Systems

Testing accounts for an increasingly large percentage of the time and cost of new software development. Using automated software testing (AST), developers and software testers can optimize the software testing lifecycle and thus reduce cost. As technologies and development grow increasingly complex, AST becomes even more indispensable.  This book builds on some of the proven practices and the automated testing lifecycle methodology (ATLM) described in Automated Software Testing and provides a renewed practical, start-to-finish guide to implementing AST successfully.

In Implementing Automated Software Testing, three leading experts explain AST in detail, systematically reviewing its components, capabilities, and limitations. Drawing on their experience deploying AST in both defense and commercial industry, they walk you through the entire implementation process—identifying best practices, crucial success factors, and key pitfalls along with solutions for avoiding them. You will learn how to:

•     Make a realistic business case for AST, and use it to drive your initiative
•     Clarify your testing requirements and develop an automation strategy that reflects them
•     Build efficient test environments and choose the right automation tools and techniques for your environment
•     Use proven metrics to continuously track your progress and adjust accordingly

Customer Reviews (11)

Good Introduction For Those New To Automated Testing
My professional background had been as a Software Engineer and Manager in application development; however, I recently became the Manager for my company's automation and performance testing team.I wanted to get a good overview of implementing automated testing, and this looked like the best of the books available for my purpose.I considered the author's previous book Automated Software Testing, but it was written in 1999.I wanted something that would talk about more current tools available so this 2009 offering seemed to better suit my needs.

Like most technology books, this book is written in a very organized manner.The first four chapters are a good overview of the what and why of automated testing along with information about developing a business case and common myths.The section on the business case is fairly involved on how to compute ROI for automated testing.You may be able to get by with something simpler than this, but it's a good starting point.The remaining six chapters give more details for executing an automated software testing effort from requirements and tools to processes and staffing guidelines.I found the chapters on automated software testing process and staffing guidelines the most helpful.The process recommendations are lightweight, but I agree with the authors that testing automation *is* software development.

The authors write from a perspective of a defense contractor, and this is important to understand.In this environment projects are typically standalone and large in nature, but this will not be the case for all readers.I work in the IT department of a for profit company, and my automated software testing team operates in a shared service model to support the highest priority projects.Whereas a defense contractor typically buys hardware, software, tools, etc. for each program as a part of their bid, my team uses a consistent development stack and reuses a consistent hardware environment.We may add tools or hardware as new situations come up, but things are fairly stable overall.We also have different titles, roles, and responsibilities than those defined in chapter 10.These differences don't change the applicability of the concepts, but it does require me to translate the application from the defense contractor mindset.

The appendices give additional checklists and some detailed information on tools in the marketplace.The tool information will become dated soon, but it's probably good for another year or so.The authors also give a lot of links to web sites throughout the book, and I like it when readers are pointed to additional information for continued learning.

Overall, I couldn't ask for a lot more given what I was looking for.I am now in a better position to work with the experience people on my team and be confident in my ability to understand the key issues and considerations.Those looking for more hands on information may be left wanting.There are not a lot in the way of examples, but this is difficult to do without slanting the book toward specific tools.I think that the authors assume a certain level of experience for the software developers who will be doing the actual implementation, and they assume that they can translate the concepts into code.Please feel free to ask questions in the comments section if there is an area that I have not addressed.

Overall:B

A Wealth of Information for Big-Project Test Teams
Implementing Automated Software Testing is a systematic examination of the why and how of large scale automation of big, complex systems.

While the back cover says "Whether you're a test professional, QA spec ialist, project manager, or developer, this book can help you bring unprecendented efficiency to testing - and then use AST to improve your entire developement lifecycle", I'm not sure this book is for everyone.

New QAers or testers, those involved with testing smaller-scale systems, or those involved in projects with smaller budgets and shorter timelines might find the book's recommendations overwhelming.It seems clear to me that this book is best for those who are charged with determining a test automation approach for very large scale, long-term systems, with large budgets, such as those used by the Department of Defense and larger commercial efforts.

From the Preface:

"We at IDT have identified a boilerplate solution, strategies, and idea, all provided in this book, that can help increase the chances of your automated testing success."

I agree.All of the authors and all of the contributing authors are IDT employees.This is IDT's boilerplate solution.As with all boilerplate solutions, it may not fit your specific situation.

If it does, you will find a wealth of information.And even if it doesn't you can still find useful nuggets of information about how some of these "big-project" teams automate their tests.For example, I particularly liked Chapter 4 - Why Automated Software Testing Fails and Pitfalls to Avoid.I believe this chapter would be useful for anyone about to embark on a test automation project.

Great reference tool. You benefit from other's experience.
(Full disclosure: I got this book for review at no cost for me)

"Implementing Automated Software Testing" walks the reader through the each of the phases necessary for going from a manual testing environment to an automated one. The book is written mostly in general terms, making it useful for most environments, regardless of the type of applications being tested.

The book reads like a compilation of tips accumulated over the course of years of experience by the authors. It can almost be described as vaccination: If you don't read the book you might not make all the mistakes it tries to prevent, but if you do read it, you'll instinctively know how to make good decisions and what to do next.

Content is organized in a very logical manner. It starts defining why AST is beneficial and how to introduce it to the current environment, including presenting the business case. From there it goes to the main subject, implementation, followed by results measurement, and personnel roles in the project.

Overall, the book is very well written. Points are made quickly and in simple terms. The page layout and fonts make the book easy to read.

The book is a very valuable tool for managers and team leads of software QA. If read before starting an AST project, it will save the reader from many of the common mistakes made by many.

IAST Is Hot!
Wanna know what's hot in test automation? Just do a Google search on the term "Implementing Automated Software Testing" (IAST), and you'll find out quickly. With approximately 3 million search results, this is clearly a very popular term, but not only that, it is now the title of a new book written by Elfriede Dustin, Thom Garrett and Bernie Gauf. We at the Automated Testing Institute aren't sure if the title is coincidently identical to one of the most popular test automation terms, or if it was a genius marketing ploy to get more attention drawn to the book; whatever the reason, it is definitely aptly named. This successor to Automated Software Testing (AST) - a 1999 book also coauthored by Dustin, and also a term with approximately 30 million Google search results (wink, wink) - wastes no time in picking up where its predecessor leaves off. AST largely focuses on how test automation may fit into the overall software development and testing lifecycles, IAST lends more of its attention to the test automation effort itself and the details of managing an automated software testing effort.

IAST does an excellent job covering the following Automation Body of Knowledge version 1 (ABOK v1) skill categories (visit [....] for more information on the ABOK):
* Skill Category 1: Automation's Role in the Software Testing Lifecycle (STLC)
* Skill Category 2: Test Automation Types and Interfaces
* Skill Category 3: Automation Tools
* Skill Category 4: Test Automation Framework Design
* Skill Category 5: Automation Framework Design
* Skill Category 12: Automated Test Reporting

This review will therefore describe the book and discuss how these categories are addressed. IAST is divided into three major segments:
* Part I: What Is Automated Software Testing and Why Should We Automate? (Chapters 1 - 4)
* Part II: How to Automate: Top Six Keys for Automation Payoff (Chapters 5 - 10)
* Appendices (Appendix A - D)

Part I does an excellent job addressing Skill Category 1 of the ABOK in that it addresses the `what' and `why' of test automation. Chapter 1 sets the tone of the book with a "unified" definition of test automation; a definition that also works to distinguish test automation from manual software testing. This chapter, along with its reference to Appendix B, also addresses ABOK Skill Category 2 with a discussion of the "typical testing types that lend themselves to automation". Chapters 2 through 4, round out Part 1 of IAST, and continue to further address ABOK Skill Category 1 with topics including: reasons for automating, making the business case for test automation with return on investment (ROI) calculations, and how to avoid typical test automation pitfalls. The latter half of Chapter 4 also addresses ABOK Skill Category 3, by discussing tool evaluation and selection. This discussion is aided by Appendix C which expands into tools and tool requirements not only for automating tests, but also for automation of processes such as requirements management, defect tracking and security testing.

Part II of IAST graduates from the `what' and `why' of test automation and delves into the `how' of test automation. Not `how' in terms of how to develop scripts, but `how' in terms of how to create, implement and monitor an automated test framework; and these are items found in Skill Categories 4, 5 and 12 of the ABOK. Part II of IAST begins with Chapter 5, which discusses how to define requirements for your test automation effort. Chapters 6 and 7 build on this by discussing how to take these requirements and develop a compatible strategy and framework. Chapters 8 and 9 cover the next logical steps of defining metrics to track test automation progress, and the implementation of the automated software test framework processes. Then finally, Chapter 10 closes the main portion of the book with a broad discussion of the skills required for test automation implementation.

In summary, IAST is strong with respect to test automation from a macroscopic level. This makes it a great resource for managers, leads, and anyone that is responsible for or will take part in defining and implementing a test automation effort. [Review originally posted in the August 09 Issue of the Automated Software Testing Magazine - [...]]

A 'must' for professionals involved in QA or project management
Testing accounts for a large percentage of the time and cost of any new software development, and using AST - automated software testing - developers and testers can make the most of testing lifecycles, reducing costs. This comes from three leading experts in AST who explain the process, review its pros and cons, and use their experience in the defense and commercial world to help users make realistic business decisions. A 'must' for professionals involved in QA or project management as well as for software engineers, this is a pick for computer and business collections alike. ... Read more

Product Description

THE most current Software Engineering text in the market– quality trusted coverage, practical case studies, strong lecturer support.

Customer Reviews (9)

Great service
Software Engineering: (Update) (8th Edition)

Received the book within 3 days and the book looks like new.

Wordy.
I was required to purchase this book for a Software Engineering class. This is an incredibly wordy, unnecessarily lengthy textbook. While it is apparent that the author is trying to be witty, it shouldn't take 10 pages to define a term. In the fast-paced world in which we live, this book is unsuitable.

Excellent condition
The book was delivered within the quoted time in the precise condition described.I was very pleased with my order.

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

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

Product Description
No book on software project management has been so influential and so timeless as The Mythical Man-Month. Now 20 years after the publication of his book, Frederick P. Brooks, Jr. (best known as the "father of the IBM System 360") revisits his original ideas and develops new thoughts and advice both for readers familiar with his work and for readers discovering it for the first time.Amazon.com Review
The classic book on the human elements of softwareengineering. Software tools and development environments may havechanged in the 21 years since the first edition of this book, but thepeculiarly nonlinear economies of scale in collaborative work and thenature of individuals and groups has not changed an epsilon.If youwrite code or depend upon those who do, get this book as soon aspossible -- from Amazon.com Books, your library, or anyone else. You(and/or your colleagues) will be forever grateful. Very HighestRecommendation. ... Read more

Customer Reviews (151)

A must read for anyone working on a software development project.
This is a classic collection of essays by Frederick Brooks based mostly on the IBM OS/360 project back in 1975.
The interesting and surprising fact is that although the technology has improved tremendously for the last two decades, most elements & challenges we face in Software development projects today are nothing different to what it was 20yrs before. Example: throwing more people to a late/troubled project making it delay further. This is the core concept he highlights throughout the book; men and months are not interchangeable.

Certain chapters are somewhat outdated especially in the scenarios where he talkes about software development in '70s with low level programming languages, assemblers, punch cards etc. However, the views, the concepts and the lessons are still valid for today's projects. The extra burden on reading definitely offset the value you get and the lessons learn after reading this book. Thus makes it a good investment

A good, undying, informative, inspiring and enjoyable read!
I learned by my own mistakes the meaning of the expression, "You can pay me now or pay me later." There are few or sometimes no short-cuts in software or hardware development or engineering, or electronics in general. Fred Brooks, best known as the "father of the IBM System 360," and after 30 years still holds the title of the most influential book on software project management, likened it to pregnancy. He said you can add all the women you want "to the project" and still, it will take nine months! That's why, in managing software development projects, I learned to spend ample time with the software developers beforehand. Otherwise, I would inevitably spend the time with them afterwards. I was the one knowing the design. I had the "big picture" that needed to be communicated to them.

In his book, Brooks described the foibles of the early design teams and programming at IBM. From his own mistakes, he came up with snappy principles like "If you don't have time to do it right the first time, when will you find time to do it over?" He also coined what became known as the "Second-System Approach," which basically said "by the time you finish developing a system, you know what you should have done"--therefore, throw it away and start from scratch again. He identified the corruptible optimism of good intentions that truly but erroneously believed, for most of the project, that the work was 90% done or that debugging was 99% done most of the time. He insisted, "Ask whenever there's a doubt. NEVER assume anything."

This book is filled with timeless development advice by a master from a previous age. The advice, however, is as valuable now as it was then.

A good, undying, informative, inspiring and enjoyable read!

While I may take heat for this but...
I have to admit, I did feel as I was reading that the text was a bit outdated and while I agree to many of the topics in the book there were also a lot of times I found myself thinking about some of the problems he had presented in the book as not being as applicable anymore.Perhaps its the semi-dated stories, the book (or at the least the second edition I had read) is already 15 years old.While I do feel I got some good information out of it, it would not be in the "if I you only could read one programming book this year" conversation.

Not that useful - pretty out-dated
This book is supposed to be a classic about software project management, maybe because it was the first to actually cover the topic and offer advice and solutions back in the 70s. Even though most principles still apply, the arguments have aged rather badly and do not translate very well in nowadays environment. I have the feeling I haven't learnt anything that I didn't already know, which is somehow frustrating.

Mythical Man-Month - a period piece
Fred Brooks discusses his experiences as a project leader in the 1960s.In the process he promulgates many lessons which he has learned.Some of these are merely opinions, but others are world-class propositions which IT professionals should pay attention to. ... Read more

Product Description
For more than a decade, Steve McConnell, one of the premier authors and voices in the software community, has helped change the way developers write code--and produce better software. Now his classic book, CODE COMPLETE, has been fully updated and revised with best practices in the art and science of constructing software. Whether you're a new developer seeking a sound introduction to the practice of software development or a veteran exploring strategic new approaches to problem solving, you'll find a wealth of practical suggestions and methods for strengthening your skills. Topics include design, applying good techniques to construction, eliminating errors, planning, managing construction activities, and relating personal character to superior software. This new edition features fully updated information on programming techniques, including the emergence of Web-style programming, and integrated coverage of object-oriented design. You'll also find new code examples--both good and bad--in C++, Microsoft(r) Visual Basic(r), C#, and Java, though the focus is squarely on techniques and practices. ... Read more

Customer Reviews (124)

Great Book
Well, I haven't finished reading the book, but I'll update this review later. I'm a college student on 3rd year. I've done a few freelance jobs, some went well others not that much. While reading this book, I remembered all my good jobs as well as my bad ones. Probably that's why I love this book so much I've pretty much it makes me realize my mistakes, and teaches me how to do it correctly, right now I'm doing a personal project in which I'm also applying what I'm reading, so this book has become pretty handy. I don't think is a bible or something like that. But it guides you really well, in a lot of aspects of programming.

Should be required reading
I do feel that this should be required reading for anybody serious about doing software development.If you are a junior programmer or fresh out of college, I don't really care what you know (or think you know) you should read this book cover to cover.If you are a more advanced you can still find some value in it or at least show it to the junior programmers and tell them that you aren't the only person who cares about variable names :)

I just felt this really reminded and enforced the idea that software craftsmanship is worth spending some time on and quality code/coding standards make life easier for everybody.

A must-read for every programmer
The focus of Code Complete is software construction, i.e. the coding part of software development. As Steve McConnell notes in the preface, "construction is the only activity that is guaranteed to be done". You can skip almost any step (requirements, testing etc), but if you don't write any code there is not going to be any software.

I bought my copy of the first edition of Code Complete in 1997, and I was immediately fascinated. I had never read anything like it before - a book that concentrated on the actual writing of the code. For example, it had a whole chapter on if- and case-statements, and another chapter on the naming of variables. I had no idea there was so much to learn about these seemingly straight forward activities. It was immediately useful to me, and I started to apply as much as I could of what I learnt from it.

Although it concentrated on coding, it covered a broad spectrum of activities around coding, from requirements and design to testing, debugging and optimization. It also had a great reference section with suggestions of further reading in the area of software engineering. This became my starting point for finding lots of other good books to read, like Peopleware: Productive Projects and Teams (Second Edition) and Programming Pearls (2nd Edition).

So this summer I decided to re-read this seminal book, partly to see what's new in the second edition, and partly to see if still think it is such a great book.

To answer my own question - yes, it is still the number one book on writing code. It is near encyclopaedic in its coverage of the nuts and bolts of programming. There are chapters on the naming of variables, on organizing straight-line code, on conditionals, on loops, on lay-out, on good commenting and on how to write good methods.

In it, there are frequent references to scientific studies that support the advice given in the book. For example, how long should variable names be? Instead of just giving us his opinion, McConnell summarized the findings of several scientific studies on the subject.

Each time there is reference to a study, there is a little "hard data" symbol in the margin. There are other symbols in the margin as well, "Coding Horror" for code examples of what not to do, and "Key Point" for, well, key points. The margin is also used for cross references to other chapters, and for quotes related to the subject discussed. For me, this works really well. It is both useful and makes the text easier to read. In general, the book is very well laid out.

Some of my favourite advice from the book (all of which I remember from reading the first edition) are:

Chapter 7.1 Valid Reasons to Create a Routine - for example: Reduce complexity, Introduce an intermediate understandable abstraction, and Avoid duplicate code (there are 6 more valid reasons in this chapter). The second part of the chapter is called Operations That Seem Too Simple to Put Into Routines and contains a great example of why it can be good to put even a one-line calculation in a routine - the code becomes more readable, and small operations tend to turn into larger operations.

Page 172 (and 264 for variables) Use opposites precisely. When naming "opposite" methods and variables, be careful to use the correct pairs, like add/remove, begin/end, create/destroy etc. This makes the relationship between them clear and obvious.

Page 433 Break complicated tests into partial tests with new boolean variables. This is such a simple thing, but it makes the code a lot more readable.

Page 754 "Make the incompleteness of a statement obvi". For example, when breaking up a logical and over two lines, end the first line with && - that way, it is clear that the statement continues on the next line.

Even though the book truly is great, there are a few things to complain about. In the first edition, the chapters on layout and comments came right after the chapters on the different control structures. But in the second edition, these two chapters have been moved further back. To me, that doesn't make sense, since they too are related to how you actually write your code. Now there are chapters on testing, debugging, optimization and refactoring in between.

And talking about refactoring: while this is an important subject, I don't feel the chapter on refactoring is particularly good. This chapter is new in the second edition. The summary of refactoring is OK, but a good part of the chapter consists of just listing different kinds of refactorings.

Overall though, the second edition is a nice face lift. The code examples are now mostly in Java, C++ or Visual Basic (in the first edition they were in Pascal, C or Ada). But since all the major themes of the book were already present in the first edition, it does not make a big difference if you happen to read the first edition instead of the second edition.

Code Complete is thick - 862 pages (not counting the bibliography and index). If that feels like a lot to read, then I suggest you start by just reading one or two chapters, for example "Using Conditionals" or "Layout and Style". They (and pretty much any chapter in the book) can easily be read without first reading the preceding chapters, and these will give you a sense of what you can expect from the other chapters. Even if these are all you read, you will still get a lot of value from the book.

However, if you are a programmer and care about how you write code, you owe it to yourself to read the whole book. It is considered by many (including me) to be the best book available on programming, and it will almost certainly make you a better programmer. Highly recommended.

Code Complete: A Practical Handbook of Software Construction
The book was in perfect conditions, it arrived before the dead line they gave me.

Required Reading
I was told this was a classic, must read for every programmer. I found that it is a classic, must-read that no programmer should be without. ... Read more

Product Description
Great Demo! provides sales and presales staff with a method to dramatically increase their success in closing business through substantially improved software demonstrations. It draws upon the experiences of thousands of demonstrations, both delivered and received from vendors and customers. The distinctive “Do the Last Thing First” concept generates a “Wow!” response from customers.

Customer Reviews (15)

Great Demo - Great approach
I work as a technical consultant for a very cool, up-and-coming software company.We have often knocked the socks off customers using the "Great Demo" methodology, but the hardest part is having everyone buy into it. Sales and Tech presales need to qualify and pinpoint pain points and map them to solutions in your product.And both need to work together to "personalize it" to the customer and make sure you're showing exactly what the customer wants to see FIRST.I usually suprise them by using a person or two they would know in my examples,like their CEO, or Director of IT...

When sales and presales work together, and when you have the time to prep your demo,it's VERY impressive.But if Sales just wants to "rush forward" and show show product... that just puts customers to sleep.;)

Make more commission with just 1 change from this book,
This book is profoundly simple yet very powerful. Even a seasoned demo pro will see dramatic results by implementing just one of the recommendations in this book - how much more a rookie! The writing ...
More is quick paced, filled with great anecdotes and quips that make you laugh as you go along. Buy one for you and your manager!

How to serve customers and your business too
Great Demo!: How To Create And Execute Stunning Software Demonstrations The book is simple, but don't let that fool you.In an age where common sense is not so common, Peter Cohan has create a book that is clear, concise and entertaining --nice hat trick-- on how to address what appears to be polar opposites; Helping prospective customers and technical selling of products.

While it appears to be a simple how-to book, weaved within the pages is a simple message we often forget.Solve the customers problems and you have a sale.Peter addressed the process to ensure that a demo addresses customer's needs as opposed to just showing flash.

Peter has made this message deployable for the Sales and Applications Engineers that struggle with trying escape the feature parade demos we've all been tortured with. Bravo!

Wish I'd read this first & saved many wasted hours!!!
As I read Peter Cohan's book I was kicking myself harder on every page. Our company is demo-ing our first virtual tool. Under my guidance we have made every mistake in Peter's book. Now we know how to: more strategically match our capabilities to our clients' needs within the demo process; create a demo flow that will foster dialogue and a deeper understanding of client concerns; and ensure that the demo supports the sales process rather than detracting from it. For those who think they already have the basics down perfectly, this book is a great way to validate and move to the next level. Thank you Peter!!!

Good book, but too long and too cute
Despite stating his preference for substance over style (p. 169) Mr. Cohan lets his style overwhelm the content of his book.Great Demo! contains excellent advice and is very practical in their presentation, particularly for people who are starting in a field role and need a basic road map for their customer encounters.

As far as style, Mr. Cohan's tendency to tell long stories from his experiences in the field ("...I set up my computer, connected to a network connection, and adjusted the LCD projector" p. 146) makes this book too long.Additionally, The Author's tendency to capitalize! Random Nouns and obsessive use of Exclamation Marks! disrupt the flow of reading.Lastly, for a writer that claims that "Humans are visual creatures" (p. 86) the lack of any illustration or charts, except sample customer org charts, is curious.I can think of a graphic model showing the author's proposed methodology and the progress made through it, allowing the reader to visualize their own progress.

In the substance section, the book is a very solid interpretation of solution selling for technical sales engineers.It gives a good methodology for discovery as well as structure for creating demos and presentations that may help capture the audience and create interest and discussion.

I recommend the book to whoever is starting in a technical sales role or feels the need to ramp up their presentation or to those managers interested in closer integration of their sales force and technical field teams.

To Mr. Cohan I recommend hiring a qualified editor for his next book. ... Read more

Product Description
The classic textbook for computer systems analysis and design, Computer Organization and Design, has been thoroughly updated to provide a new focus on the revolutionary change taking place in industry today: the switch from uniprocessor to multicore microprocessors. This new emphasis on parallelism is supported by updates reflecting the newest technologies with examples highlighting the latest processor designs, benchmarking standards, languages and tools. As with previous editions, a MIPS processor is the core used to present the fundamentals of hardware technologies, assembly language, computer arithmetic, pipelining, memory hierarchies and I/O. Along with its increased coverage of parallelism, this new edition offers new content on Flash memory and virtual machines as well as a new and important appendix written by industry experts covering the emergence and importance of the modern GPU (graphics processing unit), the highly parallel, highly multithreaded multiprocessor optimized for visual computing.

Instructors looking for 3rd edition teaching materials should e-mail textbook@elsevier.com.

A new exercise paradigm allows instructors to reconfigure the 600 exercises included in the book to easily generate new exercises and solutions of their own.

A CD provides a toolkit of simulators and compilers along with tutorials for using them as well as additional problems and solutions, and references.Amazon.com Review
This textbook provides a basic introduction to thefundamentals of current computer designs. As the title suggests, thetext skirts the border between hardware and software. After anoverview of the subject and a discussion of performance, the booklaunches into technical matter such as instruction sets, how they areconstrained by the underlying processor hardware, the constraints ontheir design, and more. An excellent critique of computer arithmeticmethods leads to a high-level discussion on processor design.Following is a great introduction to pipelining, nice coverage ofmemory issues, and solid attention to peripherals. The book concludeswith a brief discussion of the additional issues inherent inmultiprocessing machines. The extremely lucid description is groundedin real-world examples. Interesting exercises help reinforce thematerial, and each section contains a write-up of the historicalbackground of each idea. Computer Organization and Design isaccessible to the beginner, but also offers plenty of valuableknowledge for experienced engineers. ... Read more

Customer Reviews (65)

Better than expected
I bought this book used and I was very surprised at how well kept it was. I saved about $40 by buying it here as apposed to the school Bookstore.

The best book I have used in computer engineering at UCLA
I'm a fourth year UCLA student studying computer engineering, and by far this has been my favorite text. It appeals both to the programmer and circuits guy in me, as well as the DIYer hardware enthusiast. It covers much of the essential computer architecture theory, but also is well supplemented with real world examples. It emphasizes design tradeoffs that real computer architects must solve. The only thing I don't like about it is the omission of some content from the hard text, but those items are provided via CD.

Could be better.
I've only made it through the first chapter, but there has already been answer-changing typos in the homework problems, and there have been several places where units in equations are either not defined or ambiguous and other similar problems.

Masterpiece
I did not buy this book from Amazon portal because of the fact that Elsevier sells low priced editions in my country.

This book is a masterpiece. Every budding CPU hobbyist or enthusiast must own this book. Everything that you needed to know to build a microcomputer on your known can be learnt from this book. By the way, I have the 4th edition of the book which focusses on another modern marvel - ARM. The pipelines, datapaths, control paths, hazards etc are explained with intuitive visuals. This book would have changed my life if I had it 14 years ago. But with teachers like Dave Patterson and John Hennessy, it can never be too late.

I highly recommend this book for undergraduate and advanced courses on the topic.

Awesomeness
The product came as described in the description. I also received it quick and had it for use in class within a few days. I would definitely make another purchase with this seller in the future. ... Read more

Product Description
This comprehensive guide helps developers, testers and product designers write internationally-compliant, global code that is Microsoft Logo Certifiable for Windows 2000 and Windows XP. The handbook teaches users how to localize Windows-based applications more easily and less expensively, determine important culture-specific issues, avoid international information pitfalls and legal issues, and much more. It covers all of the essentials for developing international software-and it's delivered by the collective experience of the Windows International group. ... Read more

Customer Reviews (2)

Oldie but Goodie
Even though this book is a bit dated, it still contains important information that I've found nowhere else.

This book will be very helpful...
If you are developer or tester who is doing the work related to I18N and L10N, this book will be very helpful for you. ... Read more

Product Description

Effectively forecast, manage, and control software across the entire project lifecycle

Accurately size, estimate, and administer software projects with real-world guidance from an industry expert. Fully updated to cover the latest tools and techniques, Applied Software Measurement, Third Edition details how to deploy a cost-effective and pragmatic analysis strategy. You will learn how to use function points and baselines, implement benchmarks and tracking systems, and perform efficiency tests. Full coverage of the latest regulations, metrics, and standards is included.

• Measure performance at the requirements, coding, testing, and installation phases
• Set function points for efficiency, cost, market share, and customer satisfaction
• Analyze quality and productivity using assessments, benchmarks, and baselines
• Design and manage project cost, defect, and quality tracking systems
• Use object-oriented, reusable component, Agile, CMM, and XP methods
• Assess defect removal efficiency using unit tests and multistage test suites

Customer Reviews (2)

The definitive source (again!)
I've been following Capers work for more than 20 years and he has once again done a great service for the software industry. Applied Software Measurement is both comprehensive, candid, and realistic. I've made extensive use of Capers data in my new book, "Managing the Black Hole: The Executive's Guide to Software Project Risk"
ISBN-13:978-1-935602-01-9(available mid-March).

If you own just one book on software metrics . . .
Caper's Thrid Edition of Applied Software Measurement continues the tradition of being indispensable reference materials for the software process improvement professional.I own two copies, one for my suitcase when I travel and one for the office (no kidding). ... Read more