Verifiable programming means to write programs that can be verified using formal methods. The idea is that whenever you create a program, you should also think about how to construct a formal specification, and a partial-correctness proof of the program in question (you won't always actually generate the proof, but by thinking about it when programming, it will usually result in programs that are more correct, and simpler to understand).

While this is the idea, the book quickly looses sight of this, instead focusing on mechanical techniques for correctness-proofs, focusing on Hoare-logic, Guttag-style type-definitions with generator induction functions, and proving theorems in first-order logic with backward proof construction. This leads to an expressive and easily extended formalism, suitable for common imperative languages like C or Java. Certainly this material is necessary for an understanding of what verifiable programming means, but I wouldn't mind if the book at least tried to keep some kind of perspective throughout the text. Another problem is the lack of exercises helping you to digest the relatively theoretical material.

The lack of perspective and the lack of exercises are the main faults of the book. The last is the lack of interesting examples. Surely you can write a correctness-proof for your binary search routine, but since the problem is so simple, the advantages of the formal approach doesn't really shine, since testing all possible cases is just as efficient. It is when a combinatorial explosion occurs in the state-space of your problem that formal methods are really necessary, and this book fails to give any examples.

Still, there are few other books in this field, and if you are interested in an introduction to formal methods, you have at your disposal a book that provides a surprisingly usable and extendable formalism, capable of modelling nearly any program or algorithm. It is suitable for anyone who can program, but a more than passing interest in logic is probably required.

As someone very interested in information design and especially airline safety card design, I was hoping this book would have good samples of what the editorial review termed "the most interesting and imaginative of these safety cards."

Unfortunately, instead the entire book is apparently merely an only vaguely interesting set of reproductions of cards from Carl's collection -- chosen apparently on the basis of scarcity rather than interest. Thus we get two full pages of reproduction of a card from Air Ceylon which has nothing of interest to recommend it (unless you are really interested in Ceylonese typography).

The text (what little there is) unfortunately adds nothing to our understanding, as it is almost entirely about the history of the introduction of new airliners and has almost no interface with the actual (and very interesting) history of the development of the modern safety card, or the more general topic of safety and instructional graphics.

The most interesting aspect of this book for me was the few reproductions of pre-war cards, and comparing styles of commercial illustration -- but you can view better comparisons in almost any average book on the history of poster design.

In summary, get this book only if you want some nice reproductions of pretty average to poor safety cards from some small countries and short-lived airlines. I can spend at least 30 minutes each airline flight examining different aspects of the safety card, but this book didn't even hold my attention for an hour.

In spite of the bad reviews on this site,I decided to buy this book partly because this may be the only book on the sementic web in the market,and I did not want to wait till others were published.

Unfortunately,I too cannot recommend this book to anyone.Here are
my reasons:

1)Both the title of the book as well as the title of the series(Professional Developer's Guide Series)are highly misleading.No developer will learn anything practical from this book.There are no examples or any other practical instructions whatsoever.The most "difficult" examples I could find were the analysis of statements like "Hjelm is the author of a book".

2)What this book is is a theoretical and acedemic discussion of artificial intelligence(AI),XML,RDF,and intelligent agents(IA).But here too there is a catch.You wont understand much unless you already know these fields.I have some background in these fields but I found the presentation so monotonous and boring that I too learned nothing new.

3)This book could have been a classic if properly written.Time may be ripe for artificial intelligence to enter the mainstream of computer world via the gateway of XML.Therefore,the unification of AI,XML,RDF,and IA is a highly fascinating project for the future.And a classic is desperately needed on this theme.But Hjelm's book is not that classic.

I picked up this book, and several others, because I was interested in catching up on some of the emerging protocols. From the table of contents, it looked like it presented a broad overview on a variety of topics, as well as the in-depth discussion of RDF. Frankly, though, it is one of the worst books I've read in years.

There are two problems: the content, and the author. The writing and editing is poor and sloppy. The text is disjointed to the point that I often had to flip back after moving to the next page, to make sure that I hadn't skipped one. At some points, it refers back to examples that don't exist, and at others, it refers to figures that just don't match up. The larger structure is as sloppy and disjointed as the text. It's not even useful as a reference, because no single section contains all the information needed to understand the format.

The book reads like what it is: an attempt to fill 320 pages with the information that could have been (and should have been) written in a 20 page white paper ...

His editorial comments are full of contradictions and misstatements that read more like Usenet flames than thoughtful commentary. He liberally trashes SOAP, AI, and CORBA, while ignoring or glossing over any shortcomings in RDF. My favorite contradiction: KQML is a failure because it uses a lisp-based syntax, which is *hard for humans to read*. Meanwhile, elsewhere in the book, he states that humans shouldn't write out their own RDF, and should always use a remote syntax checker, because it's just too easy to make a mistake. Looking at his half-page examples of even the simplest schemas, filled with angle brackets, quotes, and syntactic oddities, makes me long for the simplicity of a lisp-based syntax, even if I have to put up with a prefix notation.

The book is a waste of time and money. One could get more information, in a better format, and with less irritation, just by going to the w3c web site.

This book is okay but needs work. It has neither good examples of RDF or programming with RDF. A better background to RDF, more examples, and better explanations are required.