5 comments about Ontological Engineering: with examples from the areas of Knowledge Management, e-Commerce and the Semantic Web. First Edition (Advanced Information and Knowledge Processing).

1. The subject of this book is incredibly relevant to today's world of information management. The chapters are presented in a logical and informative way, though some of the book only skims the surface or barely touches on significant developments, tools, and problems. Overall, I found the text too theoretical, with insufficient ties to messy real-world issues.



2. The word `ontology' is usually associated with philosophical speculation on the reality of things, and if one checks the literature on philosophy one will find a diverse number of opinions on this reality. Engineers and scientists typically view philosophical musings on any topic as being impractical, and indulging oneself in these musings will cause one to lose sight of the topic or problem at hand. Rather than simplify the problem and make it understandable, philosophy tends in most cases to complicate it by endless debate on definitions and the use of sophisticated rhetoric that seems to have no bearing on the problem at hand. The conceptual spaces generated by these debates can become gigantic and therefore unwieldy, thus making the problem appear more complex than it actually is.
   
   In the information age however, ontology has become a word that has taken on enormous practical significance. Business and scientific research are both areas that have increasingly relied on information technology not only to organize information but also to analyze data and make accurate predictions. In addition, financial constraints have forced many businesses to automate most of their internal processes, and this automation has brought about its own unique challenges. This push to automation usually involves being able to differentiate one thing from another, or one collection of data from another, or one concept from another. Thus one needs to think about questions of ontology, and this (very practical) need has brought about the rise of the field of `ontological engineering', which is the topic of this book.
   
   The authors have given a good general overview of the different approaches to the creation of ontologies. There are many of them, some of which seem "natural", while others seem more esoteric. The reader though will obtain an objective discussion of the ontologies that the authors chose to include in the book. Discussions of the ones that are not included can readily be found on the Internet.
   
   Given the plethora of ontologies that have been invented, it would be of interest to the ontological engineer to find common ground between them. The re-use of a particular ontology may be stymied by the different ontological commitments it is adhering to or it's actual content. In order to use it, it must therefore be "re-engineered". The authors discuss this prospect in the book, and define `ontological re-engineering' as the process where a conceptual model of an implemented ontology is transformed into one that is more suitable. The code in which the ontology is written is first reverse engineered, and then the conceptual model is reorganized into the new one. The new conceptual model is then implemented.
   
   Also discussed in the book, and of enormous practical interest, is the automation of the ontology building process. Called `ontology learning' by the authors, they discuss a few of the ways in which this could take place. One of these methods concerns ontology learning using a `corpus of texts', and involves being able to distinguish between the `linguistic' and `conceptual' levels. Knowledge at the linguistic level is described in linguistic terms, while at the conceptual level in terms of concepts and the relations between them. Ontology learning is thus dependent on how the linguistic structures are exemplified in the conceptual level. Relations at the conceptual level for example could be extracted from sequences of words in the text that conform to a certain pattern. Another method comes from data mining and involves the use of association rules to find relations between concepts. The authors discuss two well-known methods for ontology learning from texts. Both of these methods are interesting in that they can apparently learn in contexts or environments that are not domain-specific. Being able to learn over different domains is very important from the standpoint of the artificial intelligence community and these methods are a step in that direction. The processes of `alignment', `merging', and `cooperative construction' of ontologies that are discussed in the book are also of great interest in artificial intelligence, since they too will be of assistance in the attempt to design a machine that can reason over multiple domains.
   
   The ontologies that are actually built are of course not unique. This results in a kind of semantic or cognitive relativism between the environments that might be built on different ontologies, even in the same domain. Merging and alignment both address this relativism, along with other techniques that are discussed in the book. The selection of the actual language that is used to create an ontology is also somewhat arbitrary. The authors devote a fair amount of space in the book to the different languages that have been used to build ontologies. Through an elementary example, they discuss eleven different languages, namely KIF, Ontolingua, LOOM, OCML, Flogic, SHOE, XOL, RDF(S), OIL, DAML+OIL, and OWL. The choice of a language is dictated by what one is seeking in terms of `expressiveness' and what kind of reasoning patterns are to be deployed when using the ontology. The authors point to a tradeoff between the expressive power of the language and the reasoning patterns that are attached to the language. The expressiveness of a language is directly proportional to the complexity of the reasoning patterns that are used.
   
   Ontological engineering as it presently exists is still carried out by a human engineer. To create an ontology every time from scratch would be tedious, and so it is no surprise that tools were invented to make ontology creation more straightforward. Some of these tools are discussed in the book, such as KAON, OilEd, Ontolingua, OntoSaurus, Protege-2000, WebODE, and WebOnto, along with assessments as to their utility. The discussion is helpful for newcomers to ontological engineering who need guidance as to what direction to take. The automation of ontology building would of course be a major advance. To accomplish this however would require that the machine be able to simultaneously and recursively construct the knowledge base and reason over it effectively. This is a formidable challenge indeed.



