Software Books

This book thoroughly discuss the steps in using auto cad 2D and an opener in 3D autocad drafting. It uses a simple terms that anybody even not engineers can understand. Must buy for a beginner to intermediate autocad users.

The delivery from amazon really surprised me as the book arrives ahead of thier given arrival time. It arrives in two days only, supposedly shall arrive after 3-5 days. another 5 star rating for amazon's delivery system!

Easy to follow, Lots of excercises to practice with and explanation when you screw things up (beyond repair, sometimes.
A must read if you want to go to "AutoCAD University"?

AUTOCAD 2006 AND AUTOCAD LT 2006: NO EXPERIENCE REQUIRED is a fine, basic introduction to a powerful program which once commanded the attention only of professionals. Any seeking to utilize the CAD software should have this manual in hand: it provides a set of tutorials which are sequentially arranged for step-by-step study - but it also can be used as an at-a-glance reference sourcebook for solving specific problems. From understanding coordinate systems and drawing routines to working with fills, text, external references and more, AutoCAD's powerful tools and drawing features are all detailed in depth.

Diane C. Donovan
California Bookwatch

I work for a survey company. I have never been to college and I am a self-taught AutoCAD user. I learned AutoCAD '02 with this book. Now I train guys and we buy this book for guys that have backgrounds with Microstation and are transitioning to AutoCAD.

Fantastic book for the experienced or the beginner. Easy to understand. Highly recommmend for those just starting out.

Bottom line - great how-to book. I am NOT in any way, shape, or form, a computer geek. Technology is not my friend, and nothing about machinery is inuitive to me. I am also a no-nonsence kinda guy. In this particular case, I want to edit, not spend my time READING about how to edit. So this book is GREAT! (Wouldn't know if it's the best 'cause I'm completely dependent on doing what it says to do so I have no way to compare it to other resources.) The layout is straightforward - topics are categorized and independant from each other. Like a cookbook. Simply go to the instructions on how to do a particular thing, and there you go! The book uses paragraph format in the beginning of each topic/chapter to explain the "why's" of the upcoming topic; like a comprehensive overview. (What's the purpose and point of doing "_____".) Then when it comes to the "how-tos", each subtopic/activity converts to bullet-points. (Click A, then do B, then press C.) The book also includes side notes and hints along with illustrations of what you should be seeing on the screen at that particular stage. Wonderful! Efficient!

This book is based on Avid Express Pro as of 2004 and will serve you well as a reference text. It is well-indexed and has useful cross-references in the text.

This book is very helpful for new beginners learning AXP. It is very detailed and to the point. A must have.

figata ci vediamo al solito posto alle 12.00. porta la corazzata
pinuccio

I am a beginner with Avid and was daunted by all the different and options available to me. Monohan's book was just what I needed. I am currently giong through the book from A to Z, which gives me an overview of all the options and work-methods the program has. Even though I allready had set up my workspace, this book gave me some interesting tips. Even though I had allready developed a workflow for my previous projects, I learned some new options by reading this book.

Interestingly, serving as a guide from a to Z is not where Monohan excells. It should be used as an index to all the available options from this program. Want to know how to find those audio-peaklevels? How to get rid of that nested alpha-channel? Or you want to remember that trick in lassoing to trim mode? Use the index or the table of contents and you'll find what you're looking for in no time.

Great value for its price!

"Beyond Stone and Steel" by Brian W. Vaszily recounts a personal passage from one mental state to another far better one, describes the slow, step-by-step trudge often required by events much larger than ourselves.

That event might be death.
That event might be the loss of a job.
That event might be rejection.
That event might be bankruptcy.
Or the event might be national loss.

For this author, all of these experiences played a part in his transformation. Right from the first chapter, Vaszily makes no secret of the result; what he discovered on his path down misfortune's lane is that he is "a lucky man" in spite of the hardships he has suffered.

This slim volume may be difficult to take, depending on the reader's status with recovery from the events of 9/11. Regardless of one's recovery status, though, it may be just what the doctor ordered.
Carolyn Howard-Johnson, author of "This is the Place"

I've had this book a long time. I've read it many times. Each time I experience an expanded and enhanced spiritual and psychic understanding of an event I thought I'd come to terms with long ago. Probably because he doesn't journalistically report exactly what happened; probably because he presents the psychic reality of his personal experience: that experience enlarges our own. I was watching a local Spanish station at the time because, of course, the antenna for regular major news media broadcasting was destroyed. At the time I worked in an international on-line network. I remember being physically discomfited by others, elsewhere in the country/world, speaking as though they had some inherent legitimate authority to tell me what was happening less than 3 miles away (by flying crow). But that fortuitous allegation reminded me that the unthinkable event had happened to the "World" Trade Center - not the "New York" Trade Center. I remembered that New York Harbor was a major trading center, a stock exchange in physical goods dating back to the 1600s and housed in the Custom House which is still there. The traders were Dutchmen. I, too, have a semi-tangible psychic reality about the entire 400-year time line. We live in a spiritual world and there is still much that we really don't understand but we do get glimpses of it along the way.

This slim volume greatly humanizes the lives, hopes, fear and dreams of those about to die. It is fiction...no real names are used. It reminds us that of the thousands who died, every one of them was a living, breathing person, just like us. This is a small masterpiece and deserving of your attention.

"Beyond Stone and Steel" by Brian W. Vaszily recounts a personal passage from one mental state to another far better one, describes the slow, step-by-step trudge often required by events much larger than ourselves.

That event might be death.
That event might be the loss of a job.
That event might be rejection.
That event might be bankruptcy.
Or the event might be national loss.

For this author, all of these experiences played a part in his transformation. Right from the first chapter, Vaszily makes no secret of the result; what he discovered on his path down misfortune's lane is that he is "a lucky man" in spite of the hardships he has suffered.

This slim volume may be difficult to take, depending on the reader's status with recovery from the events of 9/11. Regardless of one's recovery status, though, it may be just what the doctor ordered.
Carolyn Howard-Johnson, author of "This is the Place"

This book was like none other I have ever read... the author seemed to digest this tradegy and somehow turned it into something beautiful. It has reminded me of all that I have, how easily it could be gone and to cherish every moment we are here. It has truly changed the way I see my life. I enjoyed this book very much and highly recommend it to everyone.

Despite its title this book is an easy and entertaining read for a broad audience. While specifically written from the perspective of management of software projects, the book actually addresses management at large. It makes a concise case showing how dangerous and detrimental it is (to the successful outcome of large scale (software) projects that is, defined by the author as a "quality product on time and on budget") to separate technical leadership/management from personnel leadership/management, as so often mandated by many organizations. The "manager-architect," as termed by the author in his book, is key to success. Consequently not everybody can be up for this task, and only few who dare to try will succeed at it, as evidenced by the disconcerting fact that many "top level managers" manage nothing but major budgetary overruns (be they hidden or not), for which they are "held accountable" by society by being hailed as "America's Best Leaders." This book puts an end to such phoniness and provides especially the inexperienced/naive reader with a skill set to reveal/uncover such mismanagement and the individuals responsible.

The book is a true eye opener for aspiring and "want-to-be" managers alike. Also, having posters on "true leadership" pinned to the office wall does not magically inhale the ability of leadership into the office occupant. Leadership is an ability rather than a skill as clarified by the author. It is just like playing an instrument: it only gets you so far if you do not have it in you and practice every day. Chapter 12 "The Impact of Leadership on Software Development" should be read by any manager (aspiring, "want-to-be", or acting alike), and in particular by those who confuse management with suddenly having power over people. Moreover, management does not and should not mean "tenure" along the lines of "now I have made it, now I can relax" or "now I am in power." Rather the "Old Fritz" (Friedrich II, Prussian King) statement, simple yet true, comes to mind: "I am the first servant of the country" ("Ich bin der erste Diener meines Staates"), and serves as a good guide.

The author puts forth an interesting concept for true autonomy founded on the philosophical considerations of the human mind, upon which the AI-(IF-THEN-ELSE)-community will most likely have to choke. In doing so, the author outlines nicely the profound difference between automation and autonomy, two terms, which are often confused, intermixed, or misunderstood, even by so-called experts in the field.

If management is done right, as exemplified/laid out in this book and practiced by its author in an exemplary fashion, managers would rather have to be pitied because of their huge added responsibility for their people/troops and the projects they manage/lead (in that order!). Special attention should be paid throughout the book and in particular throughout Chapter 12 to the "Machiavellian Prince," as this kind of "leader" unfortunately exists (and not in small numbers!), and, while striving only for personal power and gain, causes a lot of damage to otherwise noble causes.

The author of this book has deep insights and wisdom for any level of interface with computer science applications. You simply cannot go wrong for putting your weight down on patterns to follow from someone who has had success in the field. The techniques in this book go beyond basic head knowledge, into the live action of software development where the rubber meets the road. Only an experienced person can give these insights. I am very impressed with the advanced mapping, made simple. This book seems to be written for people who are looking to find answers to every day problems in a rapidly moving computer world, without fear.

Mr. deGyurky gives a great overview of his experience at JPL in organizing and developing large, complex, software systems, and delivering them on schedule, on cost. Mr. deGyurky demonstrated that the most important contribution to software management is that of leadership in life, carries over in software development also.

If you are thinking of becoming a manager of a software development project, you should check this book out, and You will be a step ahead of the game!

The author has given us a framework for conceptualizing, organizing and developing large, complex, software systems, and delivering them on schedule, on cost.

His approach to software development emphasizes two basic ideas. Unique is his application to the development process of the cognitive philosophies of the great Nineteenth Century German cognitive philosophers, principally Schopenhauer, Kant and Hegel, which De Gyurky has studied for years (- in the original Nineteenth Century High German). De Gurky also emphasizes to an extraordinary degree the active role of personal leadership required of the successful software development manager.

Far from being a purely theoretical work, the book is richly illustrated with pungent examples from De Gyurky's near-incredibly varied experience both in the US military as a Special Forces officer commanding a detachment of Montaignards in the mountains of Vietnam, as an action officer at NATO Headquarters, and as the civilian developer of very large military flight-schedule management systems as well as spacecraft software command and control systems.

All the examples are exquisitely pertinent to the software development process. But in addition, four detailed programmatic examples are presented, together with comments, figures and schedules. The author's application of the principles he developed is wholly consistent and unfailingly pertinent, if sometimes challenging, due to the likely unfamiliarity on the part of the typical software engineering reader with the application of the philosophical concepts.

In fact, the single characteristic of the book which may challenge the typical software developer is the accessibility of some of the concepts. Some of the most powerful concepts discussed, e.g., the dialectical process by which an ill-formed idea becomes an object that reflects the meeting of the minds of the design team, are likely to be unfamiliar. However this process has profound implications for the organization of the design team, its management, team-member responsibilities, and on and on. It might have been helpful if the author had expanded on these key concepts, perhaps in context closer to their original use. It would be demanding on the reader, but probably no more so than parts of the book itself.

This unique contribution is recommended to software developers interested in on-time, on-cost development of large software systems, and willing to invest in the intellectual effort required to understand the author's unique contribution. They will be well rewarded.

I have read many books on systems and software development and management principles over the years. The ones that most influenced me were: "More Reliable Software Through Composite Design" by Glen Meyers; "Up the Organization" by Robert Townsend; and "Reengineering the Corporation" by Michael Hammer and James Champy. And of course no system developer's library would be complete without "Managing the Software Process" and other books by Watts Humphry, a giant in our industry. Mr. Szabolcs Michael deGyurky's book will occupy a place along side these on my bookshelf.

In this book, Mr. deGyurky has provided a completely different and refreshing, but no less important, viewpoint on systems development. As different as all the above mentioned books are, the one theme common to all of them is their focus on the "real" problem by differentiating between the truly important and the seemingly important - commonly referred to as separating the wheat from the chaff..

"The Cognitive Dynamics of Computer Science" focuses on strength of character as being indispensable to successful completion of complex systems development projects, which not only satisfy the "real" requirements, but ensure the system is delivered within an agreed to budget and schedule. This book draws on the philosophy of such estimable historical figures as Kant, Hegel and Schopenhauer, among others, in defining the behavioral characteristics of successful leaders and managers. Personal experiences in real world projects by Jet Propulsion Laboratory (JPL) provide a substantive backdrop for Mr. deGyurky's approach to managing systems development.

It is impossible to adequately relay the impact of such a book in so short a review, but I do come away with some points which derive more meaning because of my own experience: 1) Design from the user in, but develop from the inside out, in layers, 2) Don't implement until you have an initial design documented and understood by the development team - expect that to change, 3) Manage change through the Project Implementation Plan (PIP), which is the Project Manager's equivalent to the Software Development Folder, 4) Don't hire staff until you have their tasks well defined (control burn rate and you have controlled your budget), 5) Make sure you understand exactly what your customer wants through constant customer involvement, 6) make your customer's goal, your goal, then incentivize the entire development team to focus on that goal as the highest priority, 7) There shall be no implementation without documented, repeatable process and standards, which should be tailored to the individual project, but at no time should process and standards replace common sense in a dynamically changing development environment, 8) Employ tools and ensure the team is involved in their selection, 9) Ensure the development team is trained in methodology, process, standards, tools and system requirements, and 10) the manager should place the needs of his customer and his team ahead of his personal goals.

