Software Books

This book was nice .it was NEW.I never thought I will get a New book for less cost.

I have found this book of tremendous help in my work.

My first books on use cases focused more on UML rather than use cases. I did not give a hoot on use cases, because they look so simple on paper (and that's why I didn't buy a book specifically on use cases!) But as I grew as a developer, I began to believe that use case modelling if done well can significantly reduce development effort and bring about quality solutions. Use cases are the foundation to the understanding of the system that you are trying to develop. Use cases deserve serious attention.

The main problem with use cases is that you either don't know how to start or when to stop. This book tells you both. It tells you how to develop your use case model systematically from scratch and how to make provisions so that your use case model can grow. IMO, that's the main draw for this book.

The authors also give good insights on the possible approaches the reader can take to expand his/her use case model iteratively. It cautions the modeller to keep a balanced model so that stakeholders can understand, rather than one that specifies everything but gets bogged down by the details.

Semantics, you can get it elsewhere, but this book discusses it pretty well too. The examples are clear and relevant.

All in all, Frank and Granville did an excellent job covering the topic.

It is refreshing to a read a text that caters for those of use who already have experience in this domain and are seeking to develop their skills - without reverting to acadamia style writing. Useful examples, balanced descriptions, and an excellent coverage are all attributes of this text.

This book has some powerful advice for those projects that use Use Cases to drive their analysis and design efforts. It lays out a good process to follow for developing the Use Cases so you don't jump right into the details without a plan. Much of the advice is good Software Engineering practices, but a lot of people seem to forget that it still applies even when making use of newer techniques such as Use Cases.

The chapters pertaining to relating the Use Cases to other artifacts - such as test cases, the User Interface, and the Object Model - offer very practical and sound advice. You can tell that the authors have actually done it before and are speaking from experience and lessons learned.

The chapter explaining Extend Relationships offered the clearest and most complete description of the Extend Relationship that I have encountered.

All of the writing is very approachable and the examples sprinkled throughout the book and in the Appendixes are very helpful.

I strongly recommend this book!

I have just recently started WMI and ADSI. I am a "top down" learner, get the hard stuff, then the simple stuff. This book is perfect for server '03 and windows system Admins. it is not a "solve every problem" I dont think it even solves most problems, but it does have tools and information that WILL make you a better windows administrator. If your just getting into scripting for windows, this is not the book for you. If you are looking for a resource that you can read through and use as a reference, to learn better ways to script your windows administrative tasks, this is the book for you. the CD has great examples and tools, along with a PDF of the book. the book is laid out very well, with specific projects, which is perfect for using this book as a reference. I read it straight through and was able to use parts of it almost every day. all of the information in this book is available at the scripting center, this book just has gotten the really good stuff for Admins, and laid it out perfectly. This book has helped me to write programs that sometimes save me hours of repetitive tasks. Example: manually removing a network virus from computers when I know all the information, but the scanner does not. I am quite happy with this book, and would reccomend it only to people with a light background in programming, and anyone that maintains a '03/XP network.

Absolutely excellent!! Very technical and to-the-point, so this book might not be for the absolute beginner. But for the more experienced Windows systems administrator, this book is an absolute goldmine! Also, in my view, it balances perfectly between being a reference volume and a textbook; I've started from page 1, and will go throu the whole book (and I enjoy every minute of it..). But still, this book will be seen next to my desk, within reach whenever I need to look up something...

With the book comes a CD with the whole book in searchable PDF-format. And I would like to thank Microsoft Press for doing that! I have put the PDF on my PDA, and can access its wisdom wherever I go! Great!

It never ceases to amaze me how many scripting books, including this one, start off telling you that you should already have intermediate to advanced scripting skills before you read, yet spend an initial chapter explaining what an array or an object is. It leaves me feeling that their definition of what "advanced" is will differ greatly from mine. I am also always a little dismayed when throughout, a book plugs a costly script development studio and spends time pointing out why your chosen script editor isn't good enough for your projects.

That said, Advanced VBScript delivers what it promises. It is written for intermediate to advanced scripters and has the primary goal of introducing scripting formats, utilities, objects and processes that might otherwise be overlooked. The beginning introduces you to the WSF XML format for scripts, why you would want to use it, and how to convert your existing scripts to this format. From there you are shown how to utilize scripts as COM objects, how to add an interface to your scripts via HTML and HTA applications, performing remote scripting, and expand your scripts ability using database, ADSI, WMI components. The last section focuses on working with Exchange 2003, MOM 2005 and Virtual Server 2005. At around 500 pages, the book is certainly not an exhaustive reference for each component examined. You are provided a good introduction and general instructions to the topic, given many recipe scripts for immediate inclusion in your environment, and then provided additional detail on where to go to focus on the topic.

