Markup Languages Books

I was greatly disappointed with this book. I have bought many other visual quickpro books which have been great.

This book is not advanced. The examples in this book do not separate content, presentation and function.

Javascript should be separated from the content of the page, not mashed into the (X)HTML as was typically done in early web sites. The javascript hooks in the code examples are invariably hard-coded into onclick=".." attributes. While that may work fine at first, just try updating pages full of onclick attributes and you'll be looking for a better way.

CSS should be used to separate the presentation from the content of the page as much as possible. It seems that the author has 'divitis': there are so many nested divs in some of the examples it's hard to follow the markup.

The book gives lip service to accessibility, but does not follow the concept through: many of the examples will not degrade gracefully in non-javascript enabled browsers. Dynamic html pages _can_ play well with all browsers: this is advanced javascript. If you follow the examples in this book, however, you'll be discriminating against a large part of your audience.

You will get better information in:
For css:
CSS Mastery: Advanced Web Standards Solutions
Web Standards Solutions: The Markup and Style Handbook (Pioneering Series)
For javascript:
ppk on JavaScript, 1/e (VOICES)

I've actually been using CSS for about 8 years now. Mostly just for font/color control, as positioning support wasn't wide spread until the last few years.

This book helped flip the switch on just how pure CSS layouts (header, footer, left nav, body) need to be setup to work. I probably just skipped over something in my other books.

The layouts, practical DTHML menus, and a very useful section on making great looking and performing forms, make this book well worth the price.

When I first got interested in DHTML I purchased both of Teague's books on DHTML and CSS. They have proved to be invaluable. His writing is easy to understand. The format is easy to follow and consistent throughout. He uses just enough illustrations to demonstrate the subject. His knowledge of JavaScript, HTML, and CSS is exemplary and the examples used in the book are pretty much bug/error free (unlike many books I've read that contain code). If you're just getting started with DHTML, get both of Teague's books. You won't regret it.

This is the sequel to the excellent DHTML and CSS for the World Wide Web. It is merely a cookbook of techniques, whereas the first book is an outstanding introduction to an advanced subject.

This book is worth leafing through to find items of interest but it does not advance the state of the art in the way the first book did.

I was a little surprised that the one chapter on Advanced DHTML techniques could have been titled: "Intro to JavaScript." I was disappointed because there was little on advanced CSS layout (1 chapter) with examples that were difficult to follow.

If you want a book teaching JavaScript and PHP integration this book is for you. If you want a book on advanced CSS techniques that you might want to look elsewhere.

The main problem with the book is it's lack of focus. It's neither a book for business people trying to value ebXML, it's neither a book for technical people trying to get more detail about ebXML.
The business intro is poor. It's a collection of trends without much structure or insights.
The technical part is mainly an intro.
I was disappointed. Is mainly my problem, but I would advise future buyers to look for more focused books.

This book provides a nice combination of the technical underpinnings of ebXML with an explanation of the new business strategies that it makes possible.

Too many managers believe that they can conceive and implement an eBusiness strategy without understanding the underlying technologies. This hubris contributed to the recent rash of web business failures. The Kotok and Webber book does an admirable job in explaining the technical to the business mind and the business to the technical mind. And I believe that even many of the more technically inclined will benefit from the history of how ebXML came about and how it leverages but is fundamentally different from Electronic Data Interchange.

The global focus and variety of examples from both business and not-profit organizations is also a welcome widening of the normal discussion of eBusiness.

I would read this book before many of the supposedly more business savvy tomes on eBusiness.

Like we know it from Alan and David both are good in describing complicated technical stuff so you can comprehend it. Therefore this book is a good introduction into ebXML's concepts, and even in some eBusiness, EDI and Markup Background.

One will recognize David's previous work on XML/EDI in that book. Very good examples about (mainly) small companies which can benefit from electronical exchange of business information.

This book does not aim to help programmers to implement ebXML, but it does aim to understand management, business analysts, edi experts and programers the requirements of business.