All of this is done in concert with the philosophical teachings of our great philosophers, who would encourage strict honesty and ethics in dealing with our customer, subordinates, colleagues, company management, even if it means being fired. Of course, one does not fit all the meaning of a 300-page book into such a short review, and one could easily list another 10 or more points of interest.

I agree with almost everything in this excellent book, but may differ on the role played by Computer Aided Software Engineering (CASE) and Computer Aided Design (CAD) in systems development. Since CASE tools became mature enough to use effectively, I personally selected my tools, then built my process and standards around them. This includes the way I modify process and standards (including DoD) to conform to streamlining development and associated documentation. The CASE tool, when used with discipline can ensure that interface errors are avoided during the design process, as provided through automatic leveling and validation as the system design progresses. Fixed price contracts caused me to gravitate to using the latest tools available and build around them each time.

I am certain that Autonomous Cognitive systems are in our future, but not without application of increasingly sophisticated CASE tools and compilers (Autonomous Cognitive Compilers), which can parse complex combinations of Boolean expressions with many operations per expression to simulate the human thought system in making decisions. Neither can these systems be built without addressing the transducers (sensors), which would connect to and provide stimuli to be interpreted and processed by any autonomous system as the 5 senses (sight, hearing, touch, smell and taste). I look forward to Mr. deGuyrky's next book, which may address this highly complex problem.