The book is formatted to not only be a start to finish textbook, but also serve as an excellent reference guide for the introduced components later on. Although you may find similar scripting information scattered about other VBScript books, here you have a great deal of well presented topics that cover a broad spectrum of concepts. Inclusion of this title to your reference library will provide you the information you need while keeping your bookshelf compact.

I picked this up after noticing it in a book shop (sorry Amazon!). I'm an Exchange administrator and this book gave me some great scripting tips for managing and monitoring my environment. I haven't gone much beyond that since, to my regret, but the concept of packaging scripts was news to me, and I would love to find the time to try out some of the other more elaborate techniques in there. But of course, I am an Exchange Administrator ;-)

This is an excellent follow on book to "Microsoft Windows 2000 Scripting Guide," ISBN: 0735618674, which was my previous bible. I had long ago advanced past much of what is written in that excellent foundation book for VBScript, and this advanced volume really fills in the gaps. After purchasing numerous VB and VBA references that are nothing more than syntax libraries, I feel I finally have the big picture on the capabilities of this technology with this book. It is all clear.

Combined with the Windows Internals book, I don't think there is anything I couldn't do now that I had wanted to do with this technology previously. The chapters on scripting database connections and HTAs are worth the price alone. If you do any serious scripting work, this book is the true capstone. And who else could publish such a book than the horse's mouth itself?

If you understand Agile and your team adopts all the practices with success overnight, then this book is not for you. If like the rest of us you have an understanding of Agile, but need some help to go beyond a few superficial practices, then buy the book and use it!

Amr starts with the fundamentals of Agile, from its deep roots in team dynamics and individual attitudes, and then guide you towards building a strategy for Agile adoption - not a generic strategy, but one that is adequate for your team and your objectives. Once the strategy is defined, we can put the Agile patterns to good use, one at a time, in good order, while minding the impacts, consequences and pitfalls.

This was exactly the book I was looking for. For my longer review, please refer to: http://freedomforideas.wordpress.com/2008/09/16/agile-adoption-patterns-1-2-3/.

Proven patterns for succeeding with Agile in an organization are presented in a series of case studies and hands-on exercises in Agile Adoption Patterns: a Roadmap to Organizational Success. Here are the most common stumbling points teams face in implementing strategy, along with tips on how to teach, train, and bring customers on board to an agile environment. Any Agile project manager will find this an excellent series of tips, making this perfect for software engineering collections.

There are many books about the theories and practices that are encompassed in the word "agile". Quite a number of them are quite good in terms of addressing the specific practices and how to implement them. It you want to learn Scrum or XP, there is no shortage of books and how-to materials, along with plenty of advice.

This book, however, addresses the goal of agile adoption from a new perspective - patterns of behavior and thought, and how to specifically leverage and/or address them. It addresses this from the organizational/team perspective, rather than the individual perspective, which makes it particularly valuable for those of us who are working in an organizational transformation/agile adoption environment.

While it might seem that "patterns" would appeal to the techies in its audience, my experience is that Amr has managed to frame his work in terms and concepts that are readily understood by all. This book is readily digestible by non-technical managers and staff, as well as by those of us who have spent/currently spend our time in a technology environment. It is not necessary to understand what design patterns are, for instance, to understand the patterns in this book.

For those who are either anticipating agile adoption or actively engaged in it, or even those who are struggling with what seems to be a failed adoption, this book is required reading. The way in which the patterns are presented, the clear and pragmatic exercises described to help work through them, and the suggestions for ways to approach it all are just what's needed.

Real world, pragmatic, easy to read, and easy to digest - that's what this book is all about.

It will be on my desk and heavily thumbed in short order.

There are plenty of excellent books available that explain agile practices. What has been missing until now is the guidance to apply them. Amr's approach to achieving agile practices is filling a need that has been felt by many for several years now. Amr takes an excellent approach to identifying the best means of applying agile techniques based on a combination of business needs and project pains. This approach stays focused on delivering business value to the enterprise as they move towards agile practices.

Amr has an excellent writing style that is both concise and entertaining delivering information in a manner that can be absorbed in bite-sized chunks and applied as needed based on the initial needs assessment. After identifying the business needs or pains the best agile practices to deliver the value or reduce the pain are described in a manner that determines which practices will deliver the best value to meet your identified needs.

