single page application

14 results back to index


pages: 180 words: 37,187

AngularJS Essentials by Rodrigo Branas

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. Basically, this service works by mapping URLs against controllers and views, also allowing parameter passing.

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. This can be achieved by creating nested controllers, which means registering controllers that will work only inside a specific element of the view, as shown in the following code: <body ng-controller="parkingCtrl"> <div ng-controller="parkingNestedCtrl"> </div> </body> The scope of the nested controllers will inherit all the properties of the outside scope, overriding it in case of equality.


pages: 196 words: 58,122

AngularJS by Brad Green, Shyam Seshadri

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

As it turns out, we didn’t invent any of these. 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. Let’s see an example of what assembling this data and template on the browser looks like in Angular.

with the focus highlight. 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. Loading the example that follows into a browser will display what is shown in Figure 2-5.

We reused the edit template. 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, 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

For this reason we refer to such frameworks as following the MV* pattern; that is, you’re likely to have a Model and a View, but a distinct Controller might not be present and other components may come into play. What is Backbone.js? 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 has been used to create non-trivial applications by companies such as Disqus, Walmart, SoundCloud and LinkedIn.

Backbone focuses on giving you helpful methods for querying and manipulating your data rather than re-inventing the JavaScript object model. 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.

For instance, it’s trivial to switch between reading an email or document to writing one without sending a new page request to the server. 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. Has it become more effective at solving common problems? Does it continue to improve as developers build larger and more complex applications with it?


pages: 550 words: 84,515

Vue.js 2 Cookbook by Andrea Passaglia

bitcoin, Kickstarter, 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.

Recovering from an error during a request Getting ready How to do it... How it works... Creating a REST client (and server!) Getting ready How to do it... 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 3, Transitions and Animations, where you learn how transitions and animations work to bring more life to your apps. You will also integrate with external CSS libraries. 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. Chapter 8, Organize + Automate + Deploy = Webpack, is where you actually publish your accurately crafted components to npm and learn how Webpack and Vue play together in the process.


pages: 671 words: 228,348

Pro AngularJS by Adam Freeman

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

That’s not to say that you can’t use AngularJS with round-trip applications—you can, of course—but there are other technologies that are simpler and better suit discrete HTML pages, such as jQuery. 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.

AngularJS includes a lot of built-in functionality, which I describe in depth, and provides endless customization options, all of which I demonstrate. 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 first time I use a file in a chapter, I’ll list the complete contents, just as I have in Listing 1-1.

You won’t notice any delay when using the latest browsers on a capable desktop machine, but old browsers on underpowered smartphones can really slow down the initial setup of an AngularJS app. 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, continuous integration, create, read, update, delete, en.wikipedia.org, Firefox, Google Chrome, MVC pattern, pull request, side project, single page application, 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.

Using the Vuex store to call the mutations and change the store's state propagating it through the components We don't need to bind the v-model directive anymore because all the changes happen due to the calling store's mutation method. 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. Store state and getters It is, of course, good that we can reuse the this.


pages: 296 words: 41,381

Vue.js by Callum Macrae

Airbnb, single page application, 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. Vuex enables you to handle your application’s state in one centralized place, and in this chapter I explain how you can use it to easily handle complicated application state.

You can use the same syntax with router.push(): router.push({ name: 'home' }); Naming your routes and referring to them by using only their names instead of their paths means that the route and the path are no longer so tightly coupled: to change the path of a route, you have to change only the path in the router instead of having to go through all your existing links and updating them. 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, continuous integration, don't repeat yourself, Firefox, Google Chrome, loose coupling, MVC pattern, node package manager, single page application, web application, Y Combinator

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. 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.

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. The core part of this is to have a data model at the center of your application. As your products grow in complexity, it is necessary to be able to track the state of many different components. 2 Chapter 1 ■ An Introduction to Backbone.js Gmail is a classic example of this (see Figure 1-1). You need to track whether a message has been read or not, as well as the date, subject, sender, and message content.


pages: 190 words: 52,865

Full Stack Web Development With Backbone.js by Patrick Mulder

Airbnb, create, read, update, delete, Debian, 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. x | Preface JavaScript: The Good Parts by Douglas Crockford (O’Reilly/Yahoo!

With Firebase, you now have a dashboard to easily import more movies and track mov‐ ies usage. 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. Then, we discussed the different options to influence fetch() for different needs.


pages: 355 words: 81,788

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

Airbnb, business process, continuous integration, database schema, DevOps, fault tolerance, ghettoisation, inventory management, Jeff Bezos, Kubernetes, loose coupling, microservices, MVC pattern, price anchoring, pull request, single page application, software as a service, source of truth, telepresence

The configuration and layout of these UI components is defined in a declarative fashion on the server side; Spotify engineers are able to change the views that users see and roll that change quickly, without needing to submit new versions of their application to the app store. 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. By delivering an entire interface in a single page, we obviously can’t consider page-based composition, so we have to consider some form of widget-based composition.

What is more interesting is that people are working out how to make web browsers, SPA SDKs, and componentization work together. 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. For it to work, though, you need to have the ability to change the existing user interface to allow for new functionality to be safely inserted.


pages: 266 words: 38,397

Mastering Ember.js by Mitchel Kelonye

Firefox, MVC pattern, Ruby on Rails, single page application, web application, WebRTC, WebSocket

One feature that we introduced is the ability of the controller to reference other controllers. 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. Let this property return the post's date in a readable format such as Mon, 15th.


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 first was AJAX.2 AJAX enabled developers to make web pages more interactive, and faster, by making remote calls back to the server in the background without end users having to refresh their browsers. 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. On the developer’s side, however, things weren’t all roses.


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

Affordable Care Act / Obamacare, algorithmic trading, Amazon Web Services, bounce rate, business continuity plan, business process, cloud computing, cognitive bias, cognitive dissonance, commoditize, continuous integration, crowdsourcing, dark matter, database schema, Debian, defense in depth, DevOps, domain-specific language, en.wikipedia.org, fault tolerance, fear of failure, friendly fire, game design, Grace Hopper, information retrieval, Infrastructure as a Service, Internet of things, invisible hand, iterative process, Kubernetes, loose coupling, Lyft, Marc Andreessen, 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, 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, the scientific method, Toyota Production System, web application, WebSocket, zero day

Edge products, such as site accelerators, wide-area firewall, forward proxies/load balancers, and so on, can suffer congestion issues, human configuration error, and routing failures. 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 process, carbon footprint, centralized clearinghouse, cloud computing, connected car, cryptocurrency, data acquisition, Debian, disintermediation, disruptive innovation, distributed ledger, domain-specific language, en.wikipedia.org, Ethereum, ethereum blockchain, fault tolerance, fiat currency, Firefox, full stack developer, general-purpose programming language, gravity well, interest rate swap, Internet of things, litecoin, loose coupling, 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, single page application, smart cities, smart contracts, smart grid, smart meter, supply-chain management, transaction costs, Turing complete, Turing machine, 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. uPort This platform is built on Ethereum and provides a decentralized identity management system.