I would only close this review with one last comment, directed to JPL. Mr. deGyurky and his team were on the right track with Ada. It is unfortunate that JPL didn't adopt this very highly typed and disciplined high order language as their standard development language. I believe it would have saved more than one failed project. Based on my 40 plus years of developing computer systems, I would humbly suggest that JPL require mandatory use of Ada in all "Class A" development projects.

Planguage is a word and concept that combines Planning and LANGUAGE and is rooted in the author's experience since 1960. The core tenant of Competitive Engineering is that well structured specifications have a dramatic cost reduction over down-stream error correction. The defect prevention process (DPP) is used to clean up early stages specs, or preferably measure defects and motivate lower defect injection, in specifications and the attendant issues instead of relying solely on defect detection andcorrection once actual development has begun. Competitive Engineering provides focus and skills to dramatically increase how productive many of us have been in the past.

The centrality of quality specifications means significant gains for the broadest spectrum of stake-holders who stand to win with the System Of Interest (SOI). Take this specification as an example to clean up:

"The new system will use Foo language running on OS Bar and ensure top industry quality response time on web requests."

People in the field have seen specs like these. Hopefully you aren't writing them. There are what Gilb classifies as "Major defects" in this spec. Which web requests, the front page or all of them pulling from the various databases? Can the old system be incrementally upgraded instead of an entirely new development environment? Why use Foo and Bar if something else gets the job done better, faster, and with less resource utilization? Just how fast is "fast", anyway?

In Competitive Engineering you're told to get measureable quality requirements, record who requested that requirement, and exactly what "success" is defined as. That allows you to go back to the requester with notes such as "If we use OS Baz we'll get a 27% increase in CPU performance" and let them make a decision or escalate to the project funder. You're also encouraged to weed out "design constraints"; at least out of the mandatated and into the labelled area "Design Constraint". Wouldn't it be great if you got a specification that let you design the best you could without technical input from someone that can't use a web-browser?

See if you can understand my re-write of the above spec into Planguage.

Response Time on Front Page of Company Website.

Type: Performance Requirement
Version: 1.2
Status: Draft
Owner: F. Flintstone

Stakeholders: Marketing, Server Support, Corporate Intelligence, ,

Ambition: The front page of the corporate website should respond fast enough to keep the viewer's attention.

Description: Marketing research indicates the typical business website viewer makes an opinion on the website, and thus the company, within 20 seconds. Our corporate site pulls data from three different databases and a sizeable image library, taking an average of 26.87 seconds on a home DSL/Cable modem equivalent network. Marketing advantage can be gained if we can grab viewer attention noticibly faster than our two nearest competitors who average 23.43 and 26.09 seconds, respectively.

