single page application

pages: 180 words: 37,187

AngularJS Essentials by Rodrigo Branas

business logic, Firefox, MVC pattern, node package manager, single page application, web application

This httpUnauthorizedInterceptor parameter, in the following code, is responsible for handling the unauthorized error and changing the login property of $rootScope, indicating that the application should open the login dialog: parking.factory('httpUnauthorizedInterceptor', function($q, $rootScope){ return{ 'responseError' : function(rejection) { if (rejection.status === 401){ $rootScope.login = true; } return $q.reject(rejection); } } }); After defining the interceptors, we need to add them to $httpProvider using the config function of the Module API, as follows: config.js app.config(function ($httpProvider) { $httpProvider.interceptors.push('httpTimestampInterceptor'); $httpProvider.interceptors.push('httpUnauthorizedInterceptor'); }); [ 86 ] Chapter 4 Creating a single-page application In the past few years, the single-page application, also known as SPA, has been growing in popularity among frontend developers. It improves customers' experiences by not requiring the page to be constantly reloaded, taking advantage of technologies such as AJAX and massive DOM manipulation. Installing the module AngularJS supports this feature through the $route service.

…

Animating ngRepeat Animating ngHide Animating ngClass Summary Chapter 3: Data Handling Expressions Filters Basic usage with expressions 31 31 32 34 35 36 36 37 38 42 43 44 46 47 48 48 49 50 50 51 53 53 55 55 currency date filter json limitTo lowercase number orderBy uppercase Using filters in other places Creating filters Form validation Creating our first form Basic validation Understanding the $pristine and $dirty properties The $error object Summary [ ii ] 55 56 56 57 58 58 58 59 60 60 61 62 62 63 65 65 66 Table of Contents Chapter 4: Dependency Injection and Services Dependency injection Creating services Creating services with the factory Creating services with the service Creating services with the provider Using AngularJS built-in services Communicating with the backend HTTP, REST, and JSON Creating an HTTP facade Headers Caching Interceptors 67 68 69 70 74 75 76 76 76 82 84 85 85 Creating a single-page application 87 Logging Timeout Asynchronous with a promise-deferred pattern 96 96 98 Installing the module Configuring the routes Rendering the content of each view Passing parameters Changing the location Resolving promises The deferred API The promise API Summary 87 87 88 91 92 93 100 101 101 Chapter 5: Scope 103 Chapter 6: Modules 115 Two-way data binding $apply and $watch Best practices using the scope The $rootScope object Scope Broadcasting Summary 103 104 106 110 110 113 Creating modules The UI module The search module The parking application module Recommended modules Summary 115 116 118 119 120 120 [ iii ] Table of Contents Chapter 7: Unit Testing 121 The Jasmine testing framework Testing AngularJS components Services Controllers Filters Directives 122 124 125 126 128 129 Creating the element with the directive Compiling the directive Calling the link function with the scope Invoking the digest cycle 130 130 130 130 Mocking with $httpBackend Running tests with Karma 132 140 Installation Configuration Running tests 140 141 142 Summary 143 Chapter 8: Automating the Workflow 145 Index 159 Automating the workflow with Grunt Installation Configuration Creating a distribution package Executing the workflow Managing packages with Bower Installation Finding packages Installing packages Using packages Cache Summary [ iv ] 145 146 146 147 155 156 156 156 157 157 158 158 Preface For more than 12 years, I have been developing all kinds of web applications, and along the way, I have had the opportunity to experience the vast majority of frameworks on the Java platform.

…

doctype html> <html ng-app="parking"> <head> <title>[Packt] Parking</title> <script src="angular.js"></script> <script> var parking = angular.module("parking", []); parking.controller("parkingCtrl", function ($scope) { }); </script> </head> <body ng-controller="parkingCtrl"> </body> </html> There is another way to attach a controller to a specific view. In the following chapters, we will learn how to create a single-page application using the $route service. To avoid undesired duplicated behavior, remember to avoid the ngController directive while using the $route service. [ 20 ] Chapter 2 Nested controllers Sometimes, our controller can become too complex, and it might be interesting to split the behavior into separated controllers.

