d famous, without a care for the rules of traditional journalism — The Enquirer would have had the tabloid story of a lifetime. Mary Al

Create a form that allows existing users to sign in using their email address and password. When a user completes the form, call the signInWithEmailAndPassword method:

Create a form that allows new users to register with your app using their email address and a password. When a user completes the form, validate the email address and password provided by the user, then pass them to the createUserWithEmailAndPassword method:

It integrates nicely with Cloud Functions for Firebase so if you want to send an email to your newly registered user, you can do so without the need for a server.

The Firebase Auth instance persists the user's state, so that refreshing the page (in a browser) or restarting the application doesn't lose the user's information.

Return type determines whether we continue the redirect automatically      // or whether we leave that to developer to handle.

To specify custom scopes,

it’s important to emphasize that you should only spend time fixing issues that you were able to measure. It’s very easy to end up shooting in the dark if you’re not disciplined — again, focus on building things and only invest time on fixing the key performance bottlenecks.

ou can see how the action gets dispatched in the handleSubmit method:

the component gets exported as List. List is the result of connecting the stateless component ConnectedList with the Redux store.

I fail to understand how a no such file or directory can occur on CREATING a directory.

Your application is responsible for starting a webserver and handling requests.

Your instances with manual and basic scaling should run indefinitely, but there is no uptime guarantee

For long-running computations, periodically create checkpoints so that you can resume from that state.

Hardware or software failures that cause early termination or frequent instance restarts can occur without warning and can take considerable time to resolve. Your application should be able to handle such failures.

The following example demonstrates what an app with three services might look like if you are developing your app locally. The optional dispatch.yaml has been added to that app in the root directory. Also in the root are three directories for each of the app's services. The subdirectory for service1 includes the source and configuration files for that service. Similarly, both service2 and service3 are in separate directories, which contain each service's files, although service3 includes two versions of the YAML configuration file:

It's a very common issue, when you are behind a NAT proxy or a firewall, to be disconnected without a reason.

Preventing disconnection due to network inactivity

You can live quite happily without keepalive, so if you're reading this, you may be trying to understand if keepalive is a possible solution for your problem

You can set HTTP headers for responses of your static file or directory handlers. To set HTTP headers in Node.js, do that in your app's code.

App Engine can handle URLs by executing application code, or by serving static files uploaded with the code, such as images, CSS, or JavaScript.

I was scraping a few thousand links from a single domain just a little too aggressively yesterday and kept getting ECONNRESET and socket hang up errors instead of that sweet, sweet data I longed for

Cross-site requests are preflighted like this since they may have implications to user data.

Some requests don’t trigger a CORS preflight.

browsers "preflight" the request, soliciting supported methods from the server with an HTTP OPTIONS request method, and then, upon "approval" from the server, sending the actual request with the actual HTTP request method

The Cross-Origin Resource Sharing standard works by adding new HTTP headers that allow servers to describe the set of origins that are permitted to read that information using a web browser

Cross-Origin Resource Sharing (CORS) is a mechanism that uses additional HTTP headers to tell a browser to let a web application running at one origin (domain) have permission to access selected resources from a server at a different origin.

More verbosely, you are trying to access api.serverurl.com from localhost. This is the exact definition of cross domain request.

These speedups come at a cost: storing a string's suffix tree typically requires significantly more space than storing the string itself.

Let w be the amount of words in the trie.

This technique relies on the fact that Cloud Firestore creates built-in indexes for all document fields, even fields in a nested map.

Dear gentle, kind, empathetic, generous, helpful reader,

To create or overwrite a single document, use the set() method

You can listen to a document with the onSnapshot() method

Java objects

// ... Your code here

name : "my chat room" collections_bookmark messages

maps

You can nest data up to 100 levels deep

You can create a subcollection called messages for every room document in your rooms collection

A reference is a lightweight object that just points to a location in your database. You can create a reference whether or not data exists there, and creating a reference does not perform any network operations.

A document representing a user alovelace might look like this:

app

request.rawBody The raw (unparsed) bytes of the request