3. The book is well organized in introducing the subject in a coherent manner and weaving in all important criteria of ontology together. I especially like to read the comparison of different languagees in light of knowlege represenation and knowlege reasoing. The book is great in terms of getting a broad view (survey) and is also great as a reference. In many pages, there is so much information packed in each sentences. Great book.



4. The book shows progress in how ontologies are defined from various data sets. The subject is a natural field of artificial intelligence, in attempting to automated this filling of an ontology. Various example ontologies are presented, along with the markup languages like RDF and OWL in which these are expressed. The progress is visible, inasmuch as just a few years ago, these languages were devised. Now we see non-trivial ontology constructions using them. Good.
   
   A large portion of the book describes the acute problem of somehow extracting meaning in a programmatic manner from data. Because the manual making of an ontology simply does not seem to scale, given the realities of gigabyte databases. We see that there is a natural decomposition of the problem into a linguistic step and a conceptual step. The former is tied to a particular human language. The latter is the nut of the problem. Current methods look promising, but are certainly not the last word.



5. The subject matter is much too complex, does not follow a logical order, is a slow and arduous read, and is not practical.
   
   This book was the subject of a book club where I and a small group of software engineers wanted to learn more about ontologies. Most of the members of the group had some experience with ontology languages. In each one-hour lunch session, we were not able to discuss more than 10 pages at a time due to the complexity of the writing and the subject matter. We finally gave up and none of us has finished the book. Although we read over half of the book before giving up, we gained no practical knowledge from it whatsoever.

4 comments about Programming PLCs Using Rockwell Automation Controllers.

1. Like others, I recommend this to be a part of the library in any maintenance and engineering department that is responsible for Rockwell-based automation systems. It's a good overview and should be helpful in a mixed environment.

   It is not a textbook and advanced programming techniques but should help you understand the use of data files, file instructions, indirect addressing, IO structure and data structures.

   There is probably never going to be a single book that covers the whole gambit, but this is about as close as you are likely to get with the AB platforms.




2. This book explains PLCs in terms of Allen Bradley PLCs. It is targeted at people that have never used a PLC before and does a good job of explaining the fundamentals of PLCs. If you are in this group, I would strongly recommend this book. However, it is not very helpful if you are already familiar with PLCs and are looking to learn about Allen Bradley products as much of the book concerns things such as what kind of devices are connected to PLCs, good installation practices, etc.



3. Why spend too much money for a brief overview when you can get the best manuals for programming AB/Rockwell's PLCs for free??? Just go to Rockwell's Literature Library and search for the PLC technology you're interested in. For example, if you want PLC5 hardware manuals just search for PLC5. If you want ControlLogix.... well, you get the picture. There are free, high quality, PDF versions of most all of their hardware and software products. You don't need to spend $100 for a little over 300 pages (!!! Geeze !!!) of Kindergarten stuff. Learn the real stuff for nothin'



