Customer Reviews

Developing Service-Oriented AJAX Applications on the Microsoft® Platform (PRO-Developer)

5 star:		(3)
4 star:		(6)
3 star:		(1)
2 star:		(1)
1 star:		(1)

 

 

In Daniel Larson's latest book, Developing Service-Oriented Ajax Application on the Microsoft Platform, Dan gives us a deep look on what it means to develop client based applications with JavaScript, the MS Ajax Library, and Windows Communication Foundation (WCF). This book is about Service Based Ajax development, which means developing JavaScript components running in the web browser that call back into services on the web server using XML HTTP requests using no postbacks. There is no coverage of the Update Panel or the Ajax Control Toolkit, so if you are looking for a book on those subjects, look elsewhere.

The first few chapters give a basic introduction to service oriented architecture, the MS Ajax Library, and using WCF to create the services. I was not familiar with the MS Ajax Library or WCF, but these chapters are great introductions to both. While this book is not comprehensive on WCF, Dan does a great job of explaining the basics and gives enough knowledge to get started, which is all that is required in this book. I would recommend that you have some familiarity with writing object based JavaScript, because while Dan does explain what is going on to a point, someone not experienced in creating classes and instances in JavaScript might be lost.

I felt the book dragged in the middle chapters, as more parts of the MS Ajax Library are covered, some of which are covered to some extent in the earlier chapters. It seemed like Dan was repeating himself to some amount, but probably for good reason as understanding the core library is crucial to developing the client based components. I was ready to start developing some real stuff, but was stuck on reviewing the basics. Leave it to me to get impatient and jump in over my head.

The real meat begins in chapter seven with developing client based components, which are actual chunks of reusable JavaScript code you can use in your applications. This continues through chapter nine, and in chapter ten Dan goes over some of the nice new features that came in Visual Studio 2008 SP1, persisting browser history in the Ajax framework. Chapter eleven is a nice bonus chapter on extending SharePoint with Ajax, which I just glossed over since I do not do SharePoint development.

At times I found the code in the chapters hard to follow, and there are a few occasions that code referenced is not actually in the book. I recommend downloading the source code from the website and use it to follow along with the examples in the book. The code presented in the later chapters follows best practices and guidelines, and never leaves the user with "demo ware". All the examples I tried worked great in IE7, FF3, and Chrome beta. I also recommend using Firebug to help diagnose any errors you might have in the JavaScript.

Overall, I highly recommend this book to anyone who is looking to develop service oriented applications with the Microsoft Ajax Library. It provides a pure Ajax approach that is going to be the driving force of web applications in the future. Was that a Postback? I don't think so.

I can't say enough about how pleased I am with this book.

With what seems like a flood of Ajax frameworks lately coupled with an "explosion" of new MS technologies over the past year (WCF, LINQ, etc), I have been struggling lately with how to effectively bring web apps into the web 2.0 world without compromising the use of the robust MS/ASP.NET
framework technologies I've grown to depend on.

With the introduction of WCF and the ASP.NET Ajax framework, the solution became clear. Unfortunately, these technologies (WCF in particular) are extremely robust and flexible, which can make it hard to distill a best-practices approach.

Dan's book does just that. Taking a direct head-on approach to the task of building real world applications via these technologies, he guides you steadfastly from end-to-end and point-to-point through territory that can sometimes be foggy to say the least when navigated on your own.

In clear and concise language, this book does not, as another reviewer has said, try to "overshoot its aim", but rather it gives you a crystal clear no-nonsense approach to solving the architectural challenges of today's Ajax web applications using the Microsoft platform.

This book brings together the key pieces of about ten other books on your shelf to make sense of the end-to-end "big picture", while still giving you the hands-on detailed implementation information and guidance.

Highly recommended and a definite go-to-guide when coding.

Software and web application developers who want to stay on the leading edge must move to a new paradigm every few years. Today's shifting landscape, with rich clients, enterprise integration and the desire for decoupled services, requires a new way of thinking and a new architecture. In his book, Daniel Larson does an excellent job of presenting a new paradigm for web application development using the .NET Framework.

As the title plainly states, the author shows us how to put together a service-oriented AJAX application, however, the key to the book is that he presents an architecture upon which we can immediately start building applications using this new paradigm. He starts with the fundamentals of AJAX and Windows Communication Foundation (WCF), the two technologies that he uses as building blocks for the rest of the book. He hits the right notes for the developer who is new to these technologies, but reinforces important concepts for developers who have already taken the plunge in these areas. As he moves forward, he expands on the usage of Javascript within Ajax and the Microsoft Ajax library. I found especially useful the coverage he provides of building a class library in Chapter 7, "Building an Ajax Class Library with Components". The concepts presented allow you to create a true object-oriented model with your Javascript code so that the end result is a rich class library that can be reused.

