Software Books

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

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

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

I am looking forward to the release of the book.

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

Danette McGilvray's new book is a welcome addition to the data quality literature. Finding and eliminating root causes of data errors is essential to any data program. And most people "learn quality improvement by doing," following step-by-step instructions--much as someone just learning to cook sticks close to the recipe.

McGilvray does an excellent job of putting quality improvement in context and narrowing her focus. Make no mistake. This book is specially written for project managers, who must lead improvement teams over often-confusing terrain, and for team members who must do the work.

This book is clearly written. It is richly detailed and chock full of templates that will help project teams move rapidly. It gets my heartiest endorsement.

A strong--and welcome--addition to the data quality literature. I love the "workbook" format, and commend Ms. McGilvray and her publisher for this informed, important, and most of all helpful Baedeker.

This book is a practical approach to data quality. I like that it gives many different dimensions to data quality, so that we can easily drill down into why the "data is wrong" by having a common vocabulary.

It's a practical approach to getting the data clean and keeping it that way. It's written in a very approachable way that doesn't talk down to me as a reader. I am very happy with my purchase

At first when I recieved this book over in The Netherlands (much quicker than estimated by the way!) I thought it would become a little hard to read. This was because of the big size and amount of pages (289) of the book.

But when I looked further into the book it became clear that it was a thoroughly, but very well readable book. The writer has found a way to describe difficult things in an easy and understandable way.

By the way; the writer (Danette MacGilvray) years ago got into the field of Data Quality because she worked on a assignment at Hewlett-Packard. It was this project where worked together with "consultant" Larry English and got inspired and educated by him and his TIQM-method.

By using many bulletpoints, easy steps and sub-steps, examples, check-lists, boxes and templates this book has become easy and fun to read from A-Z. On the other hand, when in you're daily practice you have to deal with a diffucult IQ or Data Quality problem this book comes in als handy, because it is very good for reference-purposes.

The book's own website (http://www.books.elsevier.com/companions/d9780123743695) with lots of material makes this all complete.

With her Ten Steps approach (based on years of experience in the work field of Danette) the writer has found a way to specify and bullet-point the most important data issues in you're company, get the fundings you need and break down difficult data quality projects in 10 steps.

