countdown boutiques-francophones Learn more vpcflyout Home All-New Kindle Explore the Vinyl LP Records Store sports Tools
Profile for Amazon Customer > Reviews

Personal Profile

Content by Amazon Customer
Top Reviewer Ranking: 1,508,401
Helpful Votes: 15

Guidelines: Learn more about the ins and outs of Amazon Communities.

Reviews Written by
Amazon Customer (Old Bethpage, NY United States)

Page: 1 | 2 | 3 | 4 | 5
Absolute C++
Absolute C++
by Walter Savitch
Edition: Paperback
31 used & new from CDN$ 3.89

5.0 out of 5 stars Truly a well written college text book, July 9 2004
This review is from: Absolute C++ (Paperback)
Walter Savitch, the author of the Absolute C++, first edition, has done an amazing job putting together a book that can be used as a teaching aid for second year or first year advanced Computer Science students. Unlike professional books, the author has geared this book towards students with little programming experience in the real-world at least, and has created problems that can aid the student in learning the material more deeply and more concretely. If I were an instructor, this would the book that I would use, and if I had to take C++ all over again, this is the book I would love to learn from.
Color aids and categorized notes, such as "Pitfall" and "Tip", aid the student along the way with little details that go a long way when you are programming. "Example" and "Self-test exercises" further the learning process after each section by testing the student's knowledge of the topic. At the end of each chapter answers are given to the "self-test exercises" and various programming projects are given that mimic the topic covered and at the same time expect the student to think outside of the box to solve the problems. Some of the programming projects given are hard enough that they can used - alone or collectively with other problems in other chapters - as semester long projects or group projects.
Examples are depicted right on spot rather than line-by-line after the example. Colored notes, arrows to the section of code being explained and highlighting of the important code sections are used to depict each and every example. The examples are well-documented and various "screen shots" are used to display what the output would look like. Pictures are inserted when needed, explaining how pointers and references work for example, and they are worth a thousand words. The pictures are easily concise and clear, simple and yet to the point.
Being a text book on C++, one would wonder about the authors approach to the C++ language. It would help if the readers on this book have some background on programming, and especially in C++. The author spends one chapter on the basics of the language, but that's not enough for readers with no programming background. A good deal is then devoted to various aspects of programming such as arrays, functions and structures first before the author starts on the in-depth coverage of C++ itself. The Standard Template Library (STL) is used throughout the book to demonstrate and teach C++, starting with Vectors. Each of the classes of the STL are covered in detail throughout the book, but the authors breaks each of the major classes (lists, string, vector, etc...) and places them to teach a specific topic to the students. The author touches on STL first before going in to operator overloading, for example. This way, the students can learn the [semi] advanced features of the language in a context in which it can later be used - more concrete and more applied approach rather than an abstract overview of the features. With that pattern, the string class is covered first before the author starts on pointers, array of pointers, character pointers and pointer and reference manipulation in general.
More advanced topics in C++ such as virtual functions, inheritance, templates and exceptions are covered towards the last half of the book. Templates being a rather interesting and possibly complicated topic are covered before the STL container classes such as linked lists and trees are covered. Not too much detail is given on templates and only the basics, as one would expect. Templates are covered just enough to get the students to understand how linked lists work, or how function templates are used in the STL, for example. UML and Patterns? They are covered too. Not in detail, but enough for a lecture or two at the end of the semester. Model-View-Controller, the classic of all patterns is covered first, and examples from the book are used to convey the message and the power of templates.
In closing, I wanted to touch on the web site for the book, and instructions material that is available for this book. Obviously all of the source code from the book is available for download, along with the slides for the students. For instructors, the slides are simply great. What reinvent the wheel? Simply use Savitch's slides for teaching. Example tests are also available for the instructors. If that wasn't enough, the CD in the book comes with an introductory version of the Visual C++ 6.0 to be used by the students. The package (website, CD-Rom and the book) is simply complete!
I would highly recommend this book to any instructor of the C++ programming language.

XML Family of Specifications: A Practical Guide
XML Family of Specifications: A Practical Guide
by Kenneth B. Sall
Edition: Paperback
19 used & new from CDN$ 4.34