I highly recommend that you pick up this book if you are either planning to adopt agile practices, struggling to adopt agile practices or are looking to enhance the agile practices that you currently employ. Well done Amr.

There are many things I like about this book, not the least of which is that it is true to the "spirit" of patterns and agile -- it does not promise easy answers or quick fixes but offers down-to-earth advice based on experience. The patterns do a good job of capturing that experience but the way the patterns are written, with "threads" of stories throughout is not only convincing but enjoyable reading. I like being able to follow the real-life adventures of the same developers who struggle to solve real problems across several patterns. I also like the case study in Chapter 46 where a real company with real problems does a pretty good job of moving forward, but it's not a "and they all lived happily ever after" scenario. We're overwhelmed with books and advice these days, so it's nice to see someone who offers help and hope but not hype!

Very comprehensive... a lot of bang for your buck in a little book. I keep it in my laptop bag 24/7 now.

I, incredulously, bought this book not expecting to refer to it because I know everything ( ;-P ). I have found that it a most invaluable resource. If you know (and love) Apache, this is the synopsis you need sitting on the left hand side of your keyboard.

For material that's mostly already online, this book is a good investment. I get really tired of window-switching references, and sometimes I like to sit away from the computer while I'm looking up stuff on directive syntax or whatever. For that, this book is worth the price.

I'd still like a more suitable binding for a small book with a font chosen for density. Lord, won't you make me said book so it will lay flat? That would make this dealie a five-star pick for me.

This little book covers the latest version of Apache, and was packed with info for its size. If you're already familiar with other releases of Apache, then this is the perfect book for you - and all you'll ever need!

A large system of configuration commands and syntax is a useful and powerful tool for allowing people to easily control complex pieces of computer software.

Large configuration files have one major problem; you tend not to look at them often enough to get the language and syntax down pat. You find yourself making too many tiny errors in command name or syntax and struggle with one window editing the file and one or more windows open displaying the documentation.

With Apache I have this problem in spades. The configuration system may be well designed and the syntax as easy as possible, but most people will still struggle to keep every detail in their head. I know what I need to do, have a fair idea how to do it, but the details elude me.

That's where this little volume comes in immensely handy. I have several of O'Reilly's pocket references and find the PHP, Apache and Perl ones never stray far from my computer. This one provides a wealth of reference information packed into a small, inexpensive little volume. It has enough information about the exact name and sytax of the Apache configuration directives that I donýt need to go to a larger book or delve into the manual.

Oh, and for those that want this volume to lay flat. I ran my copy through a paper cutter and trimmed the spine off. After punching holes in the pages I then had a loose leaf version that allowed me to add my own pages of notes in various spots and lays perfectly flat. It only took a few minutes. Sorry, O'Reilly - but it is more useful if it can lay flat and being able to add notes is great.

This is a fanastic topics book in approximation algorithms. The problems and proofs are challenging and concise, but written in a very accessible manner. It is a great reference book, and also a convenient place to grab a lecture from if you need something to fill our a course. I have found it extremely useful, and even fun to read. I highly reccomend it for any person interested in theoretical computer science.

Very good, it is easy to read the book if you have a good level
of knowledge and the experience to think some details in the
proofs of the theorems.
I think it is a very good book for a graduate student.

Vazirani's book seems well suited for a computer science researcher who has had a rigorous background in pure maths. The level of difficulty can be quite advanced. Also, it is not the sort of book that gives algorithm examples in an actual programming language. Not that this should be a handicap to a skilled reader. The algorithms are usually described in high level pseudocode. You have to manually instantiate these in the language of your preference.

The 30 chapters span a wide variety of computational topics. Some are simpler than others to understand. Like the chapter on finding the shortest vector from the integer lattice made from a set of linearly independent vectors. That requires only a year or so of introductory linear algebra.

There are exercises for each chapter. Some exercises are formidable. Essentially like little research problems in their own right. Another plus for the book.

I have been looking for books related to solving NP-complete and NP-hard problems approximately. There is another book by Hochbaum and I have that too. Unfortunately, that book is more of a research oriented book as it is written by several researchers. It's like reading several research papers within two hard covers. This means that one needs to have a sort of intermediate level of experience with approximation algorithms.

For a beginner, one would expect a book that starts from ground-up and that has been written as a textbook rather than as a set of research papers. The book by Dr. Vazirani, is the only book that is written by one author with a step-by-step evolution of concepts and ideas related to approximation algorithms.

