Computer Science Books

I agree with many of the other reviewers - this book is great. I recently got Mathematica and found the imbedded Help browser a little cryptic at times. I purchased Mathematica Navigator after reading many of the reviews here. I haven't read the book from cover to cover, but instead use it as a reference after having read chapters 1 through 3.

I'm studying Matrix algebra, so I skipped to Chapter 18 and worked through the examples without any problem, save a small error on page 467 where an upper case P was typed in lower case.

Highly recommend for anyone wanting help making the most out of very powerful software.

Very well written and full of useful information to start learning Mathematica. It covers all the foundamentals.

This is a GREAT reference book. You won't learn how to program Mathematica from it. You will learn an amazing amount about how Mathematica works by reading it. If you don't believe me, check out it's thorough explanation of cubic splines. It's better than the Mathematica Help. It also comes with the complete book which can be installed in the Mathematica help system.

There is, literally, a wealth of information to work with in this book.

I would also strongly recommend getting An Introduction to Programming with Mathematica, Third Edition. This is a first rate "course in a book" for programming.

There are other books which are good. Between these two books, you will have an amazing arsenal to work with!

Paul

Mathematica is an excellent program, with good built-in and online documentation - although many feel the Documentation Centre in version 6 is not as good as the Help Browser in version 5.2. But sooner or later you will find a problem for which the official Mathematica documentation does not help. The program can then be very frustrating, as the syntax is complicated and error messages can be very cryptic. Help online is painfully slow, as the official resource, the news group comp.soft-sys.math.mathematica (Mathgroup), is moderated, so help requests have to be approved before they will appear. (The newsgroup sci.math.symbolic is sometimes helpful and since its not controlled by Wolfram Research, posts appear immediately). Hence Mathematica users will need one or more good books - more so than with other similar programs such as Maple or Matlab.

In addition to the book Mathematica Navigator by Ruskeepaa, I own several other books on Mathematica, including:
* The Mathematica Book, Fifth Edition by Stephen Wolfram
* The Mathematica Guidebook: Programming by Michael Trott.
* The Mathematica GuideBook for Symbolics (w/ DVD) by Michael Trott.
* Schaum's Outline of Mathematica by Eugene Don
* An Introduction to Programming with Mathematica, Third Edition by Paul Wellin
* Programming in Mathematica (3rd Edition) by Roman Maeder - I also own the first edition.
* The Beginners Guide to MathematicaRG, Version 4 by Jerry Glynn and Theordore Gray

plus a few more old books I've either had a very long time or bought very cheaply on Amazon.

Given the choice of only one book, I would choose Mathematica Navigator by Ruskeepaa. It comes with a CD-ROM which has the whole contents of the book, which may be integrated into Mathematica's help system. It's not unique in that respect, as so do Micheal Trott's Mathematica Guidebooks, but they have far too much irrelevant material in them. Ruskeepaa's book sticks to important facts about Mathematica. The book covers a wide range of topics. Sometimes I wish in more depth, but the book offers a good compromise between width and depth. In particular, the information on writing Mathematica programs is far too short, so its unlikely to satisfy someone wanting to write a major Mathematica package. For writing packages, Programming in Mathematica (3rd Edition) by Roman Maeder based on Mathematica 3 is arguably still the best, although Maeder's 1997 book is very old.

The only significant fault I can find of Ruskeepaa's book is its age. Mathematica 6 is a really major upgrade from 5 with many functions now built into the kernel which previously needed to be loaded from packages. Many functions or options have been deprecated. As such, some of the information is no longer accurate. But given at the time of writing (December 2007) there is no book on Mathematica 6 published, I think Ruskeepaa's book, which is based on version 5, is the best Mathematica users can get. However, if by the time you read this, someone has published a book on Mathematica 6, then it might be worth buying that instead.

I would have given this 5 stars, but it is getting a bit dated now.

I liked the first version so much that I bought this second edition also. The first edition was based on Mathematica 3 but this second edition is based on Mathematica 5 (Mathematica 6 has only just shipped within the past 2 months).

As did the first edition, this second edition comes with a cd that contains the entire book in Mathematica notebook form. The style sheets used to format the second edition cd notebooks are much cleaner looking than the first.

At anyrate, I definitely recommend the second edition even if you already have the first edition.

Kishor's book is one of the few highly readable books on queueing
and stochastic processes. The abundant examples and discussions
of reliability also aid in understanding the material.
I would recommend this book to undergraduates and beginning
graduate students.