Personally I missed a bit the practical help you could expect from a writer so deep into ebXML and EDI. So the examples of possible gains in business sound a bit constructed, and you always miss kind of proof, that especially ebXML is the tool to make the job done.

If you are a troubled EDI Expert and wonder, how to solve those every day problems you have with "missing informations", "ERP systems which do not have article data", or simple "expensive carriers", you might wonder yourself, where in the ebXML technology is the solution to those little details. There are a lot of good concepts, which eventuelly will help you (if they get explored in great detail).

In the book you will learn a lot about the joy of automatically setting up a ad-hoc busines, you will learn that you never again have trouble receiving foreign char sets and you will learn how detailed industrie organisations can describe common knowledge in UML. How easy business would be if.... But you might actually feel, that there is something missing, which is not described in this book.

So in short, it is a good book to get to know ebXML and therefore it is highly recommended. I especially recommend this book because it is one source to establish knowege inside your company, no matter if it is an programmer, business analyst, sales guy or the manager of information systems or business development.

As a small side note, dont know how you feel about the layout, but I needed to get used to it.

On the other hand this book is a GREAT jump-platform. Each chapter is closed with dozents of links and ressources as footnotes. Dont miss to ander off and actually follow those references.

I found this book nice to read but pretty poor in terms of practical information. If you're looking for material to waffle at a VC it's all here but don't expect to sit down and start writing applications after reading it...

This book doesn't purport to cover programming. Instead it is a comprehensive guide that describes ebXML from business and technical perspectives, and does so is such a clear, well written manner that it deserves 5 stars. If you're more interested in writing ebXML applications you may want "ebXML Simplified" by Eric Chiu (ISBN 0471204757), which shows how and provides sample code.

What I most like about this book is the way the authors manage to integrate the technical details with the business value of ebXML without going over the heads of business users or talking down to IT professionals. I also like the fact that the book is kept up to date on the companion web site, and the additional information that is provided there to supplement what is covered in the book.

The highlights, in my opinion, are:

Chapter 2, ebXML in a nutshell. This chapter uses clear prose and illustrations to portray ebXML, how it fits into an enterprise solution, and all of the underpinnings. If you only read these 30 pages you'll come away with a solid understanding of what it is and how it works. The next chapter, ebXML at Work, takes this material a step further with case studies that are realistic.

All of Part II, which shows how ebXML fits into the much larger XML picture (including an interesting history of XML and how it evolved from SGML). History aside, this section ties together a number of related technologies, such as Java, XML, HTML and platforms. In fact, the four legs of a table metaphor that the authors use is one of the most elegant depictions of the interrelationships I've seen. They don't stay at high level, however. The book drills down into DTDs, and also does an excellent job of describing the business processes and technical architecture in terms that anyone can grasp. I especially liked the way UML and use cases were introduced.

If you want a book that describes ebXML (and in a larger sense, XML) from business and technical perspectives this is the one to read.

We've been in the web development business for over 11 years and have watched so much change in that time. We're often asked what tools are vital to learning how to work in our field. Many from the 'bible' series books have been on our office shelves over the years. This one is the latest to actually take up residence on each of our desks as a regular reference tool. Buy it, use it, use those nifty post-it flags & highlighters all over it, and when the pages start falling out, tape them back in & keep using it. As for the bad reviews - my suggestion is that if you're advanced in HTML or looking for advanced techniques in CSS there are books for that, too. It takes an entire library of reference books to stay up with all the changes & aspects of this industry, and as you grow beyond the levels found here add to your collection, but this one really is important to your library!

It's easy to read, full of useful information, and up to date. It is well written and has great examples.


I don't know what more to say. If you are interested in using HTML/XHTML or CSS, I'd say this is a very valuable book to own.


Jenn
ihatechunli@yahoo.com