pages: 196 words: 58,122

AngularJS by Brad Green, Shyam Seshadri

business logic, combinatorial explosion, continuous integration, Firefox, Google Chrome, Kickstarter, MVC pattern, node package manager, single page application, systems thinking, web application, WebSocket

Instead, we’ve borrowed heavily from successful idioms in other development environments and implemented them in a way that embraces HTML, browsers, and many other familiar web standards. Client-Side Templates Multi-page web applications create their HTML by assembling and joining it with data on the server, and then shipping the finished pages up to the browser. Most single-page applications—also known as AJAX apps—do this as well, to some extent. Angular is different in that the template and data get shipped to the browser to be assembled there. The role of the server then becomes only to serve as static resources for the templates and to properly serve the data required by those templates.

…

Hitting the spacebar or the enter key will cause a click and invoke the ng-click, which will set the div text to ‘focus button clicked’. Opening this example in a browser, we’d see something that looks like Figure 2-4. Figure 2-4. Focus directive Validating User Input Angular automatically augments <form> elements with several nice features suitable for single-page applications. One of these nice features is that Angular lets you declare valid states for inputs within the form and allow submission only when the entire set of elements is valid. For example, if we’re creating a signup form where we require entering a name and email, but have an optional age field, we can validate several user entries before they are submitted to the server.

…

Depending on which controller is associated, different elements are shown in the edit recipe template. With this done, we can now move on to the templates, how these controllers hook up to them, and manage what is shown to the end user. The Templates Let us start by taking a look at the outermost, main template, which is the index.html. This is the base of our single-page application, and all the other views are loaded within the context of this template: <!DOCTYPE html> <html lang="en" ng-app="guthub"> <head> <title>GutHub - Create and Share</title> <script src="scripts/vendor/angular.min.js"></script> <script src="scripts/vendor/angular-resource.min.js"></script> <script src="scripts/directives/directives.js"></script> <script src="scripts/services/services.js"></script> <script src="scripts/controllers/controllers.js"></script> <link href="styles/bootstrap.css" rel="stylesheet"> <link href="styles/guthub.css" rel="stylesheet"> </head> <body> <header> <h1>GutHub</h1> </header> <div butterbar>Loading...

pages: 420 words: 79,867

Developing Backbone.js Applications by Addy Osmani

Airbnb, anti-pattern, business logic, create, read, update, delete, don't repeat yourself, Firefox, full text search, Google Chrome, Khan Academy, Kickstarter, loose coupling, MVC pattern, node package manager, pull request, Ruby on Rails, side project, single page application, web application

Backbone.js is a lightweight JavaScript library that adds structure to your client-side code. It makes it easy to manage and decouple concerns in your application, leaving you with code that is more maintainable in the long term. Developers commonly use libraries like Backbone.js to create single-page applications (SPAs). SPAs are web applications that load into the browser and then react to data changes on the client side without requiring complete page refreshes from the server. Backbone is mature, popular, and has both a vibrant developer community as well as a wealth of plugins and extensions available that build upon it.

…

It’s a library, rather than a framework, that plays well with others and scales well, from embedded widgets to large-scale applications. As it’s small, there is also less your users have to download on mobile or slower connections. The entire Backbone source can be read and understood in just a few hours. When Do I Need A JavaScript MVC Framework? When building a single-page application using JavaScript, whether it involves a complex user interface or is simply trying to reduce the number of HTTP requests required for new Views, you will likely find yourself inventing many of the pieces that make up an MV* framework. At the outset, it isn’t terribly difficult to write your own application framework that offers some opinionated way to avoid spaghetti code; however, to say that it is equally as trivial to write something as robust as Backbone would be a grossly incorrect assumption.

…

If, however, you’re building an application that still relies on the server for most of the heavy-lifting of page/view rendering and you’re just using a little JavaScript or jQuery to make things more interactive, an MV* framework may be overkill. There certainly are complex Web applications where the partial rendering of views can be coupled with a single-page application effectively, but for everything else, you may find yourself better sticking to a simpler setup. Maturity in software (framework) development isn’t simply about how long a framework has been around. It’s about how solid the framework is and more importantly how well it’s evolved to fill its role.