Second edition of "Probability and Statistics with Reliability, Queuing and Computer Science Applications" by Kishor S. Trivedi is a highly recommendable book. The concepts provided for probability theory and stochastic processes are excellent for students of communication, networking and computer science. It provides a good understanding of stochastic processes and Markov chains which are very relevant for students and teachers especially working in the speech processing area. I found the book and its contents very relevant and the examples provided could be very well related to networking and computer science, a unique aspect of this book. The students grasped the concepts well and found the problems very challenging and helpful in building up their concepts and knowledge. I had previously taught a number of other books and introduced this book last year at my University, I feel very satisfied and content with the decision of choosing this book for my students. All eleven chapters are equipped with excellent examples, problems and exercises broadening the reader's mind. The first 5 chapters constitute the probability theory while the rest of the chapters emphasize on stochastic processes very relevant to students of advanced networking and speech processing. Other books on probability and statistics usually lack an important aspect specially when used for computer science and telecommunication students. The examples and exercises not only make students learn and understand and probability and statistics concepts but also create its relevance to their very fields, therefore the book is an extremely precious gift from Prof. Trivedi specially for the students of computer science and telecommunication. An inexpensive Asian edition (paperback), a solution manual and powerpoint slides of each chapter are now available.

Prof. Trivedi has done a tremendous job in introducing topics of advanced research not found before; the students gained knowledge about the modern research environment and felt confident too. This book is not only recommended for beginners but also for professionals and engineers.

This book from Prof. K. Trivedi is another great guide for the novice student and the expert researcher for modeling tools and techniques. It builds upon neatly explained concepts of probability, queuing and stochastic processes to provide a variety of examples of applications. It is definitely a book that one has to keep at hand, as it contains recipes for a huge number of performance and dependability evaluation needs. Besides the rich content, the structure and the presentation are great: a bit of theory and soon one example from practical life, the reader never gets lost but he is rather brought step by step to a comprehensive understanding of the topics.

The "Probability and Statistics with Reliability, Queuing and Computer Science Applications - 2nd edition " by Kishor S. Trivedi is a valuable reference for students and professionals. Didactically organized the eleven chapters presents the core concepts of probability theory and stochastic processes in an accessible easy-to-understand approach. The rich set of examples and exercises, based on numerous computer science and engineering real world applications, allow the readers to build their knowledge gradually.
I would like to highlight the system reliability fundamentals covered and articulate with the remains topics.

A very useful book. A good choice for somebody who is just starting to get a feel of the subject, or someone who is looking to build a strong foundation in the area. The best feature of this book is its lucid language. There are many books in the market, which cover a lot of material but, for the average reader, are very difficult to understand. The example-based approach coupled with a comprehensive material coverage are additional selling points. I would highly recommend this book

Good book for beginner, if you are just learning get this book.There are things in this book that took me years to learn by trial and error unfortunaely for me I only learned a couple of new things, but it did give me some certainty in what I did know. However Im now looking for a intermediate book which is what I really needed.

The book lives up to its reputation as being a beginners guide. Good resource for those now getting into computers. And, it also has some good steps for Vista too.

Like most people,i avoided the 21st century technology by continuly saying to myself it was not something i needed.I finally took the plunge,a friend set up my Toshiba A2125 and found the"Absolute beginners guide on your web page.It,s format coinsides with my 73 year old mindset.Congradulations Michael Miller

This a great book for aquainting yourself with your computer. If you are new to the computer world as I was you will find this book very helpful in taking control of your computer instead of it controlling you. It covers both versions of Windows: XP & Vista. I would recommend it to anyone just starting out. I think it would be safe to say it could save you a lot of time in the longrun and maybe keep you from pulling your hair out!

I have been using a computer for many years and still did not understand all the task/programs I could have been using. This book has been extremely helpful working as a primer explaining everything very clearly and is still up to date with the Windows Vista. I would highly recommend this book.

This book has completely smashed every possible expectation I had when I set out to read it.

Let me put it simply. There comes a time in every software developers' life when he contemplates the age old question of, "If I were to be stranded on an island and I could bring only 3 things with me, what would they be?" Well, this would be one of the 3 items. (The other two would be Windows Internals by Russinovich and some other obvious classic like the Windows via C/C++ by Richter, or UNIX Network Programming by Stevens). This book is easily on the same playing field as such classics as those, and its only flaw is that it is not 1,000 pages because when a book like this comes along, you really just don't want it to end. There is so much useful information in here.

The chapter on LPC debugging is worth the price of the book alone, as LPC is completely undocumented and you literally will not find this type of information anywhere else. Every single chapter in this book is filled with gems, and with the plethora of average books being released recently, it really took me by surprise to read such a well thought out book that hits all the right topics in all the right ways.