Vision: Enough accurate information provided quickly enough to keep the customer on our site.

Scale: Time, in Seconds, to a complete front page load on the equivalent of a 250K network connection.

Past [Front page, 1 Apr 07]: 26.87 seconds

Goal [1 November 07]: 19 seconds <- Marketing Director: BR

Stretch: 15 seconds

Wish: 9 seconds

Design Constraint: Supportability <- Server Support Manager WF Must utilize .

Design Constraint: Security <- Corporate Intelligence BB Must meet .

------------------------ end of spec example --------------------

Probably the only thing that might confuse you about that specification is the use of text within "<...>". Planguage uses that to denote a "fuzzy requirement"; something that is defined but not with the concreteness you'd like. In this example, however, it would be relatively simple to query B. Rubble for the specific guidelines her team seeks to enforce. The use of fuzzy requirements also allows for change over time; more OS versions may become supported while others are obsolete.

When I read part of an electronic copy of the text I had a problem. My antiquated home printer could not print it and if I used the work printer I view the output as a possession of my employer. The book is written as part instruction, part reference manual; I bought my own copy because I know I'm going to use it for the next few years and several employers.

This is one the books which has caused a great impression on me. It helps to get away from high-level, gut-feeling, fuzzy goals and descriptions to very concrete targets, unambiguous requirements and rational decisions. This strikes a chord at the heart of systems design and architecture, which consists in maximizing a set of business goals with limited resources (time, budget, personnel). I highly recommend it.

Building software systems is not easy, this book can help you to do a better job.

In a period where the trend is to follow agile approaches with condensed guidance (see the 12 principles of the Agile Manifesto for instance), it could seem strange to publish a book on software development with more than 500 dense pages. You should however not be frightened by this book. Beneath the size and the structured form lies an approach based on practical experience that incorporates change and flexibility without abandoning the quest for precision and delivering value.

The main concept of Competitive Engineering is Planguage, a word created mixing plan and language. Communication is the basis for working together. This is why Tom Gilb emphasises first the creation of a common vocabulary. He states that his glossary could be considered as the best contribution of this book. Beneath the definition of a common language, for me the "hidden agenda" of the book is to help us to think... further. The common language is only a tool that helps us express our thoughts more precisely and completely.

Fortunately for us, Tom Gilb didn't only write a dictionary of system engineering. A large part of the book is devoted to the activities of system engineering and project management. Based on Planguage, Gilb gives us a framework to elicit clearer requirements. He emphasises a measurable vision ("bad numbers beat good words") and presents tools to achieve this objective. He also helps us separate requirements from design. He devotes an entire chapter to quality control. Finally, there is a presentation of the techniques of evolutionary project management that supports incremental development based on the priority and impact techniques described in previous parts of the book.

In every chapter you will find examples and case studies that help to visualise how the concepts translate into practice. There is also an "additional ideas" part that presents material for further thinking. Beneath the seriousness of the topic, Gilb also manage to place some lighter parts and you will find how to compare seriously apples with oranges.

At the end, your realise that you have a book where process is not opposed to people, structure is not opposed to flexibility, precision is not opposed to allowing change, documentation is not opposed to active refinement, Gilb's proposed solution is not opposed to customisation for your needs. It is just a book that gives you new inspiration to deliver better software solutions to your customer.

If you are interested in software process improvement, you can read this book from the beginning and find practical material to examine your current practices with a different vision. If you are a lonesome project manager or developer, you could begin by just using the index to get Gilb's view on your current activity or problem. Be cautious, because there are many chances that you will be tempted to read more material ;o)

After reading this book, I browsed again my old copy of "Principles of Software Engineering" that I bought when it was published in 1988. I saw that many ideas from "Competitive Engineering" were already presented in this book. Tom Gilb just applied to his ideas the same concepts he proposes for system engineering. He refined, expanded and structured them to get a better product. The printing industry has just prevented evolutionary delivery, but you can bet that he will find a way to include this in the future.

My interest in the topic of competitive engineering (CE) was piqued several years ago when I heard very favorable comments about Tom Gilb's tutorial on that subject at the INCOSE 2002 Symposium in Las Vegas.

The book's subtitle is "A Handbook for Systems Engineering, Requirements Engineering, and Software Engineering Using Planguage". The term "Planguage" is central to an understanding of the book. Planguage, which is derived from a union of "plan" and "language", is the methodology for implementing CE. Much of the book is devoted to describing the generalized processes, rules, and vocabulary of Planguage. Tom notes, "Planguage should be viewed as a powerful way to develop and implement strategies that will help your projects to deliver the required competitive results." Fundamentally, the book presents a new take on best practices in systems engineering and management.

The book is useful on several levels. For organizations without a formal or documented process, tailoring of Planguage would jump start the process at a high level of maturity. For organizations that have achieved CMMI level 3 status, Planguage by itself is not as useful. However, many of the ideas of CE-the Planguage methods-are worth considering for enhancement of existing organizational processes. Tom states that CE is "about technological management, risk control, and breakthrough improvement in complex business systems, projects, and processes." CE is a believable approach for delivering complex projects on time and within budget.

The book passed my value-added test, when I realized that I was photocopying several pages for future reference, to be part of my "toolkit" of helpful tips and techniques. I particularly enjoyed reading the 10 often witty, summary principles in each chapter. Two examples are:

* The Principle of `Storage of Wisdom': "If your people are not all experienced or geniuses, You need to store their hard-earned wisdom in your defined process. Capture wisdom for reuse, Fail to write it, that's abuse!"

* The Principle of `The early bird catches the worm': "Your customers will be happier with an early long-term stream of their priority improvements, than years of promises, culminating in late disaster."

