Customer Reviews

REST in Practice: Hypermedia and Systems Architecture

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

 

 

I started my REST journey with the two popular O'Reilly books ("RESTful Web Services" and "RESTful Web Services Cookbook") but found that they started a little too deep into the technical details and were missing the view from 30,000 feet. Sure, I learned stuff in those books about content type negotiation, the semantics of HTTP verbs and whatnot, but I was missing a really compelling answer to the question, "Why should I choose REST for my application architecture?".

At the same time I was reading about REST online and kept seeing lots of references to a mythical, magical thing called "Hypermedia As The Engine Of Application State" (HATEOAS) which lots of bloggers were effusive about but none of them could articulate very well. I was intrigued, but I wasn't convinced.

Luckily a colleague of mine mentioned this book to me and said it answered all of my questions, and he was right. Within a couple of chapters, it was obvious that the authors had made a real effort to explain not just what REST is but *why* it represents a significant shift in architectural thinking in software design. I quickly learned what REST really is and what it isn't. Most importantly I learned how it can be leveraged to build distributed systems that don't suffer from so many of the problems found with "classic" middleware technologies and architectures based on things like CORBA, DCOM, RPC, and so on.

After reading this book I returned to those two O'Reilly books and found they were much easier to follow and made far more sense. Having the architectural basis and benefits of REST explained properly by "REST in Practice" really accelerated my learning while reading those other books (which rely much more on code snippets and HTTP payload discussions rather than the underlying concepts).

If you're tasked with building a REST system or would like to figure out if REST is an appropriate approach for your designs, then this book is for you. If you're a script kiddie who just wants to learn how to write another Twitter client for the iPhone, this book may be overkill.

Building a RESTful system is much harder to do than simply consuming one that already exists. Designing a simple, usable RESTful system that properly follows the HATEOAS principle and remains easy for clients to consume is no small task either -- but this book helps immensely in that regard.

For making an architectural topic that is so poorly described elsewhere so tremendously easy to understand, this book easily gets five stars.

This book provided a clear and concise overview of how to apply REST architectural principles to enterprise development. The books starts from the basics and in each chapter adds a new layer of sophistication to build a simple but complete business process with REST. I was especially interested in the sections that detailed how to use REST principles to handle enterprise integration tasks instead of using expensive proprietary middleware. I also liked the chapter on security which detailed how to use OpenID and OAuth to handle authentication and authorization respectively.

I would recommend this book to anybody looking for a good practical example of building a REST services.

I read the comment about the "skip it" advice. I guess it applies to some people, but not all.

There is another book, the RESTful Web Services Cookbook: Solutions for Improving Scalability and Simplicity (RESTful Web Services Cookbook: Solutions for Improving Scalability and Simplicity) is an excellent book for the ones looking for quick recipes like the authentication. But that is a reference book, not a walk-through one.

If you like a book that walks through implementation of a simple REST service, discussing all the detail, pros, cons, going from an immature implementation to a more robust one, adding complexity, transactions, security and such, REST in Practice is the book. As the title implies, it is not a theoretic discussion, but a hands on explanation. It is a very small service, the book will not show a full blown, enterprise level system, as that is not the goal. It works on the tactical and implementation level. The code will not be usable for your own system in full, but the reader will certainly find some very good explanations and answers to general questions.

There is of course the need of an architectural level book about REST. This is not it. Hope O'Reilly will support one soon.

The author team takes their RESTBucks coffee shop application through Richardson's Maturity Model explaining the issues at each level. Java (JAX-RS) and .Net implementations.

Then they go on to explain the importance of Hypermedia, and mentions that the hypermedia is a part of the representation. I'm not quite sure about this.

I tend to disagree with the way they implement this; as a List<Link> member. There are benefits and security issues with this approach. It becomes possible for any client to set a link including overwriting a link. While this can have benefits, the immediate security issues of a client setting e.g. payment links to phishing sites are also present.

They also like to use the Atom and AtomPub envelopes, which I fail to see work on a more common approach, that is, on any other media than formatted text.

The book is more recent though, and a good read.

The most useful parts of this book for me were the detailed discussions of features in the HTTP spec, e.g. for caching or security. The "Restbucks" example was also interesting, but I'd rather have had more examples showing how other kinds of applications translate to REST.

I didn't find the code examples (some .NET, some Java) all that useful: Having the requests and responses (incl headers) seemed sufficient. Showing how to set headers or send requests using specific languages and libraries could have been left to an appendix or dropped altogether, as far as I am concerned.

The discussion of advanced topics such as semantics and HATEOAS didn't seem entirely practical: For example, does the author really expect applications to be able to discover and make use of new features (such as special promotions when checking out orders), rather than just scan responses for expected links?

Im new to REST ideas. This book help me understand the concepts of REST. The book is not too technical. it gives examples of java and .net implementation. Im really happy to have this book.

As the cover depicts, this book is a gentle stepping stone into the practice of REST. The book, with its logical and well written chapters, easily steps you through this new exciting architectural style. Each chapter contains techniques with their many understandable and implementable code examples. The examples, for me, were much appreciated since it didn't require me to hunt and search for better examples a the provided code snippets.

Prier to reading this book, my understanding of REST architecture was limited. The book has provided me with a higher understanding of REST with a greater confidence in my future usage and implementation. I would highly recommend it to any who are interested in REST and its Practices.

Original review written by Andrea Polci, JUG Lugano, www.juglugano.ch

When I started reading "REST in Practice" looking for an in depth book on "what" REST is, "when" it's a viable solution and "why" one should use it. I was less interested in "how" to implement a REST service.

I'm really satisfied on what I found.

The book use the development of an example service to guide the reader throw the different aspects of REST without spending too much time in the implementation details, but concentrating on the understanding of the concepts.

The examples in the different chapters use different tools and languages, ensuring the reader don't get lost in the details of the tools but remain focused on the architecture, with the help of concrete examples. Instead if one is looking for a comprehensive guide to a specifict tool he'll have to look elsewere (like "RESTful Java - with JAX-RS" from Bill Burke, O'Really).

As a downside I have to admit that it was hard to resist the temptation of skipping examples using uninteresting (to me) technologies (all the .NET stuff).

In general I can say that the book is really clear and I found it's level appropriate to guide the reader through the comprehension of the different arguments.

There is just one argument that I'd like the book have spent more time on: transactions. It's treated in a small section near the end of the book and I have to admit that I still don't have a clear understanding of it. I have also to say that it isn't a bad thing if a book leaves the reader with the desire of further studying on some aspects.

I suggest this reading to all that are interested in the REST architecture or in the development of web services in general.

I can see what Hayden Muhl aka "Skip It", is saying. The problem is, that he's not reviewing the book, he's just blaming the book for not being what he thought it was. It's not just a collection of here's how you do this, here's how you do that, cut and paste the code from the attached cd into your dev environment, compile and tell the boss how productive you've been. That's what g o o g l e is for.

I prefer to read these kind of books from the start to the end - that way you get a full picture of what is being discussed. The kind of book I described above is not conducive to reading at all, only good for insomniacs.

So, in a similar vein to James Webber's last book (Developing Enterprise Web Services: An Architect's Guide) if you want an informative read (note 'read', not 'reference book') discussing how to go about implementing RESTful solutions and the possible pitfalls and solutions along the way, then this is your book.

If you want to look up something simple in an index and turn directly to the relevant page, then buy that book.

This book is particularly good as an introduction to the world of REST. While I didn't find the code samples helpful, I enjoyed that it didn't just explain REST, but showed the derivation from straight POX the whole way through Richardson's model. RESTbucks was a great example of implementing actual business processes through hypermedia.