Software Books

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

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

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

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

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

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

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

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

The book has the following strengths:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

I recommend you read this book and be inspired.

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

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

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

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

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

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

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

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

I strongly recommend this book.

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

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

I teach and do statistics for a living. Don't let the humor fool you. Despite being the most (only?) fun to read statistics book, it also has more thorough (and readable and usable) coverage coverage of the basics and advanced methods than any other book its size. It explains both underlying principles and practical applications. Readable, usable, thorough AND funny. Who would have thought it possible for a statistics book! I reccomend it to anybody in the biomedical or social sciences who wants to learn statistics AND as a handy reference for anybody who uses statistics AND for anybody who needs to teach students AND for anybody who needs to explain statistics to the public. Deserves to be bestseller. And it's back in print by BC Decker, available in U.S. from Blackwell; ISBN: 1550090852.

I was so upset when I learned that Mosby had dropped this book that I contacted the authors and found out it is available:

Blackwell Science (for BC Decker) ISBN: 1550090852

I was trying to find the book for residents and students. I can believe that it is out of print! It was the only book I could find in many years that could be used to learn biostatitics on your own. It was easy, fun and it did not treat you as a dummy.

I teach and do statistics for a living. Don't let the humor fool you. Despite being the most (only?) fun to read statistics book, it also has more thorough (and readable and usable) coverage coverage of the basics and advanced methods than any other book its size. It explains both underlying principles and practical applications. Readable, usable, thorough AND funny. Who would have thought it possible for a statistics book! I reccomend it to anybody in the biomedical or social sciences who wants to learn statistics AND as a handy reference for anybody who uses statistics AND for anybody who needs to teach students AND for anybody who needs to explain statistics to the public. Deserves to be bestseller. And it's back in print by BC Decker, available in U.S. from Blackwell; ISBN: 1550090852.

This book is fun and interesting, and not nearly as scary as the rest. It doesn't rely on lots of math, and it presents basic concepts in a way that regular people can understand. I recommend it to everyone I know who (1) doesn't know much about stats but (2) finds they need to do something statistical.

It breaks my heart that it's out of print, because I was hoping they'd write a whole series of books!

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

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

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

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

Two side notes:

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

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

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

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

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

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

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

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

I bought this book for an overall understanding of BI without wanting a deep dive into the technicality of the technology. This book hit the spot nicely. Explained clearly the evolution of BI, the uses and some real-life solutions. In the final section it then went into the technology at a perfectly pitched depth. If you are looking for a BI reference guide, this is the wrong book for you. However, if you just want a clearly written book on the concepts behind BI and it's real life applications, this is the book for you.

I chose this book, because I needed to get some background on BI fairly quickly. It satisfied that need very well. It is quite well-written and some parts read more like a story, which is quite the opposite of the "just the facts, ma'am" approach of Kimball and his associates. (That is not a stab at Kimball. I am a big fan and I believe they have so much to say that they don't really have the space to make it story-like. Kimball has a completely different goal with his books -- but this is not a Kimball-review.)

At the start, the book introduces us to the Director of Imports at a gift and novelty wholesale company. Her initiative of selling a certain item didn't work so well, and we get to know the steps she has taken to analyze the data to find out what happened. Along the way, we are introduced to many Data Warehousing / Business Intelligence (DW/BI) concepts.

After the story, some basic DW/BI terms are explained in more detail. The authors explain quite well where they fit in the process of getting from mounds of static data, to a useable set of data for analytical purposes, which they call the BI Roadmap.

The book contains five case studies of a few pages each, which help fix the process of implementation.

If you know nothing about DW/BI and you quickly need a framework on which to hang whatever knowledge you gain elsewhere, I'd say this is a great start. Also, if you've implemented a DW/BI system and failed, this may help get you back to your roots. However, if you've read a lot of in-depth material and maybe have an implementation or two (successful) under your belt, this will only serve as a relaxing read; you won't gain much new knowledge from it.

I give it 5 stars, because it does what I think it attempts to do. It gives you background knowledge and a framework; it does not attempt to be an encyclopaedic work and desk reference, like Kimball's books are. Therefore it reads in a fraction of the time it would take to read Kimball. If background is what you're looking for, enjoy.

The book was a very easy read. Finised it in one afternoon. Definitely recommended for a novice. However, if you have an understanding of BI, then this book is not for you.

I like the cover. Its orange !!!

First of all, I will have to admit that I am a Microsoft advocate. I like their solutions and I think very highly of what they have to offer with SQL Server and Analysis Services.

This book lays down a good foundation for anyone to follow. It explains the concept of BI, the uses of BI, and the payback of BI. What more do you want.

I have been in charge of an SAP/BW group for a large consumer electronics company for the past 4 years. SAP's architecture for BI is very expensive, inflexible, and limited. Using Microsoft's concepts of BI would be cheaper, very flexible, with much more capabilities.

So, grab this book, read it, then read it again. Install SQL Server 2k. Install Analysis Services (comes with SQL Server 2k) and install SQL Servers Service Packs 1-3).