That being said, it is advanced. Yes, I realize the title says it, but too many books come out with the word Advanced in the title that are merely Intermediate. You need some assembly language, you need to be comfortable with native code, you need to not be frightened at the thought of debugging something for which you have no source code. But for those that meet the pre-requisites, this is a must-have in every sense of the word for the serious developers' bookshelf.

Chapters on debugging heap/stack corruptions are simply invaluable. Worth reading even if you think you know everything about those issues, this book will easily prove you wrong.

A very good hands on book with many gems of knowledge. It walks you through the processes of different debugging techniques with easy to follow screen shots. I definitely recommend this to anyone writing Windows OS dependent code and it is even a very good book to read even if you are a .Net or Java developer on the windows platform. Even if you consider yourself advanced in this area you will still find a few new tricks.

The focus is on debugging using tools other than Visual Studio. There is still a lot of useful information about other tools, but if you want to learn how to debug with the Visual Studio debugger, this is not the book to get.

Have you ever tried to debug a problem in a productive environment? Do you know how hard this can be, especially when you are not allowed to install or use your full Visual Studio environment? Or did you ever try to debug a problem which only happens at the customer's side? This book shows you how to do all of this, and much more. It shows you, for example, how to create and use a memory dump and how to set up and use remote debugging.

And this is a very concentrated book. It covers a very wide area of expertise. It is an indispensable companion for every real world programmer. It explains in detail some of the lesser-known areas of programming infrastructure, like stacks and heaps and the RPC (DCOM) infrastructure, the possible error symptoms and their analysis.

Did you know about the powerful tools in the Debugging Tools for Windows package? This book begins with an introduction to these tools. It shows you how to set up and use them. It introduces you to the user-mode and kernel-mode debuggers, the Global Flags, the Application Verifier and many other tools. All of them are available for free. And you can easily give them to your customers or to the IT department of your productive environment.

I purchased Jain's "The Art of Computer Systems Performance Analysis" for a 3-month graduate course, and I must admit that, in retrospect, I was a bit daunted by its size upon receipt (we were to cover the entire text). Further, I had my doubts about the relevancy of the text in the current environment, given its age.

But I must say, both of these initial questions proved wholly unfounded.

I've never used a text quite like this one before; it is a significant departure from the standard engineering text that weighs heavily on the side of analytical proof and mathematical equations, while foregoing textual elaboration. On the contrary, this book adopts a conversational tone whereby the author develops all of the book's topics in great detail, relying on substantial insight and experience. Truly, a breath of fresh air.

There's such a richness about this text, that a careful read--while admittedly quite time-consuming--is bound to give the reader a sense that he has just become the beneficiary of a heck of a lot of wisdom.

All of this is not to say the text is overly-subjective; in fact, there is plenty of detailed analytical analysis. It is just to say that the book is different, and one that exudes quality communication: it reads more like a lecture than it does lecture notes.

So, back to my initial doubts. It turns out that the verbose depth of material which constitutes the book's 720 pages is really a foundation of its main qualities: it is a very readable and highly-detailed exploration of the art and the craft of performance analysis. And it's for that foundational reason that its age is irrelevant.

A solid book indeed. It has the right mixture of theory and practical cases well dealt with. The techinques must be tried for performance analysis and implemented in real time projects.

This old book is one of the most valued on my shelf. I was first exposed to it in a graduate class, and I have to say that the book is so good I was not aware that my professor was not a good instructor until I had him a second time in a class where the textbook was less than stellar. Don't judge the book by a quick perusal either. At first glance, especially if you are looking at Part I, it looks like one of those books on Six Sigma that will put you to sleep. In fact, the vast majority of the book is quite interesting.

Part II, "Measurement Techniques and Tools", are where things get interesting. The good part about this entire book is that it uses problems in the analysis of computer systems as the basis of presentation for all tools presented. The graphs are excellent, the mathematics are largely self-contained, and if algorithms are presented they are usually given in numbered steps and an actual computer program shown. This is one drawback of the book - it uses the ancient Simula language for its demonstration code. However, if you are familiar with C, Java, or any of the other mainstream procedural languages, you'll find that Simula looks like very readable pseudocode, so this should not be an obstacle to understanding.

Part III is a section dedicated entirely to probability theory and statistics. Starting with the simple definition of the mean, this handy section not only derives all of the statistics you need in this book, it talks about common mistakes made in applying them.

Part IV is about experimental design and analysis. Using the mathematics developed in part three this section talks about all aspects of designing a proper experiment for the measurement or simulation of a computer system, including common mistakes and the best choice for the size of your experiment.