Not only is the book based on her own experience, this book is also a blend of experience and proven techniques from people from the Information or Data Quality field like Larry English (Improving Data Warehouse and Business Information Quality: Methods for Reducing Costs and Increasing Profits), Jack Olson (Data Quality: The Accuracy Dimension (The Morgan Kaufmann Series in Data Management Systems), Tom Redman (Data Quality: The Field Guide) and Gwen Thomas.

So by reading this you get the best of all!

I work as a Data proces & quality manager in an home shopping business, so we are a "data intensive organisation". I think I will use this book (and the 10 steps) quite often.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Excellent pocket reference. I'm a 3rd year FP resident and have found it helpful in the office and in the hospital. Just wish there was a new version -last one was in 1997.

Mark Graber and staff have done it again. The 3rd edition of the Family Practice handbook is the most complete day to day reference I use. A practical and common sense approach to medicine that includes almost all family medicine topics that can be encountered each day. I even bring this book home each day for review and to assist me on my call nights. I feel this book is especially designed for the busy practioner who needs quick access of the latest medical info. I feel it is reliable and authoritative and I encourage anyone who practices family medicine and is looking for reliable information to assist them in their daily practice to try this book.

This is an evidence-based pocket wonder. Mark Graber, M.D., et. al. do an amazing job of packing the relevant practical facts needed in a daily practice or ER in a small space. The emergency care chapters particularly provide the kind of memory jogging details of care that one needs while on the job.

If you were stranded on a desert island and could only take one family practice book, this should be it. (But wouldn't you take a good novel instead?) It covers the waterfront with details of diagnosis and treatment of all of the common and most of the uncommon disorders without the clutter of the rare. Good for students and residents in my estimation.

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

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

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

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

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

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

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

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

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

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

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

Great reference book. I think every function and aspect of FW is in here! I have already found out a lot of new things about FW from this book! Lots of great ideas too! There are not many FW 4 Books available, but this one is definitely worth a look!

Great reference book. I think every function and aspect of FW is in here! I have already found out a lot of new things about FW from this book! Lots of great ideas too! There are not many FW 4 Books available, but this one is definitely worth a look!

I think anyone serious about Fireworks needs this Bible as a reference source. The index is excellent for looking up quick answers. Its a bit "design" challenged and if you have version 3 the major portion of the illustrations are the same.

You could learn Fireworks with this book if you are patient or have a lot of time, but its better suited as a reference book. The layout and order of things don't flow like a step by step, beginners book.

Don't get me wrong, this is an excellant book with a wealth of information. If you are looking for inspirational design ideas then this isn't it. There are some more advanced topics such as customizing Fireworks and a chapter on integrating Fireworks with Dreamweaver. Good value for the money. If you want to find info quick, this book fits the bill.

I highly recommend this book! I like the way the author didn't waste my time trying to include little jokes to spice up the text. Every feature was covered in complete detail. I read the book from cover to cover and immediately became a master at using Fireworks 4. Previously, I had been using photoshop to make my web images and effects but since reading this bible book I haven't touched Photoshop. Fireworks is a great program and if you want to learn all of its capabilities then you should own and read the Fireworks 4 Bible.

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

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

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

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

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

Here are my favorite techniques:

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

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

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

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

TOC:

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

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

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

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

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

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

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

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

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

a great book for any flash student with superb examples . a must for anyone connected to computers..

This is a quite thorough book that picks up where Mohler's intro book leaves off. It's written as if a Flash instructor literally transcribed his class presentations, which is good and bad. Explanations are long, but at times are wordy and dull. It will remind you at times of tedious homework assignments and drills. There is quite a bit of slogging through pages with only two or three long paragraphs with no Flash code. That's not bad, but it's a sign that an editor probably could have tightened up the writing here.

Also, these authors need to lighten up and learn to write! The tone they take is often "academic", with all the snobbiness and overuse of big words and long sentences that comes with that. Often it's clear that one or the other of the two authors has written a particular passage--and there are some awful clunkers there. Better instructors and writers strive for a more human, friendly tone.

Also, there are coding techniques that seem to me not to reflect current or common Flash coding practice, like the frequent use of the eval() function and the set() function (which I've *never* seen other advanced Flash authors use).

One good thing: the two long projects in the book are kind of neat, definately better than in some other big Flash books.

I'm a beginning flash user, and I picked this book up as a follow up to Mohler's first book. Even though it explores advanced scripting, the explanations are clear enough for beginners like myself to understand. I actually understand OOP because of the great dog class example. There are some really great examples on the cd-rom. It's so helpful to have an actual Flash file to play with, so I can see exactly how it works.

I bought this book a couple of weeks ago and I love it. It has tons of examples in the CD. It is a great book to learn complex actionscripting.

A fantastic book. Not one of those that you'll be able to get through over a weekend but is one of those books that you constantly go back to for reference or validation. Some of the techniques take the mystery out of capacity planning and forecasting performance. Excellent.

I've always been a fan of Craig Shallahamer, an author who explains complex concepts in plain English.

This is not a trivial book, but it's an excellent book for performance tuning, a worthy book for the worthy scholar.

Oracle STATSPACK and the automated workload repository have provided a gold mine for the Oracle DBA to forecast future performance, and this is a great "get started" book to the statistical techniques that are required to perform performance forecasting.

This is not a book about Oracle Performance tuning. This is a book about Oracle Performance Forecasting. This should be evident after carefully reading the book.

Good books, like good professionals, are rare. This is why I have developed a tendency to choose carefully before buying one and, in the Oracle area in particular, I can smell the author's intellectual honesty and trustworthiness from the first page.

Forecasting Oracle Performance is one of those. I enjoyed the fluid style and closeness of the author. I enjoyed the simplicity and clarity, almost reminding me of Wittgenstein's famous quote ("everything that can be said can be said clearly"). I also enjoyed these short touches of humanism (cf Erlang Krarup's life).
On the forecasting subject, I liked the book construction and the quality of the examples.

Chapter 1 gives a landscape picture of Oracle forecasting and puts the reader in scope and context.
Chapter 2 introduces the reader to the basics of forecasting and the basic concepts over which the book is built: Transactions, response time, arrival time and basic formulas are described here.
Chapter 3 shows the limits of basic forecasting (essential formulas) and the problem of baseline and model selection. It shows how to increase forecasting precision with ErlangC or weighted averages. Most importantly, it shows why it is essential to understand the concepts and implications of the application of a given formula, model or method. The author is very careful in the choice of terms and always clears potential ambiguities. Those who know how difficult it can be to forecast will appreciate it.
Chapter 4 introduces to statistics applied to forecasting.
Chapter 5, on practical queuing theory, is probably the biggest chapter of the book. After a brief introduction to queuing theory, Little's law and Kendall notation, this chapter provides such a diverse set of examples (27!) making the topic very intuitive to non-specialists.
Chapters 6 & 7 describe forecasting methodology and workload characterization. The first describes the steps across a solid performance forecasting methodology, from the initial question to the actual forecast. The second deals with workload characterization: how to get system and Oracle data, how to choose the source and peak. It describes the workload modelling and the risks of data collection.
Chapters 8 and 9 are about models: ratio and linear regression models. They describe their respective foundations, limitations and advantages. Each chapter also contain several examples and case studies to illustrate the subject.
The last chapter deals with scalability models and their relationship with forecasting models.

Overall, I found this book very useful. You will find additional resources at the author's website (there is also a discussion forum on forecasting). The errata page is always up-to-date and some examples have even been extended. Great work!

This is a great book to do FORECASTING, that is, if you already have a tunning problem you will not find the solution here. If you are in calm times regarding your application speed, this is when you have to do Performance Forecasting, for which this book is excelent. Very practical and just enough technicall to grasp the priciples.