About 30% of the book is the Planguage Concept Glossary, which Tom views as a central contribution of the book. I focused my attention on the other, more interesting, parts of the book, which describe the main CE/Planguage methods of Requirement Specification (RS), Design Engineering (DE), Impact Estimation (IE), Specification Quality Control (SQC), and Evolutionary Project Management (EVO, also known as Evo). RS describes an approach for identifying all types of requirements while avoiding ambiguity and also planning for change. Functional and performance requirements are distinguished. DE deals with identifying, choosing, and prioritizing the order in which design ideas are implemented and delivered. In conjunction with Evo, DE selects the design ideas most likely to provide a significant benefit for early delivery.

SQC is an eminently practical approach for evaluating the quality of any technical document via sampling measurements. An hour of SQC early in a project can save almost 10 hours of rework. SQC also provides a means to assess the success of process improvement efforts. IE provides a realistic method for evaluating-in quantitative terms-the effectiveness of designs in meeting both the requirements, especially critical performance attributes, and the resource budgets.

Evo focuses on early, frequent delivery of project results via a series of high-value, small evolutionary steps. An ideal Evo approach would divide the project into a series of cycles. Each cycle would consume 2-5% of the total financial budget and 2-5% of the total project time-while delivering some measurable, required results to the stakeholders. The next cycle is selected to deliver the best stakeholder value for its cost (highest ratio of value to cost, or highest ratio of performance to cost). Although an ideal approach can't always be realized, Tom provides some convincing examples to argue that there is always a solution to making a project evolutionary (small steps with critical deliveries first).

Perseverance pays off with Competitive Engineering. The book is not a quick read, which Tom acknowledges. You have to carefully study some of the pages to understand the concepts being presented. The reward occurs when you glean the nuggets of wisdom from the numerous practical examples, case studies, and Planguage examples. Tom's way of presenting the CE concepts makes the book a useful addition to the systems engineer's library.

I was mainly interested in the MES implementation part and I found those chapters quite inspiring. We are usually lead by "common practices" which form our experience and we'll use them throughout our work. But formalizing and being able to communicate a technology is always an issue (unless you're going to di it all by yourself).
Excellent.

"Domain Specific..." is another excellent book from the "Fraemwork collection". It is a set comprehensive reference books as well as a authoritative textbooks by experts in this growing research field.

The description of practical experiences as well as more conceptual descriptions, are usefull to understand the complexity of achieving high levels of software reusability.

Managers and academics, will find a lot of material to help them decide if this is the way to go. Our research group in Web Engineering at the University of Sydney (weg.ee.usyd.edu.au) will us it extensively to improve our development practices.

An almost indispensable 3-volume reading to understand the success of framework technologies in today's software systems. The books include most of the top
articles on the subject, providing a thorough insight in both design and implementation issues regarding frameworks, also complemented with practical experience
about framework usage. Although the work is mainly concentrated on technical aspects, the articles are comprehensible enough to be taken as reference material by
a broad community, for example, software engineers, programmers, or technology managers. The books are useful for anybody planning to include
framework-based techniques in software development processes or planning to improve current object-oriented practices. It is also an excellent source for graduate
courses.

Volume 1 lays the fundamental concepts supporting object-oriented frameworks, and describes the problems and challenges that this
technology raises in software development. The book covers topics such as domain analysis, development concepts and approaches,
documentation, and management, among others. Of course, the compilation of articles makes some parts little redundant, but this is a minor detail compared with the
fruitful contributions made by the book. In particular, the articles on reusing hooks, hot-spot-driven development, composing modeling frameworks in Catalysis, and
composition problems, causes and solutions, are a sample of the outstanding level of this work. Each chapter adds at the end a number of related questions and
student projects aiming to reinforce concepts and promote further investigation. As a comment, novice readers should take the sections concerning hooks and
hot-spots carefully because these topics are presented in a slightly confusing way.

Volume 2 focuses on specific framework implementations, dealing with existing frameworks for different application domains, such as businesses, multi-agent
systems, languages and system software. In this book, the readers will find a level of detail much closer to specific implementations issues than in the previous
volume. Nonetheless, the writing style remains mostly clear and accessible for a quite broad audience. The case-studies and experience reports described by the
articles show an attractive industrial perspective of the framework approach, and more important, they go an step forward in the road of a more mature discipline for
software development. In addition, a
CD-Rom with concrete examples of these applications is included with the book.

Volume 3 completes this series with a number of domain-specific application frameworks developed by industry, showing how to apply the concepts and ideas of
the previous books in software products. In this line, it includes very interesting frameworks for manufacturing systems and distributed systems, among others. It also
goes through concrete software scenarios, illustrating the benefits of combining domain knowledge and object-orientation expertise. Although the level of the articles
is rather odd, the volume certainly provides the readers a realistic picture of the problems of building and adapting frameworks by learning from others' experience.
A CD-Rom is also included with this book.

Overall, these framework books collect the state-of-the-art on framework development, offering a comprehensive and
easy-to-understand guide for both academics and practitioners in the field. It is clear that framework technologies will not solve all the problems (perhaps they rise
more challenges than current approaches), however, taking advantage of the framework possibilities can make your development process more repeatable,
productive, and also less painful. The gains of this retrain are no doubt a good investment.

A great reference and compilation of timely material. For anyone interested in frameworks targeted to specific application domains, this book surveys a broad spectrum of example systems while providing detailed in depth information concerning the particular requirements and features necessary for each domain.

This book in conjunction with the books "Building Applicaton Frameworks: Object-Oriented Foundations of Framework Design" and "Implementing Application Frameworks: Object-Oriented Frameworks at Work" are a series of three books that constitute a complete and necessary guide for the design and implementation of application frameworks. They are based on multiple academic and industrial contributors experience building a wide range of domain-specific application framework. These books are very easy to read and understand and you can learn from them not only what a framework and an application framework are, but also how to apply this technology to real world domains, like manufacturing, health care, distributed computing, real-time systems, simulation environments, ...