This is a quite nice book by an author who is well-known in the field. The book is not thematic, instead it presents certain problems in each chapter along with the main approximation algorithms and correctness proofs. Yet, each new concept is well introduced with the problems. For instance, the author presents LP-based techniques on the same problem (set cover) in the second part of the book. This makes it quite easy to compare and understand different techniques. The last part of the book is a little bit advanced compared to the first two parts which uses combinatorial or LP-based analysis of the algorithms. The presentation of the PCP theorem- arguably the deepest theorem of computer science- and its consequences are also in the last part.

A warning though: The book is quite terse at times, which enforces a dense reading. This may not be suitable for an undergradute study. My only complaint is that the PCP theorem might well be introduced with a little more intution.

Overall, I rate this book as excellent. If you are interested in algorithms, you should definitely buy it. Also, buy the "Complexity and Approximation" by Ausiello, Crescenzi and others. They provide a more comprehensive and thematic treatment. It also has an excellent bibliography and list of NP-hard problems. These two will make a great couple. The book edited by Hochbaum (Approximation Algorithms for NP-hard problems) on the other hand presents detailed information on the algorithms.

GIMP, or the GNU Image Manipulation Program to give it its proper name, is a graphics-editing program broadly similar to Adobe Photoshop in terms of functionality. The GIMP is an open source program that can be freely downloaded and installed on most computers, including maps. But on the downside it doesn't come with a manual, so figuring out how to use GIMP can be tricky.

But 'The Artist's Guide to GIMP Effects' isn't simply a book explaining what all the different tools and features do. Michael Hammel pitches this book quite a bit higher than that, focusing instead on how to use GIMP to perform a variety of useful and common tasks. From trick photography to building graphics for web sites, Hammel leads the reader expertly through nicely illustrated tutorials. The end result is more than simply a better understanding of the program, but a richer appreciation of what the program can be used to do.

There are six chapters, the first of which introduces many of the basic concepts. Although there is some attention given to where the relevant tools are found and how to use them, the focus here is on what they do and why you need them. Fundamental to success with any graphics program is understanding how different tools work when applied together, and Hammel finishes off this chapter with a set of multi-function tutorials that underline this point.

The second chapter concentrates on manipulating photographs. These include softening images, adding motion effects, and creating reflections. In each case the process is taken step-by-step, with clear text and relevant screenshots. At this point it's also worth mentioning something about the layout of the book. No Starch has really done a good job here. The book is wider than it is tall, and each page holds two columns of text. The flexible binding lets the book stay open at any page. As a result, it's an easy book to use alongside the computer.

The next chapter is about creating artwork for web sites. These include things like tiles for web page backgrounds, buttons, tabs, and menu bars. The first tutorial in this batch is all about creating glossy, gel-like buttons of the type Macintosh users will be familiar with. One of the later tutorials looks at the ubiquitous rollover buttons, though from the perspective of creating the actual artwork required rather than the necessary JavaScript or CSS coding. That said, if you use a WYSIWYG web page layout program like Freeway, you probably won't need to manually any of that sort of code to your page anyway; all you need are the graphics.

Like all the other chapters, the web design chapter finishes with a collection of useful tips. Some of these should be required reading for any web designer, and it's great to see the author lay them out fair and square.

The fourth chapter is very unusual but actually makes a lot of sense. It's a chapter devoted to creating advertising. While no substitute for a degree in marketing, there's some great stuff here for anyone who needs to produce things like packaging and posters. Small businesses attracted to GIMP by its low cost will likely find this chapter worth the price of the book alone. On the other hand, some of the tutorials in this section are only incidentally useful for advertising purposes though, and could be just as relevant to anyone creating computer artwork. Again, there's a wrap-up section with a slew of useful tips and tricks.

Chapter five brings text into the mix. This chapter kicks off with some tutorials covering things like neon, metallic, and gel-like text, among other typographic effects.

The last chapter is specifically for software developers, and illustrates the ways in which GIMP can be used to design and prototype application interfaces. While a clever and potentially useful chapter, what was obviously missing from this section of the book was something on designing icons for programs. The book then rounds off with a detailed index.

For $45 this isn't a cheap book, especially when you consider that GIMP itself is free and comes with its own online guides and tutorials. The question is whether having things laid out clearly and logically in a nicely illustrated book justifies the cost. In the opinion of this reviewer at least, the answer is yes. For the GIMP user looking to go beyond simply cropping and resizing digital images, this book is highly recommended.

Should have purchased this book months ago. Not for the absolute beginner, but a must have for the advanced beg or int user who wants to learn more about using gimp.