Then experiement with what they are telling you in this book and you will be amazed at what you can do....and cheaply!!!

Good Luck!

Techies will enjoy learning from real world examples of business intelligence technologies. Business leaders will appreciate how complex technical and business topics are tackled from various perspectives - what is BI, how BI will help your organization, and the most helpful chapter, how to actually identify, start and implement a BI solution.

Only wish the authors had spent a little more time identifying pitfalls, but that is why you hire experts to help you out.

it's just the sort of material a business English teacher needs to meet the requirements of both business classes and executives.it is comprehensive and includes major business communication skills . I have been using it for the past two years. it is just exellent. it would probably be better if an answer key was attached to it.
well Done!!

"Business Objectives" is targetted towards adult English as a Foreign Language learners who are currently learning with a trainer.

It is directed towards pre-intermediate/intermediate level learners, and supported by teacher's book, cassettes, pairwork material and lively videos, it is comprehensive and up-to-date.

Topics include: meeting people, telephoning, presentations, socialising, describing products and trends - each in easy-to-use units that can be used as on-going training, or stand alone modules. It makes great use of sketches and role plays, and references to actual companies and situations and for a trainer with little business experience it is easy to use.

Its partner "Business Opportunities" is directed towards higher level learners, and frankly there is not an English training organisation that I know who is not basing it's business English course around this book. A must!

This is the kind of English business book that gives plenty of subject for discussion and giveas the student the satisfaction of knowing that he or she is learning useful English. It is also complete and varied, can be used with any businessperson, no matter the area of interest.

"Business Objectives" is targetted towards adult English as a Foreign Language learners who are currently learning with a trainer.

It is directed towards pre-intermediate/intermediate level learners, and supported by teacher's book, cassettes, pairwork material and lively videos, it is comprehensive and up-to-date.

Topics include: meeting people, telephoning, presentations, socialising, describing products and trends - each in easy-to-use units that can be used as on-going training, or stand alone modules. It makes great use of sketches and role plays, and references to actual companies and situations and for a trainer with little business experience it is easy to use.

Its partner "Business Opportunities" is directed towards higher level learners, and frankly there is not an English training organisation that I know who is not basing it's business English course around this book. A must!

I, just want a audio cassette of business objetives

I had been introduced to C before I knew assembly and was left wondering the magic behind the curtains.. what happens when u call a function.. when u declare an array.. I mean I knew that it must mean something in assembly but the link was not there in any of the C books I looked up.

For an engineer who knows hardware and is curious, there is no other place than this book. Holub breaks up C into assembly and show you what happens as you compile and run it, side by side. He takes the mystery out of C programming. Wonderful for folks who missed the link between assembly and C. C has been called as High level assembly language and the proof is here in this book.

This is the ONLY book which explains almost everything that is going on from program as text to an executable. Well organized and well written which makes it easier to follow. Could have included a few more topics on memory management. Nevertheless, a neat book that every professional C programmers would like to own.

Personally, I think this book is better than the K&R book. If I read this book when I was just learning C, then I would give up and say to myself "It's too complicated. Why do I have to understand all about these..." But hold on. Don't you want to know what the stack frame is and how it works during recursion and how a variable number of arguments are handled, how the automatic type-conversion is related to the portability issue? Then read this book. If not, just skip this book. The only short coming of this book is that it's not ANSI C compliant. But it matters little if you already know about ANSI C. You will be able to discern the difference yourself, and probably can smell the history of the evolution of C. It's sort of a bonus. Allen I. Holub, what about writing the 2nd edition of this book? Then, that would be a great a help even to many embedded C programmers, I think. Sencon-to-none C book for me.