This is a bible for beginners, written in clean and simple language. For me, it has been the ideal reference. For somebody just beginning in web design, I recommend pairing "Head First HTML..." with this book, as the "Head First" series takes more time teaching certain basic concepts.

It is both a reference and a chapter by chapter teaching guide. All in all, it has been very helpful.

If you are an experienced coder looking for an strict HTML, XHTML, or CSS reference, I suggest you move on to another title. If you are a novice in HTML using a WYSIWYG editor and want to start getting into the HTML code itself, then this is a good book for you. I bought this book to refresh myself in HTML, and CSS being away from it for several years. I program in VB and VC++ and have many programming references that are excellent and very concise. Unfortunately this book is neither. The writers persistently wander off on long winded tangents that seem to ramble on and on.... and on! The analogies had me scratching my head wondering just what exactly the comparative was? There are many small chapters in the last half of the book that are nothing but fluff and offer no real information.
In closing, there is useful information in this book for the novice. However it is not complete or in any particular order. Happy hunting.

This book is not worth your money. It is poorly written, does not explain code, and is very incomplete. Bible in its title is very misleading...

I have started reading this book and I am very impressed. The book is very detailed and full of valuable insights and tips that no doubt come from the extensive experience of the author.

XSLT is covered by many general XML books and there are a few books dedicated to it but when one start to use XSLT for complex real-life application often these books fall short. For instance, many books do not satisfactorily explain how to deal with namespaces, or white space or how to implement recursion.

Some of the examples given in the book are great as well: producing svg, rtf, pdf and documentation for the stylesheet. I also like the fact that the author is aware of XSLT 2.0 (currently a W3C working draft) which is not the case for many others xslt books and the fact that he spends some time covering vendor extensions. Generally I find it to be the most comprehensive reference contained in a single book.

The only downside of this book is that it is catered toward advanced readers. I do not recommend this book for somebody new to XML and XSLT. I think it would be hard to grasp the concepts using only this book as it comes right in the meat of the matter. For beginners I would rather recommend to start with the XSLT book from O'Reilly (ISBN: 0596000537) which is an easier read, to be later complemented by O'Reilly's XSLT coockbook (ISBN: 0596003722) which is also excellent.

Before I bought this book, I took a look at many books for deciding which one to buy.I bought this book 'coz it seemed the best one for me, and. indeed, it is. It explains a lot about xslt template and the neccessary functions. Many other books don't have any explanation about how to use it. I strongly recommend this book!

If you want something that explains XSLT, don't buy this. The author hardly bothers to explain what anything really is, how it works, or what it's for. He provides lots of code examples, but doesn't explain them. He simply shows the code and the results. He seldom explains how the code generates the results.

The author constantly introduces topics he says he'll explain in later chapters. You're often left wondering why he bothered because introducing things and not explaining what they do or what they are makes it difficult or impossible to follow the point he's trying to make.

In addition, he sometimes introduces new features with examples that show how NOT to use them. He then does not provide examples of correct usage.

I really wasted my money on this book.

This is just another disturbing computer science book that has never been competently edited. Very verbose, but the real oddity is the lack of meaningful words, or any words, to explain syntax when it is obviously needed. I was really sorry that I waisted my money and time reading this book after reading positive reviews. Never again will I make a purchase on so few reviews. Look for similarity in negative comments to find the truth about books in reviews.

Okay, I suppose the weenies who say you have to know XML to understand this book are right. So, yeah, if you don't know XML, go to remedial school and learn it. Maybe I'm being kind of tough, but the truth is, if you're a Java programmer, or a C programmer, or a Javaascript programmer, this author knows how to talk to you. He tells you how XSL is different than OOO programming. And the differences are huge. No simple iterations and loops here, no dynamic variables, no anything you're used to, and this author explains it all in a way that makes sense. This book is absolutely the most comprehensive beginner-to-advanced-level book on XSL I've ever seen, and I've seen a lot. If you want straight reference, go to Michael Kay's book. If you want to actually learn the language, this is your book.