4. I could have purchased a similar book here on Amazon for half the price, but I chose this one for the included CD.
   
   The CD contains a 45 day free trial of LogixPro by Bill Simpson. When I installed and ran this program immediately upon receiving it, it stated that my 45 days had already expired, and then directed me to Simpson's website, "The Learning Pit" to purchase a code to unlock the full version. There I went on to have further runtime issues with the other "trial" versons available for download.
   
   I e-mailed Bill Simpson, since he invites people to do so in order to "improve" the product. He refused to stand by either the CD or his download. He offered no explanation or remedy for the problems, and told me to return the book.
   
   Do not allow this CD to influence whether you buy the book. Do not expect any support from it's maker.
   
   After five days working on my own, as an IT professional, I did finally force the thing to work. My solution was not something that even an experienced windows user could have found. Nor should they have to. Even now, the trial counter shows only 40 days remaining...I'll never get those 5 non-productive days back.

No comments about ADO Programmer's Reference.

5 comments about Practical WebObjects.

1. This is not a beginner's guide, but any WebObjects developer beyond the complete novice will find this book full of practical advice. If you are just starting out buy Joshua Marker's Quick Pro Guide but get Practical WebObjects too. When you need more detail than the QP Guide supplies, Practical WebObjects will be there for you.
   
   The sections on the request-response loop and editing context locking alone are well worth the price of admission. Each chapter clearly details its subject's processes and pitfalls in a way the benefits even the most seasoned WebObjects developer.
   
   The book offers advice and solutions to many common development tasks with code and resources from the community (WOCode, Project Wonder, Eclipse/WOLips) and its own Practical WebObjects framework. So although this book was written by two authors, it is clear that there was a concerted attempt to include the best practices for developing WebObjects applications, regardless of where they came from.
   
   If it is not obvious at this point, I highly recommend this book.



2. Well, I am not much of a fan of books on programming. Learning from book just doesn't work for me. I advocate learning by doing: grasp the basics and then set yourself challenges to resolve with the documentation at hand.
   
   Nonetheless I recommend this book to everyone who is serious about WebObjects. I have read this book cover to cover. Admittedly I practiced 'accelerated reading' on parts I know inside and out. This book is an interesting read as it tries neither being a reference nor tutorial. It is more of a guide and mainly a problem solver.
   
   The authors do an excellent job of explaining crucial concepts like the request-response loop, the EOF stack, object graph concepts, validation, etc. Unlike other books this one cuts directly to the chase. For beginners some chapters act as road map through Apple's documentation. Mind you, this book does not target the complete novice. Alongside the usual prerequisite of strong knowledge of OO and web application concepts, some WebObjects experience is required. Those who bring this along can expect a substantial boost up the learning curve.
   
   To more advanced user this book is more than an excellent way to recap core WebObjects concepts. Its a problem solver - the WebObjects edition of the Swiss army knife. The authors present ready-made solutions to many common tasks. This is book will save you hours if not weeks. And it does so while completely explaining not only the solution but also the reasonings and techniques behind it. This makes the book an interesting read and it just may spark the idea needed to solve even problems not covered.
   
   Unfortunately the book's strongest points also make for its weaknesses. For one, I find the book to be a bit too confined in the current state of things. It discusses bugs in both the current incarnation of the frameworks and the developer tools. Such information is bound to become outdated rather sooner than later. While helpful I don't think a printed book is the appropriate media to vehicle such volatile information.
   
   My other gripe is that the authors don't make it sufficiently clear that the proposed solutions and approaches are not the only ones out there. They were chosen based on the authors personal preferences. Diverging opinions exist and the reader would do well - and should be advised by the book - to dig for further views.
   
   All in all "Practical WebObjects" is an excellent book. It belongs on the shelf of every WebObjects developer. Novice or expert.