5.0 out of 5 stars Rather practical!, July 4 2004
Where to start? With the concise history of where XML came from and why each design decision was made and how the evolution of specifications took place over the years, or the thorough explanation of all the XML specifications, or the programming and parsing aspects of XML and metadata, or the cool XML timeline poster towards the end of the book? This book has much to offer any person interested in finding out what XML is and why and how it has changed our world.
Kenneth B. Sall, the author of this book, organized this book in a fashion where each section could be studied on its own, and if there are references to the previous sections, they are appropriately mentioned. This way, one does not need to sit down and cover this 1000+ page book cover to cover to realize that the topic of conversation is. The stage is set at the beginning by the author commenting on the fact that XML can describe everything under the sun, even the kitchen sink:
"XML: ... maybe it's everything but the kitchen sink? Say, have you heard the one about the XML Kitchen Sink Language? ..."
I have been working with XML for sometime now, and I am still amazed at how it has grown and expanded in to our everyday lives in the past few years. One can spend months coming up to speed with the specifications and the XML "realm", and that's not enough. This book does not even cover, in a great detail at least, the Web services realm. That alone is a couple of thousand page book. The background topics are essential to any reader: basic XML syntax, DTD, Canonical XML, Namespaces and XML Schema. Once you have these topics covered and well understood, you can jump around to any other part of the book, displaying XML data for example or XML programming API's.
One can spend a couple of hours trying to figure out how these specifications fit in, but the author hs already done the job with a very useful picture inside the cover page. What's your forte? Cascading Style Sheets to convert XML data into a PDF document for example, or an XHTML document to display on a web site? XHTML is also covered in length, if you do not know that is and what it offers over the plain old HTML.
My favorite topics were probably the authors explanation of the XML parsing and the available API's and resources. SAX, DOM, JAXP and JDOM are covered in great detail.
• SAX - the API that started it all. Minimal and light-weight. Fast and event driven.
• DOM - Memory intensive, complex, but very powerful. It's a tree based model, and the tree represents the whole document.
• JDOM - java specific. Can be used with either DOM or SAX.
• JAXP - java specific again, but easier to use than JDOM.
There are also a number of C++ XML parsers that the author touches on such as the Apache Xerces, C++ SAX and many others, but the main topics revolve around the four most popular parsers mentioned. These sections are mostly tutorials and how-to's. Each parser is used in an example and example is analyzed piece by piece. DOM is covered in more detail due to the number of levels (DOM level 1-3) that it has. Since DOM is more powerful and more complicated, the topic is a bit more advanced and would require more attention from a novice. If you read thru the SAX chapter and understand it well, DOM would not be that much of hurtle, but make sure that you read understand SAX first. Java centric API's including XML-RPC, JAXB, JDOM, JAXM are covered by the author to depict how XML can be used and how it would benefit the application - and developers in-turn. The icing on the cake is when K. B. Sall outlines the differences between SAX, DOM, JDOM and JSAX. He talks about each of the technologies in detail, tell you what the advantage and disadvantage of each one is, and then it compares them against each other. By the time you are done reading these sections, you would become an expert in XML parsing and programming.
XLink and XPointer. How can one leave without these two core technologies and tools? They are truly remarkable; easy to use, light weight and easy to learn. Well, they are well covered - as you would expect from this book. One thing about these topics is that they could be very abstract and need examples, and we got lots of those. The example depict the efficacy of how one can use XLink to create complex connections between sets of resources, even though you do not have a write access to those resources. This is very handy and resourceful technique is you need to build an e-commerce site. With XPointer, one can locate individual XML elements, set of elements or even a range of XML data between two points. The ability to specify "range" of elements is where the true power of XPointer is revealed.
The references, the related resources for each topic, simple to complicated examples and a CD filled with goodies, source code used throughout the book and the W3C specifications at your fingertips outline the some of the other benefits of Kenneth B. Sall's "XML Family of Specifications" book.

Thinking in C++, Volume 2: Practical Programming
Thinking in C++, Volume 2: Practical Programming
by Bruce Eckel
Edition: Paperback
Price: CDN$ 67.05
25 used & new from CDN$ 35.79

2 of 2 people found the following review helpful
5.0 out of 5 stars The only other C++ book you would need, June 4 2004
There are plenty of C++ books out there. When it comes down to it, one would really need two books on C++. Well, this is the second book you need; with the first one being any of many classics including the first volume of this book. Just when you think you have read or have a reference to all the C++ topics, Eckel and Allison come out with their continuation of a classic - volume two of Thinking in C++.
Exceptions, Templates, STL, Design Patterns, Multiple Inheritance, concurrency and parallel programming are just some of the main topics covered in this book. With the book being over 800 pages, one can imagine how deep each of these topics must have been covered. Exceptions grab you right off the bat. Just when you think you know all about exceptions, the authors throw you a curve ball with "Exception Specification", and how to handle the "unexpected". You are blown away by the true control that C++ gives you. .
Strings, along with examples given to depict the string class in full - as part of the standard template library (STL) of C++, begin the authors' discussion of the Standard Template Library. Vectors, sets, lists and many other features of the STL have their own dedicated section which talks about generic containers. The authors set the stage for STL by describing the containers as:
"Container classes are the solution to a specific kind of code reuse problem. ...A container class describes an object that holds other objects..."
The authors then continue on to cover the very important and broad topic in C++ - containers. Examples after examples are used to convey the details and the tricky parts of the C++ STL. The key by reading this chapter is to portray and teach efficient techniques to common problems using the generic container classes. Not only the reader can learn most of what s/he needs to know about containers in this book, a small introduction is also given to show how to actually write a generic container - a linked list. The example is simple, yet powerful in conveying to the reader the ins and outs of writing generic containers. Speaking of generic, generic algorithms are covered very well in this book. All of the algorithms currently in the C++ library are covered with an accompanying example for each one. A special attention is given to the use of function objects as the means of customizing these algorithms.
"A function object is an instance of a class that overloads operator(), the function call operator. This operator allows an object to be used with function call syntax"
Probably the simplest and the easiest definition of algorithm complexity theory is given in this book. The authors make the concept so easy to understand that even a non-programmer or mathematician can understand the reason and the complexity of complexity theory!
Templates are probably my favorite topics in this book. Next to the C++ template "bible" by Vaqndervoorde and Josuttis, this book is the best source for generic programming and templates. The authors cover the three main topics of templates well:
1) Templates with types as parameters
2) Templates with compile-time constant as values
3) Templates with other templates as values.
The authors start with small and simple examples and build on top of them. Templates are generally a difficult topics to cover and to convey, but the authors do a great job in depicting the examples and teaching the reader how templates work and to create powerful programs with them.
The advanced topics in this book (multiple inheritance, runtime type identification, design patterns, and concurrent programming) are my favorite topics. Multiple Inheritance is covered in depth, better than any other book that I have seen out there. The authors do caution the readers regarding the difficulties and the pitfalls of multiple inheritance, but they also explain with examples, pictures, etc... how a developer can overcome these difficulties (using upcast to resolve naming conflicts for example or avoiding the diamond-shaped inheritance tree).
Concurrency and concurrent programming is one of the more difficult things to do in C++. Threads are usually used to achieve such task, but it takes practice and lots of sleepless nights to debug threaded programs and resolve deadlock issues with threads. The advantages of threads (ability to run multiple tasks concurrently, very low context switching relative to processes, allow better code organization and the added convenience to the user specially for graphical user interface tasks) are depicted and shown thru a number of examples. The most important part of this section is how the authors use examples to show what the right way of doing something is as oppose to simply putting bunch of source code together to fill in the blank pages. The examples are priceless to me and very beneficial to any programmer.
All and all, Bruce Eckel and Chuck Allison did a great job putting this book together. The topics covered are very beneficial to any serious C++ programmer or anyone wishing to become one. I particularly like the examples and "how-to's" given throughout the book as they are a valuable source when I am stuck with a programming challenge.

