Modeling

Beautiful picture but if your looking for a how-to book save your money. I bought all three and it's not what I needed. If you want to go up that next step in modeling look elsewhere.

My father thought these books were excellent ways of studying aircraft and he learned many things that he did not previously know about WWII aircraft. A must have for serious WWII buffs..

Pros:

This book does a good job of describing ADO and its relationship to web controls. Covers caching, and interopability which I thought was valuable.

Cons: (not really "cons", but maybe some short-comings):

I wished it had more than a half-page section on the caching object along with some examples and real-world scenarios.

I would also have liked VB along with the C# code.

Finally, if the book is going to be about ADO & ASP.NET, then I feel it should have addressed the basics of getting data - creating a connection in .NET, and hooking it up to a sqldatareader. I already knew how to do that, however, other readers may not. They shouldn't have to go to another source to find out.

I couldn't put this book down when I got it yesterday, however, there were times when I found myself thinking "that sounds great.. but HOW do you do that?.. where is the example? What if I don't want to code in C# ?"..

Bottom line, its worth buying. Try to buy it used, and make sure you have a little background in .NET.

This is not an intermediate book:

The author knows what he is talking about. Perhaps he made it overly complex, he goes in to great detail and some of it is overkill. I started reading it and I knew that I needed to get another book that simplifies some of the subjects and I would use this book when I need to get to the gritty details. I was rather disappointed that there was no Visual Basic .NET code. The author clearly is a C# expert. I may change my review once I read the whole book, I am sure I will appreciate his thoroughness once I have a grasp of ASP.NET.

This is quite a good book on real techniques to solve real problems. It's still going to be useful if you use for you're development third party controls and frameworks, you still will find valuable information inside. I wouldn't recommend it for the very beginner that wants a Learn-This-In-1-Hour book (and keep yourself in the ignorance :-)).

For anybody else with certain degree of familiarity with the .Net environment, the book is going to be extremely useful.

complete waste of money. It's more of a Rational Rose for dummies book than anything else. Dont waste your money

I found this text easy to read and very informative. I remain unclear on some of the steps outlined in the book. For instance, why would anyone want to use external files to describe use case text? This belongs in a requirements management system like Rational Requisite Pro which just happens to link quite nicely to Rose use cases.

Second, I'm not sure why the author has the use cases copied from the Use Case view to the Logical view. Anytime such replication is required, beware.

Regardless, this was an excellent introduction to UML and Rose. I now need to find other texts to elaborate on proper Use case development in UML.

This book is extremely well-written and straight to the point. It's a nice and simple introduction to the world of UML using Rational Rose. The case study (ESU course registration) used in the book is simple enough for all the readers to understand. I finished reading the book within 3 days and started using Rose on my EJB project painlessly. I highly recommend this book for all new UML/Rose users. Thanks the author for "gave birth to Visual Modeling with Rational Rose and UML". Great "child"!

I was using this book to prepare for a data structure class after only the basic CS1 class. I could hardly imagine a better data structure book than this one: it is VERY well written, goes in very progressive steps, and only an elementary knowledge of C++ is assumed from the reader. Thus, most C++ beginners will not have to refer to another text to read this one.

Besides teaching data structures, this book accustoms the reader to using a sensible standard in program documentation and clarity, which is of course well-needed in the profession, and which will be of use for students who want to get an idea on not to lose any points in assignments because of deficient program documentation. I used that standard in my assignments, folks, and I really left the other students in the dust! (Other students were learning with the very mediocre compulsory book) This is probably something that I will use as long as I program, in any programming language.

Some people (including me) have a problem with the fact that the code is designed to work only with the GNU or Borland compilers, as they conspicuously ignore the popular VC++ development environment, classifying it under the heading "older compilers which doesn`t support static data members"... gimme a break! I usually have no patience with Microsoft-despising academics, but at least they make the minimal effort of posting VC++ compliant code on the web site, although "with no guarantee of it being correct". So I decided to give them 4 stars.

Contrary to what a reviewer has written, you do not need to be an instructor to download the code.