First book, "Building Application Frameworks: Object-Oriented Foundations of Framework Design" introduces application frameworks, their benefits and problems. It addresses all the fundamental concepts behind OO application frameworks and provides guidelines for OO application framework development. It is organized in eight parts. Part one provides a complete overview of OO application framework technology describing what is an application framework, what are the problems and benefits of application frameworks and how to use, develop and evaluate an application framework. Part Two presents some historical application frameworks and discusses some general guidelines to increase the reusability of application frameworks. Part Three describes how to build a framework analysing a concrete domain. The rest of the book provides all the necessary information to completely build an application framework. It presents all the concepts managed in framework development, which are the different development approaches, how to test the resulting frameworks, the problems derived from integration and a question sometimes forgotten but very important, the framework documentation.

This book, "Domain-Specific Application Frameworks: Frameworks Experience by Industry" is focused in the experience of industrial and academic contributors in the development of OO application framework in different domains. Each chapter covers step by step the complete development of an application framework in manufacturing, distributed systems, real-time systems, telecommunication, multimedia, chemistry and data visualization domains. It includes the motivation developers founded to choose application framework technology, the problems they had to solve and the final solutions they developed.

Third book, "Implementing Application Frameworks: Object-Oriented Frameworks at Work", shows step by step how to implement application frameworks in different domains. It is organized in six parts covering examples about i) Business Frameworks with different examples in sales and administrative domains, ii) Artificial Intelligence, iii) Agent Application Frameworks, presenting interesting frameworks for speech recognition, neural networks and agents. iv) Specialized tool frameworks, v) Language Specific Frameworks, vi) System Application Frameworks, which present and analyse the application of OO frameworks in combination with other methodologies as component-oriented programming, language constructs or constraint programming and vi) Experiences in Application Frameworks. This last section is very useful because analyse the lessons learned using the application framework technology.

I bought this book quite a while ago and I absolutely the format. It's a great resource to just pick up and get great ideas, verify that you are on/off the right track and generally learn how to get to the next level with XML. Highly recommended

The flexibility of XML can often mean that there's a gap between using XML and using XML effectively. Elliotte Rusty Harold's book Effective XML - 50 Specific Ways to Improve Your XML (Addison Wesley) is an excellent way to move towards the latter condition.

Chapter List: Syntax; Structure; Semantics; Implementation; Recommended Reading; Index

There are obviously a large number of books that will teach you the semantics of writing and using XML. But just because you can create an XML file doesn't mean that you've done it well or effectively. Harold's book provides a bridge to being able to create XML files that will be usable in nearly all situations. The book starts out in the introduction with explanations of terms that are often confused (element vs. tag, text vs. character data vs. markup, etc.). Then there are four parts of the book that include a total of 50 tips that will improve the quality of your XML usage. Some tips are pretty basic, like "Include an XML Declaration". Others are more complex like "Verify Documents with XML Digital Signatures". But every one is practical and useful for making sure that your XML is widely useable by all potential applications.

Excellent bridge book to read after you've learned the basics of XML. This is a book that, when taken to heart and used, will cause your coworkers to thank you.

Effective XML is a collection of about 50 tips for working with XML. Although XML seems is simple and easy to use, it's also easy to get wrong. I've often scratched your head and wondered why things like XML Schema, for example, just doesn't feel right. But it wasn't until I read Effective XML that I understood what was really awkward with it.

Because the book is so diverse (an amazing feat considering the small page count), it is hard to single out any specific part as being a reason to read the book. The book doesn't just talk about schemas, the infoset, etc..., it digs down and really explains what is good and bad about the technologies and what the best ways to apply them are. All I can say is that I use XML day in and day out and have learned everything I know by trial an error. I've made many mistakes along the way. I've tried my best to learn from them, but Effective XML was the book that made everything click for me. The best part is that the book went well beyond just helping me see my errors. I've already applied some of the ideas to new work I've done recently and have been able to head off some of the problems I would have encountered.


Effective XML is by far the best XML book I've ever read, and quite possibly the best tech book I've read all year. I might even have to add it to my favorite tech books list. If you work with XML to any significant degree, I can't recommend this book highly enough.

Elliotte Rusty Harold states in the introduction of Effective XML that the book is neither an introductory book nor an XML tutorial. Rather, it is a distillation of the author's experience using and teaching XML and how to use it effectively. The book does a great job of explaining how to use XML and its related technologies.

The book is divided into four major sections: Syntax, Structure, Semantics, and Implementation. Each of the fifty Items packs a lot of information into a few pages. The Items span topics such as why you should Include an XML Declaration (Item 1), Make Structure Explicit through Markup (Item 11), Program to Standard APIs (Item 31), and Write in Unicode (Item 38). Even the Introduction is valuable because it sets the definitions for XML-related terms used in the rest of the book that the author has found to be used interchangeably or inconsistently.

Item 24, Choose the Right Schema Language for the Job, provides a typical example of the great information contained in Effective XML. This Item discusses the strengths and weaknesses of four schema languages: W3C XML Schema Language, DTDs, RELAX NG, and Schematron. The use of programming languages to handle situations that the schema languages can't handle is also discussed. The Item ends with a set of questions to think about when selecting the schema language to use.

I found the book very readable and like that the information is presented in digestible chunks. Effective XML isn't meant to hype XML but to identify what the actual capabilities of XML and its related technologies are and how best to use them. The book does an outstanding job at this task.

Full disclosure: I received a complimentary copy of the book for review.

This is not a book explaining XML. This is not a book that goes into any depth on XML APIs. It is not a book explaining any one XML format like XSLT, RSS, or XSD.

Instead it is a book on how to work with XML. How to design an XML application to take full advantage of the facilties of XML: schemas, processing instructions, XSL transforms, namespaces. It is all structured to slowly introduce you into the complexities, and deserves to sit up on the bookshelf with Effective C++, Java and Enterprise Java.

