Customer Reviews

Programming the Semantic Web

5 star:		(7)
4 star:		(3)
3 star:		(3)
2 star:		(0)
1 star:		(0)

 

 

The semantic web. We have all heard about it, the buzz, the hype, and the excitement. Much of it seems well founded once you look deeper into the idea of organizing and making data available in a way that machines can find it, share it, and combine it in new ways that were not considered or even thought of when the data was being collected. This can yield amazing results and discoveries, but to do it, we need to move beyond theory and into practice. That is what this book is about.

Programming the Semantic Web starts with a clear and practical introduction to the idea of the semantic web that will give any web developer the background necessary to comprehend the potential and usefulness of the concept. This is not a book for complete novices as it does anticipate that the reader will have previous experience with programming for the web, including the concepts of relational databases, familiarity with HTML and XML and perhaps a little RDF, and it would be useful to have some knowledge of Python and/or other computer programming languages.

The first part of the book, about 20% of the text, is dedicated to a discussion of what semantics are, how they can be used to express meaning, and why they have the potential to make data storage easily searchable and allow the discovery of new connections that were not considered during the design or collection stages. We learn here how semantic modeling can be expanded with far less pain than a traditional relational database format, allowing the administrator to adjust interfaces and searches quickly in response to the needs of users.

In Part II, the book discusses the practical technological foundations necessary to begin using RDF and other formats to store data in semantic fashion and make it useful. This involves understanding the libraries available to various programming languages and sources of semantic data from which connections may be made or discovered. One of the really powerful aspects here is that you are not constrained to using data from only one database or server, but when the data is organized and stored in a standardized semantic format such as RDF, it may be made available for reading by anyone (if desired) without any risk of it being overwritten by using a query language like SPARQL instead of the better known SQL.

The rest of the book is where the real meat and uniqueness lie. We need the foundation of the previous parts to be certain that everyone has the same understanding of the philosophy and goal of the semantic web. However, the third part of the book is what makes this discussion unique and useful. Here we get a practical overview of toolkits and examples, both code and frameworks, to enable web designers and data wranglers to begin to use the ideas in real life scenarios. Finally we have a way to move beyond all of the discussions and evangelism into implementation! The examples given are clear, useful, practical, and cover all of the sorts of things one might want to do with data. This section is the reason anyone interested in the semantic web should buy the book, and it is also the reason that anyone buying the book should be familiar with coding for the web. The examples are often given in Python and/or Java, using specific toolkits and frameworks like Sesame. The section describes how to publish for internal use as well as how to format and publish data so that others may use it without risking it being corrupted or changed.

The book ends with a short section intended to separate hype from reality and give some vision for where semantic web design might fit in with other technologies already in use, coming alongside already useful tools, not to make them obsolete, but to make them even more beneficial.

While I am glad to see books about Semantic Web technologies that are written specifically for software developers, I am disappointed that I cannot give this book more than 3 stars. Why? The book contains misleading statements that may lead a developer new to these technologies astray and encourage non-optimal practices. I will give a few examples illustrating what I mean:

-On page 131, the example explaining property domains may lead the reader to believe that having two separate domain statements (ex:hasEyeColor rdfs: domain ex:Human and ex:hasEyeColor rdfs: domain ex:Animal) is "the" way to do things. Such a practice creates issues which are not properly explained. And the diagram 6-1 illustrating this modeling example is wrong. Looking at it, the reader is left believing that the domain of ex:hasEyeColor property is a universe of things that includes Humans and Animals, while in reality it is an intersection of Humans and Animals. If someone were now to add another domain triple such as ex:hasEyeColor rdfs: domain ex:Dog, the domain would become the intersection of Humans, Animals and Dogs and a conclusion could be drawn that Jamie Taylor is a dog - obviously, not what was intended.

-On page 140 it is stated that RDF schemas are usually stored in the same graph with the data they represent. This is not true and, to the contrary, is considered to be a poor practice - keeping schema and data separate is important for schema reuse. Did the writers intended to say that they are usually put in the same triple store? The statement is confusing and it is contradicted by the book examples such as those using FOAF. It is clear that FOAF schema and FOAF data files are separate graphs.

-While modularity is talked about ("semantic data model is not a monolithic thing"), the key mechanisms used for modularity (e.g., imports and named graphs) are not mentioned anywhere.