i was looking for example on using the System.xml.serialize name space. This is the example copied from the book
public enum AddressType {
Home,
Office,
Billing,
Shipping,
Mailing,
Day,
Evening,
FAX
}
If you'll look again at Example 9-7, you'll see that each state is actually listed by its full name, not the abbreviation as listed in the State enumeration. Here I've added an XmlEnumAttribute for each state name. Note that I've skipped some in the interest of space:

public enum State {
[XmlEnum(Name="Alaska")]
AK,
[XmlEnum(Name="Alabama")]
AL,
[XmlEnum(Name="Arkansas")]
AR,
[XmlEnum(Name="Arizona")]
AZ,
// ...
[XmlEnum(Name="Washington")]
WA,
[XmlEnum(Name="Wisconsin")]
WI,
[XmlEnum(Name="West Virginia")]
WV,
[XmlEnum(Name="Wyoming")]
WY
}
The Address class has one attribute, type, and four elements. Here I've added XmlAttributeAttribute and XmlElementAttribute, as appropriate. The AttributeName and ElementName fields of each attribute are used to set the names of the XML attributes and elements, respectively:

public class Address {
[XmlAttribute(AttributeName="type")]
public AddressType AddressType;
[XmlElement(ElementName="street")]
public string[ ] Street;
[XmlElement(ElementName="city")]
public string City;
[XmlElement(ElementName="state")]
public State State;
[XmlElement(ElementName="zip")]
public string Zip;
}
Similar to Address, the TelephoneNumber class has one attribute and three elements. Again, I've decorated each member with the appropriate attribute. Note also that here, as in Address, I've set the names of the attributes and elements to match the ones in the XML; that is, they all start with lowercase letters:

public class TelephoneNumber {
[XmlAttribute(AttributeName="type")]
public AddressType AddressType;
[XmlElement(ElementName="areacode")]
public string AreaCode;
[XmlElement(ElementName="exchange")]
public string Exchange;
[XmlElement(ElementName="number")]
public string Number;
}
Now we come to the meat of the personnel record, the Employee. This class has three attributes: firstname, middleinitial, and lastname, which I've treated with the appropriate attribute. However, the Employee class also has two additional elements, addresses and telephones. These two elements actually contain nested arrays of elements, so I've used the XmlArray and XmlArrayItem attributes to help the serializer figure out what to do with the XML elements it reads:

public class Employee {
[XmlAttribute(AttributeName="firstname")]
public string FirstName;
[XmlAttribute(AttributeName="middleinitial")]
public string MiddleInitial;
[XmlAttribute(AttributeName="lastname")]
public string LastName;

[XmlArray(ElementName="addresses")]
[XmlArrayItem(ElementName="address")]
public Address [ ] Addresses;
[XmlArray(ElementName="telephones")]
[XmlArrayItem(ElementName="telephone")]
public TelephoneNumber [ ] TelephoneNumbers;

[XmlAttribute(AttributeName="hiredate")]
public DateTime HireDate;
}
Here's the document element, personnel, which is decorated with XmlRootAttribute. Although the Employees member is an array of Employee objects, it is not a nested array, like addresses and telephones. By adding the XmlElement attribute directly to the member, the XmlSerializer knows that this member is to be serialized as an array of employee elements, without a separate top-level element:

[XmlRoot(ElementName="personnel")]
public class Personnel {
[XmlElement(ElementName="employee")]
public Employee [ ] Employees;
}
Finally, I've made some changes to the Serializer class, which I introduced in Example 9-5. Serializer's Main( ) method still uses the CreatePersonnel( ) to create some personnel records, but it then instantiates an XmlSerializer to deserialize the objects it created back out to a file:

public class Serializer {
public static void Main(string [ ] args) {
Personnel personnel = CreatePersonnel( );
XmlSerializer serializer = new XmlSerializer(typeof(Personnel));
using (FileStream stream = File.OpenWrite("Personnel.xml")) {
serializer.Serialize(stream,personnel);
}
}
}