Importantly, the book does not overshoot its aim. It does not try to completely cover WCF, but goes into it just enough to get you building more robust applications. No area is glossed over, so that you don't quite `get it' even after reading it and putting it to use. He makes a good case for using the REST service model, and provides alternatives to WCF if you don't want take that step right away.

While the book has plenty of code samples, the book lacks pictures and diagrams that could have enhanced the learning process, especially by showing how data flows in this architecture and how the various components interact. Hopefully, the 2nd edition will improve on this. But this doesn't detract from the fact that the author has suitably covered this particular subject.

As developers we should all be very, or at least somewhat, familiar with the Microsoft Patterns and Practices documentation. If you are not, let me rephrase my previous statement ... YOU SHOULD BE. With that in mind, that is the context of which I believe Daniel Larson has written his latest book, Developing Service-Oriented AJAX Applications on the Microsoft Platform. The book is, as stated by the publisher, very code-heavy which in my opinion is the way books and documentation should be written. I learn more from seeing the "written word" than just reading about it in a bunch of fluff-n-stuff paragraph writing. Good job Daniel on not so much fluff, but a whole lot of stuff.

Daniel is known for his Microsoft SharePoint expertise. Daniel has stepped out beyond that and really shown us what some of the best patterns for architectural design are for service-oriented applications. He starts us out in the first three chapters by discussing the "who" and "what" so that we have a good foundation which to build upon. The middle three chapters then begin the "why" and "where," which to me were some of the most important sections. I learned more from those three chapters. And then for the dessert, Daniel gives us the "when" and "how" in the last five chapters.

The one aspect to Daniels book for which I am most grateful for are the "Case Study" examples that he has included in each chapter, beginning with Chapter 8, Building AJAX Controls. I have always found that this type of example can really drive home the information that is being provided to the reader. In my own experience as a college and Secondary-level instructor, the most useful technique for student learning is the ability to apply the information to a "Real World" example or situation. This allows the students to apply the information and develop what Jean Piaget, and other Constructivism theorists, consider accommodation and assimilation. The students are allowed to learn and incorporate the new information into new or pre-existing knowledge bases. I wish there could have been more "Case Study" examples included in the previous chapters to Chapter 8. Not necessarily as thorough as the examples from Chapter 8 on, but just to include some personal experiences from Daniel's own work or others. There are "Tips," "Notes," etc. that are included, but just not quite the same. Hence, this is why I am giving the book four stars instead of five.

Daniel wrote in the Introduction, "This book is written to explain the service-oriented AJAX architecture pattern - and is not a comprehensive reference to the complete Microsoft AJAX Library, ASP.NET, and WCF" (p. 18, para. 5). While this may not be an all-comprehensive reference, I believe that Daniel has given us the foundation that we, as developers, can build quite easily upon reading this book. Where you go from here is completely up to you, but Daniel has given you the foundation required to begin developing the service-oriented applications. By keeping this book as a handy reference, you can utilize much of the information included to search for certain aspects, techniques, or sequences you wish to pursue to gain further understanding and development.

I would suggest this book for anyone who has the desire to begin exploring the position of building or extending service-oriented applications as this will be a good starting off point. You will learn the various Microsoft technologies that are available and how to get them to work together to create richer and stronger applications. After this book, you can continue on to get more in-depth coverage of some of the aforementioned technologies. Daniel has opened the door for you by writing this book. It is up to you to read, understand and then step through the door onto a pathway that will lead you to becoming a developer you have only thought about becoming.

This book contains some excellent information about ASPNET AJAX and WCF. However the downloadable source code does not match the examples in the book and some do not work. If the reader intends to go step by step with the author, he cannot quickly move from the book to observe a running application that demonstrates what is being taught. The source code presentation in relation to the books presentation is disjointed and a serious problem. If the source code were more compatible with the flow of the book, I would give this book a higher rating. (Note, I am only on Ch 03, but find this extremely frustrating)

MSFT has a tendency of providing a plethora of options to develop the same kind of application, and not all of them good. I really appreciate Daniel's calling out for the pure AJAX approach of developing today's websites, rather than using AJAH techniques like UpdatePanel, and at the same time he explained well the benefits: REST responses' cachability, decoupling of the services and UI, the re-usability of the services, etc. Around the same time I have also reached the same conclusion myself, after much frustration with the lack/difficulty of direct control from server controls and their post-back model, AJAX control toolkit (which until recently is still a server programming experience) and UpdatePanel.

Overall this book is excellent; there's some minor room for improvements like the index doesn't seem complete; I find myself spending more time than I should searching for stuff in the book since index is pretty thin. Also the only part I'm not as sure about what Daniel said is on the client-side data-binding using XSLT; it kind of defeats the purpose of compact response of the readily usable JSON data. The up-coming MS AJAX 4.0 has the client-side templating feature that parallels the server control's templating scheme; perhaps that's probably a better approach (granted I still have to study on these client-side data-binding options more).