Part V presents the key issues in simulation modeling. First it discusses simulation terminology, simulation design criteria, and stopping conditions. Random number generation is the subject of three chapters in reference to inputs to your simulation. Finally there is a chapter on the commonly used distributions such as Bernoulli, beta, binomial, etc. that talks specifically about random number generation algorithms for each of the distributions presented. What makes this section so valuable is that although you may have possibly seen the math before, more than likely you don't know the value of each kind of distribution. This section makes that issue clear in terms of modeling computer performance.

Part VI is on queuing models, and is probably the most difficult section in the book. Although it is one of the better written pieces I have read on queueing theory, it is not as easily grasped as previous sections based on reading the textbook alone. There are examples present, and the book does a good job of presenting "the big picture" as to the use of queueing theory in computer performance analysis, but you may need outside material to really grasp how to set up a queueing problem from a mathematical standpoint.

No other book I've found does such a good job of discussing all of the topics covered and clearly tying it into practical issues in measuring and monitoring system performance. I highly recommend it.

I'm a performance analyst. I couldn't do my job properly without this book. It really is that simple.

This is an absolute gem. I really think that this book must be read by every CS/EE engineer. Performance analysis is always something that comes as an afterthought and engineers think that some some "mathematical" guy called a perf analyst will stop by after the product is completed and analyze the product. This is def wrong. PA should be done at every stage of production.

This book has been written assuming a novice reader. Several parts of the book have to re-read to really understand what the author is trying to convey, but trust me you will really appreciate it.

I suggest reading the following parts of the book(in order):

Part I (whole)
Part II (4, 5, 6, browse {7,8}, 9, 10 ) 10 is cool stuff..impress your peers with this
Part III (whole) read, re-read, re-read till you have digested every line..worth it really!!!!
Part IV (whole) read, re-read, re-read till you have digested every line..worth it really!!!!
Part V : You can skip this if you are not into simulation.
Part VI : Not really that easy to follow. I suggest Gunter's book for this.

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.

I have to say that this is a true classic. It gives a very nice treatment of what is NP-completeness in a fashion that really defends the topic well. It gives nice illustrations to show different situations and how to deal with it. But after the first couple of chapters it does get a little out there with the proofs it does. It is still approachable, but it assumes that the reader is already familiar with the basics of combinatorial complexity, especially in reductions. I would only recommend this book to readers who has gone through such books as Introduction to Algorithms by Cormen et al. or Combinatorial Complexity by Papadimitriou and Steiglitz. Those two books are more for beginners and this book should be one to help anyone interested in NP-complete problems to get more practice and depth understanding. Overall a great book for anyone interested in the topic. The grand challenge is to reduce everything to at least something within the 150 problems listed on your own.

The book is excellent in explaining NP-completeness problem. Take it as a reference if you would like to do research in this field.

This is a rare example of a textbook where the authors actually go to the trouble of considering the fact that the intended reader is a non-expert. Published in 1979 and still the best.

The book arrived in time, in good condition, and adequate packing.

This is among the most eloquently written books that I have ever read in my life. Highly recommended.