After reading the poor reviews I felt bad having to buy this book for a university level data structures course. However, after using this book for a short time I really grew to like it. It is an excellent introduction to classes and OOP in addition to data structures. It picks up right around where most introductory C++ texts leave off. I found the authors explanations to be very clear and the examples to be very relavant to the topics in each chapter. The author seems to build on topics chapter after chapter so it is hard to forget what has already been learned. This is one of the few text books that I am going to keep for future reference.

This book is in my opinion the "bible" of C++ programming books. It is well-structured, precise and provides examples of how to implement commonly encountered algorithms and data structures such as equation evaluation, linked lists and recursive algorithms.
Combined with the source codes on the accompaning website, it is a invaluable source on C++ programming.

This book is a concise, tantalizingly understandable introduction to UML with Rose. But it falls short of its promise. I suspect it could've been made much better - through careful organization & better editing - without adding a great deal more material. After reading the Jan 98 version, I came to Amazon.com hoping to find a later, improved edition - in vain. The book illustrates basic aspects of Rose usage but frequently fails to tie these illustrations to the underlying "University Course Registration" system example in a consistent manner. It's not always easy to tell whether or how a Rose usage illustration relates to the system being developed. The presentation flow suffers as a result. For example, pg. 53 shows how to create a new package and relocate classes between packages. The figures show Browser views with a class under the Logical View called StudentInformation and a package called PeopleInfo. But 2 pages later, having returned to system development in the same Browser view, the StudentInformation class has disappeared and the name of the PeopleInfo package has changed to People. There are several places where new, important concepts are quickly introduced and glossed over. For example, Scenarios are an important idea related to Use Cases and interaction diagrams, but on pg. 53 the term "scenario" is introduced without definition in a manner that appears to equate scenarios with sub-flows of use cases; the transition in terminology occurs without explanation. In spite of shortcomings like these I still recommend this book as a valuable "primer" for newcomers to OO and UML / Rose.

This is a good introduction to the Rational Rose tool and the Rational method of developing software. A reader should have a prior introduction to UML even though nothing advanced is presented here. What the book does best is build your confidence for tackling a large scale project using UML and Rational Rose to develop the object model. While the book includes some step by step instructions and tracks a development project from beginning to end it is not a definitive guide. The review is very broad brush. Terry Quatrani writes very clearly and for the most part fulfills the objectives that she sets out. There were a couple of points that I could not follow even rereading multiple times and I found myself wanting just a little more explanation of illustrations.

I strongly disagree with other reviewers who rated this book just "1 star" or "2 stars". I feel they picked a wrong book in the light of what they were looking for. That's pretty much their fault, or Amazon's fault for not publishing a good online description of the title.

Here is what book's preface says:

"[this book is NOT:]

- a tutorial on all the ins and outs of analysis and design using UML

- a tutorial on all the details in the Rational Objectory Process

- an explanation of all the notation and semantics of the UML

- an abridged explanation of the UML Notation

- a book on software architecture or C++ design

(...) This book is an introduction to the concepts needed to visualize a software system process, a notation, and a tool."