If you already know the basics of XML, it is actually quite a good way to learn about some of the more esoteric concepts -from the pragmatic perspective. Too many XML books rant about how wonderful some feature like XML schema's extension stuff is, why XML is the most universal format ever, SOAP and WS-* the best protocol for distributed systems ever, and XQuery everything you need for an XML database.

This book bursts the bubble of hype with rational analysis of what makes sense, and what doesn't. Item 28: Use only what you need, is my favourite: A review of the main XML specs and analysis of what really matters, which comes down to #35, navigate with XPath.

If you are designing an XML schema/system/application, you need this book. If you have to put up with architects telling you about WS-MetadataExchange, WS-Transfer and RDF, you need a copy to roll up and hit them over the head. And, if like me, you are involved in standards bodies that produce XML related things, you need to buy a copy for all the other participants, so that what you produce will actually work.

Remember that XML is a language designed for use by people and machines. The machines have the upper hand. But with this book, and some thinking, you can design XML applications that people can use.

We've had this book for a long time and we still bring it out every now and then.
I think we enjoy the nostalgia of reading a favorite book together and we still
like seeing Marvin's adventures in the city and trying to remember where the
emu and the cat are. It took us years actually to find the emu on the subway.

This is an awesome book. I used it with fourth graders to teach the organization trait in the 6 traits writing. The kids loved the story and suggested we write a spin off of the book. They did an awesome job and made their stories into books and illustrated them. Highly recommend it to get students motivated to write.

I had never heard of this book before my son received it as a gift. He was about 9 months old and would insist that we read it again and again. He is now 4.5 and still likes it. And his little brother has enjoyed it just as much. The illustrations are fantastic and its fun to search for Marvin on every page. I highly recommend this book. I also love the language - it uses fantastic, descriptive words. My soon was 2 and used the words mesmorized and exhilarating because he learned them from this book.

My preschoolers love this book, not just because of the vivid illustrations that go with an easy-to-follow text - they love locating the hidden ostrich, police officers, and black cat tucked into nearly every single page. Check out the clouds...they look like fish, dinosaurs! Can you find Santa Claus hidden in Yankee Stadium's crowd of thousands?

I confess - my husband and I love finding the hidden pictures, too. Its also our favorite birthday gift for my kids friends. Get the book and scan the illustrations closely! Fun!

My three-year-old son enjoys this book so much because it lends itself to active participation. It is fun for him to spot Marvin, the escaped ape, in various settings ranging from a subway train to a ballgame to a ledge on a building. He also enjoys finding the two policemen who look for Marvin as he moves from locale to locale. I don't mind re-reading this book because of the clever illustrations and appealing New York City backdrops. And after reading the book for the first time, we have make a joke of finding Marvin--I say "Where's Marvin?" and he'll jokingly point to other animals or objects. His enjoyment of this book won't last forever, but it's been providing amusement for a few weeks now.

I couldn't put this book down until I finished it. Kerry does a great job of taking the reader behind the scenes at Fox.

It looks like I'm one of the few reviewers that didn't work for Fox Software. However, I have used and developed in FoxPro a lot over the last 15 years. It's still the best RAD tool that you can buy despite its treatment by Microsoft.

I thoroughly enjoyed this book and I think that anyone who has worked in software or worked for complete butthead would also like it and relate. It's so well written that I just wish it were longer.

Recently, I read Mr. Nietz's book while on vacation and found it to be very interesting and hard to put down. Within a couple of days I was finished with the book. This book is for all audiences and you don't need a degree in computers to enjoy it. I highly recommend this book and I look forward to reading other books by Kerry in the future.

Once I began this extraordinary book, I could not put it down. It's a page turner with a story that will appeal to all readers. I worked at Fox Software with Kerry for over 4 years. This story of Kerry's experience at Fox Software is a wonderful reminder that how you get to the top is more important than how high you get.

There have been many stories of what the inside of the high-tech business looks like from the most famous and successful business leaders. Most of these stories are attempts to write history and promote themselves. This story is about a hard working and honest guy who wants to work hard and make something of himself by joining a small software company. After reading this book you can tell that Kerry wrote this book to just share his experience. He is not trying to promote himself, and by doing so he tells a story that so many people can relate to, and he records for all of us a fascinating story of a small software company at a time when the industry was growing exponentially.

This story has a happy ending, despite all of the obstacles presented in the book, Kerry and others continued to work hard and were rewarded years later at Microsoft. I am looking forward to more great books from Kerry.

FoxTales is an excellent read. Once I got started, I simply could not put it down. As an employee that actually worked in the offices of Fox Software, I always felt that Fox Software was a company that succeeded more in spite of its uppermost management, rather than because of it. At times Fox was an exciting and awesome place to work and at others, it was humiliating and torturous. Kerry does a great job of presenting the experience as a whole and of wrapping up a series of somewhat loosely related events into a very entertaining story. It's nice to see someone tell the outside world what it was like at Fox Software.

If nothing else, Dr. Fulton had an excellent eye for talented developers and he certainly did manage to assemble an incredible team. It's great to see how Keary and others were eventually rewarded by Microsoft for their efforts and perseverance.

I have a virtual calculator called the DIY Calculator that accompanies my own book "How Computers Do Math" The Definitive Guide to How Computers Do Math : Featuring the Virtual DIY Calculator.

I recently added a "Conundrums, Puzzles, and Posers" section to the "Programs and Subroutines" page on my DIY Calculator website ([...]) and I've started to build a collection of simple puzzles for people to play with.