MSFT is finally coming back on the right track and embracing programming in HTML, HTTP, and Javascript rather than the leaky abstraction that is the web form, and this book is very helpful in programming in this pure and more effective way.

This book has been extremely helpful. I have a lot of experience with Asp 2.0, Ajax and xslt - but the 3.5 WCF stuff is totally new to me. Very well written, excellent examples and exactly what I've been looking for. Thank You.

This is a book focused on developing Service Oriented AJAX application as the title describes very well. I think it acomplishes its goal of
providing guidance on SOA with Windows Communication Foundation (WCF) and AJAX with MS AJAX Library and how to build applications integrating this two technologies.
The book is divided in three parts. The first part covers the fundamentals of Service Orientation, AJAX and WCF. Then the book gets practical focusing on programming the client-side, service-oriented AJAX application using the Microsoft AJAX Library. The last part of the book focuses on implementing object-oriented JavaScript control libraries and applications with the Microsoft AJAX Library while utilizing service-oriented Web service frameworks.
One of the things I like very much about this kind of books is that they contain lots of code samples which help you to understand the concepts presented. You can download all code samples from the book's site.
Overall it's a very good book about SOA with AJAX and WCF, it's not really a complete reference about these topics. The target audience are intermediate to advanced developers.

For me, there are two kinds of (tech) info that I need; firstly, a piece of info, like maybe a code snippet, that I need 'right now' to solve some issue at hand, and for this, I usually goggle around. Secondly, I need info to learn some topic, like starting from 'square one', then letting the stream of info sink into the `gray matter' as I advance through the subject. For this, a book(s) is usually the best way to go for me.

As a Sharepoint developer at a state university, there is a looming MOSS project that may call for a service oriented approach to build and present data from a warehouse. In particular, a WCF architecture may be desirable over web services. However I wasn't able to find a lot of info regarding how to implement WCF in MOSS. Well, here's where Larson's book, chapter 11 in particular, came to the rescue. For example, as Larson details how to deploy the AJAX Runtime through the ScriptManager control, he points out that Sharepoint is not your typical web application and proceeds to discuss 'Sharepoint-esq' solutions through code examples. Larson continues to build on the presented info by providing code for a chat application that implements WCF in MOSS.

This book has been a big help to me - 4 stars, bordering on 5.

Daniel Larson has written an excellent book about Developing Service-Oriented AJAX Applications on the Microsoft Platform. The title is long because the book is highly focused on the creation of web applications cleanly architected for the Service-Oriented model. This is a rifle - not a shotgun - approach to this important topic.

He maps us through the labyrinth of choices in the DOT-NET framework, keeping us on a path to highly maintainable, scalable, extensible and reliable web applications that offer those benefits because of their service-orientation. He is disciplined enough to avoid the temptation of shortcuts such as server-side controls and the famous UpdatePanel Control that employ AJAX quickly but with a price to pay later during code revision and application maintenance. But, Larson is not motivated by purism for purism's sake. He explains that other methods may be our best choice for adding AJAX function to existing applications. But, when the application is new and the Windows Communication Foundation (WCF, DOT-NET 3.0, 3.5) is at hand, Daniel makes the case for Service-Orientation.

Larson describes how to use the newest Microsoft AJAX (JavaScript) engine that can now be cleanly installed on the client-side of a web application where it can handle cross-browser issues and maximize code reusability. The latest version even handles page history so your application does not break the back button of the user's browser. Unbroken back-button is a big usability advantage in itself. But, for a truly rich user interface you may have to turn to additional JavaScript Engines that specialize in manipulation of the DOM. Larson's focus is on the plumbing, the data-exchange foundation of your web application and that is a key part of this book's disciplined focus. Being able to architect your data connections letting Microsoft Dot-Net provide for server-side programming while Microsoft's AJAX engine provides for client-side (Javascript) programming enables us developers to focus more time on solving business problems and less on time technical problems.

A focused book like this is wonderful if its focus is on exactly what you are trying to do. Otherwise, it will likely miss your target. If you do not want to separate client-side code from server side code and are happy with some of the complex Microsoft controls, or if you absolutely need their functionality, then you may not find this book helpful since, frankly, there is no way to mix client-side and server-side in a blender and wind up with Service-Orientation. In simple web applications, complex controls can be amazing, witness all the wonderful examples on the ASP.NET website. But, if you need to move diverse data, extend your application on a dime and maintain it on a nickel, then you will need Service-Orientation and Daniel Larson's book is the shortest root from scratch paper to working application. One other example, mentioned earlier, where a Service-Orientation may be suboptimal is when you are "AJAX-enabling" an existing application.

If you are building a new web-application using Microsoft Windows Communication Foundation (WCF) and Microsoft AJAX then a Service-Orientation is likely to be in order and Daniel Larson's new book is an excellent roadmap from here to there. Even if you have excellent and comprehensive texts for the framework as well as your programming language, this book is worth its price to lead you through the maze efficiently, that is, if you value your time and need a service-oriented AJAX application.