-Describing SPARQL as a "read only" language is not correct. While INSERT or DELETE keywords are not part of SPARQL 1.0, the CONSTRUCT keyword provides a way to create new triples. Developers can also use CONSTRUCT to identify triples to be deleted. I also believe it would have been useful to mention that Jena API (arguably the API most used by the developers building Semantic Web applications) already directly implements inserts and deletes and this implementation is being used in the upcoming SPARQL 2.0 spec. Perhaps, this was not known at the time certain chapters of the book were written.

-The cursory of SPARQL is disappointing. SPARQL mastery is as important to the developer working with the Semantic Web data as SQL mastery is to the developer working with the relational data.

-The blank node example of address raised a concern that the imprecise language used in describing the motivations for using the blank node does not make it clear that a blank nodes can never be referenced across graphs.

In conclusion, the book does a good job covering a broad range of topics in a very concrete, down-to-earth way. It directly addresses some of the key misconceptions about the Semantic Web standards. For example, it makes it very clear that RDF is a data model and RDF/XML is simply one serialization of it. The depth of coverage is insufficient and uneven impacting the book's effectiveness for developers. Some choices of the areas authors decided to focus on are questionable. For example, I would have preferred to see less coverage of Freebase and more of SPARQL. I am also left wondering how much of a peer review the book had received prior to publication. An even modestly rigorous review process would probably have caught the most notable errors, imprecisions and omissions and resulted in a stronger book.

Note: this review is based on a pre-release copy of the book.

When I first encountered RDF years ago, I wrote it off. It seemed unlikely that it would get much use. But the recent arrival of collections of so-called 'semantic' data via organizations like Freebase, has made me rethink that position. Of course, figuring out how to make use of this data is another proposition, but Programming the Semantic Web serves as a solid introduction and survey of the tools and techniques necessary to make it into something worth your effort.