pages: 550 words: 84,515

Vue.js 2 Cookbook by Andrea Passaglia

bitcoin, business logic, cognitive load, functional programming, Kickstarter, Large Hadron Collider, loose coupling, MVC pattern, node package manager, Silicon Valley, single page application, web application, WebSocket

You can change the name of the cookie that Axios will pick up by setting the axios.defaults.xsrfCookieName variable, and you can edit the name of the header that will return the token acting on the axios.defaults.xsrfHeaderName variable. Single Page Applications In this chapter, the following recipes will be covered: Creating an SPA with vue-router Fetching data before switching route Using named dynamic routes Having more than one router-view in your page Composing your routes hierarchically Using route aliases Adding transitions between your routes Managing errors for your routes Adding a progress bar to load pages How to redirect to another route Saving scrolling position when hitting back Introduction Many modern applications are based on the SPA or Single Page Application model. From the users perspective, this means that the whole website looks similar to an application in a single page.

…

How it works... Implementing infinite scrolling Getting ready How to do it... How it works... Processing a request before sending it out Getting ready How to do it... How it works... Preventing XSS attacks to your app Getting ready How to do it... How it works... Single Page Applications Introduction Creating an SPA with vue-router Getting ready How to do it… How it works… There's more… Fetching data before switching route Getting ready How to do it… How it works… Using named dynamic routes Getting ready How to do it… How it works… Having more than one router-view in your page Getting ready How to do it… How it works… Compose your routes hierarchically Getting ready How to do it...

…

Chapter 4, Components!, is where you realize everything in Vue is a component and you can exploit this to reduce duplication and reuse your code. Chapter 5, Communicate with the Internet, is where you make your first AJAX call and create forms and a full fledged REST client (and server!). Chapter 6, Single Page Applications, is where you use vue-router to create static and dynamic routes to create a modern SPA. Chapter 7, Unit Testing and End-To-End Testing, is where you learn to create professional software by adding Karma, Chai, Moka, Sinon.JS, and nightwatch to make sure you can refactor your app with confidence.

pages: 671 words: 228,348

Pro AngularJS by Adam Freeman

business logic, business process, create, read, update, delete, en.wikipedia.org, Google Chrome, information retrieval, inventory management, MVC pattern, place-making, premature optimization, revision control, Ruby on Rails, single page application, web application

In Figure 3-1 you can see the spectrum of web application types and where AngularJS delivers benefit. AngularJS jQuery Round-Trip Single-Page Figure 3-1. AngularJS is well-suited to single-page web apps AngularJS excels in single-page applications and especially in complex round-trip applications. For simpler projects, jQuery or a similar alternative is generally a better choice, although nothing prevents you from using AngularJS in all of your projects. There is a gradual tendency for current web app projects to move toward the single-page application model, and that’s the sweet spot for AngularJS, not just because of the initialization process but because the benefits of using the MVC pattern (which I describe later in this chapter) really start to manifest themselves in larger and more complex projects, which are the ones pushing toward the single-page model.

…

Part 3: AngularJS Modules and Services Part 3 of this book explains the roles that two important components play in AngularJS: modules and services. I show you the different ways you can create both components and explain the wide range of built-in services that AngularJS provides. This includes support for simplifying Single-Page Application development, Ajax and RESTful APIs, and unit testing. Are There Lots of Examples? There are loads of examples. The best way to learn AngularJS is by example, and I have packed as many of them as I can into this book. To maximize the number of examples in this book, I have adopted a simple convention to avoid listing the contents of files over and over again.

…

The goal, therefore, is to perform this setup as infrequently as possible and deliver as much of the app as possible to the user when it is performed. This means giving careful thought to the kind of web application you build. In broad terms, there are two kinds of web application: round-trip and single-page. Understanding Round-Trip and Single-Page Applications For a long time, web apps were developed to follow a round-trip model. The browser requests an initial HTML document from the server. User interactions—such as clicking a link or submitting a form—led the browser to request and receive a completely new HTML document. In this kind of application, the browser is essentially a rending engine for HTML content, and all of the application logic and data resides on the server.