IMHO, the book achieves the purpose it states in 100%. It explains what visual modeling is in principle. It ligtly explains the notation. It walks the reader through the creation of a model of! a software system using Rational Rose. It is written in nice clean English (can't say that about mine ;-) ). It contains screenshots and provides Rational Rose GUI digest and sample auto-generated code in the Appendix. It does not obscure the picture with excruciating detail or complexity of the example software system (the author consciously chose to forget about some details of the sample software system for the sake of clarity).

Basically, you read the book on Saturday, digest it on Sunday, read it again over the next week (in a subway or where ever, the book is an easy read), realize where you messed up on your current project and how the Rational Rose tool could have been used to eliminate your problems, and buy another book on Visual Modeling next Saturday. This time a thick one.

Terry did a good job. If you need an easy read to get a picture on what Visual Modeling is because you heard a co-worker mention "Rational Rose is cool", get the book. Otherwise r! ead Rose help files or buy some thick volume on UML and &qu! ot;tri amigos'" work.

This book would be excellent... if it weren't for one mysterious member of the pair, Edwards or Penney who can't teach for his life and/or is lazy. I would've guessed two authors wrote this text even if they only claimed it had one author and called him edward penney... You see, every couple of sections or so there are a lot of typos and poor overly wordy "proofs" , stupid joke proofs that are almost like winking and smiling between one professor and another while the student sits there dumbfounded. One proof in particular goes: "Theorem 2 says yes!" Oh yeah? Unfortunately I am not as comfortable with math as you with your doctorate degree sir I don't just "see" the truth of a claim as you probably do -or maybe you are just bluffing. You see, I also take the types of proofs this guy does to be as though they were designed to make him look more intelligent to other professors who may be teaching out of the book. Mr. Edwards or Penney you know who this guy is! Ditch him as a fellow author for your next edition! As far as the other mysterious author, his explanations and proofs are patient and lucid and involve a good bit less words (words are nonsense! The whole point of math is to learn how to think with fewer stupid words so you can understand more fundamental and abstract ideas which cannot be expressed in words!) As a piece of advice, I would like this text to be a bit less concrete in its explanations of mathematical generalities. It weighs them down and confuses people who have an intuition for their logical consequences, it almost makes them feel constrained and stupid and it is irritating to learn about a general fact through the use of a stupid example and then have the generality taken for granted thereafter without proof!

I think the strength of this textbook is the amount of material it encompasses: this book is used in two separate courses in my school--introduction to DE and engineering analysis. I didn't appreciate the textbook so much until I completed my differential equations course and then looked back at the sections on mechanical vibrations to review for my physics course. I then realized that the explanations and derivations were extremely satisfying, much more than your average introductory physics text. Also, the emphasis on the qualitative aspects of DEs, such as slope fields and phase portraits, aid in the coneptual understanding of the otherwise rigorous computation aspects of the topic. My only complaint is that the proofs could've been done in a more understandable manner.

I am currently using this text for an intro level differential equations course, and I feel that this book is well suited as such. It should be easily acessible to anyone with a basic intro calculus foundation and it is ideal for self-study. On the other hand, this text does contain a noticible number of typos, both in "back-of-the-book" answers and example problems. A potential reader should note that this book is fairly applied in its nature (as the title would indicate--engineers take delight, theoreticians take dismay), so one shouldn't expect more than an introduction to the theory of differential equations (ie. don't expect much proof or mathematical rigour).

Wait for a colleage to waste $40 on it, then pick it out of the trash. I can hardly believe that Microsoft would put their imprimatur on such a book. Numerous code samples simply do not work. Connection strings for Riordan's own installation have to be replaced; it you don't know already know something about ADO.NET, you'll be in despair. The format is a "color by numbers" sort of thing; the various objects are poorly explained. Different ways of creating objects should not be mixed together in the same program; it makes the source unreadable, and pedagogically useless.

I learned a lot trying to fix the errata myself; I should get paid.

Normally I wouldn't give a bad review on a book just because it was too advanced for me. This case is different, however. I am one of the people who came from the fabulous visual basic.net step by step book. It really got me interested in microsoft press. VB step by step stayed true to it's title. ADO.net, however, failed miserably at this. Although it does follow a weak numbering system, it isn't really step by step at all. The flow pattern is horrific. I must admit I was excited after reading the first chapter. It was extremely easy to follow. All hell broke loose though when chapter two came about. There is plenty of room on the market for this book, as I am sure there are many who are ready for this high level of understanding. But please don't publish a step by step book which doesn't follow the usual beginner to intermediate content of other MSpress step by step books. I suppose I will go with the old standby and give vb.net database programming for dummies a try. Perhaps that will cover the foundation needed to give this book another try.

I found this book extremely useful to build my basic understanding with ADO .NET, Windows Form and Web Form data binding and XML. The book is easy to read and has lots of examples to practice.

This book will not teach you VB.NET/C#. So you should be comfortable with the language of your choice before reading this book. Some examples have minor errors. At some place VB.NET code is referred in C# example. If you are an intermediate VB.NET or C# programmer then you can easily catch and fix them.