One of the first problems I posed was to count the number of ones in the 8-bit accumulator and to present the result as a binary value. I thought I had discovered the best-possible solution, until someone pointed me in the direction of the "Hacker's Delight". (In this context, "Hacker" refers to a hero who is manipulating code; not a nefarious rapscallion who breaks into other people's computer systems.)

I immediately ordered a copy from Amazon, and took delivery just yesterday as I pen these words. This book is fantastic - I kid you not - on the first page of Chapter 2, for example, I discovered at least five or six capriciously clever tricks that blew my solutions out of the water!

I highly recommend this book.

My first introduction to binary operators wizardry was in a 1st year, 1st semester course in Digital Systems at the Technion, IIT. I thought it was fun. While I was trying to write a computer program to compute Karnaugh Maps for me, I run into performance problems, and then some binary hackery helped me get back on the horse.

Since then, whenever I come across some binary trick I write it down with a few examples of usage and sometimes with some reasoning why it works.

Then came "Hacker's Delight" and I felt compelled to buy it.

I wasn't disappointed at all! Not only it contained all of the tricks that I have collected, but also it contains a lot more in depth examples of how these tricks can come in handy when trying to squeeze performance from an implementation or save a few more bytes and bits.

The book also gave me a fresh perspective on the implementation of some well known algorithms with the twist of binary arithmetic. This was very enlightening.

I read the "BASICS" chapter (chapter 2) with a single breath of air, and just couldn't leave it down. Not only it was nice to have all these tricks summarized in one book, but also I liked some of the reasoning and the "so-called" proofs.

Remaining chapters were, as I mentioned before, a fresh look for me on known algorithms. This fresh look was through the glasses of binary arithmetic.

I'd recommend this book to anyone who feels comfortable with binary arithmetic and/or computer organization -- even just for the fun of it!

I'd recommend the book to developers who don't necessarily have a sympathy to this topic, but would like a Copy&Paste solution to some problems they have to tackle.

I really enjoyed reading this book, and I will probably reference it from time to time.

The term "hacker" in this book means someone who enjoys making computers do interesting tricks regardless of whether it turns out to be useful, not someone who is intent on circumventing computer security. Plus, how relevant would those kind of tips be coming from a book that was written in 2002? Don't let the author's definition of a hacker fool you, though - the tricks in this book are very useful.

This book is a collection of small programming tricks on various subjects. The presentation is very informal, and the methods use very basic computer math. You should know your binary number system backwards and forwards before you start this book. Either C or assembly language is used to demonstrate the hacks in code form. When assembly language is used, it is that of a fictitious machine that is representative of RISC computers. That is because the tricks are meant to be platform independent.

After disposing of basic arithmetic operations early in the book, the author turns his attention to more complex math problems such as calculating square roots. His discussion of the subject is both complex and simple. First, he explains Newton's method of computing square roots through a page full of equations that require some effort to follow. Then he gives an implementation that requires fewer than twenty lines of C code. This is followed by another method that is longer and more cryptic but executes faster, by using a binary search algorithm. Whether you are interested in the equations or merely need the C code to do your job, these solutions are efficient and elegant.

Other topics addressed include Gray codes, the Hilbert curve, and prime numbers. Gray codes are a method of arranging the integers from 1 to N in a list so that each number can be visited exactly once by flipping only one bit at a time. The Hilbert curve is a similar idea expressed geometrically: a single continuous curve which, given a space divided into a grid of squares, touches every square exactly once and does not cross itself. In each case, both the mathematical discussion and the code to solve the problem are provided.

The chapter on prime numbers is the most challenging mathematically but also one of the most interesting. It starts with a concise overview of various mathematicians' efforts to devise ways of finding prime numbers. The author is one of those people who periodically become fascinated by some problem and devote themselves to learning more about it and searching for a solution. The chapter ends not with the usual code sample, but instead with an invitation to continue the search for interesting solutions to the problem.

Clearly, the author views this book not as a finished collection, but rather as a snapshot of work in progress. After decades of interest-driven research, the author has amassed a collection of studies big enough to fill a book, and it is fortunate for the rest of us that he has written one.

They don't make them like this anymore. Amid the "Learning XXX in 21 days" and various other computer book for which depth is almost non existent (and are read like eating peanuts), this is a refreshing book that talks about solutions to sometimes common (IMHO) coding problems.
If you enjoy programming gems, or remember that beyond your C code there is a machine that executes your program, this is the book for you. For example, think how would you count the 1 bits in a 32 bit integer - the book has an elegant solution in log(n). Aside from this, the book has about 50 or so problems, with their solutions (and proof).
Bottom line: fine book, worthy to be near my Knoth, R&K and Stroustrup books.

This book is an absolute essential to the right reader. That right reader is either a low-level coder, a high-level logic designer, or someone who builds tools and libraries for same. In other words, not a lot of people. This is hacking at its bit-level finest, though. If you're among those few, or think you might be, or want a good laugh at the people who are, dig in.

It's good for things like counting the number of 1 bits in a word-length integer (hint: if you count the bits, you're doing it the hard way). It's good for things like fast division by an integer constant, or mod to a constant integer modulus (hint: if you perform division by dividing, you're barking up the wrong tree). If you can look into a 32x32 bit multiplication and see a convolution going on, you're way ahead of the game. The only tricks I know that didn't appear here are A) for purposes that almost no one has or B) for machines that almost no one has.

Warren presents the coolest collection of slimy coding tricks ever collected, with full attention to the number of machine cycles and the compiler-writer's unique needs. I've seen a lot, and this is by far the biggest and coolest collection around. I have two complaints, though, a small one and a really big one. The small one is that the author didn't score a direct bullseye on my somewhat offbeat needs. Well, he never tried to - that's just me griping that he didn't write a different book. The big complaint is that pages, lots of them, just fluttered out of this pricey book and onto the floor. GRRR. This takes nothing away from the content of the book, until some critical page flutters off never to be seen again. Still, if you can keep a rubber band around it, this will be one of the deepest mines of coolness in your uber-geek library.

//wiredweird