notice its in java??? for crying out loud if your going to say .net and xml use .net examples not JAVA

This book has probably all you need to know about reading, writing, formatting and sending XML over the wire with C#. Standout chapters for me were chapters seven, on XSLT, and nine, on web services. That being said all of the non-reference chapters were evenly written, easy reads and neither rat hole nor pander to the reader. The code samples are numerous but they are hilighted with bold to emphasizes the portions that a critical to the narrative.

C# is the only imperative language covered in the book even though most .NET authors cover both C# and VB.NET. In the introduction the author calls C# the central language of .NET and says it's the best language for the job. I don't have big issues about that but other potential .NET readers may, especially considering the popularity of VB.NET. Personally I prefer when the author chooses one language and then leaves the other to the site or the CD. I think VB.NET example code fragments on the O'Reilly site probably would have been a safer bet.

It's this one language approach in the dual language .NET environment that kicks the rating from five down to four.

A careful reader would have noticed the "using" keyword in the code sample, and realized that this is C#, not Java. I found this book a good supplement to the MSDN; its well-conceived examples got me off to a good start in this area.

Note that I decided to write this review because I could not believe that so many people wrote so nice reviews about this book. My assumption is that someone or some people are really trying to sell this book, because this book is definitely not that good whatsoever.

Actually, this book is definitely not what I expected from a .NET/XML book. I was expecting a practical book with some theory, a good description about .NET's XML implementation and good examples. This is not what this book included. I'm very flexible with books. It's impossible that every book will be perfect. Actually, most aren't, so you have to get used to it, but again this book is for the most part terrible, unless you only want to get a general idea of how to use XML with .NET, otherwise get a different book. Again, I don't know where the reviews for this book came from, because this book is really not that good.

To name a couple of things that I find wrong with the book, lets start with the examples included. Two words: they suck! Each chapter is pretty much like this: here is the general theory, some of it unnecessary like the constant reference to W3C stuff; then, here are a few lame, simple examples without much substance; now, lets go to the next chapter.

The first time I looked inside the book I was looking for information about how .NET did Xml Validation, and it is just terrible. I actually found more information out of general .NET books I already had, than from this one. And when you are working on a project where you need this information, and you have a book that's suppose to help you with this stuff, it is very disappointing to find out that the book is pretty much irrelevant.

You would assume validation is a very important XML topic, among many others, but there's really not a lot of info on it. Actually, if you look on the book's index, you'll see that about half the related info is in the reference section, which you could get out of MSDN anyway. BTW, almost half of the book is simply reference for the different .NET XML namespaces. Again, the same data you could get out of MSDN.

In any case, I know there's not much else to choose from, but pretty much anything else might be as good or possibly way better...

Over the years, I've found it increasingly difficult to buy technology related books simply because of the speed in which they become obsolete. So now I look at each book as not only an instructional tome, but whether or not it will be useful 6 months down the road as a reference. This book (like many of O'Reilly's titles) has easily earned a place in my library.

Mr. Bornstein's method of writing seems to fit very well with the way I learn, and his coverage of the subject matter makes this book a great resource when I'm trying to remember the exact syntax of a specific method call.

I bought this book several months ago and was disappointed. One of the problem is that I am consistently debugging the codes. I am at Chapter 5 now and have spent numerous times googling to try to understand what is the correct syntex for some codes, such as using xml method for column-level contraints, which was demonstated in the book, but does not work. The other thing I don't like is the lack of explanation about the code examples. Many times, a code was throw out without clear explantion, such as how cross apply, outer apply works.

The web was designed for people to read what was stored at a computer somewhere else. After the web was set up, it wasn't long before people wanted to extract information from one system to incorporate into their own web page.