So, let’s add some error handling:

Flexible environment

Focus just on writing code, without the worry of managing the underlying infrastructure.

I try not to demean or dismiss but rather educate and enlighten, hopefully while sounding less preachy than that just did.

given the possibility of a faulty process, it’s impossible for a system of processes to agree on a decision

while the goal is to execute the function exactly once, this is not guaranteed.

onFinalize((object, context)

Nope, just the first parameter will be treated as resolution value in the promise constructor. You can resolve with a composite value like an object or array.

The maximum value for timeoutSeconds is 540, or 9 minutes

Cloud Functions for Firebase lets you select runtime options such as the Node.js runtime version and per-function timeout and memory allocation.

Resolve functions that perform asynchronous processing (also known as "background functions") by returning a JavaScript promise

The accidental exposure of a service account credentials file may have serious consequences in terms of application and data security.

To use JavaScript promises to handle external processes like the thumbnail processing tasks in the sample, also import child-process-promise:

Take a deep breath.

Local disk storage in the temporary directory is an in-memory filesystem. All files that you write consume memory available to your function. Files that you write are usually available at consecutive invocations, therefore failing to delete these files may eventually lead to an out-of-memory error and a subsequent cold start.

When you use generation-match preconditions, a request succeeds only if the live version of the requested object has the specified generation number. If no such object exists, or is archived, Cloud Storage returns 412 Precondition Failed.

If you send a delete request with a generation that corresponds to the currently live object, Cloud Storage deletes the object without making an archived copy.

ETags

Each archived version of an object is charged at the same rate as the live version of the object. If you enable versioning, consider using Object Lifecycle Management, which can remove the oldest versions of an object as newer versions get archived.

Object Versioning details

Object archive events can be used only with versioning buckets. They are triggered when an old version of an object is archived. In particular, this means that when an object is overwritten or deleted, an archive event is triggered.

Cloud Functions provides access to a local disk mount point (/tmp) which is known as a "tmpfs" volume in which data written to the volume is stored in memory. There is no specific fee associated with this however writing data to the /tmp mountpoint will consume memory resources provisioned for the function.

There are still some areas where Google Cloud Functions and the Firebase SDK for Cloud Functions do not have full interoperability

Cloud Functions for Firebase is optimized for Firebase developers:

Creating a response to an event is done with a Trigger. A trigger is a declaration that you are interested in a certain event or set of events. Binding a function to a trigger allows you to capture and act on events.

Every deployed function is isolated from all other functions—even those deployed from the same source file. In particular, they don’t share memory, global variables, file systems, or other state. To share data across deployed functions, you can use storage services like Cloud Datastore, Cloud Firestore, or Cloud Storage

The only writeable part of the file system is the /tmp directory (as defined by os.tmpdir()), which you can use to store temporary files in a function instance. This is a local disk mount point known as a "tmpfs" volume in which data written to the volume is stored in memory. Note that it will consume memory resources provisioned for the function.

The function execution environment contains a runnable function file, plus files and directories included in the deployed function package such as local dependencies. These files are available in a read-only directory

In the case of HTTP functions, this also means returning the desired value even if the caller retries calls to the HTTP function endpoint

the code executed after sending the HTTP response could be interrupted at any time:

You can assume that the global scope has been executed exactly once before your function code is invoked in a new function instance (and on every subsequent creation of a new function instance)

it is recommended to cache state across invocations in global scope where possible. Your function should be still prepared to work without this cache available as there is no guarantee that the next invocation will reach the same function instance

For example, the counter value returned by the following function does not correspond to the total function invocation count because invocations may be handled by different function instances, which don’t share global variables, memory, file systems, or other state

However, each function instance handles only one concurrent request at a time. This means while your code is processing one request, there is no possibility of a second request being routed to the same function instance, and the original request can use the full amount of resources (CPU and memory) that you requested.

a perfect candidate for lightweight APIs and webhooks.

Cloud Functions are written in Javascript and execute in a Node.js v6.14.0 environment on Google Cloud Platform

You can use background functions to handle events from your Cloud infrastructure, such as messages on a Google Cloud Pub/Sub topic, or changes in a Google Cloud Storage bucket.

projectId: 'grape-spaceship-123', keyFilename: '/path/to/keyfile.json'

Passing the path to the service account key in code You can alternately choose to explicitly point to your service account file in code, as shown in the following code example.

you can pass the path to the service account key in code.

Rapper Drake became the first artist to chart seven simultaneous Billboard Top 10 singles last week, besting the Beatles' record of five in 1964

Using these functions executes a read operation in your database, which means you will be billed for reading documents even if your rules reject the request

As a better solution, you can reduce the number of indexes by taking advantage of Cloud Firestore's ability to merge indexes for equality clauses:

Indexes contribute to the storage costs of your application

Cloud Firestore does not automatically create composite indexes like it does for single-field indexes because of the large number of possible field combinations. Instead, Cloud Firestore helps you identify and create required composite indexes as you build your app.

A single-field index stores a sorted mapping of every document in a collection with a specific field. Each entry in a single-field index records a document's value for a specific field and the location of the document in the database.

This work has focused on new interfaces and algorithms for helping people sift effectively through large masses of information

db.collection('coll').doc('doc').collection('subcoll').doc('subdoc') even though the document referenced by db.collection('coll').doc('doc') no longer exists. If you want to delete documents in subcollections when deleting a document, you must do so manually

exists(/$(prefix())/admins/$(request.auth.uid))

userId == request.auth.uid

allow read, write: if roomId in get(/$(prefix())/users/$(request.auth.uid)).data.chats                            || exists(/$(prefix())/admins/$(request.auth.uid));

db.collection('user').doc('myuid').get(...);

20 document access calls

Batched writes have fewer failure cases than transactions and use simpler code. They are not affected by contention issues, because they don't depend on consistently reading any documents. Batched writes execute even when the user's device is offline.

ransaction functions should not directly modify application state.

Your smartphone is your ticket

within documents.

CLI

Firebase CLI.

allow read, write: if request.auth.uid != null;

The book identifier usually contains the book ISBN number, that is used by cataloging systems

entire blog post

The tl;dr: Just tell me what to use!

all queries are shallow, meaning that you can simply fetch a document without having to fetch all of the data contained in any of the linked subcollections. This means you can store your data hierarchically in a way that makes sense logically without worrying about downloading tons of unnecessary data

Now if you're experiencing some deja vu, you're not alone. We realize this sounds awfully similar to another product you might already be using -- the Firebase Realtime Database. So if you're experiencing some deja vu, you're not alone.

It seems you can't dispatch() inside a reducer! This is how Redux was designed. Reducers only define how to move from one state to another; it can't have side effects

Redux provides a function called combineReducers that lets you avoid writing this code by hand

dispatcher

Flux is a pattern and Redux is a library.

Managing this ever-changing state is hard. If a model can update another model, then a view can update a model, which updates another model, and this, in turn, might cause another view to update. At some point, you no longer understand what happens in your app as you have lost control over the when, why, and how of its state. When a system is opaque and non-deterministic, it's hard to reproduce bugs or add new features.

When an event happens, the Dispatcher would send the “payload” to the Store that is registered to listen for that particular action. Now it is up to the Store to update the View, which in turn triggers an action. The action to happen is also predetermined like name, type of action and so on.The View propagates the Action though a central Dispatcher and this will be sent to various Stores. These Stores would contain an application’s business logic and other data. It updates all the Views.

All the functionality is usually found within the Store. The Store is where all the work is done and tells the Dispatcher which events/actions it is listening for

the cascading updates makes the app really difficult to understand and debug

MVC cannot model single objects, Flux can do it to store any application related data.

MVC has stood the test of time, and ever since its launch in 1976, it has been the favorite for many developers.

problem with MVC is that it doesn’t scale well for Facebook’s huge code base

Flux boasts of a better structured data flow — unidirectional

editing, task

...props

export default

<Note> <span>{task}</span> <button onClick={onDelete.bind(null, id)}>x</button> </Note>

a controlled component. We'll control the editing state explicitly from outside of the component. This gives us more power, but it also makes Editable more involved to use

This uncontrolled way of designing can be valid if you don't want to do anything with the state outside of the component.

It is equivalent to this ES5 code:

[name]: value,

refs support a callback that gets called right after the component is mounted

I was first prompted to take a close look at how Genius works on March 25th, when sexual health blogger Ella Dawson published a searing complaint alleging that the web annotator was tantamount to the forcible creation of comments for sites that don’t want them. I sympathized with her concerns somewhat, especially since Genius has thus far neglected to provide an opt-out mechanism for site owners. I immediately began working on a WordPress plugin called Genius Defender, which renders the service unusable for pages where it is running.

The cross-site scripting prevented by the Content Security Policy is one of a broad class of security issues collectively known as "code injection."

onDelete={this.deleteNote}

To keep our code from crashing if onDelete is not provided, I defined a dummy callback for it

onDelete.bind(null, id

onDelete=() => {}

with a given sequence of arguments preceding any provided when the new function is called.

The bind() method creates a new function that, when called, has its this keyword set to the provided value, with a given sequence of arguments preceding any provided when the new function is called.

or an object expression to be expanded in places where zero or more key-value pairs (for object literals)

concat

After this change App owns the state even though the application still should look the same as before

the function based component definition

export

default

If you have used JavaScript before, the intuitive way to handle it would be to set up an event handler like () => notes.push({id: uuid.v4(), task: 'New task'}). If you try this, you'll see that nothing happens.

prop

Given React components have to return a single element, we had to wrap our application within a div

o make room for more functionality, we could add a concept known as App on top of that. This component will orchestrate the execution of our application. We can add the button we want there and manage state as well as we add notes.

The development setup will install the uuid dependency automatically.

Another interesting way to approach data would be to normalize it. In this case we would end up with a [<id> -> { id: '...', task: '...' }] kind of structure. Even though there's some redundancy

a “read it later” service is just a fancy bookmarking app. You create an account, save articles you want to read from any web browser, and the app organizes them and lets you read them in a clean, uncluttered view that ditches most of the ads and focuses on the text.

Highlighting in Pocket has two tiers: Free and Premium. All Pocket users will be able to create 3 highlights per article, and those who subscribe to Pocket Premium will be able to create an unlimited number of highlights.

export statement cannot be used in embedded scripts

If more than one trailing comma is used, an elision (or hole) is produced. An array with holes is called sparse (a dense array has no holes). When iterating arrays for example with Array.prototype.forEach() or Array.prototype.map(), array holes are skipped

shaders

WebGL

Historically we have mixed the concerns of the DOM and state and tried to manage it there

Alt

Even though it's a simple tool, it's quite powerful, and you can find use for it in many places

Kanban, originally developed at Toyota, allows you to track the status of tasks. It can be modeled in terms of Lanes and Notes. Notes move through Lanes representing stages from left to right as they become completed

You can use it to implement mobile applications for example.

I can assure you, React and its ecosystem have many more treats in store (shout out to Babel, ES6, and arrow functions)

theoretically, all components in React could hold state, this is not the case — one of React’s best practices is to keep as many components as possible stateless, and isolate state into as few places as possible.

In an application that employs a two-way binding model, a change to the view is able to mutate the model data, and visa versa.

Where most frameworks choose to employ a two-way data binding model (hi Angular),

Below is an example of the JSX syntax:

Getting from one’s wireframes to a working user interface was quite the ordeal, only intensified by the fact that one’s Photoshop layers didn’t directly map to HTML element

As a beginner programmer, my front-end stack comprised of CSS (Cascading Style Sheets) and jQuery

This is a necessary redundancy for two-way relationships. It allows you to quickly and efficiently fetch Ada's memberships, even when the list of users or groups scales into the millions or when Realtime Database security rules prevent access to some of the records.

For example, listing the titles of chat conversations requires the entire chats tree, including all members and messages, to be downloaded to the client.

Avoid nesting data