3. Hill and Mallais wrote this book in order to address what the back cover describes as a dearth of WebObjects documentation. While commendable, the book could have been easily improved. It lacks a short introduction that summarises the book and indeed, explains broadly what WebObjects do. Plus, it might also usefully explain what prerequisites you need.
   
   To someone new to WebObjects, the first chapter offers little guidance to these issues. The material it covers is fine, but it is potentially confusing without that introduction. Indeed, it is only by the second and third chapters that the reader gets some glimmerings of what this is all about.
   
   Granted, the authors are probably writing for those already knowing something of WebObjects. But an introduction can make this explicit. Especially since WebObjects are still a fairly specialised topic. If the authors want to increase its usage, they need to accomodate neophytes. The incremental cost of a few pages of introduction is negligible to address this.



4. Every webobjects programmer should read this book. I found it very useful because it explains many concepts that you don't find in official documentation. However, it is required an already high level of prior knowledge of webobject if you want to fully appreciate the book. It is not a book for beginners.
   I ask to the authors to write other books for all the other (many) topics that too often are omitted, like deployng and administration, java client programming, third party open source frameworks, etc.



5. As a begining WebObjects developer, I was looking forward to reading this book. After receiving it, I was very disappointed. The book focuses on using Eclipse and neglects the use of XCode.
   
   The information included in the text of the book seems to focus more on the esoteric and obscure aspects of the WebObjects architecture than on use of the tool. To use as an introduction for someone who was going to maintain the WebObjects application, it may be fine, but for someone learning the tool and using it to develop dynamic sites, the value is limited.
   
   It seems that there was more effort put into making cute chaper titles than on the content of the book. The cute titles are not really amusing to me, not because they are not cute, but because in most cases, they do not convey the contents of the chapters. When I buy a technical book, I use it to learn and have available as a reference. This book is busy gathering dust.

5 comments about Absolute Beginner's Guide to Databases (Absolute Beginner's Guide).

1. The book does contain SOME good information. That is as far as I will go. Every review failed to mention that the diagrams require a magnifying glass to read. I would assume that every reviewer had 20/20 vision but I know my wife does and she needed a magnifying glass to read the diagrams as well. It is littered with errors. One such is on page 63 "Did you notice relationship 5 is marked with an asterisk". I would like to know where the asterisk is, magnifying glass or not on any page. The book and reviews fail to spell out you better have Visio 2000 and Access 2000 to follow along. That aside from everything else the book never states that Visio 2000 and Access 2000 are what are used, it is assumed. You know what they say about assume. For a begginers book and the lack of editing I give it a "D". For general information about databases I give it a "C". I would say better luck next time but I would not drop another dime on a book written by this author. I hope he makes a better Attorney than an author.



2. This may be a good book, but after 50 pages and finding that I need Microsoft Access, as well as Visio to follow along, and then my Visio version doesn't have the required template...it is just a very frustrating book to get anywhere with. I'll keep trying, but this book just isn't for the beginner...sorry.



3. This won't necessarily be a book you look at much once you've digested its contents. What it does is outline basic database concepts using Access in its examples. You can use the book to get a basic Access database started, but don't rely on it if you're looking to create databases. Get an Access or database design book if that's your primary goal - IF, that is, IF you can make heads or tails out of most of what those books are talking about.
   
   What I love about the book is its dedication to simplicity: I looked all over the place for a book that outlined basic database concepts in an easy to understand manner, and found book after book that promised to be 0-60, and spent about, oh, 2 pages on the 0-10. Where's the core basics, guys? Answer: in this book. It'll getcha up to 10 MPH, and then you can move on to bigger and better stuff.
   
   After reading this book (and I had it bookmarked twelve ways come Sunday for about two months), I am finally ready to consider those more advanced books. I'm not a dummy, but sometimes a simple book is needed to bridge the gap between being a novice and being experienced. This was the book for me, and I highly recommend it to anybody who needs more than 2 pages of core database theory explanation. It's also easy to read and very user-friendly, by the way.