UML Distilled: A Brief Guide to the Standard Object Modeling Language (3rd Edition)
UML Distilled: A Brief Guide to the Standard Object Modeling Language (3rd Edition)
by Martin Fowler
Edition: Paperback
Price: CDN$ 34.12
46 used & new from CDN$ 1.64

5.0 out of 5 stars : Good introductory book that covers the basics well, May 7 2004
A good mixture of UML, new additions to UML and how UML integrates into software processes. The topics are at a high level and only get skin deep, so this book is good for practically anyone interested in UML: developers needing to know the new additions to UML, managers with little time that want to learn UML to be able to talk to their developers, and even marketing staff wanting to communicate the needs of their customers with the engineers and product managers.
Martin Fowler has done it again with the third edition of the UML Distilled book. Informative, well organized, quick read and more importantly an easy read. He starts with a background on UML and where it came from, and where it is currently heading. He continues with the introduction with going over what a software process is and why it's needed. The importance and the benefits of how UML can assist the software process during all the phases of the process sets the stage for UML throughout the rest of the book. If you are unfamiliar with software processes such as the Rational Unified Process, Fowler's introduction goes a long way and clear things up.
"... the creators of the UML see the [UML] diagrams as a secondary; the essence of the UML is the meta model. Diagrams are simply a presentation of the meta-model."
Probably the best explanation of UML you can find anywhere. Folwer, from the get go tries to set the stage straight and clear up some of the misconceptions that UML. At the beginning, he focuses on the fact that UML is not the solution to everything a development team faces during a project, but rather a starting point, and "you shouldn't hesitate to use a non-UML diagram if no UML diagram suits your purpose."
Starting with the basics of UML, such as class diagrams and sequence diagrams, Fowler delves into the basics of UML and mainly the critical components on UML 1.0. A very controversial topic in UML and mainly the class diagrams are the notion of Aggregation and Composition. Aggregation being the part-of relationship and composition being an object with only one owner are depicted well thru a number of examples. For simplicity, Fowler suggests the aggregation be entirely dropped from diagrams.
Associations versus class Properties are another unclear point that is covered well. If you have been working with UML for a while, you have certainly realized that anything that can be presented via Associations can also be presented via the use of Properties. This point of ambiguity could mean the difference between a clean and clear class diagram and a clotted diagram that looks like a web of coupled classes. The author clears the point between the two notions up by specifying a rule of thumb: use attributes for small things such as dates and Boolean types, and use associations between large object types with clear dependencies between the objects. This rule can certainly help when you are trying to do round-trip-engineering, and your reversed engineered class diagram is totally not what you were expecting! Has that ever happened to you?
Object Diagrams, Use Cases, State Machines and Activity diagrams mark some of the UML tools that have been around since the earlier versions of UML.
Composite Structures, Interaction Overview and Timing Diagrams are new to the UML 2.0. Composite Structures enable the internal structure of a class to be decomposed. It clearly defines and marks what the interfaces are, and what the required external interfaces are for each of the interfaces shown. Interaction Overview diagrams graft together activity diagrams and sequence diagrams. The author does however mention that he has no interest in using the Interaction Overview diagram due to the fact that they are too busy. I agree!
Overall, Martin Fowler's UML Distilled book provides a clear, concise and brief but sweet introduction to UML. Each topic is short and gets to the point. Main pitfall of UML are explained well, and the reader upon reading this book can "speak" the UML language.

