SPA Design and Architecture: Understanding Single Page Web Applications First Edition

This book filled in some knowledge gaps I had on how to build a single page web app. It is a design book which explains the architecture of building a SPA along with guiding principles. The sections on the MV* frameworks were well written with diagrams explaining the differences between them.I found the choice of Backbone, Knockout, and Angular to be disappointing though. The chapters often switch between the frameworks and the author never states an opinion about which he prefers. Also the author dismisses React.js as not being part of the MV* family, even though React is more popular and superior in many ways to these frameworks. Backbone, and Knockout are getting dated at this point... this would not be a problem except the copyright for this book is 2016, not 2013. Also, there was no mention until the Appendix that Angular version 2 is a complete rewrite with different syntax than Angular version 1.This is still a decent book, but by the end the author has presented so many different choices of frameworks and technologies that I did not get a clear picture of the best way to build a SPA. The author suggests that SPA architecture should be technology agnostic; because Javascript technologies are changing quickly... it would have been a stronger book to choose one framework, state why, and go in depth more.

I have spent the last decade developing J2EE web applications with traditional frameworks like Struts and Spring MVC. I am very new to SPA and have only looked briefly at a few frameworks and frankly I had a lot of concerns of how SPA could be used for creating complex applications and more importantly how you could troubleshoot and support a SPA application. This book did a great job of explaining how to organize your project code, how to maintain code integrity with modules (great section for me), how to use the browser history without going to the server (important for support), how to test your code, and how to automate tasks. These were all areas of concerns for me and how to implement SPA at work. The book does not pick a framework but evaluates many and even better shows extensive examples in AngularJS, Backbone, and Knockout. This book did what it says and I now feel like I have the understanding and design concepts to proceed with a SPA framework.

This book is an excellent blend of concepts that constitute SPA’s along with just enough technical examples to put these concepts into perspective. A good book to know how SPA’s work.

It feels like author was under pressure to prove that he had worked hard enough,mor than transfering the information to the reader.Just subjective feeling.

This book is well organized and written with a goal of introducing the reader to SPA concepts. I highly recommend this book as a valuable guide to understanding the inner workings of SPA design, which can be applied to modern web frameworks.

Single Page Applications (SPAs) bring the power of a desktop application to the web browser. For Windows developers, think of it as kind of building a Windows Forms application for the web, though it's a lot more difficult (the analogy falls apart for the comparative effort of both approaches). SPAs have actually existed for some time, though they only reached a level of prominence in the past 5 to 7 years. Earlier SPA examples amalgamated code from various libraries into a fully functioning web application. The "Single Page" refers to the need for only one HTML page for the SPA. Behind the scenes the code manipulates this single container to present the illusion of moving from one page to another. Performance should increase greatly as well, since the SPA can load its resources as it needs, or even in advance of navigation, to make for a very smooth ride.More recently, SPA frameworks have come to dominate the scene. Angular JS sticks out as a major player in this genre, though many others also exist. Though one doesn't need a framework to create a SPA, many argue fervently for the convenience and extra maintainability that one offers. The Manning book "SPA Design and Architecture" approaches SPA development from a framework perspective and runs through SPA best practices and patterns through a filter of three major frameworks: Angular.js (version 1), Backbone.js and Knockout.js. Each section discusses an element of SPA development and then provides code examples in one or all of these frameworks.The book contains two main sections: "The Basics" and "Core Concepts." Its first section covers a lot of SPA theory and architectural fundamentals. Right away, it illuminates SPA concepts by comparing an application that follows SPA patterns and one that doesn't. Those new to this domain will benefit greatly from this juxtaposition. Some may have to relearn or unlearn old practices to follow this new path, but in principle it requires no new tools, just the usual HTML, JavaScript and CSS. This section also introduces a theme that runs through the entire book: the concept of MV* frameworks. The "*" represents a wildcard into which can fit a number of popular design patterns, such as MVC, MVP, MVVM and whatever else clever brains can concatenate with Model and View patterns. Additional concepts such as binding, templates and separation of concerns provide plenty of theory for later practice.Modular JavaScript remains one of the crucial SPA topics and thus it receives a thick chapter. Those not familiar with IIFEs (Immediately Invoked Function Expressions) will learn the basics of this important pattern that allows a more controlled and organized approach to sometimes wild and scopeless JavaScript code. These modules function somewhat like namespaces, somewhat like class functions. They tidy up code to an incredible degree. But nothing comes without downsides and some cons of this methodology also appear along the way. One example uses AMD (Asynchronous Module Definition) with RequireJS to demonstrate module loading libraries.With the basics now mostly covered, Part 2 begins and delves into SPA navigation and routing and the HTML5 History API. Next comes a discussion of views and best practices for laying out an application's main section with menus and sidebars. Modules also need to communicate, otherwise the application would probably not provide much value. Since modules should utilize encapsulation of their inner functionality, other modules can't just kick their APIs in and grab code. Improperly managed inter-module dependencies can make maintainability a wretched and never-ending ghoulish nightmare. An example of Pub/Sub with subscribing and unsubscribing functionality for unrelated modules provides some concrete context. An old friend then reappears, the XMLHttpRequest (XHR) API to discuss server communication. Those needing a refresh on this topic, especially in raw JavaScript, will find a handy review in Appendix B. Some basics of HTTP and JSON help understand how the three frameworks go about making server calls. Even the relatively recent Promise pattern receives a basic rundown. Then, not surprisingly, the inevitable subject of RESTful web services follows.The final two chapters look at Unit testing and automation tools for SPAs. Once again, the book goes through the basics of Unit testing and a little bit of TDD before showing examples using the now well established QUnit supplemented with SINON.js. Those already familiar with Unit Testing probably won't derive much from this chapter, though newcomers will learn plenty, along with the fact that there remains plenty more to learn. A final chapter examines "task runners" or what many may call Continuous Integration. Again, this chapter skims the surface conceptually and then lightly introduces Grunt.js and Gulp.js. These tools can provide automatic browser reloading, integration with JavaScript and CSS transpilers, automated unit testing, automated linting, code bundling and minification. The main chapters end by running through examples with the chosen tools already mentioned.Most of code examples throughout the book appear in abstraction from a larger project. When introducing a new concept, it gets presented in code, using one of the three frameworks, in isolation from the entire project. This can make it difficult to follow or code along, especially for those unfamiliar with the frameworks, since the book doesn't cover the initial setup of the project in great detail, though Appendix A walks through the project using Backbone.js, Knockout.js and Angular.js. The book does not provide a detailed introduction to the frameworks themselves, but only really utilizes them for code examples. This technique may bewilder some new to any of the frameworks. Plus, this doesn't allow comprehension of the code examples in the context of a larger application. One only sees a snippet and not the whole until Appendix A. Of course readers can download the code at any time, but the book does make following along a little annoying. Regardless, the book contains enough useful information that a simple read-through will provide more than adequate enlightenment. Those who have switched from Angular 1 to Angular 2 or 4, or those who never even used Angular 1, may find the Angular examples disappointing, but books do have a hard time keeping up these days. In the end, "SPA Design and Architecture" excels as explaining the theory behind SPAs and anyone seeking illumination on this subject will accrue enough vital knowledge to make a reading worthwhile.

So read it quickly. It's a great single page application primer, well written and great reference material.