pages: 292 words: 66,588

Learning Vue.js 2: Learn How to Build Amazing and Complex Reactive Web Applications Easily With Vue.js by Olga Filipova

Amazon Web Services, business logic, continuous integration, create, read, update, delete, en.wikipedia.org, Firefox, Google Chrome, leftpad, MVC pattern, pull request, side project, single page application, single source of truth, Skype, source of truth, web application

Following is how the output differs from both commands: The output from the commands vue init webpack and vue init simple The following is how the application structure differs: The difference in structure in application scaffolded with vue init simple and vue init webpack The index.html file in the simple configuration already contains Vue.js from the CDN, so if you just need to do something really simple such as quick prototyping, use this one. But if you are about to start a complex Single Page Application (SPA) project that will require testing and hot reloading during development, use the Webpack or Browserify configuration. Vue plugins for IDEs There are plugins for Vue syntax highlighting for some major IDEs. I will leave you with the links to the fanciest of them: IDE Link to the Vue plugin Sublime https://github.com/vuejs/vue-syntax-highlight Webstorm https://github.com/postalservice14/vuejs-plugin Atom https://github.com/hedefalk/atom-vue Visual Studio Code https://github.com/LiuJi-Jim/vscode-vue vim https://github.com/posva/vim-vue Brackets https://github.com/pandao/brackets-vue Installing, using, and debugging a Vue.js application In this section, we will analyze all the possible ways of installing Vue.js.

…

Yes, this is true, now we've done something really simple in a rather complex way, but if you stay with me a bit longer, you will see how complex things become easy to implement if we use the proper tools. Also, do not forget to check your Pomodoro timer, maybe it's time to take a rest! vue-cli As we have already mentioned in the previous chapter, Vue provides its own command-line interface that allows bootstrapping single-page applications using whatever workflows you want. It immediately provides hot reloading and structure for a test-driven environment. After installing vue-cli, just run vue init <desired boilerplate> <project-name> and then just install and run: # install vue-cli $ npm install -g vue-cli # create a new project $ vue init webpack learn-vue # install and run $ cd learn-vue $ npm install $ npm run dev Now open your browser on localhost:8080.

…

Thus, the msg property can be bound as the value's attribute to the input box: <template> <input :value='msg' @keyup='changeMsg'> </template> Check the code for this section in the chapter5/simple-store folder. In this example, we have used a very simplified version of the store. However, complex Single-Page Applications (SPAs) require a more complex and modular structure. We can and should extract the store's getters and actions that dispatch mutations to separated files. We can also group these files according to the corresponding data's responsibilities. In the next sections, we will see how we can achieve such a modular structure by using getters and actions.

pages: 296 words: 41,381

Vue.js by Callum Macrae

Airbnb, business logic, single page application, single source of truth, source of truth, web application, WebSocket

Chapter 4, Render Functions and JSX In addition to the templating syntax that you’ll recognize if you’ve seen much Vue code or read the Getting Started guide, Vue supports custom render functions, which also allow you to use JSX, a syntax you’re familiar with if you’ve used React before. I explain how to use JSX in your Vue application in this chapter. Chapter 5, Client-Side Routing with vue-router Vue by itself is just a view layer. To create an application with multiple pages that can be accessed without making a new request (or in buzzword format: a single-page application), you need to add vue-router to your website, which you can use to handle the routing—saying which code should be executed and displayed when a given path is requested. This chapter explains how to do just that. Chapter 6, State Management with Vuex In more complicated applications with many levels of components, passing data between components can become a bit of a pain.

…

To link to a route with params such as the preceding user route, you can specify them in the params property of the object: <router-link :to="{ name: 'user', params: { userId: 1234 }}"> User #1234 </router-link> Summary In this chapter, you looked at using vue-router to create a single-page application—an application with multiple pages in which the routing is handled client-side. You looked at various ways to configure a router, using dynamic routes to create dynamic paths; nested routes to create child routes; and redirects, aliases, and wildcard paths for 404 pages. You also looked at <router-link> to create links, named routes to almost entirely separate the path from the route, and navigation guards to run additional logic when a navigation event occurs. 1 Many static site hosts have an SPA mode that you can enable to do this.