Most texts on industrial control are long on theory and short on practice. This book is a rare gem that presents the theory (without overloading you on details) and then explains how to actually use the theory in practice. (One note: the practical applications are focused on electric motor control, which is the author's background.) If I had to have only one book on controls in my library, this would be the one.

This is a really good book that simplified control system for the real world. Most text spend too much time on theory and analysis and end the discussion with a bunch of equations and graphs without explaining how to implement the design. This book covers both analog and digital control, and lets you download a software from the author's web site. This software, ModelQ, lets you play with various parameters so you can see how the system behaves when it is not optimized.

One drawback with the book is it only covers PID control and its variants, but doesn't cover state-space control. While state-space control may be considered "overkill" by many control engineers, state-space is used in industry. The decision to use state-space is often not in the hands of individual engineers, so it may not be an option to ignore state-space. It would be nice if Mr. Ellis could cover state-space in his next edition of the book.

I had three main reasons for buying this book:
1. To bridge the gap between the control theory from school and the systems that I now design and build
2. To gain insight on how to improve the performance and reliability of real motion systems
3. To find ways to apply advanced techniques to help meet challenging performance requirements

I got all of this and more from this book. The topics covered clearly and concisely in this book span three courses I took at Cal Poly SLO: basic controls, digital controls, and modern/advanced control theory. Mr. Ellis does a great job of quickly introducing these topics and getting straight to the practical implications.

The free software and examples work well to illustrate his points quickly and easily while helping to commit the insights to memory. I also hope to use it as a training tool for our techs.

I highly recommend this book to anyone working with control systems, especially grad students and people getting started in the field. I look forward to reading his book on observers.

The author attempts to bridge the gap between theory and practice, and does a good job at it. Familiarity with control concepts will help one to get more out of the book, because the book focuses more on the practical aspects. The explanations in some of the sections can definitely be more complete, and thus I have to give it only a 4 star rating. Overall it is a good book.

Ellis has made a fantastic book on PID and similar control loops. He takes a very different tact than most controls books -- he writes with a voice similar to a handbook, but delivers enough content to compete with more traditional textbook-style controls books. It is light on the math in comparison, but I don't find myself wanting for more math.

I do a lot of controls design, consulting, and teaching. I recommend this book often and find that people that buy it uniformly track me down and thank me for the recommendation. I can't think of much higher praise for this book.

The simplicity, yet thoroughness, which he uses to explain one of the more difficult topics in engineering and mathematics shows that Dr. Hershey is a true expert in the field. I highly recomend this book for both the novice and the advanced reader.

Cryptography Demystified is a great intro guide to cryptography, well worth its price.

If you can make sense of this then you'll be able to make sense of the rest of the book (From Module 4):

Prob[p(t)=1lc(t)={Prob[c(t)=1lp(t)=1]Prob[p(t)=1]}/{Prob[c(t)=1]}
Now,
Prob[c(t)=1lp(t)=1]=Prob[k(t)=0]
and
Prob[c(t)=1]=Prob[p(t)=1]Prob[k(t)=0]+Prob[p(t)=0]Prob[k(t)=1]
therefore,
Prob[p(t)=1lc(t)=1]={prob[k(t)=0]Prob[p(t)=1]}/{Prob[p(t)=1]Prob[k(t)=0}+Prob[p(t)=0]Prob[k(t)=1]}

This book is slanted towards more theory and math than others that deal in practicality, for instance "Cryptography for Dummies". But if you have a solid foundation in mathematics and have the temporal ability to "quantinize" then this is a fantastic book. I would speculate this book is meant for graduate comp. sci/eng coursework as it is broken down into 35 Modules with problem solving exercises at the end of each. At any rate, good luck!

This book was used in a course I took taught by the author, Dr. John Hershey. I have read and own several books in this category, am working to obtain two advanced degrees in the field of computer security, and feel that I have enough information to write an objective review. It is an excellent introduction book to the general area of cryptography, but suffers from several shortcomings.

If you do not know much about what cryptography and encryption are, this book should provide a decent introduction. The book provides the mathematical concepts needed to understand the chapters, but I felt it did not cover enough detail or provide enough examples to let me feel I had a solid understanding of everything.

There are three aspects to cryptography: authentication, integrity, and verification. This book only discusses integrity issues, i.e. encryption. DES, RSA, and Diffie-Hellman are discussed, but a detailed covering of AES is noticibly absent. It covers integrity rather well, breaking down the different methods of using block encryption into separate chapters. In other words, DES operation in electronic codebook, output feedback, and cipher feedback modes are three different chapters. This is something that isn't usually done and is a rather nice touch. It makes it much easier to learn the advantages and disadvantages for each mode of operation.

In terms of total mathematical theory, Hershey's book does not contain much theory. If you want theory, I recommend you find William Stallings book titled "Cryptography and Network Security: Principles and Practice." Also, Hershey's book does not contain code to let you start programming a security system. If you want applications, I recommend you find Bruce Schneier's book titled "Applied Cryptography: Protocols, Algorithms, and Source Code in C." Those books are for advanced readers, however, and may be difficult to understand if you don't know the area.

Overall, it is a good read. I recommend it more for IT people than computer scientists or engineers simply because it touches upon the topic, instead of being very detailed. Look at the editorial review section criteria for who should read the book, it is right for the most part.

If you are looking to expand your mind, think about learning Cryptography. It is an excellent discipline to help you think in new ways. If you decide you want to learn Cryptography, this is the book for you. The book is written in modules, making it easy to digest. The book is equally suitable for a formal classroom or self-study environment. Using the book for self study is enhanced by the modular format, superb clarity of the teaching, the well-explained answers to the problems, and the appropriately injected humor. People that need to learn Cryptography will undoubtedly have this book on their shelf, whether they are an expert or beginner. I would like to speak to the people that don't need to learn Cryptography - this book is for you too, as you will enjoy learning the thought processes of Cryptography that will enhance your creativity in any field. This book is a gift.

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.