I experience some problems with examples in Chapter 12 "Data-Binding in Web form" using MSDE 2000 SQL Desktop Engine
1- Connection Error with OLEDB Jet 4.0: "The Microsoft Jet database engine cannot open the file ......nwind.mdb"
2- Connection Error with OLEDBSQL: "Login failed for user 'SERVER_NAME\ASPNET'"

I was able to solve it by keeping the MSDE password in the connection string.

My connection string looks like this:
"workstation id=SERVER_NAME;packet size=4096;user id=sa;data source="SERVER_NAME\ InstanceName ";persist security info=True;initial catalog=nwind;password= AStrongSAPwd"

The people who trashed this book didn't do much with it, that's clear. When you first go to the book (or if you've seen Coad speak, as I did @ JavaOne), you will think that Mr. Rogers is trying to talk you into teaching you a new way to program w/crayons. I was also struck by the proliferation of classes that Coad advocates. However, I have returned to this book a number of times, in part because Coad's tool Together/J is now the preeminent Java/UML tool, it makes Rational look like a set of tinker toys. This last time, I've become quite enamored with what is going on in here. Here are my suggestions: 1. Really try and understand the DNC (domain neutral component). It is a very good approach to a kind of design completeness theorem that I haven't seen much talk about elsewhere. 2. Look at the diagrams. I look at them over and over again. After going a couple of rounds I found that I was becoming addicted to the visualization process, not merely as a representational apparatus, but as a way of actually doing more work/understanding the work I'd already done.

If you get the 30 day eval of Together/J and you work through understanding the DNC and color, you'll pass into another dimension from which you will not readily want to return. Plain white UML is dimensionless to me now.

All that said, I gave the book a 4 because it really needs an update. The FDD (feature driven development) methodology is not really interesting or appropriate anymore, I think. In the new massively interconnected, distributed component world, features are not what its about anymore, unless you're developing a word processor. Also, the archetypes are based on a non-EJB approach that will change if distributed computing is applied to it, quite significantly. Still this is an important book and combined w/TogetherSoft's tool it's perhaps the best design/UML teaching combo available. There aren't enough books out there that have models for real things in them. This does that and a lot more.

Don't be fooled by the colors and informal communication style. It takes talent to deliver state of the art software development theory in such an easy to understand and practical way.

Consider industry thinking on Business Object Component Architecture. Consider IBM's SanFrancisco project with 4 BOCs completed. This book gives us 12! (My copy accordingly has 12 colorful sticky tags.) If someone has seen a more intuitive, comprehesive set of components, please let me know.

As Dragan's review says, these guys have done the "heavy lifting." Building on this book's BOCA even the poorest programmers will end with superior software.

And anyone who doesn't sense the far reaching implications, as Booch implies, of the colors and the "domain neutral component" either doesn't have the ability to do abstract thinking or just isn't paying attention. I didn't believe it until I added color to my own UML diagram.

Though "Java" is in the title, this book is not limited to Java, and, indeed, there are no Java code examples. Usage of UML, however is extensive. The book presents an approach to generalizing business components (modelliing patterns - referred to as archetypes) that really helps one to understand the structure and interaction of business components. I use this book as a regular reference. It includes a near-complete business component model through 12 compound components.

This review took almost one year. Unlike many previous referees (rank them by Amazon.com's "most helpful" feature) I read all 1197 pages including notes. Just to make sure I won't miss the odd novel insight hidden among a million trivial platitudes.

On page 27 Wolfram explains "probably the single most surprising discovery I have ever made:" a simple program can produce output that seems irregular and complex.

This has been known for six decades. Every computer science (CS) student knows the dovetailer, a very simple 2 line program that systematically lists and executes all possible programs for a universal computersuch as a Turing machine (TM). It computes all computable patterns, including all those in Wolfram's book, embodies the well-known limits of computability, and is basis of uncountable CS exercises.

Wolfram does know (page 1119) Minsky's very simple universal TMs from the 1960s. Using extensive simulations, he finds a slightly simpler one. New science? Small addition to old science. On page 675 we find a particularly simple cellular automaton (CA) and Matthew Cook's universality proof(?). This might be the most interesting chapter. It reflects that today's PCs are more powerful systematic searchers for simple rules than those of 40 years ago. No new paradigm though.

Was Wolfram at least first to view programs as potential explanations of everything? Nope. That was Zuse. Wolfram mentions him in exactly one line (page 1026): "Konrad Zuse suggested that [the universe] could be a continuous CA." This is totally misleading. Zuse's 1967 paper suggested the universe is DISCRETELY computable, possibly on a DISCRETE CA just like Wolfram's. Wolfram's causal networks (CA's with variable toplogy, chapter 9) will run on any universal CA a la Ulam & von Neumann & Conway & Zuse. Page 715 explains Wolfram's "key unifying idea" of the "principle of computational equivalence:" all processes can be viewed as computations. Well, that's exactly what Zuse wrote 3 decades ago.

Chapter 9 (2nd law of thermodynamics) elaborates (without reference)on Zuse's old insight that entropy cannot really increase in deterministically computed systems, although it often SEEMS to increase. Wolfram extends Zuse's work by a tiny margin, using today's more powerful computers to perform experiments as suggested in Zuse's 1969 book. I find it embarassing how Wolfram tries to suggest it was him who shifted a paradigm, not the legendary Zuse.

Some reviews cite Wolfram's previous reputation as a physicist and software entrepreneur, giving him the benefit of the doubt instead of immediately dismissing him as just another plagiator. Zuse's reputation is in a different league though: He built world's very first general purpose computers (1935-1941), while Wolfram is just one of many creators of useful software (Mathematica). Remarkably, in his history of computing (page 1107) Wolfram appears to try to diminuish Zuse's contributions by only mentioning Aiken's later 1944 machine.

On page 465 ff (and 505 ff on multiway systems) Wolfram asks whether there is a simple program that computes the universe. Here he sounds like Schmidhuber in his 1997 paper "A Computer Scientist's View of Life, the Universe, and Everything." Schmidhuber applied the above-mentioned simple dovetailer to all computable universes. His widely known writings come out on top when you google for "computable universes" etc, so Wolfram must have known them too, for he read an "immense number of articles books and web sites" (page xii) and executed "more than a hundred thousand mouse miles" (page xiv). He endorses Schmidhuber's "no-CA-but-TM approach" (page 486, no reference) but not his suggestion of using Levin's asymptotically optimal program searcher (1973) to find our universe's code.

On page 469 we are told that the simplest program for the data is the most probable one. No mention of the very science based on this ancient principle: Solomonoff's inductive inference theory (1960-1978); recent optimality results by Merhav & Feder & Hutter. Following Schmidhuber's "algorithmic theories of everything" (2000), short world-explaining programs are necessarily more likely, provided the world is sampled from a limit-computable prior distribution. Compare Li & Vitanyi's excellent 1997 textbook on Kolmogorov complexity.

On page 628 ff we find a lot of words on human thinking and short programs. As if this was novel! Wolfram seems totally unaware of Hutter's optimal universal rational agents (2001) based on simple programs a la Solomonoff & Kolmogorov & Levin & Chaitin. Wolfram suggests his simple programs will contribute to fine arts (page 11), neither mentioning existing, widely used, very short, fractal-based programs for computing realistic images of mountains and plants, nor the only existing art form explicitly based on simple programs: Schmidhuber's low-complexity art.

Wolfram talks a lot about reversible CAs but little about Edward Fredkin & Tom Toffoli who pioneered this field. He ignores Wheeler's "it from bit," Tegmark & Greenspan & Petrov & Marchal's papers, Moravec & Kurzweil's somewhat related books, and Greg Egan's fun SF on CA-based universes (Permutation City, 1995).

When the book came out some non-expert journalists hyped it without knowing its contents. Then cognoscenti had a look at it and recognized it as a rehash of old ideas, plus pretty pictures. And the reviews got worse and worse. As far as I can judge, positive reviews were written only by people without basic CS education and little knowledge of CS history. Some biologists and even a few physicists initially were impressed because to them it really seemed new. Maybe Wolfram's switch from physics to CS explains why he believes his thoughts are radical, not just reinventions of the wheel.

But he does know Goedel and Zuse and Turing. He must see that his own work is minor in comparison. Why does he desparately try to convince us otherwise? When I read Wolfram's first praise of the originality of his own ideas I just had to laugh. The tenth time was annoying. The hundredth time was boring. And that was my final feeling when I laid down this extremely repetitive book:exhaustion and boredom. In hindsight I know I could have saved my time. But at least I can warn others.

Having browsed through the book -no proper thorough reading, I admit- and the various reviews, I find here a similarity with that well known 2nd class author. And I truly enjoyed in the meantime Jozsef Gregor's version of a similarly overdimensioned work: Salieri's Falstaff. Cool !

I found this book worthwhile and would recommend it to any scientist or technically oriented non-scientist.

The author demonstrates that cellular automata are capable of computing anything that can be computed by today's computing machines. He also shows that exceedingly simple rules can lead to exceedingly complex results. An implication of this is claimed to be that cellular automata can model most anything in the known universe and can serve as a model for exploring significant questions about our universe.

The author explores significant fields of science using the notions of cellular automata. For example, the chapter on biological evolution has many very interesting insights. The author also uses cellular automata to make what I would call a "first order" model of spacetime that includes the properties of time and causality. I found this to be quite interesting.

Reading this book also affords a glimpse for us non-braniacs into the course, from conception to fruition, of an actual scientific inquiry. This is a rare opportunity.

The author's intent, as I see it, is to offer ideas; to provide what I would call "plausibility arguments" for his claim that he has discovered a fundamental property of nature (the "Principle of Computational Equivalence"). I think he succeeds in making his claim plausible.

The author is not claiming that this book contains any actual, formal, scientific, final and conclusive proof of indisputable law by any completely rigourous method.

But our intuition can be notoriously misleading - that's why science is what it is.

While I am kind of impressed by this book, reviews by significant people in the scientific community seem to be mixed.

Therefore, paraphrasing what the author himself has said, the final review will be written only after a long time.

This book is grossly overpriced and not useful, at all, to anyone trying to learn about databases. I find some of the "positive" reviews to be unfounded and grossly biased (they must be friends of Kronke or bad instructors trying to justify their use of this BAD textbook). I would suggest that both Kroenke and his buddies look for a dumbies book on "how to write a textbook." Note how the publishers comments about this book refer to it as discussing "fundamentals" and providing a "foundation" on databases. This book fails completely at doing either of those things.

David Kroenke's newest edition of his work, Database Processing: Fundamentals, Design, and Implementation (9th Edition), is an excellent book that serves well as an introductory text on Databases. What makes this text even more valuable is that it takes you beyond the basics as you work your way through it. The Rochester Institute of Technology (RIT) uses this text for two different database courses. Here is an overview of the sections in the book (each section contains multiple chapters):

Part I - Entity-Relationship Data Modeling
Part II - Database Design
Part III - Structured Query Language (SQL)
Part IV - Part Four (multi-user databases, Oracle 9i, and SQL Server 2000)
Part V - Database Access Standards (ODBC, OLE DB, ADO, ASP, XML, ADO.NET, JDBC, Java Server Pages, MySQL)
Part VI - Object-Oriented Database Processing

As you can see, Kroenke covers the necessary foundations of multiple DBMS systems, and goes into good detail on different schema regarding E-R data modeling. Additionally, screenshots are abundant in this text from numerous applications and DBMSs (including Access), and Kroenke does a great job at giving examples and discussing topics in a reader-friendly manner.

I found some of the reviews interesting and would like to put a few comment of my own-
We used David Kroenke "Database Processing: Fundamentals, Design, and Implementation" in a cram course for preparation of graduate placement test here in Chulalongkorn University last year, and everyone was happy with it, especially it offers very clear concept of database and database design, internet. I don't know why some of the "Amrican" reviewers give it a very low rating. May be for those reviewers who found the text difficult are not well prepared in the technology yet, in this case may be they can try some 24 days or dummy types of book...