pages: 290 words: 119,172

Beginning Backbone.js by James Sugrue

Airbnb, business logic, continuous integration, don't repeat yourself, Firefox, Google Chrome, loose coupling, MVC pattern, node package manager, single page application, web application, Y Combinator

The wide array of smartphones and tablets, all with their own platforms and idiosyncrasies, have led a significant majority of developers to work on HTML5-based web apps that behave in a similar fashion to native apps. Single-page applications enable such applications to be built and made available directly from web sites, rather than requiring users to acquire the app through the app store on their device. The Continuing Need for Structure As browser-based applications continue to dominate, the architecture behind single-page applications becomes much more significant. With so much logic now residing in the client side, it’s clear that the practices and patterns that have applied to traditional desktop applications are now relevant in JavaScript.

…

Single-Page Web Applications A single-page web application is one that requires just one page load and where all required elements can be loaded dynamically onto the page without needing to leave. This more immersive user experience is what desktop applications have always benefited from. Now that Ajax had proved itself and the JavaScript ecosystem was providing more robust libraries and frameworks, single-page applications were easier to implement. These applications are not without their challenges. For a single page to deal with different stages in the application life cycle, page state is required. In addition, there is a need to enable the user to bookmark the application at a particular stage—this one of the places where Backbone really helps alleviate the complexity of implementing such solutions.

pages: 190 words: 52,865

Full Stack Web Development With Backbone.js by Patrick Mulder

Airbnb, business logic, create, read, update, delete, Debian, functional programming, Kickstarter, MVC pattern, node package manager, Ruby on Rails, side project, single page application, web application, WebSocket

The goal of this book is to show how clientside applications can evolve from basic interaction ideas, and how more modular and maintainable web applications can be built. Other Resources To understand the perspectives in this book, you need a sound knowledge of JavaScript, browsers, and DOM manipulation, as well as a basic knowledge of web applications. Also, there are a number of resources available to go deeper into single-page application development. The JavaScript Language To learn JavaScript, there are a number of good resources available: JavaScript Garden This is an open source resource on programming in JavaScript. This online guide is a good place to turn to for improving your understanding of quirky aspects of the language without consulting a book.

…

You can also wire up Firebase with other APIs via Zapier to trigger sending emails or other tasks. This might be interesting for some applications, but for others, you want to build your API yourself. This will be the topic of the next chapter. Conclusion In this chapter, you made quite some progress toward a full, single-page application that fetches data from a remote data store. To prevent developing a full backend at this stage, we saw a strategy to mock a RESTful API with canned. We then used the mock API to learn about different approaches to populate the Movies collection over a network. First, we learned about the basic events Conclusion | 95 that are evolved.

pages: 355 words: 81,788

Monolith to Microservices: Evolutionary Patterns to Transform Your Monolith by Sam Newman

Airbnb, business logic, business process, continuous integration, Conway's law, database schema, DevOps, fail fast, fault tolerance, ghettoisation, inventory management, Jeff Bezos, Kubernetes, loose coupling, microservices, MVC pattern, price anchoring, pull request, single page application, single source of truth, software as a service, source of truth, sunk-cost fallacy, systems thinking, telepresence, two-pizza team, work culture

This allows them to much more rapidly experiment and try out new features. Example: Micro Frontends As bandwidth and the capability of web browsers have improved, so has the sophistication of the code running in browsers improved. Many web-based user interfaces now make use of some form of single-page application framework, which does away with the concept of an application consisting of different web pages. Instead, you have a more powerful user interface, where everything runs in a single pane—effectively in-browser user experiences that previously were available only to those of us working with “thick” UI SDKs like Java’s Swing.

…