I can say that after reading this book, I finally get the concept of semantic data and the relationships it defines. The book begins by walking through the building of a basic triple-store (that is, a data store full of triples -- if you don't know what they are, you should read the book). This and the ensuing discussion of the graph structures built from these triples leads into an introduction to RDF. In this context, it really starts to make sense.

The examples in this book are quite useful and not too abstract. For instance, one of the examples shows how to take legacy data from an RDBMS and generate an RDF graph, going from implicit to explicit semantics. Another uses a programmatic version of the popular 'Six Degrees of Kevin Bacon' trivia game to show how you can use a semantic database of movie data to find the shortest path between two given actors (one, clearly, being the ever-popular Kevin Bacon). The final example in the book shows in brief how you might build a system for managing job listings for various companies. The example is thorough and reasonably complex, but still manages to cover a lot of ground, including integration with libraries for visualizing the data. The majority of the examples in the book are written in Python, though Java makes an appearance in the toolkit chapter, which covers various libraries available for working with RDF.

One item of note is that in the conclusion, the authors do stress caution about this technology or at least particular approaches or tools. It's important to sort out the hype from the real deal and it takes a realists perspective to understand that semantic web tools have been considered the 'next great thing' by various pundits for much of the last decade -- clearly it's not what some envisioned back when the ideas were first brought forth.

I can't say that I'm going to be rushing out and building next great application after having read this book, nor will I be looking at bring RDF into each system I build. But I do have an appreciation for what semantic data and RDF can bring to aspects of future projects I might work on. I would have enjoyed seeing more details about using external, non-semantic data source and using that data in a semantic graph, but given the range of material to cover, I can understand that this could be an entire book of it's own.

This is the first book I have read on the semantic web that does not give me feeling that I am in outer space. It is also one of the few books that honestly appraises the current, usable state of the semantic web. It is clearly written and took me a day to read (without working the examples). In the beginning, it starts with a pure triples system built from the ground up, rather than plunging the reader into the standard technologies, which are levels of abstraction above triples and may not be essential. The reader is left with the impression that he is the one who chooses to use the technologies introduced. It is also the only book that mentions how RDF evolved. It contains many example programs using existing data sources (e.g. freebase). There is a two page introduction by Jim Hendler, one of the top figures in the semantic web and co-author of "The Semantic Web for the Working Ontologist" (also, a good companion book).

The main view of this book is the semantic web as extension, modification, and very major improvement, to relational systems. It also discusses the pure AI approach. I does not get into other uses of the semantic web, such as text retrieval or approaches such as topic maps.

The large majority of this book is in Python, the easiest and probably the best designed of modern languages. It has a few examples in JavaScript and Java. Readers are encouraged to implement the examples in other languages, if they are inclined to.

Physicists and chemists are required to run experiments to prove their assertions. Many other sciences have emulated aspects of physics to acquire the mantle. The semantic web does not ask for "experiments" although it is about semantics and, therefore, about something to be discovered. This book starts in that direction.

There aren't many other books that a programmer can buy hoping to actually learn how to build real systems based on semantic data. Rather then get bogged down in the academic backing behind semantic data this book sidesteps a the idealistic principles of semantic data to instead focus on getting things done, and what the actual advantages to representing your data as a semantic graph are. As such, it explains how to actually accomplish real, concrete tasks using real technologies - and explains how to do this using simple, but realistic examples, and realistic code.

So much written about the Semantic Web is theoretical, often verging on esoteric. Programming the Semantic Web crosses the gap from theory to practice: it's a book for real-world developers trying to bring products to market.

I fortuitously discovered this book just as our company embarked on the design of a new product, one that needed to store massive amounts of structured, but sparse, data culled from a variety of sources. Since most developers are trained solely in relational database structures, our initial inclination was to use a sharded relational data model to ensure we'd be able to get new developers up-to-speed and meet our deadline. Programming the Semantic Web provided a clear explanation of the limits of relational data models for this kind of data, and contained a great walk-thru of how an RDF-based model offered a multitude of benefits. In fact, using a triple store has reduced our development time dramatically. The book's balanced discussion of the myriad of toolkits and RDF Stores available also helped us get off the ground selecting the right platform quickly.

Programming the Semantic Web is now required reading for all developers joining our project team. Using the ideas and models described in the book, we've made our system more scalable, more flexible, and dramatically accelerated our development cycles.

this book will take your breadth away both in spirit of how its written and examples it provides. i had read it with delight from start to end.

Programming the semantic web provides a practical hands on overview of this exciting new technology. Before reading this book I thought that the "semantic web" was just another buzzword like "Web 2.0" or "Web 3.0". After reading it I understand the goals and uses for this technology. The book is full of practical examples and working code. I have done data modeling in the past using relational databases and have run into the huge database schema with extension fields that they use as an example. After reading this, I knew what they were talking about was grounded in real world problems. This book talks about this problem and shows how using semantic web technologies can solve this. In the future I will have another method of solving these problems. This book is a valuable resource for understanding and utilizing semantic web technologies in real world situations.

According to this book Web 3.0 is the semantic web and it will be coming soon to a web browser near you. The book starts out describing what semantics is and how the web needs to be able to handle an expanding collection of semantic data that cannot fit a conventional relational database design. To cater fully for what the semantic web needs to become the relationships themselves become data that needs to be stored.

After introducing the concepts the book moves on to a discussion of technologies that have already been developed that make the semantic web possible. The technologies mentioned include RDF, N-Triples, RDF/XML, RDFa, SPARQL, Freebase, OWL, Protege, microformats, and Sesame. Some of these are programming languages, some database query languages, and some markup languages. Some of the markup works with existing HTML 4.01 web pages (although it will fail validation) as well as XHTML 1.0 (where the extensible nature of the language allows for such interactions between different markup languages).

The information that the book presents clearly demonstrates that a web page is not a stand alone element any more and that extensibility to work with other markup languages is the way of the future. The examples that the book gives makes it clear that this combination of technology is a very real future and not just something that a few people hope might happen.

The book concludes by showing how the semantic web is built up of a lot of different layers not all of which currently exist but goes on to explain how by using those layers that do already exist we are moving ever closer to what this web 3.0 technology promises.

The Semantic Web has been percolating in the buzzword soup for years, but its concepts seemed miasmal and lifeless to me until I read this book. It helped me see clearly the implications of semantic technology on a number of levels.

The first few chapters explain in simple language some basic concepts of the semantic web: triple stores, rdf, graph databases, data integration, etc. Concrete examples are given that a typical programmer could follow with ease. Later chapters build on these concepts to demonstrate how the power of semantics might be used to enhance existing web technologies in some truly spectacular ways.

I was left with a strong impression of the semantic web as an inchoate technology with huge implications -- very different from the foggy ideals I'd read about previously in tech blogs.