The GIMP is an image editor whose power and easy use rivals the industry standard Photoshop - and is a popular free software item. While The Artist's Guide to GIMP Effects could've been explored in our Computer Shelf area, it's reviewed here to alert every artist working with computer images. It shows how to use the GIMP's powerful features to apply to ads, photos, and business pursuits, and comes from an author who has used GIMP since its first public release. From specialty photographic techniques available within the GIMP model to advanced web design features for special effects, no photo artist using the computer should be without THE ARTIST'S GUIDE TO GIMP EFFECTS - and any collection strong in Photoshop-type books needs it.

Diane C. Donovan
California Bookwatch

In my opinion, there can never be too many books like this one by Michael J. Hammel. This project-based book has great examples of how the graphic designer can use the GIMP software to get the job done. Each tutorial in this book is an individual project, allowing the reader to pick which tutorials best meets his or her needs. But read them all. Each technique is not presented in a vacuum. Hammel discusses these techniques in a way that prepares the readers to reproduce the results in their own projects.

Besides being a project-based book, I also liked that Hammel did not waste the reader's time, and his own, discussing every detail about each panel, menu command and keyboard shortcut. Instead, he commits those pages to more information that you can really use. Don't get me wrong, he does give a short overview of the GIMP workspace in order to orient the novice to the software. But he does a good job of giving the readers only the information that they will need for the rest to the book.

So what does Hammel cover in this book? He writes each project-based tutorial from the point-of-view of the graphic designer. He begins with a short description of the design criteria for the project and ends each tutorial with suggestions for other projects where the reader might apply these techniques. He divides the book into six chapters and each chapter covers a different area of graphic design. Once he covers the basics, he moves on to techniques for the photographer, web designer, advertising designer and UI designer. Throughout each chapter, he discusses how type applies to the project and he also devotes a chapter to type effects.

For the photographer, he begins with some simple techniques for adding steam to a photo and creating a vignette. Then he covers more advanced techniques such as simulating depth of field. Have you ever wondered how graphic artists get type to look so good on top of any background? Hammel shows you how this is done, along with some other nice text effects. Also, he has one of the best techniques for converting a photo into a sketch that I have seen so far. His technique goes beyond the usual examples that you find in books and on the web.

Moving from photography to web design, Hammel states that "color is king" on the web today. Only just a few years ago, books were preaching just the opposite. But now with the better monitors, Hammel can share some of his techniques for creating mood, simulating 3D and reflections, and "popping" an image. He also has some great techniques for creating folds from texture and gradients and for creating the popular Toon style.

With the advent of widgets and other ways to create your own desktop applications, graphic designers are being asked to design user interfaces (GUI) for these applications. Hammel devotes the last section of his book to take you through the design process for creating a UI for a video player. He starts with the face plate and designs each part of the UI individually. However, these same techniques could be used to create environments for digital games and other design applications.

Hammel has been working with GIMP from its beginnings in 1996. He has authored and co-authored many GIMP related books and articles.

If you don't know what GIMP is, it's an alternative to Photoshop that allows you to do the same things (essentially) but is free.