4. This is just what I was looking for, it's clear and covers the basics, the fourdational information about databases. I'm very pleased with the purchase.



5. If you are interested in learning about database client/server technology (SQL Server, MYSQL, Oracle, DB2, etc this book is probably not for you. If you want to learn SQL this book is probably not for you. This book does attempt to make clear the most basic database concepts. You must have MS Acess and Visio, though.

5 comments about Component Software: Beyond Object-Oriented Programming (2nd Edition) (Component Software Series).

1. If you are wondering what a component is - READ THIS BOOK! It gives you an excellent foundation of components and component technologies irrespective of any particular implementation or commercial product. It will allow you to distinguish between component systems and those that are not. C. J. Date's book on the definition and properties of relational database systems was a landmark book. This book does the same for component technologies. Get smarter - get this book. Totally Awesome!



2. When I started SW Engineering the SW functional decomposition methods were in fashion. People became relatively quickly familiar with them, and we developed our SW on Intel's 8086 based chip sets, with a few Ks of memory. The programming practices were reinforced by our peers and the Management.

   Then came the buzz-word SW Object Orientation. I first heard it in the mid 80s. To be frank about it, it had taken me about three years to get to the bottom of it. In my experience about 95% of the people who talked about it were either clueless or those who only wanted to jump on the fast track wagon.

   In my view, the OO in its pure form is a little bit complex concept. Lets face it, when you start with a mean set of customer requirements and you have your boss breathing down your neck in some cases for no good reason, you are not going to be in the best frame of mind to look for SW objects in a bubble pool of analysis. OOD requires all kind of disciplines. Even the best OO design may not be supported by your target language and it may not be the best approach to your problem, what I'm mean that is like trying to dig your garden with a eating fork which may look like a garden fork !

   Here comes the SW component part. Why not group the requirements into a set of likely entities ? Once the requirements are grouped in such fashion the SW Analysis elements are easily mapped onto what is called 'SW Components' which are well described in this book. The author is very descriptive about the idea and he is able to convey it in a simple manner. This book is not only about SW components it also covers other serious technologies such as SW Standards, differences in Components and Objects, SW design architecture, parallel and concurrency.

   My comments here are related to SW System Developments, NOT System programming which requires different set of rules and support.

   This book is for those who wish to learn about new technologies, the SW Components. It may not necessarily solve your current problems. At the end of the day there is never an optimal SW Technology which has all the best solutions for all the SW cases.




3. Clemens Szyperski's ability to describe and explain complex systems is almost unparalleled in software literature. If you need to understand software componentry, you must read this book.



4. Szyperski has written a truly outstanding introduction to component software systems. This is the most complete, clearest introduction to the basic problems and practice of component software development that I've seen.

   After the introductory chapter, about the first third of the book discusses object oriented development. That's no contradiction: OO technology is usually the implementation vehicle for component systems. Szyperski adds (or at least collects) real content about OO technique, including the problematic relationship between 'contracts' and callbacks, language features for containment and control, and the many needs that current OO languages don't meet. Lots of the discussion sounds like 'the loyal opposition' - he supports OO practice, even demands it, but is harshly critical of the OO techniques that cause real problems.

   The remainder of the book describes requirements of a workable component system and a workable component industry. If done right, component software really could solve a lot of problems: squabbling in multi-vendor environments, maintenance across multiple generations of releases, and more. The theoretical discussion is backed up with case studies, including JavaBeans, CORBA, and OpenDoc.

   The would-be component user won't find a lot here; this book is really for the component or component framework developer. Developers, however, should not expect a lot of direct, technical detail. This discusses principles, not implementation. That's my one real disappointment in this book: the lack of detail. Even the case studies are brief and somewhat shallow. Those problems are easy to fix, however, with other books on specific APIs, systems, and development techniques.

   If you are planning a component-based system, whether as a component user or a component developer, this book may be essential. It gives a complete, critical view of what components can do and what they should but cannot yet do. As you go through development, you'll come back to this book (or at least to its issues) again and again.




5. Very well written and informative. I 've read a few book that tend to be either very verbose or written for novices. This one hits the spot.
   The best part is that reading this book makes you think.

5 comments about C++ GUI Programming with Qt 4.

1. What impressed me the most, was how simple was to build a drawing icon widget and a spreadsheet with qt 4. I believe that this is a must have.



2. I've recently started GUI programming again after about 12 years doing other things, and I've never used Qt. I needed a book to get me started, and this one really worked well. It provides many examples and pieces of template code that help bootstrap whatever it is that you need to do. The major pieces of functionality are all covered, and the explanations are precise and understandable.
   
   My one complaint for this book is that it doesn't cover everything in Qt. For more esoteric things you'll have to switch over to the Qt on-line documentation available at trolltech.com. I've read other reviewers' complaints that the information in this book is all available at the Qt web site. That may be true, but if you're just learning, this book presents things in a logical and subsetted way. Also, since it has an index, it's easier to look up a specific area of interest.
   
   Overall, I highly recommend this book if you're just starting out with Qt and/or GUI programming in general.



3. This book is well written and covers everything needed to get up and running. I bought the book and used it to learn Qt for my CS masters research. I went through it cover to cover, and was programming professional quality, rock solid, GUIs in a month and a half. Using just the Trolltech supplied on-line documentation, that would have been impossible.



4. Just a note of caution if you decide to buy the Kindle version: of course the CD-ROM is not included, and I have not been able to locate any alternative source for the example code (although the Qt software is readily available for download). I assumed this would be a minor issue, but some of their examples are cumulative, so having the source would give one the option of skipping topics that are not of immediate interest. In addition, I encountered an apparent ambiguity or omission in a description of constructing a dialog in the designer tool; having the source would clear this up, but it is difficult to resolve without it. Interestingly, the latest hardback edition does not have this problem -- the same section has a slightly different description that makes sense. So perhaps the Kindle edition is an earlier version.



5. The UK based magazine, Linux Format 109, gives it a poor grade: 4/10
   And says "As easy to read as a Croatian trains time table".
   
   I would certainly agree with Linux Format: this book was quickly (hastely?) written.
   In its current form, it is not good at all: I do regret my purchase (made only because Trolltech somewhere recommends it).
   
   I have been browsing: "The Book of Qt 4: The Art of Building Qt Applications" by Daniel Molkentin.
   
   My first impression of "The Book of Qt 4: The Art of Building Qt Applications" is a lot more positive, and I will probably purchase it.
   
   Note: My previous posting, also negative (never derogative though) just disappeared.
   I am wondering if Amazon delete negative evaluations.
   This would not be so wise: trust here is of some value.

4 comments about Foundations of JSP Design Patterns.

1. A good reworking of what are now classic JSP design patterns, as codified by Sun and others. You need never have read about design patterns to appreciate this book. But chances are, you're already coding JSPs and Servlets. If so, you need a book like this. At the very least, a rough Model-View-Controller design will aid your coding.
   
   But Patzer also goes into more detailed patterns. Like a decorator filler and a front controller. But perhaps as important as any specific pattern is that you get some idea of what to look for as a pattern that might arise out of your work. The patterns in the book show you code reuse, at a higher level than literal reuse of a given body of source code. A very powerful idea for you to grasp.
   
   I reiterate. Understanding, using and looking for new patterns moves you into the realm of design. Increases your experience and your value. Design is higher margin work. Makes your skill sets more valuable.
   
   He also introduces you to the discipline of testing. Especially having a unit testing framework. And since this is java, you have JUnit to help you.



2. For the front end of Java web applications JSP has never been given a lot of respect. It's always been the domain of lower paid 'front end programmers'. But that doesn't mean that it isn't difficult to do it right. This book takes the time to emphasize the patterns of implementation to make a solid web front end.
   
   The book covers the web application page flow of forwarding and maintaining state. It also covers tag libraries, data validation and a host of other topics.
   
   The text of the book is well written, and graphics are used effectively.
   
   This is a great book for front end developers. This is the type of coverage this complex topics needs. Hopefully we can get similar books for PHP and Perl web development.



3. If you're familiar with JSP technology and you're ready to take the next step, you might find the book Foundations Of JSP Design Patterns by Andrew Patzer (Apress) interesting...
   
   Chapter list: JSP Foundations; Using JSP; Role Separation with JavaBeans; Role Separation with Custom Tags; Development Using Patterns; The Decorating Filter Pattern; The Front Controller Pattern; The View Helper Pattern; Testing Techniques; Deployment Techniques; Application Frameworks; Putting It All Together; Index
   
   While this book does cover some basics of JSP, I wouldn't recommend it for a complete newcomer to the subject. This book is more designed for the person who has learned the basics, done some work with JSP, and would now like to learn how to better structure their code to separate business logic from presentation. Patzer does a good job in showing how a consistent approach to presentation/logic separation can avoid maintenance issues down the road, and how it allows developers and designers with different roles to work together on a project. By introducing patterns, the developer can build applications with a solid structure that follow proven architecture that works. The thing I appreciate most is that the pattern chapters have plenty of code that allows you to understand the pattern both by explanation and by example of a real application. That helps take the information from a theoretical to a practical level. The chapters at the end that deal with testing and deployment are also very valuable, and they should help the developer to follow a solid approach to JSP application development from design through implementation. Very good material here.



4. Very helpful book for beginners to intermediate level java developers. Because,
   this book starts with introduction to jsp and chapter 1 and 2 cover,
   * The basics of the JSP2.0 specification
   * Describes the syntax and commands, used to produce dynamic content.
   
   After the two introductory chapters, you will move into the real thrust of the
   book. Chapter 3 and 4 take the roles of developer and page designer, which
   gives you,
   * Introduction to javabean to deal with data,
   * form handling to deal with html data
   * Custom tags to build with reusable html tags.
   
   The next chapters show you how to separate designer and developer role by
   separating the application into layers, or tiers (View, Model and Controller).
   Chapter 5,6 and 7 present about,
   * Pattern for your web application design,
   * MVC action for controlling your application
   * Filter to intercept the HTTP requests and responses.
   
   Chapter 8 finishes the pattern with,
   * View helper pattern that you use to adapt data to the presentation
   layer of application.
   
   Now those chapters they have provided after 8 are surprised, personally I like this
   very much about they have discussed on testing techniques and deployment techniques.
   Which are very helpful chapters for some one who wants start to finish developing web
   application.
   I have liked chapter 3, 4, 5, 9 and 10 of this book.

1 comments about Creating Components: Object Oriented, Concurrent, and Distributed Computing in Java.

1. This book provides a good introduction to Concurrent and Object Oriented Programming in Java. I was fortunate enough to take Dr. Kann's class last semester, while this book was being finalized. This is probably the best book I have been assigned as a class textbook while in school, both in readability, and usefulness.

   Reading this book will make programming concurrent applications in Java easy, just by following the design patterns in the text. Use of notification objects and synchronization is well explained. If you'd like to understand object oriented concepts such as composition and classification in an easy to understand way, this book will help. Throughout the course of the book, the reader can watch the construction of a concurrent program from beginning to end. The concurrent program (the animator), is also a handy class which can be used to perform simple multithreaded animations.

   The section on distributed computing (Java RMI) implements a simple chat client/server in Java which can be used across the internet. Very easy to write your own chat program in Java using the material in this book.

   Code included in the book should have you up and running quickly. If you're ready to start utilizing the full power of java objects and multithreading, buy this book.

3 comments about Expert One-on-One Microsoft Access Application Development.

1. Helen has been around since Access was introduced. She knows how to solve problems. This book is better than her previous book (Microsoft Press) for Access 2002. Great examples, plenty of code. Helen gives the reader insight into every day solutions. I especially like her Menu Manager Add-in. It is a good help for using her solutions. And, she even has code for sending a fax from Access with WinFax. I wrote my own procedure (it took a great deal of time) and it works fine, but Helen's code is very efficient (over 20 pages devoted to this in her book). It checks for all the folders and sends the fax. Much more information included - from a sample interview with a client, to using Access with Word, Outlook, and Excel.

   My only complaint concerns the sample files. Wrox used to include a CD, but now they seem to be leaining toward web downloads. Not a bad idea but, in this case, the files are over 100 MB. If you don't have broadband, you may be working in Access 2004 before you're finished downloading these samples.




2. I bought this book hoping, as the author stated in her introduction, to make the transition from an experienced and competent Access user to an Access developer who can make a living developing applications for clients. I had hoped that the book would be chocked full of tips, tricks and wisdom from an Access expert. But I was disappointed. The author stated that she wrote this book for experienced Access users, who knew how to create tables, queries, forms and other Access objects, and had some familiarity writing VBA code. It has always been my opinion that the creation of a good Access database application requires a solid knowledge of VBA, the available control events and how to effectively program those control events. Unfortunately the chapter on VBA was rather weak and the chapter on controls had little discussion of the numerous control events.

   On the other hand, the author presented 13 full pages of VBA code to demonstrate using the ItemsSelected collection of a MultiSelect listbox, a concept that could have been demonstrated in about 10 lines of code. I found it interesting that the author never mentioned the Control Wizard, which can automatically generate VBA code for many control events. Also the author never mentioned that a callback function could be used as the record source for a combobox (or listbox).

   In the first half of the book the author uses the Toy Workshop database example to illustrate how to create/modify tables, relationships, forms, controls and reports. The reader very quickly must become familiar with the structure of this database. A complete summary of the tables (listing the fields), forms (listing the controls), queries, and reports in an appendix would have been very helpful. The reader is almost forced to download the sample databases from the Wrox website to get anything out of the book.

   The author had many pages presenting the three add-ins that she developed: Design Schemes, LNC Rename and the Menu Manager add-in. On the surface these add-ins appear to be good tools for an Access developer, but the LNC Rename add-in (used to rename objects using the Leszynski naming convention) was not designed to work for controls with existing VBA code. And I wasn't crazy about the design of the main form created by the Menu Manager. Not to mention the fact that this add-in required you to rename your main form using a non-standard "fpri" tag. I would have liked for the author to give me the expert guidance that I need to create my own add-ins rather than to simply use the "canned" add-ins developed by the author.

   I didn't read the chapters on Automation dealing with Word, Outlook or applications outside of Office. The chapter "Working With Word" probably is one of the best chapters since this subject appears to one of the author's areas of expertise. I did read the chapter on "Working with Excel". It was OK. It just scratched the surface of the subject of automation between Access and Excel, primarily dealing with how to programmatically export data from Access to Excel and import data from Excel into Access.

   Before you decide to purchase this book, I'd recommend taking a look at Alison Balter's book "Mastering Microsoft Access 2000 Development " and Scott Barker's book "Microsoft Access 2000 Power Programming". And if you decide to purchase this book, plan on downloading the sample databases (Note: the three ZIP files are a whopping 114MB) and plan on spending a lot of time studying the sample tables, forms, queries, reports, and VBA code.




3. Like all programming books, the trick is to match the reader's current level and skill set with the level of information presented in the book. On a scale of 1 to 5, the vba programming training here is about level 2 in my opinion. This is not bad training, it is just not at an advanced level. You should probably have some previous knowledge of vba but if you are an experienced vba programmer the only areas of interest are likely to be the word/excel integration issues.