For a quick example, go to www.books-on-line.com. At the upper left is a little box for you to enter an ISBN number. Put in a number and click on Get Prices. Then what happens is that the Books-On-Line web site goes to Amazon and gets up to the minute information and displays it back to you in a simple format.

As part of their ASP.NET design effort, Microsoft has added a new datatype called XML to their SQL Server database. This book is on using this new feature. It describes the data type. Talks about constraints, schemas, all the things you would expect. It then talks about the integrated features to facilitate the generation of XML code that can be sent out over the web.

XML is a major new concept in distributed computing. The book covers this aspect of the Microsoft approach and does so very well. It is complete and thorough and very well written.

I didn't read all of it but the code samples in the first 3 chapters has a terrible mismatch with variables names. Some of the chapter's paragraphs are repeating them self.
I got the feeling they get to rush in this edition.
But you should take into account that i'm very pedantic.
Search inside before you make your decision.

If you are considering using XML in SQL Server 2005, this book will pay for itself quickly. The clear examples of creating XML Schema collections, altering them, etc. are very helpful.

The only problem with this book is that SQL Server 2005 does not fully support XML Schemas. Because this book was written using a beta product (I believe) perhaps the author could not have know exactly how the final version would shake out. However, partial support of standards is important to any developer. You often find out only by trial and error what is supported and what isn't. The Wrox web site offers nothing of the kind for this book. So buy this book, but be aware if you are using complex XML Schemas there may be some surprises (e.g., notation not supported).

Just been thru Chapter 1 - what is in the book and the snippets of the code that follow do not correlate. This is just like a developer code, wrote something and threw it across the wall for testing, never matters if the code matches requirements or not.

If you are considering this book, Amazon includes the Table of Contents in the links to the left, where you can see the organizational structure of the 24 hours.

The error in logic mentioned in the second review was actually a typo in the layout codes...the code for a numbered list was used instead of the code for a bulleted list.

This mistake was first discovered in mid-February and has been listed on the book's errata page since late February. The errata page itself was made available in late October, 1999, after the book was first released.

For those who purchased the book before March, the mistake can be found on page 59 in Hour 5. This mistake (and several others) were fixed for the second printing, which started shipping in March.

I would have preferred to not rate this book, but it's a required field. I'm entering a 3 so that the current average remains the same. (Personally, I think it ranks higher than that! ;-) )

If you don't have the time or budget to go to a hands-on training class, this book is the best way to learn to use RoboHELP to create HTML Help. In 24 digestible chunks, the book leads you through all the major features of the product. There are plenty of tips to help you get started on the right foot, as well more advanced technical topics to help you "push the envelope" if you're inclined that way.

The author obviously knows her stuff, and I would recommend this book to anyone wanting a comprehensive introduction to RoboHELP HTML.

Looking through the TOC for this book, I was impressed at the extent to which it covered the applications of RoboHelp. But, once I started using the book, I found myself spending progressively more time trying to understand what the author was saying.

The structure for a good book is here, it just needs a few more months on the desks of some good editors.

I'm self-taught in a lot of different areas and have used a great many books of this type. The author needs to pare this down to the essentials before going into so many details. One problem is that she covers things like how to make DHTML effects before she covers something as essential as how to make a table of contents. She also tries to offer too much information in each page -- there are too many little "hint" boxes with information that you don't need to know yet. Larger graphics would be helpful, as I had trouble reading the text on many of them.

I'm self-taught in a lot of different areas and have used a great many books of this type. The author needs to pare this down to the essentials before going into so many details. One problem is that she covers things like how to make DHTML effects before she covers something as essential as how to make a table of contents. She also tries to offer too much information in each page -- there are too many little "hint" boxes with information that you don't need to know yet. Larger graphics would be helpful, as I had trouble reading the text on many of them.

This book has several frustrating errors in the examples, you have to find the errors to make the example work, e.g., mispelled field name in SQL statement. I was only interested in the XML portion of the book and learned far more by digging in at MSDN's XML site.