I was impressed and surprised (in a good way) on the depth of tutorials in this book. I was really looking for something that would give me a good overview of using GIMP from the top, and was surprised at how many things you can do creatively that I hadn't even thought of. My only criticism is the paper used is flat and it would be nice to have something a little glossier for the images. The images are in color, which is nice though. I've used photoshop and now GIMP from probably a pretty basic level (I'm not a graphic artist) for album coverwork for compilation CD's for myself and friends, posters, and just playing around with abstract art to frame and hang on my own wall. I've been impressed with GIMP as an alternative to Photoshop and I think this book is a great companion to help me get the most out of it. If you've tried GIMP, which is free to download, and want to get more out of it, I would recommend this book.

As a Java developer who is a true beginner with Groovy and Grails, I found Beginning Groovy and Grails an excellent starting point. The book's strength is providing a core structure for the Groovy language and the Grails framework, then building on them.

I had read other Groovy books, and still use them as a reference. But BGG kept Groovy at the right level for me to start -- showing the core features without getting bogged down in the details. I was able to work through the examples and get an excellent feel for the power and elegant simplicity of the language.

The Grails overview is an excellent start to understanding the framework. I appreciated the step by step introduction to setting up and evolving a simple web application.

In terms of writing, I found this book very readable. I wish that the copy editors had helped out a bit more in spots, and the errata pick up some glitches in code, but overall I truly appreciated the authors' efforts and have learned a great deal.

I concur with the previous reviews. I've been looking to dive deeper into Groovy and Grails for a while now. I'm hoping this is the first of many new titles to come on this subject. I would really like to see the language and the framework take off as it should. There are many people out there doing cool things with both like Graeme Rocher, Guillaume LaForge, and one of the above reviewers (Scott Davis....you gotta see this guy talk about Groovy if you can!). People who work in the Java space really should give these technologies a look. This book should really get you going. I would also suggest looking at some of the book offerings by the contributors mentioned above. Good stuff. Buy this book!

I found this book to be a great introduction to both the use of Groovy and Grails, and also introduced the implementation of these technologies into a more mainstream architecture present in modern corporate America. It offers great insight, and hands on exposure to the benefits of Grails as a means to reducing development cycle time, and has allowed me to convince senior management where I work to fund a 'Proof of Concept' implementation of a Grails application deployed on a WebLogic Application Server.

While this book certainly covered a wide range of topics, it served to only increase my desire to delve deeper into Grails and Groovy, so now I must continue onward - but thankfully, this book leads nicely into The Definitive Guide to Grails by the same publisher.

Whether you're new to web application development or an experienced veteran, Beginning Groovy and Grails will be a great addition to your tech. library. The book highlights the power of the Groovy language and the Grails framework while providing a great deal of breadth and practical information on topics important to web application developers, i.e, presentation, persistence, security, and reporting. Developers will get a good handle on Groovy and Grails and more importantly will understand how to locate additional resources on advanced topics. This book has given me a strong appreciation for the advantages offered by dynamic languages like Groovy and the unbelievable productivity gains introduced by Grails. This book is an excellent compliment to Groovy in Action and the Definitive Guide to Grails.

Let me start by saying "Beginning Groovy and Grails" is the book that the Grails community has been clamoring for. Two very good books kicked off the Grails revolution ("Definitive Guide to Grails" and "Getting Started with Grails"), but both predate the 1.x version of Grails by many dot-versions and many years (as of the time of this review, August 2008). BGG will certainly have worthy competition on the bookshelf before long, but right now it is the book that we all have been waiting for. Luckily, it easily lives up to the heightened expectations.

After reading BGG cover to cover, it seems to break naturally into three sections: Core Groovy, Core Grails, and Ancillary Grails. This division is mine, not the authors; the table of contents lists 13 chapters with no explicit section breaks. (Whether the three sections correspond to the three authors is an interesting question -- the tone of voice and writing style is consistent across the entire book.)

The first three chapters do an admirable job of covering the Groovy language from the basics to advanced topics. Groovy offers lots of syntactic sugar that might initially catch a Java programmer off-guard. These features, once you've seen them, dramatically reduce the lines of code you have to write. But more than that, there are some fundamentally new features in Groovy that don't have an easy match in Java. Builders, Expandos, metaprogramming, and DSLs are all discussed in these early chapters. While you don't have to use these features yourself to be successful in Grails, it certainly helps the reader understand how much of the Grails "magic" occurs under the covers.

The next three chapters (Introduction to Grails, Building the User Interface, and Building Domains and Services) hit the Core Grails features hard. These 150 pages do a great job of walking you through the basics of getting a Grails application up and running with a minimum of effort. They also make testing feel like a natural part of the development process (which it should be!). Rather than having a single chapter dedicated to testing, each new topic organically includes testing as a way to validate that the new code does what it promises to do.

The remaining chapters (Security, Ajax, REST, Reporting, Batch Processing, Deploying, and Alternative Clients) make up close to half the book. Each chapter covers the subject material as advertised, including working sample code. Not every Grails application will use every feature discussed here, but I still found a clever snippet of code here or a nice explanation of a general concept that rewarded me for reading every chapter.

Overall, "Beginning Groovy and Grails" delivers on its title -- if you are new to either (or both) technologies, you will be up and running before you know it. But don't be fooled by the title; even though it has "Beginning" in it, this book doesn't shy away from the advanced topics, either. This isn't a completist volume. Rather, it is a broad survey of the Groovy and Grails ecosystem. Christopher, Joseph, and Jim covered a lot of ground in an easy, readable way. I highly recommend it.

For someone who started teaching in the days of spirit duplicators, long before copiers, computers, and the internet, I found this book to be both useful and very inspiring. It is clearly written, full of clear illustrations, tips, and resources. I've been looking for ways to incorporate more technological tools into my U.S. history course, in ways that further my teaching and my students' understanding. This book provides a clear path to follow. It is, by far, the most practical text on the use of technology in the classroom that I've read. As I work on new course materials and lesson plans, Best Ideas is always close at hand.

This book does a great job of giving ideas that are both practical but still ambitiously tackle some of the most exciting trends in ed tech today. Inviting tone and supporting resources. Great work.

As a teacher, nothing frustrates me more than knowing tools exist, even what the tools are, but not knowing how use them to increase students' learning. Daccord and Reich, both top-notch teachers, have done a superb job of solving this problem through clear but imaginative explanations and suggestions for recruiting the extraordinary possibilities presented by recent developments in technology, especially via the Internet.

Rather than being daunted by all these possibilities, picking just one or two great ideas from this book and folding them into one's teaching practice can have salutary effects on student learning and teacher enthusiasm for new ideas and approaches, and once those become habitual, one can return to dip again into this cornucopia of great ideas, exercises, and activities.

If you are a teacher or educator looking to develop ideas to utilize technology into your classroom this is a must have book. There are 10 chapters ranging from Enhancing Teaching and Learning with Multimedia to Class Management. Each chapter features one or two tools with specific directions (simply written) on how to use the tool as well as hundred's of web site's that are relevant to education. If you are someone who is looking to take technology into the classroom or want to learn more this is a well written, well researched book. I highly recommend it, you won't be disappointed!

The title of this book says it all. This book provides great background information and simple strategies for teaching WITH technology. As a professional development provider, I often see teachers struggle with how to use technology in their classrooms. Best Ideas for Teaching with Technology not only gives the background knowledge that teachers need, but it also shows teachers how to use technology as a tool to engage students in the classroom. Even better, the book is well-organized and an easy read - a great time saver for all busy teachers!

I bought this book for general project evaluation purposes, for a project that I was called in on that was in trouble.

Well worth the read - a lot of it is just good common sense, straightforward project management process, but it provided a great roadmap for validation of my plan to put the project back on track.

Definitely would recommend it - it's an easy read; I finished it in under 5 hours on the flight out, complete with note-taking. Kudos to E.M. Brennatan for writing this in a straightforward fashion.

It is a law of nature, grouped under the general name of entropy, that it is easy to mess things up and very hard to straighten them out. In fact, it is the natural state of nature to tend towards increasing disorder. This law also applies to software projects, since they are naturally very complicated entities; they easily reach a point where difficulties compound to the point of dysfunction. The author calls this state a catastrophe, although in my opinion that is an overstatement.
A catastrophe is a major disaster, far beyond what most software development projects actually are. Granted, there are problems, but most of the situations described in this book are ones that can be recovered from with more effective planning and focused execution. The author puts forward a ten-step plan for disentanglement:

1) Stop the project - not permanently, just long enough to examine the project in detail before things get worse.
2) Assign an evaluator - a disinterested party is assigned to perform an honest and unbiased appraisal of the project and what is going wrong.
3) Evaluate the project - the evaluator takes the lead in doing a complete dissection of all aspects of the project, what is being done right and what is going wrong.
4) Evaluate the team - examine the people working on the project and determine if all are suited to their jobs and if all are performing at the appropriate level.
5) Define minimum goals - determine what is considered to be the minimum level of achievement that will be considered a success.
6) Determine if the minimum goals can be achieved - if the minimal level of success is not possible, then the decision must be made to terminate the project.
7) Rebuild the team - this step has two basic components. Personnel changes if necessary and reinvigorating those who are going to remain part of the team. One of the greatest tasks is to overcome the defeatist mindset.
8) Risk analysis - attempt to identify all possible risks and assign a reasonable probability of occurrence to all of them.
9) Revise the plan - as circumstances change, modify the plan to reflect the different conditions.
10) Create an early warning system that will flag the appearance of problems when they are not yet serious.