How exactly do you create a single UI out of bits of Vue and React without having their dependencies clash, but still allow them to potentially share information? Covering this topic in depth is out of scope for this book, partly because the exact way you make this work will vary based on the SPA frameworks being used. But if you find yourself with a single-page application that you want to break apart, you’re not alone, and there are many people out there sharing techniques and libraries to make this work. Where to Use It UI composition as a technique to allow for re-platforming systems is highly effective, as it allows for whole vertical slices of functionality to be migrated.

pages: 422 words: 86,414

Hands-On RESTful API Design Patterns and Best Practices by Harihara Subramanian

blockchain, business logic, business process, cloud computing, continuous integration, create, read, update, delete, cyber-physical system, data science, database schema, DevOps, disruptive innovation, domain-specific language, fault tolerance, information security, Infrastructure as a Service, Internet of things, inventory management, job automation, Kickstarter, knowledge worker, Kubernetes, loose coupling, Lyft, machine readable, microservices, MITM: man-in-the-middle, MVC pattern, Salesforce, self-driving car, semantic web, single page application, smart cities, smart contracts, software as a service, SQL injection, supply-chain management, web application, WebSocket

OAuth addresses these concerns by allowing arbitrary clients (for example, a first-party iOS application or a third-party web application) to access user's (resource owner's) resources on resource servers via authorization servers with secure, reliable, and effective methods: The preceding diagram depicts OAuth authorization stakeholders and their roles. Now, let's look at a few OAuth 2.0-based authorization schemes and the situations or business cases you would choose those specific schemes for, with the following table: Schemes / Flow Client type Brief description Implicit Single-page application (SPA) such as Google Fonts. Application requests access tokens from the gateway and the user grants permission Client-credentials Machine-to-machine non-interactive programs such as services, daemons, and so on The application passes the client credentials and gets the access token from the gateway server Authorization code Less trusted apps (third-party apps requesting access to your application) The application sends a temporary authorization code it receives from the gateway and gets it validated (by the same gateway) Resource owner password credentials Highly trusted apps (first-party apps) The client will ask the user for their authorization credentials (usually a username and password), then the client sends a few parameters (grant_type, client_id, client_secret) to the authorization server As part of this chapter, we have provided OAuth 2.0 example code that implements the Resource Owner password credentials flow and is available on GitHub for anyone to download and execute.

…

DOM XSS The third type (developed by Amit Klein and available since 2005), DOM XSS, occurs when client-side code uses insecure references to DOM objects that are not entirely controlled by server-provided pages. Generally, but not limited to, APIs that dynamically inject attacker-controllable data to a page and JavaScript frameworks. Single-page applications are vulnerable to DOM XSS. XSS protection needs to filter malicious content from user input and also needs encoding (escape). Cross-site request forgery Cross-site request forgery (CSRF), Sea Surf, or XSRF, as it's known, is a one-click attack vulnerability that web applications exposes the possibility of the end user being forced (by forged links, emails, and HTML pages) to execute unwanted actions on a currently authenticated session.

pages: 266 words: 38,397

Mastering Ember.js by Mitchel Kelonye

Firefox, information security, MVC pattern, off-the-grid, Ruby on Rails, single page application, web application, WebRTC, WebSocket

We will discuss this in a later section, but the important thing to note is that we are able to generate results by filtering the model of the posts controller. The search template automatically redisplays results as the user types along. This example demonstrates how trivial it is to add such seemingly difficult features in single-page applications. Here are a few other features that you can try adding into the application: A spinner that shows up new posts every time are being loaded from the server. Now is a good time to revisit the loading-and-error action hooks we discussed in Chapter 3, Routing and State Management. Define a humanizedDate computed property for each of the loaded posts.

pages: 323 words: 65,306

Programming in CoffeeScript by Mark Bates

don't repeat yourself, en.wikipedia.org, MVC pattern, node package manager, Ruby on Rails, single page application, web application