I read Mr. Martinsson's other book, ActivePerl, and I really enjoy his writing style. I guess some people get it, and some don't. This book is especially strong if you are interested in WMI. While it touches on XML, it may be misleading to put XML first in the title. Nonetheless, it is an excellent treatment of scripting for SQL Server 2000 ...

This book has several frustrating errors in the examples, you have to find the errors to make the example work, e.g., mispelled field name in SQL statement. I was only interested in the XML portion of the book and learned far more by digging in at MSDN's XML site.

Wanted to learn programming SQL Server 2000 with WMI. I'm a programmer, so the book's approach fits me. WMI text and samples worked for me. I learned WMI. I'm happy.

XML is not what I bought it for. I know MSXML, XSLT, XPath, yada yada yada. But I found some stuff I can use with ADO and MSXML. It's a bonus.

Another bonus: the code samples are available in Perl. Found them on the CD-ROM next to the VBScript samples. A pleasant surprise because the booktext shows example-code in VBScript.

I thought this book was one of the worst I have ever purchased. There are annoying mistakes in the sample queries, e.g., mispelled field names that will just drive you crazy. I can't speak for the WMI section, I bought this book for the SQL Server 2000 with XML info. I learned more at MSDN.

after reviewing the wanderful books that Amazon has on the internet I wander how can Amazon assist me in publishing my several, book lengh manuscripts. I have had several publishers and agents desire to see and perhaps publish my works. I am quite afraid to put my manuscripts in any= one hands for fear that they may change the theme of each manuscript. I write in several areas. including business, religion, psychology/thera- py, education and etc. Please advise me steps I should take to obtain a well known agent and publishers who may like to evaluate my manuscripts sincerely,

bill battiest 1201 E. Drachman St.#104 Tucson,Az85719

The tone of the book made it an easy read and an useful introduction to PageMill and web publishing.

However, I did find that some of the information was out of date - but it was printed 2 years ago!!

I was disappointed with the tutorials because firstly they did not span the whole book and did not include exercises in putting sound and video into PageMill and secondly I failed to find the Chapter 1 tutorial on the CDROM.

Furthermore, the web address - vmedia.com is not available.

Overall, I feel the book is a useful introduction but one you would borrow from the library rather than buy!