Of all the C books I had, I would rate this book my number 1. Just the section on pointers is worth the price of the book. The way it explains pointers, pointers to pointers, etc is so done so elegantly and clearly. No complex double talk or technical quibbs.

I wonder why Mr. Holub stop authoring anymore books... Mr Holub, if you are reading, please continue your excellent work ...

When I started programming in C I was doing embedded operating system design and this was the only book I found that clearly explained what a stack frame was and how to unwind it in assembler to handle errors. It contains information for the experienced C programmer that I have never found elsewhere on how C code works 'behind the scenes' (assembly language, binary arithmetic, complex pointer math, stack frames, function call jump tables, etc.). It is not a book for beginning programmers, and it is not in any way an introduction to the C language, it is however, an unusual resource for the experienced programmer.

this book is a real gem, it is a must for any cics programmer. mine has a ton of tabs so i can find the commands that i use most often

This is an EXCELLENT CICS reference. It's really the only book you'll need if you have CICS projects at work. It has handy programming examples, a complete INDEX (novel concept, eh?), and detailed explanations.

One word review: Excellent.

Doug Lowe is a great writer/teacher. The book is well indexed and anyone could understand his writing. He tells you what you need and also show you examples. Trash the IBM manuals, it's all here. There are more copies of Doug's book in our office than any other writer.

Once you begin to modify CICS programs, you soon find out all about the little idiosyncrasies and problems inherent in anything as complex as online programming. The CICS Desk Reference contains practically all Command-Level CICS commands and error explanations, and shows many examples on using the commands. Although it deals with COBOL programming, Assembly programmers can find many answers here, too.

Some one always has it. Thats why I am going to buy one of my own. (Me and 4 other guys!) The best feature is it's alphabetized. And nothing is better than a good example. The only way it could get better is to add a chapter on Linkage Section and its use in calling/linking to background CICS programs. (PS. Hi Rick, glad to see you got CIO at Amazon) Mark Lankford

HomePage 3.0 is an older program but it has the advantage of being cross-platform (meaning Mac and PC) on the same disk. I have made a dozen websites using it and it is a wonder to behold. Newer standards have overtaken the WWW so not all of the new functions are integrated into it.

It has a first rate tutorial on the disk which can help you to make perfectly decent small websites. However, this book is the perfect manual to go along with that tutorial. In fact I think it is essential to own this book so that you can address problems as they arise without having to bounce around between the program, the Help, and the tutorial.

As with most of the Visual Quickstart series, this one is filled with pictures so that those of us who cannot grab the meaning from the text alone can guide ourselves with the screenshots showing what the text just spoke of.

I recommend both this program and this book to my students who wish to build their own websites, even though both the book and the program are out of print.

This book was very helpful getting me up and running and doing what I wanted to do--make my website. It was also helpful in stepping me through publishing my first database on FileMaker Pro. I would reccomend it to anyone wanting to use Home Page. I should say that Home Page is a very easy to use, but powerful program. It is quite intuitive. This book just happens to make it even easier to use. I just kept it on my desk and if I hit a snag it would unsnag me.

i need to know how to make a web page for 5$ if any one can give me instructions how to make a page mail me them thanks. p.s.hoss8617@aol.com

This book was very helpful getting me up and running and doing what I wanted to do--make my website. It was also helpful in steping me through publishing my first database on FileMaker Pro. I would reccomend it to anyone wanting to use Home Page. I should say that Home Page is a very easy to use, but powerful program. It is quite intuitive. This book just happens to make it even easier to use. I just kept it on my desk and if I hit a snag it would unsnag me.

I found this book very understandable and full of explanations. It summarized much of what the help menu in Claris Homepage offered, but showed detailed diagrams and steps on how to complete the functions for most web page design. I recommend this to any beginner with Claris Homepage to use as a basis to learn the program and understand the buttons and capabilities of the total program.