These ten steps are each the topic of a chapter. Exercises for further practice are included at the end of each chapter, although no solutions are given.
I enjoyed the book; it contains a lot of sound advice on how to right a rudderless software project. Most of the advice will work only on a project that is not yet seriously out of control. Quite frankly I don't believe that a ten-step plan like this is powerful enough to get the most dysfunctional death marches back to a point of potential profit. Therefore, while I believe that the advice is sound, it is limited in scale, where the measurement is of the level of dysfunction in the project. On that basis, I can recommend the book.

Catastrophe Disentanglement : Getting Software Projects Back on Track teaches the kind of skills you hope you never have to use. It's something like taking a CPR class for project management. You hope you never have to administer CPR in real life, but when you do get put in that position, you're really glad you have that training to fall back on. That clear, logical list of steps can mean the difference between life and death. In the world of project management, the skills taught in this book can save projects and careers.

This book differs from traditional project management books in that it focuses on corrective rather than preventive measures. The author teaches two critical things. First, he presents a set of criteria used to recognize a project that is in need of rescue. This is an important step! Once a project is identified as seriously out of control, you can apply the steps presented in this book to bring it back on track and guide it to a successful completion. This book will give you the reasoning and courage necessary to make hard decisions.

Table of Contents
Chapter 1 An Introduction to Catastrophe Disentanglement
Chapter 2 When Is a Project a Catastrophe?
Chapter 3 Step 1--Stop
Chapter 4 Step 2--Assign an Evaluator
Chapter 5 Step 3--Evaluate the Project
Chapter 6 Step 4--Evaluate the Team
Chapter 7 Step 5--Define Minimum Goals
Chapter 8 Step 6--Can Minimum Goals Be Achieved?
Chapter 9 Step 7--Rebuild the Team
Chapter 10 Step 8--Risk Analysis
Chapter 11 Step 9--Revise the Plan
Chapter 12 Step 10--Create an Early Warning System
Chapter 13 Epilogue: Putting the Final Pieces in Place