I have read several good software instructional books, and I found Ventana's "Ultimate Guide" to Pagemill to be ULTIMATELY FRUSTRATING. The author tends to mention a particular attribute of the program without telling you how to access it until the very end of his discussion. A good example of this problem can be found in his explanation of HTML "anchors." He tells us how to create a single anchor and how to name it, but once we've done that, he doesn't tell us of what use they are or how to move between one anchor and the next--the entire reason these objects exist. I find myself continually marking up my copy with questions that I hope are answered later in the book. Some are, others aren't. This book could be very useful in another, more carefully edited edition. (I've also found quite a few typos which suggests the haste of the publication process.) In short, stay away from the 1997 edition and be wary of this series of "Ultimate Guides."

This is a very simplistic introduction to PageMill with many key instructions either missing or buried between the lines of the overly-cutsie prose. For example, the Attributes Inspector has a key menu that allows the detailed placement of graphics - this menu is never mentioned nor is an illustration of it shown anywhere in the book (I only stumbled across it accidentally). Also, several files are not on the accompanying CD. Finally, it is very hard to concentrate when reading such rubbish as, "...do you recall seeing a funny looking bull's- eye... Surprise! That bull's-eye..." ad nauseum. Although the book is 418 pages, only 135 deal directly with the technical aspects of PageMill; all the rest is vague generalities about web design, hosting and outdated information about web software.

Couldn't find the author of this book to ask him to explain this ripoff and waste of time. The initial browse was tempting, especially the tutorials and online updates. But the files required for some tutorials are not on the disc. The online update information is outdated-wrong because vmedia.com is not available. None of this inspires a further investment of time. I would rather invest a little more money in another book that fulfills promises which were crucial in the decision-to-purchase. Who is responsible for this deception?

I was studying for the Microsoft exam 70-310 on XML Web Services and they suggested this MS press book on web services, but the MS press book is ONLY in C# even though the exam they want you to take is for Web services in VB.NET! Had to return that book. I got this one instead. I was happy to see that this book covered XML Web services in both VB.NET and C# and I was able to use this book to study for my exam. Passed!

Excellent book on webservices. Chapter 23 was something I had never seen before. WSDL is used extensively in the book, and Chapter 23 shows how to build take a standard HTML page and turn it into a WSDL document. What does this get you? Now you can screen scrape HTML pages and access the data as a property of the WSDL Document. I had never seen this before. Totally cool and unique technique!!

I have purchased three books on XML Web services and this one was the most comprehensive and got right to the point on how to not only build webservices, but also to how consume them in my applications (.NET, VB and classic asp). It is interesting that this is such a talked about topic everywhere, but there are not too many books out on this subject. You won't do yourself wrong by getting this book.

Any book on ASP.NET will mention Web services development, but "XML Web Services for ASP.NET" is an entire book dedicated to explaining all of the different sub-areas within the technology platform. And very well done. It's written by everyone's friend in .NET, Bill Evjen, one of the most outspoken advocates of .NET technology around.

The book is outstanding and takes an in-depth look at XML Web services, and Microsoft's specific implementation of the paradigm. All of the major considerations are explained well and adequately to become productive in developing your own library of Web services, or by extending the functionality of your applications.

The book's tone is very friendly, and non-intimidating, so it's a very easy, quick read. Bill also uses lots of practical analogies to make the more complex topics relevant, so it's an added bonus that this book appeals to the beginning as well as the seasoned developer.

Bill discusses areas critical to a thorough understanding of WS technology using .NET such as SOAP, UDDI, remoting, security, authentication, performance, and client development for calling an XML Web service from an ASP.NET WebForm or Windows Form, VB 6.0 app, or an ASP 3.0 Web page. The book also features some really good appendices, especially those on .NET's Web service classes, and an XSD primer for schema development.

The book is not about ASP.NET development, and so providing the reader has some experience with building third-generation Web applications, gets right to the meaty stuff. The chapters are short and to the point, and Bill's overview of ADO.NET is one of the better ones I've read in recent times. The most outstanding thing to me is that Bill liberally uses real-world code samples, with all code presented in both Visual Basic .NET and C#. Snafus in the code are very minimal, and I know form personal experience that good ol' Bill is extremely available and answers all his e-mail...about anything.

However, the book's printed code samples (I haven't checked the downloadable source code from the publisher) tend to reflect code generated from Visual Studio .NET, which in my opinion become confusing and therefore more difficult to replicate in an IDE environment like Dreamweaver MX or ASP.NET Web Matrix or non-IDE environment like Notepad due to all of the proprietary code VS.NET generates, and in doing so, using code behind. It's been my experience that it's easier to go the other way - provide the raw code and leave it up to the developer to implement in whatever means they see fit.

Another thing I did not care for (some of you may agree, I'm assuming most may not) was the physiology of the book itself, which was beyond the author's reasonable control. The binding is very flimsy and the spine breaks without much trouble. The paper isn't very durable, and doesn't lay flat for very long. I hope Wiley Publishing take into consideration that books of this nature get used & abused for their content more than most, and consider making corrections in the book's composition to make them last longer.

But beyond this, the book is a must-have for a user group as it's cross-language, multi-developmental platform, multi-subject appeal make it applicable to many different levels of developers, and is great for team environments.

When I purchased this book, hope will find examples, information about Web Services to help my projects. But I only found identical MSDN information. I could not believe my eyes but several of sentences was same with MSDN. If you want to buy a Web Services book this should not be one. I have purchased several books on XML Web services and this one was the most identical (also just copy and paste) one.