The second was the popularity of JavaScript libraries, such as Prototype,3 that made writing cross-browser JavaScript much simpler. You could use AJAX to make your applications more responsive and easier to use and a library like Prototype to make sure it worked across major browsers. In 2010, and certainly in 2011, the Web started evolving into “single page” applications. These applications were driven through the use of JavaScript frameworks, such as Backbone.js.4 These frameworks allowed the use of an MVC5 design pattern using JavaScript. Whole applications would be built in JavaScript and then downloaded and executed in the end user’s browser. This all made for incredibly responsive and rich client-side applications.

pages: 283 words: 78,705

Principles of Web API Design: Delivering Value with APIs and Microservices by James Higginbotham

Amazon Web Services, anti-pattern, business intelligence, business logic, business process, Clayton Christensen, cognitive dissonance, cognitive load, collaborative editing, continuous integration, create, read, update, delete, database schema, DevOps, fallacies of distributed computing, fault tolerance, index card, Internet of things, inventory management, Kubernetes, linked data, loose coupling, machine readable, Metcalfe’s law, microservices, recommendation engine, semantic web, side project, single page application, Snapchat, software as a service, SQL injection, web application, WebSocket

It was originally designed to overcome the challenges of supporting web and mobile clients that need to obtain data via APIs at different levels of granularity and with the option of retrieving deeply nested graph structures. Over time, it has become a popular choice by front-end developers that need to bridge backend data stores with single-page applications (SPAs) and mobile apps. All GraphQL operations are tunneled through a single HTTP POST or GET-based URL. Requests use the GraphQL query language to shape the response of desired fields and any nested resources in a single request. Mutations support modifying data or performing calculation logic and use a similar language as queries to express the data input for a modification or calculation request.

Seeking SRE: Conversations About Running Production Systems at Scale by David N. Blank-Edelman

Affordable Care Act / Obamacare, algorithmic trading, AlphaGo, Amazon Web Services, backpropagation, Black Lives Matter, Bletchley Park, bounce rate, business continuity plan, business logic, business process, cloud computing, cognitive bias, cognitive dissonance, cognitive load, commoditize, continuous integration, Conway's law, crowdsourcing, dark matter, data science, database schema, Debian, deep learning, DeepMind, defense in depth, DevOps, digital rights, domain-specific language, emotional labour, en.wikipedia.org, exponential backoff, fail fast, fallacies of distributed computing, fault tolerance, fear of failure, friendly fire, game design, Grace Hopper, imposter syndrome, information retrieval, Infrastructure as a Service, Internet of things, invisible hand, iterative process, Kaizen: continuous improvement, Kanban, Kubernetes, loose coupling, Lyft, machine readable, Marc Andreessen, Maslow's hierarchy, microaggression, microservices, minimum viable product, MVC pattern, performance metric, platform as a service, pull request, RAND corporation, remote working, Richard Feynman, risk tolerance, Ruby on Rails, Salesforce, scientific management, search engine result page, self-driving car, sentiment analysis, Silicon Valley, single page application, Snapchat, software as a service, software is eating the world, source of truth, systems thinking, the long tail, the scientific method, Toyota Production System, traumatic brain injury, value engineering, vertical integration, web application, WebSocket, zero day

CDNs for static objects, such as JavaScript and stylesheets, play a role in perceived user experience; improper configuration can lead to ineffective cacheability and high page load times, leading to increased bounce rates. The ability to diagnose and triage performance has become increasingly complicated with Single-Page Application (SPA) frameworks.4 Indirect impact Some providers impact site reliability in less obvious ways. Based on experience, these are third parties that process transactions on the backend of the technology stack. The following are examples of providers with indirect impact: Payment processors outages — for instance, failed API key rotation or incorrect billing codes — should not delay user experience.

…