Charles F. Goldfarb's XML Handbook (5th Edition)
Charles F. Goldfarb's XML Handbook (5th Edition)
by Charles F. Goldfarb
Edition: Paperback
17 used & new from CDN$ 7.00

5.0 out of 5 stars The One source you need to answer any question about XML, April 13 2004
It took Charles Goldfarb, Paul Prescod and many others, sixty-seven chapters to explain all there is to know about XML and XML related technology. This book must be the most complete reference book when it comes to XML: any thing from history of XML in Chapter 1 to VoiceXML in Chapter 46 and everything in between. This book is filled, and each chapter is appropriately marked with, Introductory Discussions, Application Discussions, Tool Discussions, Case Studies and Friendly Tutorials.
The author has broken the book into 24 distinct parts; each part can be studies independently as they are very well contained with background information, case study and appropriate discussions. The first part is devoted to readers who are not XML savvy, followed by three chapters of the basic XML use: Three-tier applications, E-Commerce and Integration. It is very much amazing to me how the author packs three very important topics in to less than one hundred pages, and gets the point across. If the topic get s a bit complicated like the chapter on Integration with the Web (chapter 13), the author quickly switches to a Case Study chapter and shows the reader how things are done by example.
"Content is King". Reading this phrase at the beginning of Part 5 tells you that Goldfarb knows what he is talking about, because content IS king. Content Management must be one of the best parts of this book. A case study followed by a chapter on content systems (Chapter 16) and a chapter on what the key components of a Content Management is (chapter 17) really wheels the context in and the reader gets a very good understanding of what this growing field is all about. "Content is King". Content Acquisition, which is covered in Part 10, is another very well covered set of topics. Being is a VERY complicated topic, the authors (guest authors and experts who helped with writing this section) start off by explaining what syndicators and subscribers are: Content providers and content receivers. ICE, a new protocol for content delivery created by the ICE Authoring Group is introduced and used thru out the chapter. The authors add:
"The ICE protocol defines a model for the ongoing management of syndication relationships, including the roles and responsibilities of syndicators and subscribers"
Using ICE:
- The syndicators can describe business rules
- The syndicators can create and manage catalogs of subscription offers
- A common format - XML, is used to exchange data between the syndicators and subscribers.
- Various delivery modes such as push or pull and frequency of delivery can be indicated by the subscribers
- The subscribers determine if content can be updated in delta format or otherwise
- The content can be received from and sent to many locations and repository types.
The authors show the power of the tool and how it can benefit the end user and their application content management needs.
"... If Web Services really is a revolution, it may be the first in history to be led by the parties in power."
Web Services are the next set of topics covered in this book and two parts (13 and 14) are devoted to Web Services and Service Oriented Architecture. The author starts by giving the reason and the background of where Web Services came from and why they are here. (This is very common for this author as he explains every XML technology first and gives the reason why it's here) The good thing about this section is that Web Services have yet to be proven and the author conveys that message well:

"Web services is a very far-reaching and ambitious vision, with implications for all Web users and, if the goals are achieved, for much of the economy as well."
The two big players in the Web Services world, mainly IBM and Microsoft helped in writing these two parts. It is very interesting to see that for the first time in a very long time, these two rivals see eye-to-eye about a technology such as Web services. A discussion of UDDI, the directory for discovering Web Services, WSDL, the Web Services Description Language, and SOAP are given. The icing on the cake is chapter 41 where experts from IBM talk about Service deployment and outlines the steps that need to be taken to do such task. The application that they deploy is very much useless, but the steps taken to deploy are priceless as they are very concise and clear. Service Oriented Architecture, their vision, methodology and benefits are given in chapter 42. The two main architectural patterns that are used today: service-centric design and the rich-client design are explained and are used as the groundwork to explain why SOA is a better approach to either of the two.
Jumping to the last few parts of the book where the author[s] has added tutorials of all the major topics that were discussed in the text. XML Basics, Namespaces, DTD are just the beginning of some of the tutorials that added towards the end of this book. Whole parts are devoted to XPath, XSLT and XSL. XPointer also gets its own section with a chapter devoted to XLink. The great thing about these tutorials are that they are self contained and can be read independently of any other chapter of the book. They are quick study guides when you need them.
C. Goldfarb, Paul Prescod and many experts that were involved in putting XML Handbook together did a great job in doing so. This book truly contains everything one needs to know about XML and XML technologies.

Operating Systems (3rd Edition)
Operating Systems (3rd Edition)
by Gary Nutt
Edition: Hardcover
Price: CDN$ 65.86
27 used & new from CDN$ 13.02

0 of 1 people found the following review helpful
5.0 out of 5 stars Very good intro book that covers a broad topic well, March 18 2004
There are many books written on the topic of Operating Systems, but no book covers all the major and even some not so popular Operating Systems so well. Anything from Pocket PC to Unix and Linux in detail: Distributed computing, clustered computing, virtual machines and everything in between. Various important topics in Operating System such as File management, Memory Management including virtual memory, Security and Networking topics are discussed in detail, and popular Operating Systems frequently used today are used as examples of how each subsystem is developed.
Gary Nutt starts this book by going over the basic of Operating Systems. Its components, subsystems and more specifically what are know to be the most important component of a well established Operating System: Memory Subsystem, File System, I/O System and Process Management. The book takes a unique approach in introducing various components of an OS to the reader. The author assumes that the reader has some programming experience, which is a very good assumption, and instead of taking a bottom up approach, it takes a top down approach in showing the various aspects of an OS. In Chapter 2, the student/reader is shown a multi-threaded program in Linux/Unix and Windows. The programs in this chapter and all the subsequent chapters are used to bridge the gap between theory and actual practice in the design and implementation on an Operating System. Other books mainly talk about the various aspects of an OS, but none really actually shows the reader/student how it actually works under the hood via programming examples, and code samples. By the end of chapter 4, the reader has a fairly good understanding of what Operating Systems are made out of and what each component of an OS actually works, even down to the CPU level with interrupts and memory allocation.
Chapter 5 talks about Device Management: device drivers, various I/O strategies and it discusses the steps required to build be device manager. The lab at the end of the chapter is particularly interesting as it walks the student thru building a floppy disk driver.
The next four chapters are probably the most well written chapters on Process Management. As with the other parts of the book, the two main Operating Systems: Windows and Unix, are covered in detail and an emphasis is put on how these two OS's differ from each other and in what aspect. The author starts by talking a little abstractly about processes, their various states and how they fit into the overall architecture of an OS. The authors then goes into more specific details and talks about the various implementation details on Process Managers and what their job is. This pattern continues throughout the chapter with the author spending a bit of time on various aspect of a process manager, and then going deeper into it and talking about how Unix or Windows have implemented such function. The topic of process Synchronization which tends to be a very difficult topic to cover is probably the best written chapter in the entire book. The author uses coding samples from the get go to discuss the topic. The coding samples apply to Unix, but they are still very applicable to Windows. The author step by step peels the onion and teaches the student how process sync is done in an Operating System, and how the same techniques can be used in everyday programming practices. The labs at the end of these five chapters are very practical, as I have come across these same problems more than once in my professional life.
Memory Management is covered in the next two chapters. Paging and segmentation are covered in detail and the two labs focus on Memory Management topic in Windows and Unix. The interesting part about topic is that the author does not hesitate to use an old and obsolete Operating System, Multics, to convey to the reader how Memory Management is best done. The reader does get a solid understanding of how Memory Management is done in the popular OS's, however.
File Management and Security relatively small chapter in this book. The chapter in security is relatively a little dry, but I guess that's just the nature of the topic - not much can done about that. Very informative chapter, nonetheless.
Distributed Computing, Middleware, Networking and Distributed Programming cover some of the advanced topics at the end of this book. Chapter 20 and 21 gets down and dirty with comparing Linux with Windows. A head to head objective comparison of these two Operating Systems thru two case studies. I found these two chapters to be a very good closing to this book, as there is so much controversy surrounding these two OS's.
Overall, Gary Nutt has done a great job putting this textbook together. The organization, examples, labs and more importantly the contents are well worth the read. A students, this might be the best book covering the topic of Operating System as it covers by example and by showing the reader how it's done in the read world.

XForms: XML Powered Web Forms
XForms: XML Powered Web Forms
by T. V. Raman
Edition: Paperback
Price: CDN$ 45.99
19 used & new from CDN$ 9.31

5.0 out of 5 stars Size does not matter, March 4 2004
In about 200 pages or so, T. Raman has been able to convey the power of XForms to its readers. XForms leverage the power of using XML in creating web forms. It enables the developers to design simple, yet powerful and feature rich, browser-based interfaces for creating XML documents. It ensures the validity of the XML documents without the use of JavaScript, VBScripts and the entire headache and cumbersome that comes along with scripting languages. The author in a few chapters, using useful examples and just plain old good writing style, depicts the power of XForms, and shows the reader how the development time of creating a feature-rich web site can be dramatically reduced using this new technology. Website developers, technology managers and software architects would be able to realize the benefit of using XForms, and determine by reading this book how XForms can save their website project time and money.
This book is divided into three parts:
· Introduction - Gives the reader the 20-mile high overview of XForms and the various XML standards that it uses such as XML Schema, DOM2, Namespaces, XML Events and XPath.
· Components - Talks about the various components that make up the XForms architecture.
· Emerging Areas - Talks about the connection between XForms and other emerging Web-Services technologies.
If you were familiar with Struts, it would be very easy for you to learn XForms as it follows the same Model-View-Controller (MVC) design pattern. XForms consists of mainly three parts:
The "data" part of XForms is for any and all nonrepresentational aspects of Web applications. It is used for user data input, and for validation of that input. The metadata is also presented at this layer, which is necessary to communicate the user input with the Web Server.
The "UI" part of XForms defines a vocabulary that consists of abstract controls and aggregation constructs used to create feature-rich UI's. There is an abstraction layer built-in that allows the applications to be deployed on many different devices and platforms
The "submit" part of XForms allows the developer to specify how and what pieces of data need and can be passed to the Web Server. It also acts as the controller of the data in that it specifies the actions to be taken once a response have been received from the server.
The author then goes into detail talking about the various components that make up XForms. The MVC design pattern is broken down even more and the details of each component (properties of XForms, the UI to back-end bindings, XForms events, etc) are further discussed and examples are given to convey each topic better.
Chapter 4 puts the true power of XForms in perspective for the reader. It talks about a multi-stage UI Wizard and it shows thru an extensive example how it can be developed via XForms. The same application would take at least a couple of weeks to develop with Struts and JSP/Servlets. The author in a couple of pages, implements this example and shows the reader how much simpler and faster it is to develop with XForms. The author concludes his remarks on XForms with talking about the XForms processing model. The processing model defines various XForms specific events that can be raised, and talks about how and when these events take place. There are a total of 4 events that occur in XForms: Initialization, Interaction, Notification and Errors events. Each of these events is described in detail in chap 8 and examples are given so the reader can grasp the topic faster.
The last part of this book, the author talks about how XForms fits into the Web Services world, and more generally, with other XML technologies and standards such as SOAP, XHTML 2.0 and CSS.
For a book that would be considered an easy and a quick read, it sure has lots of information packed into it. In one weekend, you can become familiar enough with XForms that you would be comfortable in writing a Web application using it. I recommend this book to any developer involved in Web development.

XQuery from the Experts: A Guide to the W3C XML Query Language
XQuery from the Experts: A Guide to the W3C XML Query Language
by Howard Katz
Edition: Paperback
Price: CDN$ 57.99
25 used & new from CDN$ 11.78

5.0 out of 5 stars Very informative set of essays, Feb. 23 2004
Simply good. A collection of essays written by so many well-known names in the industry covering various aspects of the XQuery language from a "A Guided Tour" to "Introduction to Formal Semantics". A book that would be very useful for people with XSLT background, and need more power to do their job. A book that closes the between Relational Databases and XML.
A good number of authors and innovators contributed materials to this book:
- Don Chamberlin (an editor of the XML Query Use Cases, XQuery 1.0, XML Path Language 2.0 working drafts),
- Denise Draper (one of the editors of XQuery 1.0 Formal Semantics),
- Mary Fernandez (one of the editors of the working drafts of XQuery 1.0, XPath 2.0 Data Model, XML Path Language and XQuery 1.0 Formal Semantics),
- Howard Katz (editor of this book)
- Michael Kay (an editor of the XSLT, XSLT 2.0 and XQuery Serialization and XML Path Language 2.0 working drafts)
- Jonathan Robie (an editor of XQuery 1.0, XML Query Requirements, XML Syntax for XQuery 1.0 and XPath 2.0 working drafts)
- Michael Rys (an editor of the XQuery Formal Semantics, XML Syntax for XQuery, XML Query Requirements, XML Query and the XPath Full-Text Requirements working drafts)
- Jerome Simeon (an editor of XQuery 1.0, XPath 2.0 and the XQuery Formal Semantics working drafts)
- Jim Tivy (System architect of the ODMC 1.0 SQL Engine for Microsoft)
- Philip Walder (an editor of the XQuery, XPath Formal Semantics and the XML Schema working drafts)
Even though that some of the chapter in this book will benefit an expert programmer, with a solid background in XML, there are more than enough chapter that will benefit the beginner and one's who are no really familiar with XPath, XQuery and XSLT. The book starts by going over the basics of the XQuery language. The Guided Tour is simply a refresher, and introduces the reader to XQuery and its syntax/semantics. It talks about the differences between XPath and XQuery for example, and the benefits of XQuery over XPath. Small code sections are used to convey to the read the difference of one technology versus the other. XPath and XQuery get a lot of attention in this book as there are lots of similarities between the two as far as syntax is concerned and plenty of difference as far as its capabilities with XPath.
The author[s] dedicate the second chapter to the principles behind the design decisions of the XQuery language. Don Chamberlin, the author of this chapter, write the following mission statement for XQuery:
"The purpose of the new query language was to provide a flexability to extract information from real and virtual XML documents."
It is very refreshing to see the committee for creating XML actually went to the process of defining requirements, design definitions and the rest of the formal specification realization before they actually "wrote" the language. The message of formalism is very clear throughout the book. At each stage of design for this new language, proper documents have been generated (Use Case doc, Requirements doc, etc) that portray a good process. The section on formal semantics adds the following:
"After the Java programming language was released, several formal semantics of the language were written. Some of these semantics revealed errors in the type system, which in turn could lead to security holes in browsers that run Java programs. ..."
XQuery looks very similar to XPath, and this book spends a couple of chapters (a little of chapter 2, and most of chapter 3) to talk about the similarities, differences and influences of one language over the other. The new releases of XSTL, XPath and XQuery 1.0 look very similar since these groups collaborated with each other throughout the process of development. If you don't know anything about XPath or XSLT, and want to know how they differ and hoe they have evolved in the recent years, chapter 3, by Michael Kay, is what you need to read - or may even start with before you read the other chapters in this book. Chapter 3 starts off very easy, but it goes into more advanced topics such as optimization techniques used with XQuery - specially the one's that have been used before with XSLT and XPath for the same purpose.
One of the most interesting chapters in this book is chapter 5 on Formal Semantics. It is rare and rather refreshing to see a language being broken up like that and it's predicate logic and semantics be given in such detail. You can skip this chapter all together, but I suggest otherwise. Even if it is to realize how language processing and semantics of a language work. I would love to see such topic for C++ or JAVA... This chapter is good for anyone interested in optimization techniques and wishes to learn more about the details and correctness of the XQuery language.
Applications of XQuery at they apply to Databases and how it can be integrated into databases are covered in part 4.
XQuery had the capability to navigate, select, combine, transform, sort and aggregate XML data - thus making the integration of XQuery with the backend database very powerful and rather simple. XML data, and how it can be integrated into the database with the help of XQuery is covered in detail and two techniques are laid out: the LOB (large object) representation where the entire XML data is saved as a large object in the database, and the composed representation where each XML element is stored individually.
Even though XQuery is fairly a new language, the authors in this book go to great length depicting the formalism, the correctness, the stability and flexibility of the XQuery language. The chapters that cover Database integration with XML data clearly convey the power of this language, and thought process that went behind designing such stable and powerful language.

Unix Network Programming, Volume 1: The Sockets Networking API (3rd Edition)
Unix Network Programming, Volume 1: The Sockets Networking API (3rd Edition)
by W. Richard Stevens
Edition: Hardcover
Price: CDN$ 73.76
38 used & new from CDN$ 57.07

1 of 1 people found the following review helpful
5.0 out of 5 stars Continuing the work of a legend in the field of CS, Feb. 6 2004
It would be difficult to put value on a book that has been a classic text and a reference in academia and in the real world in the context of Network Programming for over a decade. Richard Stevens published the ever-popular Unix Network Programming [UNP] back in 1990, followed the second edition in 1998. With a dedication to the memory of R. Stevens, the UNP book found itself two new authors, Bill Fenner and Andrew M. Rudoff, who would write the third edition of this book. The third edition has many updates, a new look and feel and many of new chapters that cover the topics more applicable these days. In my opinion, it is still the most valuable and profound text in the context of Network Programming.
For those of us who have the first two editions of this book, the third edition has the following changes in effect:
· IPv6 updates. In the second version of the book, IPv6 was merely a draft and the sections covering IPv6 has been updated to take these changes into effect.
· POSIX updates. The functions/APIs and examples have been updated to reflect the changes to the latest version of the POSIX specification (1003.1-2001)
· SCTP coverage. 3 new chapters that cover this new reliable, message-based transport protocol have been added.
· Key Management Sockets coverage. Network security and its applicability and use with IPsec.
· Updated Operating Systems and machines that are used to run the examples in the book.
· Some topics such as Transaction TCP and X/Open Transport Interface have been dropped.
Many topics and sections have been updated with the authors' comments. These comments even though simple for someone new to the profession, are extremely useful as they are like hints and tips from one developer to the next to help you out in your next programming assignment.
If this is the only edition of the book that you are reading, you are in for a treat. Topics in Network Programming are covered in detail and using concrete programming examples that all of us can relate to - all Unix, but what else is there?! All kidding aside, the topics are covered well enough that they are useful information under any Operating System. The concepts don't change; sockets are sockets under any Operating System. The function call is different, but one needs to go thru the same steps under any environment.
Being the most popular networking protocol, TCP/IP is covered in Part I of the book. One needs to have prior understanding of the TCP/IP protocol and the OSI model, however. If this is the first time you are looking at the programming aspects of networking protocols, Part I of this book will cover the basics. It starts you off with a couple of simple examples such as daytime client and a daytime server and it builds on that as the reader reads along. TCP, UDP and SCTP (Stream Control Transmission Protocol) are covered in brief in Part I, and basic concepts such as the three-way handshake of TCP and the four-way handshake of SCTP are depicted.
Part II of the book covers sockets and socket programming. Topics such as the socket Address Structure in IPv4 and IPv6 for TCP, UDP and SCTP are covered and examples (the same daytime client/server) are given to convey the point to the reader. It is important to mention here that all the topics and concepts are depicted for the three transport protocols: TCP, UDP and SCTP. Every single socket API under the Unix programming environment is covered and examples are given for each function call to show the reader how the function can be utilized. An entire chapter has been dedicated to Socket Options and how they are used/can be used for best results. Hints are given throughout the chapter to tell the user about the pitfalls and best practices of each option.
After the basics have been covered, various I/O models are depicted in detail and examples are shown to convey the pro's and con's of each I/O model. The five I/O models used thru the book and available under the Unix environment are:
· Blocking I/O
· Non-blocking I/O
· I/O Multiplexing (using select and poll)
· Signal driven I/O
· Asynchronous I/O
SCTP - Stream Control Transmission Protocol, a new IEFT standard are covered in later chapters of 9 and 10 and again in chapter 23. The two interface models of SCTP (one-to-one and one-to-many) are covered in detail, and their differences with TCP are also explained in full. The client/server example that has been used throughout the book is ported to use the new SCTP protocol. The authors then go into great detail explaining the problems that SCTP solves over TCP and where and how it would be useful to use SCTP.
Advanced topics such as IPv4 and IPv6 portability, Unix Domain Protocols, Multicasting and advanced Socket programming for UDP, TCP and SCTP cover the rest of the chapters in this book.
Various options for interoperability between IPv4 and IPv6 start off the last section of the book. A chapter on Advanced I/O functions brings the reader a new perspective of how complicated Network Programming can become. Non-blocking I/O, befits and examples are covered in chapter 16. The topics on Multicasting, and adding reliability to UDP are probably my favorite chapters in this book. The Time Server that has been used throughout the book is re-coded to become a multicast application. Some issues that arise when designing multicast applications such as multicast on a WAN are also discussed.
The third edition of the UNP book is as good as ever. The updates truly reflect solutions to today's challenges in Network Programming. Bill Fenner and Andrew Rudoff did an amazing job continuing the work a true legend in the field of Computer Science.

Code Reading: The Open Source Perspective
Code Reading: The Open Source Perspective
by Diomidis Spinellis
Edition: Paperback
Price: CDN$ 72.99
20 used & new from CDN$ 25.02

5.0 out of 5 stars Valuable resource of Information and good practices, Jan. 21 2004
A valuable resource for best practices, do's and don'ts, what works and why, what you should do in various situations of project, code, and architecture evaluation, and everything in between. In one phrase, this book depicts Software Engineering's best practices for the real world. No heavy-duty processes to follow, no reading of Software Engineering text books that are over a 1000+ pages. More importantly, everything in this book is REAL. References are given to open source projects where the author took the examples from, and the CD-Rom includes the complete code examples given in the text.
The author starts off by giving a background on the most popular programming languages used in the open-source community such as C/C++ and Java. Some scripting languages such as a PHP and Perl are also covered, but the main focus of the book is on C and C++. Data types, data structures and control flow are covered respectively and various best practiced of "what to-do" is given for each topic. These topics are somewhat basic, and if you are an advanced programmer, you can read thru these chapters in an hour or so. Even though these chapters are basic, they contain valuable to-do's and best practices that everyone of us will surly benefit from. They style of the book and its structure is nothing like I have seen before and it takes a couple of chapter to get used to it.
Chapter 4 is one of my favorite chapters in this book. It talks about C Data Structures. Towards the end of the chapter, the author talks about Graphs and Trees. These two rather complex topics (books have been written on these two topics) are covered so well that with about 20 pages, the reader can get a very good understanding of the topics at hand. Concrete examples from various open-source projects are used again to get the point across, and the source code that is on the CD-Rom is reusable with little effort.
The fun begins with chapter 5, Advanced Control Flow. Recursion, exception handling, parallel programming and non-local jumps are the main topics covered in this section. Again, the sample codes really help the reader to understand the topic better, and they also can be refereed to in your next project - something I found very beneficial. Another interesting thing about this chapter is the part that compares the different thread implementation in various languages and platforms - Java, Win32 and POSIX. Example from each implementation is given to show the reader the difference in practices and to get the point across more clearly.
If you have ever been bored to death by reading books on Software Engineering and Software Processes and just wanted to be able to have a very light and proven process to help you out with your next project, then Chapter 6 - Tackling Large Projects, is for you. The author starts the chapter by going over some of the design and implementation techniques used widely in large projects such as:
· The need for a software process
· Complex Architecture
· The need to support multiple platforms
· The use of OO techniques
· Operator overloading techniques when appropriate
· The need for Libraries, Components and Processes
· The need for custom languages and tools
· The use of pre-processing for portability and other reasons
Some or all of these methods are needed in large software projects, and author goes into detail in chapter 6 to cover how these tasks can be accomplished efficiently and proactively throughout the project life cycle. The author starts by going over Project Organization such as directory structure and source tree organization to the build process to revision control for future releases and end the chapter with a topic on testing of software applications.
The next two chapters, Coding Standards and Documentation are simply priceless. In about 40 or so pages, the author is able to cram over twenty years of best practices in coding standards and documentation techniques. I have never read a book that covered these two topics so well. If you are a project lead, you can simply take these two chapters and use them in your next project because you will not find anything better elsewhere.
The biggest and the most imperative chapter in this book is Chapter 9, Architecture. Various architectural patterns are covered. Each pattern includes a list of projects in the open-source community where it was applied and was proven successful. The author then goes into various Control Models that are used in the industry such as:
· Event Driven Systems
· System Manager
· State Transition
And examples of each of these Control Models along with code samples are given. Various packaging methods and schemes such as namespaces, modules, objects, generic programming, Abstract Data Types and libraries are also depicted in this chapter. Chapter 9 is the longest chapter in this book, but also the most informative one.
D. Spinellis did a great job putting this book together. This book is packed with examples, best practices and information that are useful to developers, project leads and managers. Now you can have all the experience of the open-source community, the people that developed Linux, Apache and other popular software applications, at the tip of your finger.

Page: 1 | 2 | 3 | 4 | 5