Programming Books

Kent Tong Ka Iok's book contains far more code than commentary, and I'm learning, really learning, some of these skills now in a way that never came through in all of the dozen or so books on agile techniques that I've read before.

Oh, I'd occasionally like a little more commentary than he delivers, and I'd sure like a good editor to work it over and clean up the prose, but the examples are first-rate, non-toy examples, and the chapter exercises are making me think in whole new ways about writing my own code. I'd love to see lots more examples and exercises in some of the chapters, especially the code smells chapter (where he only covers a few of the smells from Martin Fowler's list in Refactoring). I've also found a few errata that I haven't been able to report because of problems on Kent's site (www.agileskills.org) - but I've emailed him about that.

I don't want to pull punches here, which is why I've mentioned several negatives about the book. But those are nothing compared to the book's qualities. This is one of those great, really valuable books, like Fowler's Refactoring and Freeman & Freeman's Head First Design Patterns. You can find out how great without spending a penny: download the chapters from Kent's site (but note that they won't print, and you can't copy the text, which is why I eagerly came to Amazon and bought the hard copy, which I'm avidly annotating as I work through the examples and exercises). Get this book!

Kent is really doing a good job on writing this book that focus on OO problems and solutions by using examples without using too much boring theory words.

The idea of pointing out "code smell" in source code described in this book really helps programmers know when they should do something OO to keep code fit.

I highly recommended people should read this book first before reading any OO design pattern books. Once you understand the OO basic and concept, later you will figure out "Oh, that example in this book is using strategy pattern!, oh that code is using visitor pattern!" I am sure after you read this book, you will believe how amazing that this book can help you and me!

Kent, a programming genius in Macao, has been actively promoting XP for serveral years. This is a good book coming from the course material of the XP course in CPTTM. I was ever a newbie of XP, however, with this book, I merge my mind with a newer, more powerful, more effective devopment methodology.

Automate Testing and Test Driven is the kernel of XP. Readers are able to learn a more effective way of how to write tests, especially acceptance tests.

Not only does Kent introduce new skills of testing, but also introduce important skills of OO programming. Once and Once Only, IOC principle,etc, newbies of OO can learn essential skills from this book under Kent's simple explaination.

Kent is my teacher of OO. Without him, I was still struggling at the dark age of the Procedure Oriented programming.

If you are a newbie of OO or stranger of XP, don't doubt, read this book immediately. You will soon realize that the sky of OO and XP 's world is Free !

This is a book for software developers interested in gaining the right skills for agile development.

This book has an elegant yet highly effective minimalist style. Rather than long theoretical discussion (of the type I'm sometimes guilty of writing) the book does what it does by example - and there's plenty of example code given.

For example, in chapter 2 - turning comments into code - Kent examines some typical code (I've seen enough like it) littered with comments that are apparently intended to make life easier. Step by step he takes us through removing the comments and expanding variable and method names to show the intent of the code - along the way pointing out useful refactorings to improve the overall code structure and make clearer what's going on. It's a convincing description and easily applied.

Overall the book covers many topics and issues related to agile software development, including: keeping code fit; handling inappropriate references; seperating database, UI and domain logic; unit testing and acceptance testing amongst others.

The thing I really like about this book, and the reason I would recommend it to developers, is that even if you're not doing full on "agile" development, there's still plenty of useful material in it. The lack of hype is also refreshing - the book focuses on examples and shows good solutions. You should get it!

Books give idia opn core technology on exchange. I am happy that this book will not for paper passing orientation

Books give idia opn core technology on exchange. I am happy that this book will not for paper passing orientation

I am a Microsoft Certified Trainer and had the pleasure of sitting in on one of the authors presentaions. I expect the technical content of the book will be first rate. This should also be an easy read if half of her sense of humor translates well into print.

I am looking forward to the release of the book.

I wish this author would put pen to paper again - this book was a joy to read; succinct, apposite and conversational in tone. Brilliant!

This book is best ever! You can learn IL, but you can undarstand MSIL, how aplications are build.

Wonderful experience writing an IL code generator. Project went quickly, easily, with high quality result. Thanks to Microsoft's .Net and IL ecosystem, and three books; Expert .Net IL Assembler (Serge Lidin), Common Language Infrastructure Annotated Standard (James S. Miller), ECMA-335 CLI Standard (downloadable from ECMA).

I needed a good "go-to" reference which would aid me in quickly gaining knowledge so I could understand disassembled PE files related to a "small" project I had already invested 40 man-hours. There are references you can find on the web, however, this book will save you time looking for them. It consolidates all information you need to quickly get up to speed if you have not been doing assembler code projects for a while. The author's writing style reflects his extensive knowledge and "comfortableness" in discussing it. He includes invaluable references to tools one can use related to the subject he is discussing. The Appendixes contain excellent information that is quickly accessible simply flipping through the pages. I am not a compiler writer by trade, but I had a good laugh related to the author's comments in Chapter 19's Summary (on page 408). You'll just have to purchase the book to find out! I look forward to investing more time in reading this book in detail. If you have to spend money on a tool, this book is money well spent.

This is an excellent treatment of the MSIL topic at just the right level if you're in need of nitty gritty details for debugging, disassembling, or generating IL code. Coverage of the PE format for managed executables is the best I've seen. The text is well-written, the examples are clear and concise, and the diagrams are very helpful. The book can be used as both a tutorial and a reference: the appendices include an ILAsm grammar reference, a metadata tables reference, and an IL instruction set reference. The book is also available electronically to owners of the physical book.

After reading "Exploring the Year 2000," I was able to follow all of the current reports in the press, magazines, and on the Internet, because the author defines the computer terms relating to Y2K, explains who all the major players are in this phenomenon, and gives details about the congressional committees and industry organizations that are monitoring Y2K progress worldwide.

I have been worried about my obligations as a landlord (for example, I still don't have assurances from the utility companies that there will be no disruptions of services to my tenants). I also have investments, and I don't know if the value of my stock is going to be affected by Y2K. Ms. Vannelli's book has helped me understand what recourse is available for me. Also, the author has been great about responding to my questions about such issues.

I have been worried about my obligations as a landlord (for example, I still don't have assurances from the utility companies that there will be no disruptions of services to my tenants). I also have investments, and I don't know if the value of my stock is going to be affected by Y2K. Ms. Vannelli's book has helped me understand what recourse is available for me. Also, the author has been great about responding to my questions about such issues.

"Exploring the Year 2000: A Comprehensive Layman's Guide," is the only Y2K resource book on the market that covers the entire field of this subject matter (including legal rights you should know about should your life be affected by Y2K disruptions, and a detailed family Y2K preparedness plan). Because the book is written in a simple and lively style, anyone, including those who are computer illiterate, can understand the the details of the problem (how it arose, how it is fixed, how to prepare for disruptions). The author, an Ohio attorney, has followed all of the Senate and House hearings on Y2K since they began, and monitors the federal regulatory reportings. Use the toll free number at the front of the book to get current updates through the end of 1999.

If you have ever thought of a feature request for Flash then this book is for you. It teaches you how to make your own! Flash MX 2004 is in the title but it's just as useful for Flash 8. This book is worth the price just for the JSFL reference alone.

This book has gone under the radar based upon its title. It truly does not explain what this book can teach you.

Basically it teaches the basic Flash user that you can extend what Flash normally does for you in its normal authoring environment. Like create new drawing tools, create commands that perform complex real-time tasks instantly (similiar to custom macros), create custom user interfaces, add timeline effects (scripted tweens) to any object, and create scripted behaviors (prebuilt code components) to help almost automate your Flash development.

If your an exisiting Flash developer who knows how code with ActionScript and needs a way to streamline your development environment and development time, this is a book you shouldn't pass up.

If you are an advanced Flash user, Extending Flash MX 2004 may be just the right book for you. Written by veteran Flash developers Keith Peters (bit-101) and Todd Yard (ego7), this book introduces you to the world of extending Flash MX 2004 by teaching you how to create custom functions and features for the Flash MX 2004 authoring environment.

At first I had never heard about 'Extending' Flash MX 2004, but hopefully my following explanation may help you to understand this concept if you are new to this term. Imagine Flash MX 2004 being a customizable browser such as Firefox. In Firefox, you can download snippets of programs called extensions that add some cool, extra features to your browser. Creating new extensions for Flash MX 2004 is similar to developing extensions for your browser. Using a new language called JavaScript Flash (JSFL), you have the ability to create scripts, commands, behaviors, etc. that add new functionality to not a Flash animation, but to your actual Flash MX 2004 application itself.

This book teaches you how to use JavaScript Flash to create extensions - custom commands, menu items, and others things to help make repetitive tasks easier and enhance your Flash MX 2004 program. You start with the basics and progress towards complicated techniques. Early on you start by creating a command that, for example, allows you to take any shape and automatically arrange them on a user-defined grid. Towards the end, you move beyond simple commands and learn how to modify Behaviors, create custom interfaces using XML, and more!

Another great feature of this book is the expansive JavaScript Flash (JSFL) reference. The JSFL reference section contains all of the various items of the JSFL language that you can refer to when creating your own JSFL extensions. For any JSFL code item or property, you will find a description, the types of values it accepts, and a code example.

If you use Flash MX 2004 extensively and are interested in automating some of the repetitive tasks or adding new, useful features to Flash, you will find this book's coverage of this new topic excellent for intermediate and advanced users.

Keith and Todd command a huge knowledge of one of the more interesting and productive new features of Flash MX 2004, extensibility. The authors guide you on your way to learning about these new features starting off with easy concepts and then moving into more specific areas. This book is essential for anyone who develops with Flash MX 2004, the skills and tools that you get from the book will streamline your work flow and improve your productivity. From JSFL commands, xml to UI, custom behaviors and custom tools this book will load your Flash IDE with tools and widgets to get the job done faster and smoother. Excellent book!

Good layman's level overview of the technical problems with critical control via software and a discusssion of how industry and individual experts are trying to deal with the problem

Henry Petroski has written several books that explore his dictum, "Form follows failure." His thesis is that improvements in engineering are made to overcome the failures of previous design. Petroski's books cover advances in civil and mechanical engineering. Ivars Petersen has written a similar book covering some of the notorious failures in software engineering and the efforts by a few leading engineers to define practices and design methods that can prevent such failures from recurring.

Fatal Defect describes dozens of software failures, how they happened, and the efforts to correct them. The defects occur in banking systems, stock exchange mechanisms, aircraft and spacecraft guidance computers, medical equipment, telecommuncations, and scientific computation. Some of these failures are famous; others are little known. Regardless, the descriptions always provide the kind of technical detail that you need to really appreciate the situation. Petersen is a journalist for science news and is clearly a professional when it comes to describing technical issues for the intelligent layman.

Moreover, he tells the stories of people who found the errors, lead the efforts to correct them, or who tried to raise the standards of the industry. Nancy Leveson investigated the Therac-25 defect that lead to several deaths in 1986. This influenced her efforts to design software safety standards. Learning from failures requires knowing about them. But the details of many failures are often kept quiet, being marked proprietary or secret to avoid embarrassment or litigation. Peter Neumann tried to open up the discussion of computer failures with RISKS digest. He started it in 1985 but even today it remains one the best places to learn about the technical details behind dangerous system failures. David Parnas took the lead in criticizing the Star Wars strategic defense initiative. He noted that there would inevitably be defects in the software and that there was no way to conduct a comprehensive system test, short of a nuclear war. He then moved on to overseeing the engineering processes at the Darlington nuclear plant, ensuring that the software was correct, even though this delayed the project completion by three years. Vic Basili was one of the first to conduct controlled experiments with programming teams to determine which development methods actually produced the most reliable software. For example, in 1982, he established that code reviews were far more effective than functional testing, a result that is only beginning to be regularly applied to engineering practice today. These results lead he and Harlan Mills to develop the Cleanroom process which Mills taught at NASA and IBM.

Petersen tells the stories of these and other engineers, describing their background and how their careers lead them on the paths that they ended up. I'd been familiar with the ideas of many of these people, but i found it very interesting to learn of the experiences that had lead them to formulate and articulate these ideas.

The issue of what constitutes effective means for developing reliable software is becoming more than just a practical matter with recent events. Earlier this year the Texas board of professional engineers started licensing software engineers and the Institute for Electrical and Electronics Engineers plans to start certifying software engineers in 2000. Licensing means more than just professionalism and status. It also means acknowledging accepted practice and deviating from it at the risk of malpractice. If the licensing process is done well, it will base itself on the fine, but tentative work done by the people described in this book. If it is done poorly, it may merely enshrine the latest fad in law.

Ivars Peterson has written a well thought-out and interesting book that provides just the right amount of depth to this fascinating subject. Both the layman and the software engineer will find Fatal Defect interesting reading.

This book should be required reading for everybody in the IT industry!

From the subtitle, "Chasing Killer Computer Bugs," you would think that this would be a book about software testing. It isn't. Rather, it's a book about things going wrong with software. The author tells readable stories about some infamous software bugs, at least one of which I've never been able to forget. This is the story of the Therac-25 radiation therapy machine, which caused deaths and injuries due to a software problem. Some of these stories have morals which software professionals would do well to keep in mind--and not just developers, but the people who give them their marching orders. For instance, the Therac-25 story makes clear in a very sobering way how an apparently VERY minor change to a program can have VERY unanticipated consequences. The A320 story makes a convincing case for thinking hard about user interface design.

Other parts of the book talk about why building good software can be so hard, and about some of the people and organizations that work towards developing approaches to issues in software quality and construction. You wouldn't think that these would be particularly interesting subjects, but for the most part the author makes them come alive.

This is not a technical book--don't expect to come away from it with any new debugging techniques. Rather, expect it to give you lots of food for thought.

This book is the text book of my cs education of file organization. And i can comfortably say that it gives much insight not just on file organization but also on algorithms. I haven't read all the chapters but among the chapters i read, without any exaggeration i can say that i've learnt every word of what the author wants teach.

This book is one of the few gems in computer science. It is written intelligently. One can read it fluently. It is about a reasonably important subject. The book is well crafted (hardcover, layout...). In short reading it makes you happy and smart.

The only disadvantage of it: there is no sample code. Desperate people might want to check on Folk, Zeollick, Riccardi "File Structures".

I've got a whole bookshelf of algorithms books, and this is by far the best book on file organization in my collection. Tharp was one of the best professors I ever had, and it was a pleasure to work from his excellent (and unfortunately hard to find) book. If I had to own a single book on this topic, well, here it is.

It's ~old book (1988), but it still very actual now, and will be actual in future. This book contain only principles and algorithms, but it all showed so deep and clear, so I was very impressed then read it first time. B-tree type structures description is best I ever seen. (Need to have this book if You perform serious low-level work on NTFS, BFS or other File System, based on B-trees.). And even if You not work with such File Systems - this book is classic algorithm book and I put it on my bookshelf near Knuth's volumes.

This practical guide deals mostly with software and is directed primarily at professionals but contains much that is accessible and useful to accountants and others who are responsible for Year 2000 software reviews. The book is well organized, most chapters are self contained, and the many check lists are useful guides. The comprehensive coverage of date keeping in PCs and how it affects everyday software is invaluable. This book has earned its place on our Y2K reference shelf.

This is the only book on the Y2K problem that is a "start to finish" guide to help any business identify its year 2000 vulnerabilities and do something about them. Looks at the year 2000 problem from a business perspective, not just a computer perspective. Every business needs this book.

A clear and concise handbook for assessing Year 2000 issues. This book walks the small business owner through the process of analysis, implentation and testing in a straightforward manner. I highly recommend it.

I found this book to be quite helpful in developing Year 2000 strategies for my small business clients, from assessment through remediation and testing. Clearly written, concise, and informational.

I didnt buy this book to learn about flash coding, or web development. I bought this book because I am interested in Software rendered graphics. That is, applications that dont utalize OpenGL or Direct 3D for rendering to the screen. I bought this book for the techniques it discusses in "faking" 3d, and also producing real 3d. So far it has done a perfect job in giving me ideas and techniques that I can use in my applications. For anybody interested in producing anything that is real time, and 3d, I would reccomend this book.

This is the best book I have read in years! If you know the basics of ActionScript and you know sine and cosine, this book opens up whole dimensions of possibilities for both games and business applications of Flash.

It is clearly written and reads more smoothly than most programming books. While it does assume a basic literacy with ActionScript, it does not leave you flailing with complex 3D concepts. You may have to pull out your definitions of sine and cosine, but beyond that, it is pretty light lifting.

The genious of the book is that it violates commmon assumptions, and this results in simple, elegant techniques that are also powerful for a wide range of problems. The common assumption is that Flash doesn't do 3D. Don't believe it anymore. If you are willing to use some basic limitations to your application (such as keeping your polygon count down), you can have some smoothly flowing, useful 3D applications with relatively little effort. And unless I'm mistaken, those applications will run equally well on a browser running on a Mac, Windows or Linux.

The solutions are simple and eclectic. The authors have created a variety of 3D engines - each optimized for a given purpose. The engines are simple enough that (in theory) you can take the source and enhance it to your needs. Each technique is backed up by source code that you can download from the publisher's web site. But don't shortchange yourself with only the sample code - the explanations in the text are worth the cost of the paper book.

Here are my favorite techniques:

* ch 8 (P 195) - Drawing API and Math for 3D - here they explain and provide a working polygon 3D engine. The demos work smoothly (at least 20-30 frames per second) on my cheap Dell laptop. The demos include a oragami bird and a rocket ship with at least 10-20 polgons each. It doesn't support bitmapped textures, but it does offer fill color and shading support.

* ch 9 - 3D Slice Engine - this is the more clever, powerful and non-obvious technique of the book. Check out "dad.swf" in the binary samples from the web site to get an idea of the power of this approach - the author has made a 3D talking head of his father from a photograph! The idea here is that if you can view your 3D world as a topographical map, then you can model it with a set of parallel planes, where each plane represents a certain cut through the entire 3D model. This approach, though not immediately intuitive, is extremely powerful in Flash because it plays on the strenghths of Flash. Each plane is represented by two "movieclip" objects, with one embedded in the other. The first one handles scaling, and the second handles rotation, within the scaled clip. The hidden surface problem is finessed because the planes are parallel - so you only reverse the rendering order once every 180 degrees of change in viewer angle. This enables you to handle full bitmap detail of your scenes, and the result is pretty dazzling! The basic rendering engine requires only about 50 lines of ActionScript!

* Ch 6 - Parallax Scrolling - This name is misleading - it really goes beyond a scrolling 2D game model. In the Wyvern's Claw" example, it explores the idea of building a 3D world like a movie set - with a set of strategically placed flat surfaces (like the fronts of buildings in the studio sets). Each surface is a movieclip, and your script manages the proper scaling and shading as the viewer moves through. The demo then shows an animated walk-through of a small town rendering in such a way. This seems very cool for a potential game.

I'm already using the Chapter 9 slice engine for a work-related project - multidimensional data browsing. So for me, the book was not only stimulating to read but valuable!

TOC:

Chapter 1 Introduction to Flash 3D
Chapter 2 Light and Shadow
Chapter 3 Scaling for 3D
Chapter 4 Isometric 3D
Chapter 5 Focus and Depth of Field
Chapter 6 Parallax Scrolling
Chapter 7 Text Effects in 3D Space
Chapter 8 Drawing API and Math for 3D
Chapter 9 3D Slice Engine
Chapter 10 Departure Lounge: Moving beyond Flash 3D

Chapters 1, 2, 3, 4, 6 and 10 don't require a trigonometry
background. One of Chapter 6 topics uses XML though.

The best chapters for me were 1, 2, 3, 4 and 6.

I gave the book 5 stars because it has something for everyone.
Some people use Flash to create digital art while others use it
for practical purposes. This book delivers to both people.
Unfortunately, I belong to the latter kind and some of the topics
aren't for me.

I also think that some chapters are impractical unless you're
really a math geek. For example, I think Chapter 8 - Drawing
API and Math for 3D -- is unnecessary because you can import
Swift 3D files.

Some of the authors also show you Actionscript without really
explaining what it does (I think they assume you do know trig).
I work for a software engineering firm (not as an engineer
though) but I do know that it's bad practice to embed magic
numbers -- literals that don't have apparent meaning -- in
any code. It's better to put them in constants.

One of the authors (the Chapter 4 author I think) said to get
a good book on trigo. I don't think I will because there are
plenty of free trigo tutorials on the web. I agree though that
to get the most out of Flash and this book, learning trigo is a
must.

This has to be about the best book I have ever seen. The 3D cheats in it are amazing -- and you surely wouldn't know you were cheating. There are some incredibly insightful techniques, and some more staple things if you're not quite steady on your feet yet.

I think I am, but this book showed me how much more there was to know!

This is a really useful book. It's a must if you need to look deep into the Function Point Analysis and get a clear understanding of what this is all about. As a professional and local instructor in Function Point Analysis I've got a lot of inspiration from this book for my course. I believe that beginners would gain even more from this book, however. It covers all topics from the current IFPUG Function Point Counting Practices Manual (release 4.1). It guides you all the way through the whole process and presents a lot of examples and additional explanations on the way.

Beside the operational guidelines this book also describe the Function Point Analysis in the perspective of related topics as e.g. estimation and benchmarking. Those topics are covered very thoroughly as well and the book provides a good insight in how Function Points can be used as a management tool.

In the last chapters "hot issues" as applying Function Points to GUI applications and OO-system development are discussed. Some very useful guidelines are presented here, indeed. But it's my personal experience that mapping OO components to the Function Point concept might be quite more challenging that the book indicates.

Published in 2001, this is a very detailed book on Function Points that follows the guidelines in the 4.1 version of the International Function Point Users Group (IFPUG) standard. Function Point metrics originated in IBM back in the 1970's and spread slowly out to the rest of the world in the late 70's and early 80's. As with anything originating from IBM, it's a process that's heavy on detail and requires a lot of work to get it right. Over the years, FPA has got more and more technical, to the extent that you really need to get certified in it these days (when I first took an FPA course in the early 80's, it wasn't nearly as comprehensive as it is these days, 20 years on..). The authors of this book between them have published a number of articles on the subject and have more than a few years of experience under their respective belts.

The book kicks off with an overview that provides a useful introduction for those "new" to software estimation, although it's still pretty heavy going and it assumes a process-heavy background. If you've worked for a large organization with a comprehensive PMBOK-like methodology, it'll all make sense. If not, you're going to have a headache by the time you finish the first chapter. . There's some good advice on preparing for IFPUG (International Function Point User Group) certification and the authors emphasize the fact that FP counting should only be performed by certified counters. IMPORTANT ENOUGH TO REITERATE - FP counting should only be performed by certified counters!!!! Keep this in your mind at all times. FPA is "Estimating-Heavy", not estimating-light. It don't come cheap in time or education.

The other reviewers have covered the content in enough detail that it's rather pointless to reiterate - suffice it to say I agree with their comments on the content. So, cutting to the chase, if you're looking at books on Function Point Analysis, you've obviously got a serious interest in estimating, and if so, and if FPA is where you want to go, this book is going to be very useful for you as a reference and as a guide. On the other hand, FPA is, while accurate if applied correctly (the nub of the matter.....), both time and expertise intensive - I can't emphasis the expertise factor enough. You need a sizable project with a budget sufficient to fund the additional overhead to make it worthwhile - for your average development project, this is overkill. If you've got a $50-$100 million plus project within the grasp of our sticky little paws and you can get a certified FPA resource on board, using FPA may very well help you stay within your rather sizable budget. And if your're studying towards your FPA certification, by all means delve into this book - it'll help you no end.

But having been there and done that in my past, don't try this at home kids. This book is a great resource, you'll learn all about FPA from it, but reading the book is a completely different kettle of fish to actually doing it. As another reviewer has pointed out, FPA is accurate IF DONE CORRECTLY. To get accurate estimates, you need certified FP counters, and the data needs to be interpreted correctly. Easier said than done. If you want to use FPA yourself, go study and get yourself certified before you try it for real - otherwise, you may well send your career as an estimator down the tubes.

If you've got to come up with estimates and you've got no real estimating experience, DON'T START HERE. Go look at Steve McConnell's book on "Software Estimation: Demystifying the Black Art" to get yourself started. You could also look at Caper Jones' "Estimating Software Costs" although it's a little dated and not up to date with Agile estimating practices (my bias shows through.....). (Subsequent update - apparantly -the second edition (2007) of "Estimating Software Costs" by Capers Jones addresses Agile methods...).

On the third hand, I do give this book 5 stars for what it is. Well-written, understandable, effective - and it follows IFPUG guidelines. If you're after CFP certification, this book won't lead you astray (although it is a version or 2 out of date) and it will prove a useful study aid. I've got it on my bookshelf at work and although I now use Agile Estimating Practices a la Ken Schwaber (Agile Project Management with Scrum) and Mike Cohn (Agile Estimating and Planning), I do take a look at this one every now and then just to see what the FPA guidelines are. Mind you, every time I look thru this book and think of what I might have been doing, I bless Ken Schwaber for coming up with Scrum (OK, OK, I like smaller projects and I like the Agile approach.....).

This is an authoritative book by two authors who have a published a large number of articles on the subject.

Function point analysis is, in both my experience and opinion, one of the most accurate estimating tools a software engineer has at his or her disposal. I have previously used the constructive cost model (COCOMO) through version 2, Raleigh curves, and hybrids such as Software Estimation Analysis Tool, which computes both COCOMO and function point statistics. Granted, not all of these estimating models are equal - the Raleigh curve approach has a focus on quality and manpower loading that the others lack. But each (and many I have not cited) are estimating tools for software development.

My experience shows function point analysis to be the most accurate - if done correctly. Therein lies the crux of the matter. Function point analysis, in order to yield accurate estimates of effort, needs to be performed by certified counters and the resulting data needs to be properly interpreted. That's where this book comes in.

It starts with an overview that serves as an understandable introduction for someone who is new to software estimation, yet is interesting enough to hold the attention of more experienced professionals. The advice on preparing for IFPUG (International Function Point User Group) certification is a highlight and underscores the fact that FP counting should only be performed by certified counters.

The chapters on software measurement and executive introduction to function points are really extensions of the introduction. I found both the software measurement model in this chapter, and how to establish a world class measurement program interesting and informative.

This segues into three chapters that cover measuring and using function points, and industry benchmarks. Some highlights are the way the authors tie function points to key performance indicators such as productivity, quality, financial and maintenance. I also liked the way that the authors stratify the users of function point data into project managers, IT managers and cross-organizational stakeholders. I was particularly interested in the last group because I am often involved in both service and application delivery projects. The use of function points as a basis for service level metrics and outsourcing is an intriguing idea that I will explore further.

When you arrive at chapter 6 the foundation built in the first five chapters prepare you for a detailed, methodical approach to performing function point analysis. This is straightforward and appears to be completely consistent with IFPUG. All you need to know about function point analysis is, in my opinion, provided in the remainder of the book. The material is augmented by case studies, and also addresses contemporary issues such as applying function point analysis to object-oriented, web, client/server and data warehouse applications. While each of these topics are not given in-depth treatment the fact that they are addressed at all is impressive. The authors end the book with advice on preparing for the certified function point specialist exam, and gives sample exam questions. They also provide sample worksheets in the appendices.

This book merits a solid five stars because it is well written, up-to-date and follows IFPUG recommendations. If you are pursuing CFP certification this book will simplify your life. If you want to learn about an effective software estimating technique this book is a great starting point. To be completely fair, if you are new to software estimation you should also read Estimating Software Costs (Caspers Jones), which gives a complete and unbiased survey of all of the major (and some obscure) software estimating approaches.

Even though dated, this is still the best book on Function Points available in the English language. It complies with the 4.1 version of the International Function Point Users Group (IFPUG) standard, while the current version is 4.2. Nevertheless, the book contains many interesting hints and examples not available in the standard. You may also want to buy the IFPUG Counting Practices Manual - the official reference - directly from the International Function Point Users Group.