I would recommend this book to anyone involved in software projects.

Good book, good subject, well covered. The book builds an organized process around the rescue of a failed (or failing) software project. The steps are easy to read and understand, and seem well thought out. Some good methods for identifying projects headed for serious trouble. Also, some useful guidance on how to handle political (not just technical) problems. Obviously, the result of significant experience. Well recommended.

There are plenty of books that try to help you keep your project on track. But what happens when you are sitting on a catastrophe and you don't know how to salvage it? E. M. Bennatan fills a necessary niche with the book Catastrophe Disentanglement : Getting Software Projects Back on Track.

Contents: An Introduction To Catastrophe Disentanglement; When Is A Project A Catastrophe?; Step 1 - Stop; Step 2 - Assign An Evaluator; Step 3 - Evaluate The Project; Step 4 - Evaluate The Team; Step 5 - Define Minimum Goals; Step 6 - Can Minimum Goals Be Achieved?; Step 7 - Rebuild The Team; Step 8 - Risk Analysis; Step 9 - Revise The Plan; Step 10 - Create An Early Warning System; Epilogue - Putting The Final Pieces In Place; References; Glossary; About The Author; Index

If you're in IT for any length of time, you'll be part of a project that is massively over budget or late. Rather than just continue the death by 1000 cuts or a quick mercy killing, Bennatan presents a ten step process that allows an organization to take a (hopefully) objective look at the project and decide what can possibly be saved from it. I was impressed that it wasn't a long drawn-out procedure either. The plan calls for an evaluator (or a small team for huge projects) to come in and quickly assess the environment... what's been done, the climate of the team, and what could be redefined as a "minimum system". At the end of this process, the organization should be able to either kill it off with the knowledge that it can't be saved, or continue on with a redefined set of deliverables that are achievable. It won't be everything that was originally wanted, but it will be more than you'd get by letting it die. I was also impressed with the "What Can Go Wrong (And What To Do About It)" section in each step. He doesn't present this as some cut and dried panacea that will flow smoothly every time. It may not be an easy task, but the book will give you the help you need to make it all work.

Definitely a book that is worthy to be on every IT project manager's bookshelf, as you *will* need it some day...

Good for someone who is just starting to use CATIA V5

It is an excellent book for beginner. It lets you get into Catia easily. It is important to make things simple for beginners. This book does a good job of making things simple.

This book offers the principles needed for any Catia user, both experienced and new, to be able to obtain a firm understanding of Catia V5. It teaches through easy-to-follow examples and illustrations. It was well worth the money.

A good book is the one that doesn't require an engineer to understand. This book is excellent! It slowly guides a beginner step by step away from frustration and closer to satisfaction. However, the minus side is that it doesn't cover any electrical application. I would pay triple the price if this book had electrical coverage.

This book is a good introduction to Catia. The steps taken and the end result of the book is good and successfully takes you through the basic workbanches. However much of the book is waisted with repetition and over worded explinations for the simplest tasks. The illustrations, typography and loayout are typical home-word processor stuff (clearly an accademic project) after the first chapter the lengthy explinations take far to long to get through and you find yourself skipping them and just getting on with the task. At the end of the day there dont seem to be any other books out there so this is probably your best bet, but I was still left with a few basic problems that were not covered. This book could probably have been edited down to half its size if the wordy introductions were cut out and you would be able to get though it much quicker - after this work book you are left with both a need to learn all the workbenches covered in more depth and many many more workbenches to learn.