histograms and, Histograms-Where Percentiles Fall Down (and Histograms Step Up) percentiles vs. histograms, Where Percentiles Fall Down (and Histograms Step Up) SysAdmin–SRE transition and, Service-Level Objective third-party services and, SLOs service-oriented teams, Get Rid of as Many Handoffs as Possible Shannon, Adam, Replies shard-aware routingrouting queries in the application, Routing queries in the application routing requests in the application, Routing requests in the application routing requests with a scriptable load balancer, Routing requests with a scriptable load balancer routing requests with DNS, Routing requests with DNS Sharpe, Jeremy, Do Docs Better, Do Docs Better: Integrating Documentation into the Engineering Workflow-Communicating the Value of Documentation Shopify, Case Study: Checkout Queue-Case Study: Checkout Queue shopping websites, Case Study: Checkout Queue-Case Study: Checkout Queue Short, Chris, Replies Shoup, Randy, Pattern 3: Create a Shared Source Code Repository sidecar proxy, Service Mesh to the Rescue-The Benefits of a Sidecar Proxy, Sidecar Performance Implications Siegrist, John, Replies Sigmoid function, A neural network from scratch-A neural network from scratch silosenterprise operations model–SRE transition and, Silos Get in the Way-Silos Get in the Way Kata and, Start by Leaning on Lean mismatches and, Silos Get in the Way missed SLOs and, Antipattern 17: Tossing Your API Over the Firewall Spotify and, Unintentional specialization and misalignment Single Points of Failure (SPOFs), Beginning Chaos, Isolated failure domains Single-Page Application (SPA) frameworks, Direct impact Sinjakli, Chris, Replies site up, as SRE goal, Keeping the Site Up-Graduated degradationgraduated degradation, Graduated degradation isolating failure domains, Isolated failure domains redundant systems, Redundant systems SLA inversion, Avoiding Disaster Slicer, Routing requests with a scriptable load balancer snapshots, Offline storage social activismassigning/avoiding blame in reviews of, Charlottesville in review: assigning and avoiding blame building capacity instead of assigning blame, Beyond culpability: building capacity instead of assigning blame crisis management, Managing Crisis: Responding When Things Break Down-The corollary to trust is forgiveness forgiveness as corollary to trust, The corollary to trust is forgiveness intersections between operations and, Intersections Between Operations and Social Activism-Conclusion planning stage, Creating the Perfect Plan postmortems, Writing Our Own History: Making Sense of What Went Down-Beyond culpability: building capacity instead of assigning blame principles of organizing, Principles of Organizing software engineering as analogous to, Before, During, After turning action into change, The Long Tail: Turning Action into Change-Activism and Change Within a Company Soundcloud, SRE at, How to Apply SRE Principles Without Dedicated SRE Teams-Further Readingdeployment platform, The Deployment Platform embedded SREs, The Embedded SRE failure of team approach, SREs to the Rescue!

Mastering Blockchain, Second Edition by Imran Bashir

3D printing, altcoin, augmented reality, autonomous vehicles, bitcoin, blockchain, business logic, business process, carbon footprint, centralized clearinghouse, cloud computing, connected car, cryptocurrency, data acquisition, Debian, disintermediation, disruptive innovation, distributed ledger, Dogecoin, domain-specific language, en.wikipedia.org, Ethereum, ethereum blockchain, fault tolerance, fiat currency, Firefox, full stack developer, general-purpose programming language, gravity well, information security, initial coin offering, interest rate swap, Internet of things, litecoin, loose coupling, machine readable, MITM: man-in-the-middle, MVC pattern, Network effects, new economy, node package manager, Oculus Rift, peer-to-peer, platform as a service, prediction markets, QR code, RAND corporation, Real Time Gross Settlement, reversible computing, RFC: Request For Comment, RFID, ride hailing / ride sharing, Satoshi Nakamoto, seminal paper, single page application, smart cities, smart contracts, smart grid, smart meter, supply-chain management, transaction costs, Turing complete, Turing machine, Vitalik Buterin, web application, x509 certificate

DAPPLE This is another framework for Ethereum that allows easier development and deployment of smart contracts by taking care of more complex tasks. It can be used for package management, contract building, and deployment scripting. This is also available via npm. It is also available via GitHub at https://github.com/nexusdev/dapple. Meteor This is a full-stack development framework for single-page applications. It can be used for Ethereum DApp development. There is a development environment available in meteor, and it allows easier and easy development of complex DApps. It is available at https://www.meteor.com/ and Ethereum-specific DApp building information is available at https://github.com/ethereum/wiki/wiki/Dapp-using-Meteor.