PSALMS 47
A psalm written by one of the descendants of Korah for the choir director
1 You people all over the world, clap your hands!
Shout joyfully to praise God!
2 Yahweh, who is much greater than any other god, is awesome;
he is a king who rules over all the world!
3 He enabled us to defeat the armies of the people groups that lived in Canaan.
4 He chose for us this land where we now live;
we Israelite people, whom he loves, are proud that we own this land.
5 God has gone up into his temple.
The people shouted joyfully and blew trumpets as he went up.
6 Sing songs to praise our God!
Sing to praise him !
Sing to God, our king!
7 God is the one who rules over everything in the world;
sing a psalm to him!
8 God sits on his sacred throne
as he rules over the people of all ethnic groups.
9 The rulers of those people groups gather in front of God's people, the people descended from Abraham.
God has more power than the weapons of all the kings on the earth;
he is great, and all people everywhere will honor him.


Tests developed by Solomon<EMAIL_ADDRESS>MRC IGMM at The University of Edinburgh
Additional tests created by Ken<EMAIL_ADDRESS>HWU
Data provided by Ilinca<EMAIL_ADDRESS>EMBL-EBI


The ExpressJS Way To Write APIs
The ExpressJS Way To Write APIs
This article will cover the basics of express from the perspective of a beginner without concerning its self with the underlying mechanisms and theory that underlies the application of the framework.
For starters, what is express JS¿
When introduced, node.js gave developers the chance to use JavaScript to write software that, up to that point, could only be written using lower level languages like C, C++, Java, Python…
This tutorial will cover how to write web services that can communicate with clients (the front end application) using JavaScript Object Notation (JSON).
- JavaScript is asynchronous, which allows us to take full advantage of the processor it’s running on. Taking full advantage of the processor is crucial because the node process will be running on a single CPU.
- Using JavaScript gives us access to the npm repository. This repository is the largest ecosystem of useful libraries (most of them free to use) in npm modules.
Explain what Node.js is and its core features
Traditionally, developers only used the JavaScript language in web browsers. But, in 2009, Node.js was unveiled, and with it, the developer tool kit expanded greatly. Node.js gave developers the chance to use JavaScript to write software that, up to that point, could only be written using C, C++, Java, Python, Ruby, C#, and the like.
We will use Node to write server code. Specifically, web services that can communicate with clients using the JavaScript Object Notation (JSON) format for data interchange.
Some of the advantages of using Node.js for writing server-side code are:
- Uses the same programming language (JavaScript) and paradigm for both client and server. Using the same language, we minimize context switching and make it easy to share code between the client and the server.
- JavaScript is single-threaded, which removes the complexity involved in handling multiple threads.
- JavaScript is asynchronous, which allows us to take full advantage of the processor it’s running on. Taking full advantage of the processor is crucial because the node process will be running on a single CPU.
- Using JavaScript gives us access to the npm repository. This repository is the largest ecosystem of useful libraries (most of them free to use) in npm modules.
Some of the disadvantages of using Node.js for writing server-side code are:
- By strictly using JavaScript on the server, we lose the ability to use the right tool (a particular language) for the job.
- Because JavaScript is single-threaded, we can’t take advantage of servers with multiple cores/processors.
- Because JavaScript is asynchronous, it is harder to learn for developers that have only worked with languages that default to synchronous operations that block the execution thread.
- In the npm repository, there are often too many packages that do the same thing. This excess of packages makes it harder to choose one and, in some cases, may introduce vulnerabilities into our code.
To write a simple web server with
Node.js
:
-
Use Node’s
HTTP
module to abstract away complex network-related operations. - Write the single request handler function to handle all requests to the server.
The request handler is a function that takes the
request
coming
from the client and produces the
response
. The
function takes two arguments: 1) an object representing the
request
and 2)
an object representing the
response
.
This process works, but the resulting code is verbose, even for the simplest of servers. Also, note that when using only Node.js to build a server, we use a single request handler function for all requests.
Try It Out:
Using only Node.js, let’s write a simple web server that returns
a message. Create a folder for the server and add an
index.js
file
inside.
Next, add the following code to the
index.js
file:
const http = require("http"); // built in node.js module to handle http traffic
const hostname = "<IP_ADDRESS>"; // the local computer where the server is running
const port = 3000; // a port we'll use to watch for traffic
const server = http.createServer((req, res) => {
// creates our server
res.statusCode = 200; // http status code returned to the client
res.setHeader("Content-Type", "text/plain"); // inform the client that we'll be returning text
res.end("Hello World from Node\\n"); // end the request and send a response with the specified message
});
server.listen(port, hostname, () => {
// start watching for connections on the port specified
console.log(`Server running at <http://$>{hostname}:${port}/`);
});
Now navigate to the folder in a terminal/console window and
type:
node index.js
to execute your file. A message that reads "Server running at http://<IP_ADDRESS>:3000" should be displayed, and the server is now waiting for
connections.
Open a browser and visit:
http://localhost:3000
.
localhost
and
the IP address
<IP_ADDRESS>
point
to the same thing: your local computer. The browser should show
the message: "Hello World from Node". There you have it, your first web server, built from
scratch using nothing but
Node.js
.
Explain what Express is and its core features:
Node’s built-in
HTTP
module
provides a powerful way to build web applications and services.
However, it requires a lot of code for everyday tasks like
sending an HTML page to the browser.
Introducing Express, a light and unopinionated framework that
sits on top of Node.js, making it easier to create web applications and services.
Sending an HTML file or image is now a one-line task with the
sendFile
helper
method in
Express
.
Ultimately, Express is just a Node.js module like any other module.
What can we do with Express? So many things! For example:
- Build web applications.
- Serve Single Page Applications (SPAs).
- Build RESTful web services that work with JSON.
- Serve static content, like HTML files, images, audio files, PDFs, and more.
- Power real-time applications using technologies like Web Sockets or WebRTC.
Some of the benefits of using Express are that it is:
- Simple
- Unopinionated
- Extensible
- Light-weight
-
Compatible with
connect middleware (Links to an external site.). This compatibility means we can tap into an extensive
collection of modules written for
connect
. - All packaged into a clean, intuitive, and easy-to-use API.
- Abstracts away common tasks (writing web applications can be verbose, hence the need for a library like this).
Some of the drawbacks of Express are:
- It’s not a one-stop solution. Because of its simplicity, it does very little out of the box. Especially when compared to frameworks like Ruby on Rails and Django.
- We are forced to make more decisions due to the flexibility and control it provides.
Main Features of Express
Middleware functions are functions that have access to the request object ( req), the response object ( res), and the…expressjs.com
Middleware
Middleware functions can get the request and response objects, operate on them, and (when specified) trigger some action. Examples are logging or security.
Express’s middleware stack is an array of functions.
Middleware can change the request or response, but it doesn’t have to.
Routing
Routing is a way to select which request handler function is executed. It does so based on the URL visited and the HTTP method used. Routing provides a way to break an application into smaller parts.
Routers for Application Modularity
We can break up applications into routers. We could have a router to serve our SPA and another router for our API. Each router can have its own middleware and routing. This combination provides improved functionality.
Convenience Helpers
Express has many helpers that provide out of the box functionality to make writing web applications and API servers easier.
A lot of those helpers are extension methods added to the request and response objects.
Examples
from the Api Reference (Links to an external site.)
include:
response.redirect()
,
response.status()
,
response.send()
, and
request.ip
.
Views
Views provide a way to dynamically render HTML on the server and even generate it using other languages.
Try It:
Let’s write our first server using Express:
-
Create a new file called
server.js
to host our server code. -
Type
npm init -y
to generate apackage.json
. -
Install the
express
npm module using:npm install express
.
Inside
server.js
add
the following code:
const express = require('express'); // import the express package
const server = express(); // creates the server
// handle requests to the root of the api, the / route
server.get('/', (req, res) => {
res.send('Hello from Express');
});
// watch for connections on port 5000
server.listen(5000, () =>
console.log('Server running on <http://localhost:5000>')
);
Run the server by typing:
node server.js
and visit
http://localhost:5000
in the browser.
To stop the server, type
Ctrl + c
at the
terminal window.
Create an API that can respond to GET requests
The steps necessary to build a simple Web API that returns the
string “Hello World” on every incoming
GET
request.
The program should return the string every time a request comes
into the root route ("/"). For now, you don't need
to code along, just read through the steps.
To make things easier, we’ll use an existing repository as the base for our API. Later in the week, as we learn more about Node.js and Express, we’ll create an API from scratch.
To build our first API, we will:
- clone the node-express-mini repository (Links to an external site.) to a folder on our computer.
-
Navigate into the folder using
cd
. -
Use
npm install
to download all dependencies. -
Add a file called
index.js
at the folder's root, next to thepackage.json
file. -
Open the
index.js
file using our favorite code editor. - Add the following code:
// require the express npm module, needs to be added to the project using "npm install express"
const express = require('express');
// creates an express application using the express module
const server = express();
// configures our server to execute a function for every GET request to "/"
// the second argument passed to the .get() method is the "Route Handler Function"
// the route handler function will run on every GET request to "/"
server.get('/', (req, res) => {
// express will pass the request and response objects to this function
// the .send() on the response object can be used to send a response to the client
res.send('Hello World');
});
// once the server is fully configured we can have it "listen" for connections on a particular "port"
// the callback function passed as the second argument will run once when the server starts
server.listen(8000, () => console.log('API running on port 8000'));
make sure to save your changes to index.js
.
We are using the
express
npm
module in our code, so we need to add it as a dependency to our
project. To do this:
- Open a terminal/console/command prompt window and navigate to the root of our project.
-
Add express to our
package.json
file by typingnpm install express
.
Now we’re ready to test our API!
In the terminal, still at the root of our project:
-
Type:
npm run server
to run our API. The message "Api running on port 8000" should appear on the terminal. - Open a web browser and navigate to “http://localhost:8000".
There we have it, our first API!
A lot is going on in those few lines of code (only six lines if we remove the comments and white space). We will cover every piece of it in detail over the following modules, but here is a quick rundown of the most important concepts.
First, we used
require()
to
import
the
express module
and make it available to our application.
require()
is
similar to the
import
keyword
we have used before. The line
const express = require('express');
is equivalent to
import express from 'express';
if we were using ES2015 syntax.
The following line creates our Express application. The return
of calling
express()
is an
instance of an Express application that we can use to configure
our
server
and, eventually, start listening for and responding to requests.
Notice we use the word server, not API. An Express application
is generic, which means we can use it to serve static content
(HTML, CSS, audio, video, PDFs, and more). We can also use an
Express application to serve dynamically generated web pages,
build real-time communications servers, and more. We will use it
statically to accept requests from clients and respond with data
in JSON format.
An Express application publishes a set of methods we can use to
configure functions. We are using the .get()
method to set up a
route handler
function that will run on every
GET
request. As
a part of this handler function, we specify the URL which will
trigger the request. In this case, the URL is the site's
root (represented by a
/
). There are
also methods to handle the
POST
,
PUT
, and
DELETE
HTTP
verbs.
The first two arguments passed by
express
to a
route handler function are 1) an object representing the
request
and 2)
an object representing the
response
.
Express expands those objects with a set of useful properties
and methods. Our example uses the .send()
method of the response object to specify the data we will send
to the client as the response body. You can call the first two
arguments anything you want, but it is prevalent to see them
dubbed req
and
res
.
That’s all the configuring we need to do for this first example We’ll see other ways of configuring our server as we go forward.
After configuring the server, it’s time to turn it on. We use
the .listen()
method to monitor a port on the computer for any incoming
connections and respond to those we have configured. Our server
will only respond to
GET
requests
made to the
/
route on port
8000
.
That’s it for our first Web API, and now it’s time for you to follow along as we add a new endpoint to our server that returns JSON data!
Try It Out:
Let’s try returning JSON instead of just a simple string.
Please follow the steps outlined on the overview, but, to save
time, copy and paste the content of
index.js
instead of typing it. Then run your API through a browser to
make sure it works.
Now follow along as we code a new endpoint that returns an array of movie characters in JSON format.
The first step is to define a new
route handler to
respond to
GET
requests at
the
/hobbits
endpoint.
server.get('/hobbits', (req, res) => {
// route handler code here
});
Next, we define the return data that our endpoint will send back to the client. We do this inside the newly defined route handler function.
const hobbits = [
{
id: 1,
name: 'Samwise Gamgee',
},
{
id: 2,
name: 'Frodo Baggins',
},
];
Now we can return the
hobbits
array.
We could use .send(hobbits)
as we did for the string on the
/
endpoint, but
this time we'll learn about two other useful methods we find
in the response object.
res.status(200).json(hobbits);
We should provide as much useful information as possible to the
clients using our API. One such piece of data is the
HTTP status code
that reflects the client's operation outcome. In this case,
the client is trying to get a list of a particular
resource
, a
hobbits
list.
Sending back a
200 OK
status
code communicates to the client that the operation was
successful.
We will see other status codes as we continue to build new endpoints during this week. You can see a list by following this link to the documentation about HTTP Response Codes on the Mozilla Developer Network site (Links to an external site.).
We can use the .status()
method of the response object to send any valid
HTTP status code
.
We are also chaining the .json()
method of the response object. We do this to communicate to both
the client making the request and the next developer working
with this code that we intend to send the data in
JSON format
.
The complete code for
index.js
should
now look like so:
const express = require('express');
const server = express();
server.get('/', (req, res) => {
res.send('Hello World');
});
server.get('/hobbits', (req, res) => {
const hobbits = [
{
id: 1,
name: 'Samwise Gamgee',
},
{
id: 2,
name: 'Frodo Baggins',
},
];
res.status(200).json(hobbits);
});
server.listen(8000, () => console.log('API running on port 8000'));
Now we can visit
http://localhost:8000/hobbits
in our browser, and we should get back our JSON array.
If you are using the Google Chrome browser, this extension (Links to an external site.) can format the JSON data in a more readable fashion.
Congratulations! You just built an API that can return data in JSON format.
Let’s look at a basic example of routing in action.
First, to make our Express application respond to
GET
requests on
different URLs, add the following endpoints:
// this request handler executes when making a GET request to /about
server.get('/about', (req, res) => {
res.status(200).send('
About Us
');
});
// this request handler executes when making a GET request to /contact
server.get('/contact', (req, res) => {
res.status(200).send('
Contact Form
');
});
Two things to note:
1.) We are using the same HTTP Method on both endpoints, but express looks at the URL and executes the corresponding request handler.
2.) We can return a string with valid HTML!
Open a browser and navigate to the
/about
and
/contact
routes. The appropriate route handler will execute.
Please follow along as we write endpoints that execute different request handlers on the same URL by changing the HTTP method.
Let’s start by adding the following code after the
GET
endpoint to
/hobbits
:
// this request handler executes when making a POST request to /hobbits
server.post('/hobbits', (req, res) => {
res.status(201).json({ url: '/hobbits', operation: 'POST' });
});
Note that we return HTTP status code 201 (created) for
successful
POST
operations.
Next, we need to add an endpoint for
PUT
requests to
the same URL.
// this request handler executes when making a PUT request to /hobbits
server.put('/hobbits', (req, res) => {
res.status(200).json({ url: '/hobbits', operation: 'PUT' });
});
For successful
PUT
operations,
we use HTTP Status Code 200 (OK).
Finally, let’s write an endpoint to handle
DELETE
requests.
// this request handler executes when making a DELETE request to /hobbits
server.delete('/hobbits', (req, res) => {
res.status(204);
});
We are returning HTTP Status Code 204 (No Content). Suppose you are returning any data to the client, perhaps the removed resource, on successful deletes. In that case, you’d change that to be 200 instead.
You may have noticed that we are not reading any data from the
request, as that is something we’ll learn later in the module.
We are about to learn how to use a tool called
Postman
to test
our POST
,
PUT
, and
DELETE
endpoints.
Reading and Using Route Parameters
Let’s revisit our
DELETE
endpoint.
server.delete('/hobbits', (req, res) => {
res.status(204);
});
How does the client let the API know which hobbit should be
deleted or updated? One way, the one we’ll use, is through
route parameters
. Let's add support for route parameters to our
DELETE
endpoint.
We define route parameters by adding it to the URL with a colon
(:
) in front of
it. Express adds it to the .params
property part of the request object. Let's see it in action:
server.delete('/hobbits/:id', (req, res) => {
const id = req.params.id;
// or we could destructure it like so: const { id } = req.params;
res.status(200).json({
url: `/hobbits/${id}`,
operation: `DELETE for hobbit with id ${id}`,
});
});
This route handler will execute every
DELETE
for a
URL that begins with
/hobbits/
followed by any value. So,
DELETE
requests
to
/hobbits/123
and
/hobbits/frodo
will both trigger this request handler. The value passed after
/hobbits/
will
end up as the
id
property on
req.params
.
The value for a route parameter will always be
string
, even if
the value passed is numeric. When hitting
/hobbits/123
in
our example, the type of
req.params.id
will be string
.
Express routing has support for multiple route parameters. For
example, defining a route URL that reads
/hobbits/:id/friends/:friendId
, will add properties for
id
and
friendId
to
req.params
.
Using the Query String
The query string is another strategy using the URL to pass
information from clients to the server. The query string is
structured as a set of key/value pairs. Each pair takes the form
of key=value
,
and pairs are separated by an
&
. To mark
the beginning of the query string, we add ?
and the end of the URL, followed by the set of key/value pairs.
An example of a query string would be:
https://www.google.com/search?q=lambda&tbo=1
. The query string portion is ?q=lambda&tbo=1
and the key/value pairs are
q=lambda
and
tbo=1
.
Let’s add sorting capabilities to our API. We’ll provide a way
for clients to hit our
/hobbits
and
pass the field they want to use to sort the responses, and our
API will sort the data by that field in ascending order.
Here’s the new code for the
GET /hobbits
endpoint:
server.get('/hobbits', (req, res) => {
// query string parameters get added to req.query
const sortField = req.query.sortby || 'id';
const hobbits = [
{
id: 1,
name: 'Samwise Gamgee',
},
{
id: 2,
name: 'Frodo Baggins',
},
];
// apply the sorting
const response = hobbits.sort(
(a, b) => (a[sortField] < b[sortField] ? -1 : 1)
);
res.status(200).json(response);
});
Visit
localhost:8000/hobbits?sortby=name
, and the list should be sorted by
name
. Visit
localhost:8000/hobbits?sortby=id
, and the list should now be sorted by
id
. If no
sortby
parameter is provided, it should default to sorting by
id
.
To read values from the query string, we use the
req.query
object added by Express. There will be a key and a value in the
req.query
object for each key/value pair found in the query string.
The parameter’s value will be of type
array
if more
than one value is passed for the same key and
string
when
only one value is passed. For example, in the query string ?id=123
,
req.query.id
will be a string, but for ?id=123&id=234
, it will be an array.
Another gotcha is that the names of query string parameters are
case sensitive,
sortby
and
sortBy
are two
different parameters.
The rest of the code sorts the array before sending it back to the client.
Reading Data from the Request Body
We begin by taking another look at the
POST /hobbits
endpoint. We need to read the hobbit's information to add it
to the
hobbits
array.
Let's do that next:
// add this code right after const server = express();
server.use(express.json());
let hobbits = [
{
id: 1,
name: 'Bilbo Baggins',
age: 111,
},
{
id: 2,
name: 'Frodo Baggins',
age: 33,
},
];
let nextId = 3;
// and modify the post endpoint like so:
server.post('/hobbits', (req, res) => {
const hobbit = req.body;
hobbit.id = nextId++;
hobbits.push(hobbit);
res.status(201).json(hobbits);
});
To make this work with the hobbits array, we first move it out of the get endpoint into the outer scope. Now we have access to it from all route handlers.
Then we define a variable for manual id generation. When using a database, this is not necessary as the database management system generates ids automatically.
To read data from the request body, we need to do two things:
-
Add the line:
server.use(express.json());
after the express application has been created. - Read the data from the body property that Express adds to the request object. Express takes all the client’s information from the body and makes it available as a nice JavaScript object.
Note that we are skipping data validation to keep this demo simple, but in a production application, you would validate before attempting to save to the database.
Let’s test it using Postman:
- Change the method to POST.
-
Select the
Body
tab underneath the address bar. -
Click on the
raw
radio button. -
From the dropdown menu to the right of the
binary
radio button, select `JSON (application/json). - Add the following JSON object as the body:
{
"name": "Samwise Gamgee",
"age": 30
}
Click on Send
,
and the API should return the list of hobbits, including Sam!
Try It:
Please code along as we implement the
PUT
endpoint
and a way for the client to specify the sort direction.
Implement Update Functionality
Let’s continue practicing reading route parameters and information from the request body. Let’s take a look at our existing PUT endpoint:
server.put('/hobbits', (req, res) => {
res.status(200).json({ url: '/hobbits', operation: 'PUT' });
});
We start by adding support for a route parameter the clients can use to specify the id of the hobbit they intend to update:
server.put('/hobbits/:id', (req, res) => {
res.status(200).json({ url: '/hobbits', operation: 'PUT' });
});
Next, we read the hobbit information from the request body using
req.body
and
use it to update the existing hobbit.
server.put('/hobbits/:id', (req, res) => {
const hobbit = hobbits.find(h => h.id == req.params.id);
if (!hobbit) {
res.status(404).json({ message: 'Hobbit does not exist' });
} else {
// modify the existing hobbit
Object.assign(hobbit, req.body);
res.status(200).json(hobbit);
}
});
Concentrate on the code related to reading the
id
from the
req.params
object and reading the hobbit information from
req.body
. The
rest of the code will change as this is a simple example using
an in-memory array. Most production APIs will use a database.
TBC…………………………………
If you found this guide helpful feel free to checkout my GitHub/gists where I host similar content:
Instantly share code, notes, and snippets. Web Developer, Electrical Engineer JavaScript | CSS | Bootstrap | Python |…gist.github.com
Web Developer, Electrical Engineer JavaScript | CSS | Bootstrap | Python | React | Node.js | Express | Sequelize…github.com
Discover More:
Update(Bonus Best Practices):
Things to do in your code
Here are some things you can do in your code to improve your application’s performance:
- Use gzip compression
- Don’t use synchronous functions
- Do logging correctly
- Handle exceptions properly
Use gzip compression
Gzip compressing can greatly decrease the size of the response body and hence increase the speed of a web app. Use the compression middleware for gzip compression in your Express app. For example:
var compression = require('compression')
var express = require('express')
var app = express()
app.use(compression())
For a high-traffic website in production, the best way to put compression in place is to implement it at a reverse proxy level (see Use a reverse proxy). In that case, you do not need to use compression middleware. For details on enabling gzip compression in Nginx, see Module ngx_http_gzip_module in the Nginx documentation.
Don’t use synchronous functions
Synchronous functions and methods tie up the executing process until they return. A single call to a synchronous function might return in a few microseconds or milliseconds, however in high-traffic websites, these calls add up and reduce the performance of the app. Avoid their use in production.
Although Node and many modules provide synchronous and asynchronous versions of their functions, always use the asynchronous version in production. The only time when a synchronous function can be justified is upon initial startup.
If you are using Node.js 4.0+ or io.js 2.1.0+, you can use the
--trace-sync-io
command-line flag to print a warning and a stack trace whenever
your application uses a synchronous API. Of course, you wouldn’t
want to use this in production, but rather to ensure that your
code is ready for production. See the
node command-line options documentation
for more information.
Do logging correctly
In general, there are two reasons for logging from your app: For
debugging and for logging app activity (essentially, everything
else). Using
console.log()
or
console.error()
to print log messages to the terminal is common practice in
development. But
these functions are synchronous
when the destination is a terminal or a file, so they are not
suitable for production, unless you pipe the output to another
program.
For debugging
If you’re logging for purposes of debugging, then instead of
using
console.log()
,
use a special debugging module like
debug. This module enables you to use the DEBUG environment variable
to control what debug messages are sent to
console.error()
, if any. To keep your app purely asynchronous, you’d still
want to pipe
console.error()
to another program. But then, you’re not really going to debug
in production, are you?
For app activity
If you’re logging app activity (for example, tracking traffic or
API calls), instead of using
console.log()
,
use a logging library like
Winston
or
Bunyan. For a detailed comparison of these two libraries, see the
StrongLoop blog post
Comparing Winston and Bunyan Node.js Logging.
Handle exceptions properly
Node apps crash when they encounter an uncaught exception. Not handling exceptions and taking appropriate actions will make your Express app crash and go offline. If you follow the advice in Ensure your app automatically restarts below, then your app will recover from a crash. Fortunately, Express apps typically have a short startup time. Nevertheless, you want to avoid crashing in the first place, and to do that, you need to handle exceptions properly.
To ensure you handle all exceptions, use the following techniques:
Before diving into these topics, you should have a basic understanding of Node/Express error handling: using error-first callbacks, and propagating errors in middleware. Node uses an “error-first callback” convention for returning errors from asynchronous functions, where the first parameter to the callback function is the error object, followed by result data in succeeding parameters. To indicate no error, pass null as the first parameter. The callback function must correspondingly follow the error-first callback convention to meaningfully handle the error. And in Express, the best practice is to use the next() function to propagate errors through the middleware chain.
For more on the fundamentals of error handling, see:
- Error Handling in Node.js
- Building Robust Node Applications: Error Handling (StrongLoop blog)
What not to do
One thing you should
not do is to listen for
the
uncaughtException
event, emitted when an exception bubbles all the way back to the
event loop. Adding an event listener for
uncaughtException
will change the default behavior of the process that is
encountering an exception; the process will continue to run
despite the exception. This might sound like a good way of
preventing your app from crashing, but continuing to run the app
after an uncaught exception is a dangerous practice and is not
recommended, because the state of the process becomes unreliable
and unpredictable.
Additionally, using
uncaughtException
is officially recognized as
crude. So listening for
uncaughtException
is just a bad idea. This is why we recommend things like
multiple processes and supervisors: crashing and restarting is
often the most reliable way to recover from an error.
We also don’t recommend using domains. It generally doesn’t solve the problem and is a deprecated module.
Use try-catch
Try-catch is a JavaScript language construct that you can use to catch exceptions in synchronous code. Use try-catch, for example, to handle JSON parsing errors as shown below.
Use a tool such as JSHint or JSLint to help you find implicit exceptions like reference errors on undefined variables.
Here is an example of using try-catch to handle a potential process-crashing exception. This middleware function accepts a query field parameter named “params” that is a JSON object.
app.get('/search', function (req, res) {
// Simulating async operation
setImmediate(function () {
var jsonStr = req.query.params
try {
var jsonObj = JSON.parse(jsonStr)
res.send('Success')
} catch (e) {
res.status(400).send('Invalid JSON string')
}
})
})
However, try-catch works only for synchronous code. Because the Node platform is primarily asynchronous (particularly in a production environment), try-catch won’t catch a lot of exceptions.
Use promises
Promises will handle any exceptions (both explicit and implicit)
in asynchronous code blocks that use
then()
. Just
add .catch(next)
to the end of promise chains. For example:
app.get('/', function (req, res, next) {
// do some sync stuff
queryDb()
.then(function (data) {
// handle data
return makeCsv(data)
})
.then(function (csv) {
// handle csv
})
.catch(next)
})
app.use(function (err, req, res, next) {
// handle error
})
Now all errors asynchronous and synchronous get propagated to the error middleware.
However, there are two caveats:
- All your asynchronous code must return promises (except emitters). If a particular library does not return promises, convert the base object by using a helper function like Bluebird.promisifyAll().
- Event emitters (like streams) can still cause uncaught exceptions. So make sure you are handling the error event properly; for example:
- const wrap = fn => (…args) => fn(…args).catch(args[2])
- app.get(‘/’, wrap(async (req, res, next) => { const company = await getCompanyById(req.query.id) const stream = getLogoStreamById(company.id) stream.on(‘error’, next).pipe(res) }))
The
wrap()
function
is a wrapper that catches rejected promises and calls
next()
with the
error as the first argument. For details, see
Asynchronous Error Handling in Express with Promises,
Generators and ES7.
For more information about error-handling by using promises, see Promises in Node.js with Q — An Alternative to Callbacks.
Things to do in your environment / setup
Here are some things you can do in your system environment to improve your app’s performance:
- Set NODE_ENV to “production”
- Ensure your app automatically restarts
- Run your app in a cluster
- Cache request results
- Use a load balancer
- Use a reverse proxy
Set NODE_ENV to “production”
The NODE_ENV environment variable specifies the environment in which an application is running (usually, development or production). One of the simplest things you can do to improve performance is to set NODE_ENV to “production.”
Setting NODE_ENV to “production” makes Express:
- Cache view templates.
- Cache CSS files generated from CSS extensions.
- Generate less verbose error messages.
Tests indicate that just doing this can improve app performance by a factor of three!
If you need to write environment-specific code, you can check
the value of NODE_ENV with
process.env.NODE_ENV
. Be aware that checking the value of any environment variable
incurs a performance penalty, and so should be done sparingly.
In development, you typically set environment variables in your
interactive shell, for example by using
export
or
your .bash_profile
file. But in general you shouldn’t do that on a production
server; instead, use your OS’s init system (systemd or Upstart).
The next section provides more details about using your init
system in general, but setting NODE_ENV is so important for
performance (and easy to do), that it’s highlighted here.
With Upstart, use the
env
keyword in
your job file. For example:
# /etc/init/env.conf
env NODE_ENV=production
For more information, see the Upstart Intro, Cookbook and Best Practices.
With systemd, use the
Environment
directive in your unit file. For example:
# /etc/systemd/system/myservice.service
Environment=NODE_ENV=production
For more information, see Using Environment Variables In systemd Units.
Ensure your app automatically restarts
In production, you don’t want your application to be offline, ever. This means you need to make sure it restarts both if the app crashes and if the server itself crashes. Although you hope that neither of those events occurs, realistically you must account for both eventualities by:
- Using a process manager to restart the app (and Node) when it crashes.
- Using the init system provided by your OS to restart the process manager when the OS crashes. It’s also possible to use the init system without a process manager.
Node applications crash if they encounter an uncaught exception. The foremost thing you need to do is to ensure your app is well-tested and handles all exceptions (see handle exceptions properly for details). But as a fail-safe, put a mechanism in place to ensure that if and when your app crashes, it will automatically restart.
Use a process manager
In development, you started your app simply from the command
line with
node server.js
or something similar. But doing this in production is a recipe
for disaster. If the app crashes, it will be offline until you
restart it. To ensure your app restarts if it crashes, use a
process manager. A process manager is a “container” for
applications that facilitates deployment, provides high
availability, and enables you to manage the application at
runtime.
In addition to restarting your app when it crashes, a process manager can enable you to:
- Gain insights into runtime performance and resource consumption.
- Modify settings dynamically to improve performance.
- Control clustering (StrongLoop PM and pm2).
The most popular process managers for Node are as follows:
For a feature-by-feature comparison of the three process managers, see http://strong-pm.io/compare/. For a more detailed introduction to all three, see Process managers for Express apps.
Using any of these process managers will suffice to keep your application up, even if it does crash from time to time.
However, StrongLoop PM has lots of features that specifically target production deployment. You can use it and the related StrongLoop tools to:
- Build and package your app locally, then deploy it securely to your production system.
- Automatically restart your app if it crashes for any reason.
- Manage your clusters remotely.
- View CPU profiles and heap snapshots to optimize performance and diagnose memory leaks.
- View performance metrics for your application.
- Easily scale to multiple hosts with integrated control for Nginx load balancer.
As explained below, when you install StrongLoop PM as an operating system service using your init system, it will automatically restart when the system restarts. Thus, it will keep your application processes and clusters alive forever.
Cache request results
Another strategy to improve the performance in production is to cache the result of requests, so that your app does not repeat the operation to serve the same request repeatedly.
Use a caching server like Varnish or Nginx (see also Nginx Caching) to greatly improve the speed and performance of your app.
Use a load balancer
No matter how optimized an app is, a single instance can handle only a limited amount of load and traffic. One way to scale an app is to run multiple instances of it and distribute the traffic via a load balancer. Setting up a load balancer can improve your app’s performance and speed, and enable it to scale more than is possible with a single instance.
A load balancer is usually a reverse proxy that orchestrates traffic to and from multiple application instances and servers. You can easily set up a load balancer for your app by using Nginx or HAProxy.
With load balancing, you might have to ensure that requests that are associated with a particular session ID connect to the process that originated them. This is known as session affinity, or sticky sessions, and may be addressed by the suggestion above to use a data store such as Redis for session data (depending on your application). For a discussion, see Using multiple nodes.
Use a reverse proxy
A reverse proxy sits in front of a web app and performs supporting operations on the requests, apart from directing requests to the app. It can handle error pages, compression, caching, serving files, and load balancing among other things.
Handing over tasks that do not require knowledge of application state to a reverse proxy frees up Express to perform specialized application tasks. For this reason, it is recommended to run Express behind a reverse proxy like Nginx or HAProxy in production.


Java Library¶
This page provides information pertaining to AACon Java library usage.
Using the library¶
Note
For impatient please find the complete example below!
To calculate conservation using AACon follow the steps:
- Loading data - Load data
- Initialising the executor - Initialise the executor
- Normalisation - Decide on normalisation
- Setting the conservation methods - Set conservation methods
- Output the results - Output the results
All these steps are discussed in greater details below.
Loading data¶
AACon methods require a List of FastaSequence objects as input. Below is an example of how to load the Fasta formatted sequence file or the Clustal alignment file. For this call to succeed all the sequences must be of the same length (as this is an alignment).
List<FastaSequence> sequences = CmdParser.openInputStream(<PATH_TO_INPUT_FILE>);
For the examples of the input file please see AACon standalone executable help page.
Initialising the executor¶
AACon methods require the ExecutorService object which is used to parallel the calculations. The ExecutorService initialised with the number of threads equals to the number of cores on the executing machine is recommended for a faster calculation and can be obtained as follows:
int corenum = Runtime.getRuntime().availableProcessors();
ExecutorService executor = Executors.newFixedThreadPool(corenum);
Please take care to initialise and pass only one executor to all the methods to avoid the waist of resources. After use, the executor must be disposed of, it can be done as follows:
executor.shutdown();
Normalisation¶
AACon methods require the boolean parameter telling the system whether the results should be normalised or not. Normalised results have values between 0 and 1. Please note however, that some results cannot be normalised. In such a case, the system returns not normalised values, and log the issue to the standard error stream. The following formula is used for normalisation
n = (d - dmin)/(dmax - dmin)
Negative results first converted to positive by adding an absolute value of the most negative result.
Setting the conservation methods¶
AACon ConservationCalculator.getConservation()
method takes a Set of ConservationMethod
to use for calculating the conservation. Below is a few examples of making such sets.
To calculate conservation according to KABAT method construct a set in the following way -
EnumSet.of(ConservationMethod.KABAT).
For all the methods use the following construct -
EnumSet.allOf(ConservationMethod.class)
For a set of methods including KABAT, JORES, SCHNEIDER, SHENKIN and GERSTEIN use the following construct -
EnumSet.range(ConservationMethod.KABAT, ConservationMethod.GERSTEIN)
Output the results¶
The results can be output using one of the following methods:
- ConservationFormatter.formatResults(Map<ConservationMethod, double[]> scores, OutputStream outStream)
- ConservationFormatter.formatResults(Map<ConservationMethod, double[]> scores, String outFilePath, Format format, List<FastaSequence> alignment)
Use the first method to output the results of the calculation without an alignment to any OutputStream. Use the second method to output results with the alignment.
First method usage example:
// Usage example - printing results to the console
ConservationFormatter.outputScoreLine(result, System.out)
// printing results to the file
FileOutputStream outfile = new FileOutputStream("results.txt");
ConservationFormatter.formatResults(result, outfile);
outfile.close();
Second method usage example:
// Usage example - printing results with alignment in Fasta format to the file called output.txt
ConservationFormatter.formatResults(result, "test.txt", Format.RESULT_WITH_ALIGNMENT, sequences);
For more information on the output formats please see standalone AACon help.
Example¶
Using AACon library for calculating conservation:
// Determine the number of CPU cores available on the system.
int corenum = Runtime.getRuntime().availableProcessors();
// Initialize the Executor instance with a number of cores
ExecutorService executor = Executors.newFixedThreadPool(corenum);
// Load the data from the file containing either Clustal formatted alignment
// or a list of FASTA formatted sequences. Assuming that small.align file is
// in the same directory as this program
List<FastaSequence> sequences = CmdParser.openInputStream("small.align");
// Calculate conservation scores using all methods.
Map<ConservationMethod, double[]> result = getConservation(sequences, true,
EnumSet.allOf(ConservationMethod.class)), executor);
// Print the results to the console.
ConservationFormatter.formatResults(result, System.out);


A meeting site based on your personality where you can socialize with new people through 2+ users chat rooms !
Get to know your future friends... or lover.
Join the community now !
Welcome
For who ?
Chat Me Baby is the most popular amongst youngsters and middle-aged single as well as web development teachers.
Thanks to its innovative design and brilliant matching algorithm it will satisfy every user !
Made for you
How to use it ?
Chat Me Baby


{extend name="model"} {block name="js"} {/block} {block name="body"} Home Category Detail Product ¥ {$goods.goods_price} {$goods.goods_name} 2 minutes ago {$type[0]['type']} {$find[1]} {$find[2]} {$find[0]} {$find[1]} {$goods.goods_quality} {volist name="pic" id="a"} {/volist} {$goods.goods_name} {$goods.goods_introduce} More From {$goods.goods_owner} {volist name="more" id="more" length="3"} {$more.goods_name} Today 10.35 am {$type[0]['type']} {$find[1]} {$find[2]} {$find[0]} {$find[1]} {$more.goods_quality} {/volist} Seller {$goods.goods_owner} Location: {$find[1]} {$find[2]} {$find[0]} {$find[1]} Joined : 21 June 2010 Browse by Category 小卡卡贴 (2,342) 专辑海报 (2,342) 明信写真 (2,342) 衣服配饰 (2,342) 限量定制 (2,342) 其余周边 (2,342) Browse by Brand SuperJunior EXO Bigbang TVXQ 李易峰 华晨宇 周杰伦 张杰
{$goods.goods_introduce}
Location: {$find[1]} {$find[2]} {$find[0]} {$find[1]} Joined : 21 June 2010


App package¶
Submodules¶
App.main module¶
-
App.main.
check_adt
()¶ A method to demonstrate possibilities of adt
-
App.main.
display_career_stats
(player_name, label)¶ A method to display given player career stats on given label
- Parameters
player_name (str) – Name of the player
label (tkinter.Label) – Label, where to display
-
App.main.
display_player_injuries
(player_name, label)¶ A method to display given player’s list of injuries on given label
- Parameters
player_name (str) – Name of the player
label (tkinter.Label) – Label, where to display
-
App.main.
display_recent_injuries
(label)¶ A method to display recent injuries on given label
- Parameters
label (tkinter.Label) – Label, where to display
-
App.main.
display_season_stats
(player_name, year, label)¶ A method to display given player’s given season stats on given label
- Parameters
player_name (str) – Name of the player
year (str) – Year, when the season begins
label (tkinter.Label) – Label, where to display
-
App.main.
hide_all_elements
()¶ Hides all the elements, except background
-
App.main.
process_user_input
()¶ A method to get user input and process it
-
App.main.
set_background
()¶ Draws background picture
-
App.main.
show_latest_injuries_page
()¶ Hides current page and shows page for getting last injuries
-
App.main.
show_search_career_stats_page
()¶ Hides current page and shows page for getting player’s career stats
-
App.main.
show_search_injuries_page
()¶ Hides current page and shows page for getting player’s injuries list.
-
App.main.
show_season_stats_page
()¶ Hides current page and shows page for getting player’s season stats
-
App.main.
show_welcome_page
()¶ Hides current page and shows home page
App.player_info module¶
-
class
App.player_info.
PlayerInfo
(name)¶ Bases:
object
A class to get different NBA player’s information
-
find_player_id
()¶ A method to find player’s id
- Parameters
self – self
- Returns
player’s id, found in nba_api
- Return type
if (int)
-
get_career_stats
()¶ A method to get player’s career stats
- Parameters
self – self
- Returns
Dictionary with list of season stats and headers
- Return type
career_stats(dict)
-
get_injuries
()¶ A method to find all player’s injuries
- Parameters
self – self
- Returns
List of injuries, got from csv file
- Return type
injuries(list)
-
get_year_stats
(year)¶ A method to get player’s career stats
- Parameters
self – self
year (int or str) – year, when the season begins
- Returns
Tuple with headers and asked season
- Return type
tuple
-
App.player_info_test module¶
-
class
App.player_info_test.
PlayerInfoTest
¶ Bases:
object
A class with collection of unit tests for PlayerInfo
-
test_with_empty_data
()¶ A method that tests PlayerInfo with empty data (self) -> None
-
test_with_usual_data
()¶ A method that tests PlayerInfo with existed data
-
test_with_wrong_data
()¶ A method that tests PlayerInfo with wrong data
-


You have entered a wrong url. This part of the domain is used as a server for xdgames. Please visit My Home Page


dart:io library
File, socket, HTTP, and other I/O support for non-web applications.
Important: Browser-based applications can't use this library. Only servers, command-line scripts, and Flutter mobile apps can import and use dart:io.
This library allows you to work with files, directories, sockets, processes, HTTP servers and clients, and more. Many operations related to input and output are asynchronous and are handled using Futures or Streams, both of which are defined in the dart:async library.
To use the dart:io library in your code:
import 'dart:io';
For an introduction to I/O in Dart, see the dart:io library tour.
File, Directory, and Link
An instance of File, Directory, or Link represents a file, directory, or link, respectively, in the native file system.
You can manipulate the file system through objects of these types. For example, you can rename a file or directory:
File myFile = new File('myFile.txt');
myFile.rename('yourFile.txt').then((_) => print('file renamed'));
Many methods provided by the File, Directory, and Link classes run asynchronously and return a Future.
FileSystemEntity
File, Directory, and Link all extend FileSystemEntity. In addition to being the superclass for these classes, FileSystemEntity has a number of static methods for working with paths.
To get information about a path, you can use the FileSystemEntity static methods such as 'isDirectory', 'isFile', and 'exists'. Because file system access involves I/O, these methods are asynchronous and return a Future.
FileSystemEntity.isDirectory(myPath).then((isDir) {
if (isDir) {
print('$myPath is a directory');
} else {
print('$myPath is not a directory');
}
});
HttpServer and HttpClient
The classes HttpServer and HttpClient provide HTTP server and HTTP client functionality.
The HttpServer class provides the basic functionality for implementing an HTTP server. For some higher-level building-blocks, we recommend that you try the shelf pub package, which contains a set of high-level classes that, together with the HttpServer class in this library, make it easier to implement HTTP servers.
Process
The Process class provides a way to run a process on
the native machine.
For example, the following code spawns a process that recursively lists
the files under web
.
Process.start('ls', ['-R', 'web']).then((process) {
stdout.addStream(process.stdout);
stderr.addStream(process.stderr);
process.exitCode.then(print);
});
Using start()
returns a Future, which completes with a Process object
when the process has started. This Process object allows you to interact
with the process while it is running. Using run()
returns a Future, which
completes with a ProcessResult object when the spawned process has
terminated. This ProcessResult object collects the output and exit code
from the process.
When using start()
,
you need to read all data coming on the stdout and stderr streams otherwise
the system resources will not be freed.
WebSocket
The WebSocket class provides support for the web socket protocol. This allows full-duplex communications between client and server applications.
A web socket server uses a normal HTTP server for accepting web socket connections. The initial handshake is a HTTP request which is then upgraded to a web socket connection. The server upgrades the request using WebSocketTransformer and listens for the data on the returned web socket. For example, here's a mini server that listens for 'ws' data on a WebSocket:
runZoned(() async {
var server = await HttpServer.bind('<IP_ADDRESS>', 4040);
server.listen((HttpRequest req) async {
if (req.uri.path == '/ws') {
var socket = await WebSocketTransformer.upgrade(req);
socket.listen(handleMsg);
}
});
}, onError: (e) => print("An error occurred."));
The client connects to the WebSocket using the connect()
method
and a URI that uses the Web Socket protocol.
The client can write to the WebSocket with the add()
method.
For example,
var socket = await WebSocket.connect('ws://<IP_ADDRESS>:4040/ws');
socket.add('Hello, World!');
Check out the websocket_sample app, which uses WebSockets to communicate with a server.
Socket and ServerSocket
Clients and servers use Sockets to communicate using the TCP protocol.
Use ServerSocket on the server side and Socket on the client.
The server creates a listening socket using the bind()
method and
then listens for incoming connections on the socket. For example:
ServerSocket.bind('<IP_ADDRESS>', 4041)
.then((serverSocket) {
serverSocket.listen((socket) {
socket.transform(utf8.decoder).listen(print);
});
});
A client connects a Socket using the connect()
method,
which returns a Future.
Using write()
, writeln()
, or writeAll()
are the easiest ways to
send data over the socket.
For example:
Socket.connect('<IP_ADDRESS>', 4041).then((socket) {
socket.write('Hello, World!');
});
Besides Socket and ServerSocket, the RawSocket and RawServerSocket classes are available for lower-level access to async socket IO.
Standard output, error, and input streams
This library provides the standard output, error, and input streams, named 'stdout', 'stderr', and 'stdin', respectively.
The stdout and stderr streams are both IOSinks and have the same set of methods and properties.
To write a string to 'stdout':
stdout.writeln('Hello, World!');
To write a list of objects to 'stderr':
stderr.writeAll([ 'That ', 'is ', 'an ', 'error.', '\n']);
The standard input stream is a true Stream, so it inherits properties and methods from the Stream class.
To read text synchronously from the command line (the program blocks waiting for user to type information):
String inputText = stdin.readLineSync();
Classes
- BytesBuilder
- Builds a list of bytes, allowing bytes and lists of bytes to be added at the end. [...]
- CompressionOptions
- Options controlling compression in a WebSocket. [...]
-
ConnectionTask<
S> -
Returned by the
startConnect
methods on client-side socket typesS
,ConnectionTask<S>
allows cancelling an attempt to connect to a host. - ContentType
- Representation of a content type. An instance of ContentType is immutable.
- Cookie
- Representation of a cookie. For cookies received by the server as Cookie header values only name and value properties will be set. When building a cookie for the 'set-cookie' header in the server and when receiving cookies in the client as 'set-cookie' headers all fields can be used.
- Datagram
- Datagram package. Data sent to and received from datagram sockets contains the internet address and port of the destination or source togeter with the data.
- DetachedSocket
-
When detaching a socket from either the
HttpServer
or theHttpClient
due to a HTTP connection upgrade there might be unparsed data already read from the socket. This unparsed data together with the detached socket is returned in an instance of this class. - Directory
- A reference to a directory (or folder) on the file system. [...]
- File
- A reference to a file on the file system. [...]
- FileLock
- Type of lock when requesting a lock on a file.
- FileMode
- The modes in which a File can be opened.
- FileStat
- A FileStat object represents the result of calling the POSIX stat() function on a file system object. It is an immutable object, representing the snapshotted values returned by the stat() call.
- FileSystemCreateEvent
- File system event for newly created file system objects.
- FileSystemDeleteEvent
- File system event for deletion of file system objects.
- FileSystemEntity
- The common super class for File, Directory, and Link objects. [...]
- FileSystemEntityType
- The type of an entity on the file system, such as a file, directory, or link. [...]
- FileSystemEvent
- Base event class emitted by FileSystemEntity.watch.
- FileSystemModifyEvent
- File system event for modifications of file system objects.
- FileSystemMoveEvent
- File system event for moving of file system objects.
- GZipCodec
- The GZipCodec encodes raw bytes to GZip compressed bytes and decodes GZip compressed bytes to raw bytes. [...]
- HeaderValue
- Representation of a header value in the form: [...]
- HttpClient
- A client that receives content, such as web pages, from a server using the HTTP protocol. [...]
- HttpClientBasicCredentials
- Represents credentials for basic authentication.
- HttpClientCredentials
- HttpClientDigestCredentials
- Represents credentials for digest authentication. Digest authentication is only supported for servers using the MD5 algorithm and quality of protection (qop) of either "none" or "auth".
- HttpClientRequest
- HTTP request for a client connection. [...]
- HttpClientResponse
- HTTP response for a client connection. [...]
- HttpConnectionInfo
- Information about an HttpRequest, HttpResponse, HttpClientRequest, or HttpClientResponse connection.
- HttpConnectionsInfo
- Summary statistics about an HttpServers current socket connections.
- HttpDate
- Utility functions for working with dates with HTTP specific date formats.
- HttpHeaders
- Headers for HTTP requests and responses. [...]
- HttpOverrides
- This class facilitates overriding HttpClient with a mock implementation. It should be extended by another class in client code with overrides that construct a mock implementation. The implementation in this base class defaults to the actual HttpClient implementation. For example: [...]
- HttpRequest
- A server-side object that contains the content of and information about an HTTP request. [...]
- HttpResponse
- An HTTP response, which returns the headers and data from the server to the client in response to an HTTP request. [...]
- HttpServer
- A server that delivers content, such as web pages, using the HTTP protocol. [...]
- HttpSession
- HttpStatus
- HTTP status codes. Exported in dart:io and dart:html.
- InternetAddress
- An internet address. [...]
- InternetAddressType
- InternetAddressType is the type an InternetAddress. Currently, IP version 4 (IPv4) and IP version 6 (IPv6) are supported.
- IOOverrides
- This class facilitates overriding various APIs of dart:io with mock implementations. [...]
- IOSink
- A combined byte and text output. [...]
- Link
- Link objects are references to filesystem links.
- NetworkInterface
- A NetworkInterface represents an active network interface on the current system. It contains a list of InternetAddresses that are bound to the interface.
- OSError
- An OSError object holds information about an error from the operating system.
- Platform
- Information about the environment in which the current program is running. [...]
- Process
- The means to execute a program. [...]
- ProcessInfo
- ProcessInfo provides methods for retrieving information about the current process.
- ProcessResult
- ProcessResult represents the result of running a non-interactive process started with Process.run or Process.runSync.
- ProcessSignal
-
On Posix systems, ProcessSignal is used to send a specific signal
to a child process, see
Process.kill
. [...] - ProcessStartMode
- Modes for running a new process.
- RandomAccessFile
-
RandomAccessFile
provides random access to the data in a file. [...] - RawDatagramSocket
- A RawDatagramSocket is an unbuffered interface to a UDP socket. [...]
- RawSecureServerSocket
- The RawSecureServerSocket is a server socket, providing a stream of low-level RawSecureSockets. [...]
- RawSecureSocket
- RawSecureSocket provides a secure (SSL or TLS) network connection. Client connections to a server are provided by calling RawSecureSocket.connect. A secure server, created with RawSecureServerSocket, also returns RawSecureSocket objects representing the server end of a secure connection. The certificate provided by the server is checked using the trusted certificates set in the SecurityContext object. The default SecurityContext object contains a built-in set of trusted root certificates for well-known certificate authorities.
- RawServerSocket
- A RawServerSocket represents a listening socket, and provides a stream of low-level RawSocket objects, one for each connection made to the listening socket. [...]
- RawSocket
- A RawSocket is an unbuffered interface to a TCP socket. [...]
- RawSocketEvent
- Events for the RawSocket.
- RawSocketOption
- The RawSocketOption is used as a parameter to Socket.setRawOption and RawSocket.setRawOption to set customize the behaviour of the underlying socket. [...]
- RawSynchronousSocket
- A low-level class for communicating synchronously over a TCP socket. [...]
- RawZLibFilter
- The RawZLibFilter class provides a low-level interface to zlib.
- RedirectInfo
- Redirect information.
- SecureServerSocket
- The SecureServerSocket is a server socket, providing a stream of high-level Sockets. [...]
- SecureSocket
- A high-level class for communicating securely over a TCP socket, using TLS and SSL. The SecureSocket exposes both a Stream and an IOSink interface, making it ideal for using together with other Streams.
- SecurityContext
- The object containing the certificates to trust when making a secure client connection, and the certificate chain and private key to serve from a secure server. [...]
- ServerSocket
- A ServerSocket represents a listening socket, and provides a stream of Socket objects, one for each connection made to the listening socket. [...]
- Socket
- A high-level class for communicating over a TCP socket. [...]
- SocketDirection
- The SocketDirection is used as a parameter to Socket.close and RawSocket.close to close a socket in the specified direction(s).
- SocketOption
- The SocketOption is used as a parameter to Socket.setOption and RawSocket.setOption to set customize the behaviour of the underlying socket.
- Stdin
- Stdin allows both synchronous and asynchronous reads from the standard input stream. [...]
- StdioType
- The type of object a standard IO stream is attached to.
- Stdout
-
Stdout represents the IOSink for either
stdout
orstderr
. [...] - SystemEncoding
- The system encoding is the current code page on Windows and UTF-8 on Linux and Mac.
- WebSocket
- A two-way HTTP communication object for client or server applications. [...]
- WebSocketStatus
- WebSocket status codes used when closing a WebSocket connection.
- WebSocketTransformer
- The WebSocketTransformer provides the ability to upgrade a HttpRequest to a WebSocket connection. It supports both upgrading a single HttpRequest and upgrading a stream of HttpRequests. [...]
- X509Certificate
- X509Certificate represents an SSL certificate, with accessors to get the fields of the certificate.
- ZLibCodec
- The ZLibCodec encodes raw bytes to ZLib compressed bytes and decodes ZLib compressed bytes to raw bytes.
- ZLibDecoder
- The ZLibDecoder is used by ZLibCodec and GZipCodec to decompress data.
- ZLibEncoder
- The ZLibEncoder encoder is used by ZLibCodec and GZipCodec to compress data.
- ZLibOption
- Exposes ZLib options for input parameters. [...]
Constants
- APPEND → const FileMode
-
The mode for opening a file for reading and writing to the
end of it. The file is created if it does not already exist.
@Deprecated("Use FileMode.append instead")
FileMode.append
- GZIP → const GZipCodec
-
@Deprecated("Use gzip instead")
gzip
- gzip → const GZipCodec
-
An instance of the default implementation of the GZipCodec.
const GZipCodec._default()
- READ → const FileMode
-
The mode for opening a file only for reading.
@Deprecated("Use FileMode.read instead")
FileMode.read
- SYSTEM_ENCODING → const SystemEncoding
-
@Deprecated("Use systemEncoding instead")
const SystemEncoding()
- systemEncoding → const SystemEncoding
-
The current system encoding. [...]
const SystemEncoding()
- WRITE → const FileMode
-
The mode for opening a file for reading and writing. The file is
overwritten if it already exists. The file is created if it does not
already exist.
@Deprecated("Use FileMode.write instead")
FileMode.write
- WRITE_ONLY → const FileMode
-
Mode for opening a file for writing only. The file is
overwritten if it already exists. The file is created if it does not
already exist.
@Deprecated("Use FileMode.writeOnly instead")
FileMode.writeOnly
- WRITE_ONLY_APPEND → const FileMode
-
Mode for opening a file for writing only to the
end of it. The file is created if it does not already exist.
@Deprecated("Use FileMode.writeOnlyAppend instead")
FileMode.writeOnlyAppend
- ZLIB → const ZLibCodec
-
@Deprecated("Use zlib instead")
zlib
- zlib → const ZLibCodec
-
An instance of the default implementation of the ZLibCodec.
const ZLibCodec._default()
Properties
- exitCode ↔ int
-
Get the global exit code for the Dart VM. [...]
read / write
- pid → int
-
Returns the PID of the current process.
read-only
- stderr → Stdout
-
The standard output stream of errors written by this program. [...]
read-only
- stdin → Stdin
-
The standard input stream of data read by this program.
read-only
- stdout → Stdout
-
The standard output stream of data written by this program. [...]
read-only
Functions
-
exit(
int code) → void - Exit the Dart VM process immediately with the given exit code. [...]
-
sleep(
Duration duration) → void -
Sleep for the duration specified in
duration
. [...] -
stdioType(
dynamic object) → StdioType - For a stream, returns whether it is attached to a file, pipe, terminal, or something else.
Enums
- HttpClientResponseCompressionState
- Enum that specifies the compression state of the byte stream of an HttpClientResponse. [...]
Typedefs
-
BadCertificateCallback(
X509Certificate cr, String host, int port) → bool
Exceptions / Errors
- CertificateException
- An exception that happens in the handshake phase of establishing a secure network connection, when looking up or verifying a certificate.
- FileSystemException
- Exception thrown when a file operation fails.
- HandshakeException
- An exception that happens in the handshake phase of establishing a secure network connection.
- HttpException
- IOException
- Base class for all IO related exceptions.
- ProcessException
- RedirectException
- SignalException
- SocketException
- StdinException
- StdoutException
- TlsException
- A secure networking exception caused by a failure in the TLS/SSL protocol.
- WebSocketException


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use org.hornetq.api.core | |
|---|---|
| org.hornetq.api.core | Core Messaging API. |
| org.hornetq.api.core.client | Core Client Messaging API. |
| org.hornetq.api.core.management | Management API for HornetQ servers and its Core resources. |
| org.hornetq.api.jms | API to create HornetQ JMS resources. |
| org.hornetq.api.jms.management | Management API for HornetQ JMS resources. |
| org.hornetq.spi.core.protocol | |
| org.hornetq.spi.core.remoting | Remoting SPI. |
| Classes in org.hornetq.api.core used by org.hornetq.api.core | |
|---|---|
| HornetQBuffer
A HornetQBuffer wraps a Netty's ChannelBuffer and is used throughout HornetQ code base. |
|
| HornetQException
HornetQException is the root exception for HornetQ API. |
|
| PropertyConversionException
A PropertyConversionException is thrown by Message methods when a property can not be converted to the expected type. |
|
| SimpleString
A simple String class that can store all characters, and stores as simple byte[], this minimises expensive copying between String objects. |
| Classes in org.hornetq.api.core used by org.hornetq.api.core.client | |
|---|---|
| HornetQException
HornetQException is the root exception for HornetQ API. |
|
| Interceptor
This is class is a simple way to intercepting calls on HornetQ client and servers. |
|
| Message
A Message is a routable instance that has a payload. |
|
| Pair
A Pair is a holder for 2 objects. |
|
| SimpleString
A simple String class that can store all characters, and stores as simple byte[], this minimises expensive copying between String objects. |
|
| TransportConfiguration
A TransportConfiguration is used by a client to specify a connections to a server and its backup if one exists. Typically the constructors take the class name and parameters for needed to create the connection. |
| Classes in org.hornetq.api.core used by org.hornetq.api.core.management | |
|---|---|
| Message
A Message is a routable instance that has a payload. |
|
| SimpleString
A simple String class that can store all characters, and stores as simple byte[], this minimises expensive copying between String objects. |
| Classes in org.hornetq.api.core used by org.hornetq.api.jms | |
|---|---|
| Pair
A Pair is a holder for 2 objects. |
|
| TransportConfiguration
A TransportConfiguration is used by a client to specify a connections to a server and its backup if one exists. Typically the constructors take the class name and parameters for needed to create the connection. |
| Classes in org.hornetq.api.core used by org.hornetq.api.jms.management | |
|---|---|
| Pair
A Pair is a holder for 2 objects. |
|
| TransportConfiguration
A TransportConfiguration is used by a client to specify a connections to a server and its backup if one exists. Typically the constructors take the class name and parameters for needed to create the connection. |
| Classes in org.hornetq.api.core used by org.hornetq.spi.core.protocol | |
|---|---|
| HornetQBuffer
A HornetQBuffer wraps a Netty's ChannelBuffer and is used throughout HornetQ code base. |
|
| HornetQException
HornetQException is the root exception for HornetQ API. |
|
| Interceptor
This is class is a simple way to intercepting calls on HornetQ client and servers. |
|
| SimpleString
A simple String class that can store all characters, and stores as simple byte[], this minimises expensive copying between String objects. |
| Classes in org.hornetq.api.core used by org.hornetq.spi.core.remoting | |
|---|---|
| HornetQBuffer
A HornetQBuffer wraps a Netty's ChannelBuffer and is used throughout HornetQ code base. |
|
| HornetQException
HornetQException is the root exception for HornetQ API. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


In this crazy life
You can erase
But you won't copy and paste
Chapters
Pages
Sentences
Words
Characters.
They may repeat themselves
But in each shadow of a font
It lies either
An hidden filth or
A quiet magic
That differentiates
That hierarchises
Highlighting and lifting the hidden exceptional
From the loud degenerates.
It's singularity:
In it's specificity,
In the way it's written,
A single word
Changes the rhythm
The theme and track
Of a whole book.
And Life
It is a book
Handwritten
With Permanent Ink.
Each word
Even repeated
Is different
And some of them
For some weird reason
Just big bangs
Your life.


Blog:
11/16/14
Asking Good Questions
I just read Jon Skeet’s post on asking questions on stack overflow. He outlines the importance of using the title to frame the question and of providing context to help someone understand the problem.
When confused it can be difficult to explain exactly where you got lost. That’s part of the problem. I personally can have the tendency to be vague out of frustration or to overload the person I am asking with information. Jon Skeet outlines the importance of giving context in a controlled thoughtful way and to phrase your question in a straight forward way that broadly contains your intent without getting lost in details right away.
A strategy I often use is to include my best guess along with my question. I find that this can help to elucidate my thought process to someone and help them figure out where it went wrong.


QHeightMapSurfaceDataProxy Class
Base proxy class for Q3DSurface. More...
| Header: | #include <QHeightMapSurfaceDataProxy> |
| Since: | QtDataVisualization 1.0 |
| Instantiated By: | HeightMapSurfaceDataProxy |
| Inherits: | QSurfaceDataProxy |
Properties
|
- 3 properties inherited from QSurfaceDataProxy
- 1 property inherited from QAbstractDataProxy
- 1 property inherited from QObject
Public Functions
| QHeightMapSurfaceDataProxy(QObject *parent = Q_NULLPTR) | |
| QHeightMapSurfaceDataProxy(const QImage &image, QObject *parent = Q_NULLPTR) | |
| QHeightMapSurfaceDataProxy(const QString &filename, QObject *parent = Q_NULLPTR) | |
| virtual | ~QHeightMapSurfaceDataProxy() |
| QImage | heightMap() const |
| QString | heightMapFile() const |
| float | maxXValue() const |
| float | maxZValue() const |
| float | minXValue() const |
| float | minZValue() const |
| void | setHeightMap(const QImage &image) |
| void | setHeightMapFile(const QString &filename) |
| void | setMaxXValue(float max) |
| void | setMaxZValue(float max) |
| void | setMinXValue(float min) |
| void | setMinZValue(float min) |
| void | setValueRanges(float minX, float maxX, float minZ, float maxZ) |
- 16 public functions inherited from QSurfaceDataProxy
- 1 public function inherited from QAbstractDataProxy
- 32 public functions inherited from QObject
Signals
| void | heightMapChanged(const QImage &image) |
| void | heightMapFileChanged(const QString &filename) |
| void | maxXValueChanged(float value) |
| void | maxZValueChanged(float value) |
| void | minXValueChanged(float value) |
| void | minZValueChanged(float value) |
- 9 signals inherited from QSurfaceDataProxy
- 2 signals inherited from QObject
Additional Inherited Members
- 1 public slot inherited from QObject
- 1 public variable inherited from QObject
- 10 static public members inherited from QObject
- 9 protected functions inherited from QObject
- 2 protected variables inherited from QObject
Detailed Description
Base proxy class for Q3DSurface.
QHeightMapSurfaceDataProxy takes care of surface related height map data handling. It provides a way to give a height map to be visualized as a surface plot.
Since height maps do not contain values for X or Z axes, those values need to be given separately using minXValue, maxXValue, minZValue, and maxZValue properties. X-value corresponds to image horizontal direction and Z-value to the vertical. Setting any of these properties triggers asynchronous re-resolving of any existing height map.
See also QSurfaceDataProxy and Qt Data Visualization Data Handling.
Property Documentation
heightMap : QImage
This property holds the height map image to be visualized.
Access functions:
| QImage | heightMap() const |
| void | setHeightMap(const QImage &image) |
Notifier signal:
| void | heightMapChanged(const QImage &image) |
heightMapFile : QString
This property holds the name of the file with a height map image to be visualized.
Access functions:
| QString | heightMapFile() const |
| void | setHeightMapFile(const QString &filename) |
Notifier signal:
| void | heightMapFileChanged(const QString &filename) |
maxXValue : float
This property holds the maximum X value for the generated surface points.
Defaults to 10.0
.
When setting this property the corresponding minimum value is adjusted if necessary, to ensure that the range remains valid.
Access functions:
| float | maxXValue() const |
| void | setMaxXValue(float max) |
Notifier signal:
| void | maxXValueChanged(float value) |
maxZValue : float
This property holds the maximum Z value for the generated surface points.
Defaults to 10.0
.
When setting this property the corresponding minimum value is adjusted if necessary, to ensure that the range remains valid.
Access functions:
| float | maxZValue() const |
| void | setMaxZValue(float max) |
Notifier signal:
| void | maxZValueChanged(float value) |
minXValue : float
This property holds the minimum X value for the generated surface points.
Defaults to 0.0
.
When setting this property the corresponding maximum value is adjusted if necessary, to ensure that the range remains valid.
Access functions:
| float | minXValue() const |
| void | setMinXValue(float min) |
Notifier signal:
| void | minXValueChanged(float value) |
minZValue : float
This property holds the minimum Z value for the generated surface points.
Defaults to 0.0
.
When setting this property the corresponding maximum value is adjusted if necessary, to ensure that the range remains valid.
Access functions:
| float | minZValue() const |
| void | setMinZValue(float min) |
Notifier signal:
| void | minZValueChanged(float value) |
Member Function Documentation
QHeightMapSurfaceDataProxy::QHeightMapSurfaceDataProxy(QObject *parent = Q_NULLPTR)
Constructs QHeightMapSurfaceDataProxy with the given parent.
QHeightMapSurfaceDataProxy::QHeightMapSurfaceDataProxy(const QImage &image, QObject *parent = Q_NULLPTR)
Constructs QHeightMapSurfaceDataProxy with the given image and parent. Height map is set by calling setHeightMap() with image.
See also heightMap.
QHeightMapSurfaceDataProxy::QHeightMapSurfaceDataProxy(const QString &filename, QObject *parent = Q_NULLPTR)
Constructs QHeightMapSurfaceDataProxy from the given image filename and parent. Height map is set by calling setHeightMapFile() with filename.
See also heightMapFile.
[virtual]
QHeightMapSurfaceDataProxy::~QHeightMapSurfaceDataProxy()
Destroys QHeightMapSurfaceDataProxy.
void QHeightMapSurfaceDataProxy::setHeightMap(const QImage &image)
Replaces current data with the height map data specified by image.
There are several formats the image can be given in, but if it is not in a directly usable format, a conversion is made.
Note: If the result seems wrong, the automatic conversion failed and you should try converting the image yourself before setting it. Preferred format is QImage::Format_RGB32 in grayscale.
The height of the image is read from the red component of the pixels if the image is in grayscale, otherwise it is an average calculated from red, green, and blue components of the pixels. Using grayscale images may improve data conversion speed for large images.
Not recommended formats: all mono formats (for example QImage::Format_Mono).
The height map is resolved asynchronously. QSurfaceDataProxy::arrayReset() is emitted when the data has been resolved.
Note: Setter function for property heightMap.
See also heightMap().
void QHeightMapSurfaceDataProxy::setHeightMapFile(const QString &filename)
Replaces current data with height map data from the file specified by filename.
Note: Setter function for property heightMapFile.
See also heightMapFile() and heightMap.
void QHeightMapSurfaceDataProxy::setValueRanges(float minX, float maxX, float minZ, float maxZ)
A convenience function for setting all minimum (minX and minZ) and maximum (maxX and maxZ) values at the same time. The minimum values must be smaller than the corresponding maximum value. Otherwise the values get adjusted so that they are valid.


HISTEX- triprolidine hydrochloride syrup
Allegis Pharmaceuticals, LLC
Disclaimer: Most OTC drugs are not reviewed and approved by FDA, however they may be marketed if they comply with applicable regulations and policies. FDA has not evaluated whether this product complies.
temporarily relieves these symptoms due to hay fever (allergic rhinitis) or other upper respiratory allergies:
Do not exceed recommended dosage.
Ask a doctor before use if you are taking sedatives or tranquilizers
Do not exceed recommended dosage.
| AGE | DOSE |
|---|---|
| Adults and Childen 12 years of age and older: | 1 teaspoonful (5 mL) every 4 to 6 hours, not to exceed 4 teaspoonfuls (20 mL) in 24 hours, or as directed by a doctor |
| Childen 6 to under 12 years of age | ½ teaspoonful (2.5 mL) every 4 to 6 hours, not to exceed 2 teaspoonfuls (10 mL) in 24 hours, or as directed by a doctor. |
| Children under 6 years of age | Consult a doctor |
Store at 15°-30° C (59°-86° F).
Tamper evident by foil seal under cap. Do not use if foil seal is missing or broken.
Dispense in a tight, light-resistant container with a child-resistant cap.
|
HISTEX
triprolidine hydrochloride syrup | ||||||||||||||||||
| ||||||||||||||||||
| ||||||||||||||||||
| ||||||||||||||||||
| ||||||||||||||||||
| ||||||||||||||||||
|
| Labeler - Allegis Pharmaceuticals, LLC (792272861) |


Britain's first gay dad 'plans to have twins with his daughter's ex-boyfriend'
Barrie Drewitt-Barlow, 50, has split from his husband Tony and started a relationship with his daughter's 25-year-old ex-boyfriend Scott Hutchinson - the trio all live under the same roof in an 'unorthodox' set-up
by Matthew Dresch, https://www.mirror.co.uk/authors/matthew-dresch/One of the UK's first gay dads is planning to have twin girls with a man who once dated his daughter, according to a report.
Barrie Drewitt-Barlow recently split from his husband Tony, 55, after falling in love with 25-year-old Scott Hutchinson.
The 50-year-old now wants to have daughters with his new partner through a surrogate mother.
Mr Hutchinson was previously in a relationship with Mr Drewitt-Barlow's 19-year-old daughter Saffron.
In a bizarre twist, the Drewitt-Barlows and Mr Hutchinson all currently live under the same roof.
Mr Drewitt-Barlow said the set-up was 'unorthodox', however, he insisted it worked for his family.
He told Mail Online : "I don't want there to be any secrets and I want to get any negativity out of the way before our babies arrive."
"Yes, it is unorthodox, but we are a loving family and our priority is to have a stable home for our kids and what is now an extended family.
"It works for us – and if people are shocked, well that's their problem not ours."
Mr Drewitt-Barlow and Tony were registered as parents in 1999 and lived in luxury in Florida, US, after making millions through their surrogate business.
He has been in a platonic relationship with Tony since his cancer diagnosis in 2006.
The businessman developed feelings for his assistant Mr Hutchinson when his husband was going through treatment.

Mr Drewitt-Barlow now hopes to have twin daughters with his new partner, choosing their sex through IVF.
Tony fully supports their plans and is set to become the children's godfather, Mail Online reports.


Getting API metadata.. API metadata loaded
Processing operations from metadata... Processed operations
Meta-KG
Search for API operations given a combination of input, output(s), and/or predicates.
An example would be: all operations where the predicate is "treats" and its output is a "Disease".


Please select the type of Reading you would like
to have from the following drop-down menu. *
If you would like to choose your own personal Psychic,
Reader, Astrologer, or Numerologist from the list of our
Readers, please check the button at the right of this
window and type in their name here:
(If you leave this blank, we will choose the Reader for you) *


{% trans 'Your new password has been set. You can log in now on the' %} {% trans 'log in page' %}.
{% extends 'base_layout.html' %} {% load i18n %} {% load bulma_tags %} {% block title %}{% trans 'Password reset complete' %}{% endblock %} {% block content %}
{% trans 'Your new password has been set. You can log in now on the' %} {% trans 'log in page' %}.


Below are unit test results for the directives. To see examples of these directives in use, launch the Examples Page


- Accelerated Mobile Pages Advanced Concepts
- Accelerated Mobile Pages Foundations
- Achieving Single Sign-on with AppAuth
- AdMob Native Advanced Ads in an Android Feed
- AdMob Native Advanced Ads in an iOS Feed
- Add Rewarded Video Ads to your Android App
- Add Rewarded Video Ads to your iOS App
- Add Voice Interactions to Your App
- Add Your Web App to a User's Home Screen
- Adding Complications to your Android Wear Watch Face
- Adding Leanback to your Android TV app
- Adding Push Notifications to a Web App
- Adding a Service Worker and Offline into your Web App
- Adding a Service Worker with sw-precache
- Advanced Interactivity in AMP
- Agera: reactive Android apps
- An Introduction to Web Assembly
- Android & TensorFlow: Artistic Style Transfer
- Android N: Quick Settings
- Android Network Security Configuration Codelab
- Android Paging codelab
- Android Persistence codelab
- Android Room with a View
- Android TV Games in Unity
- Android Testing Codelab
- Android Things Assistant
- Android Things Image Classifier
- Android Things Peripheral I/O
- Android Things Weather Station
- Android VTS v9 . 0 Codelab
- Android Wear Always-on Application
- Android lifecycle-aware components codelab
- Application Performance Management (APM) with Stackdriver
- Artistic style transfer & other advanced image editing
- Auto Backup for Android codelab
- Autocomplete To Improve Your Forms
- Automated Performance Testing Codelab
- Awwvision: Cloud Vision API from a Kubernetes Cluster
- Background Location Updates in Android "O"
- Barcode Detection with the Mobile Vision API
- Basic Android Accessibility : making sure everyone can use what you create!
- Basics of Angular
- Basics of TypeScript
- Batch load Wikimedia CSV data into BigQuery
- Beautiful, interactive, canonical AMP pages
- Build Applications for Single-Use Devices
- Build Google Maps Using Web Components & No Code!
- Build Your First Android App in Java
- Build Your First Android App in Kotlin
- Build a Database Web App in App Maker
- Build a Material Design App with the Android Design Support Library
- Build a Mobile-First Google Drive Client
- Build a Node.js & Angular 2 Web App using Google Cloud Platform
- Build a Node.js Web App using Google Cloud Platform
- Build a PWA using Workbox
- Build a Progressive Web AMP
- Build a Progressive Web App with Firebase, Polymerfire and Polymer Components
- Build a Slack Bot with Node.js on Kubernetes
- Build a Thread network with nRF52840 boards and OpenThread
- Build an AngularDart & Firebase Web App
- Build an App with Architecture Components
- Build an ES2015/ES6 app with the Polymer Starter Kit
- Build an Offline Weather Web App with <platinum-sw>
- Build an offline-first, driven PWA
- Build and Deploy a Polymer 2.0 App From Scratch
- Build and Launch Spring Boot Java-based Web Application from Google Cloud Shell
- Build and launch an ASP.NET Core app from Google Cloud Shell
- Build your First Android Instant App
- Build your first ES2015/ES6 application
- Build your first Polymer element
- Building Apps that Sign In with Google
- Building Beautiful Apps Faster with Material Components on Android
- Building Beautiful Apps Faster with Material Components on Android (Kotlin)
- Building Beautiful Apps Faster with Material Components on iOS
- Building Beautiful Apps Faster with Material Components on iOS in Swift
- Building Beautiful Sites Faster with Material Components for the web
- Building Beautiful UIs with Flutter
- Building Custom Overlays
- Building a Progressive Web App in Polymer from scratch
- Building a Serverless Data Pipeline: IoT to Analytics
- Building a gRPC service with C#
- Building a gRPC service with Java
- Building a gRPC service with Node.js
- Building an Image Carousel Element with Polymer 2.0
- Building rich web apps with Lovefield
- Building for VR on the Web
- Buy and Subscribe: Monetize your app on Google Play
- Caching with progressive libraries
- Cast SDK v3 Android Codelab
- Cast SDK v3 iOS Codelab
- Chromecast elements
- Chromecast elements
- Classify Text into Categories with the Natural Language API
- Classify images of clouds in the cloud with AutoML Vision
- Cloud Datalab の起動（日本語版）
- Cloud Firestore Android Codelab
- Cloud Firestore Web Codelab
- Cloud Firestore iOS Codelab
- Cloud Functions for Firebase
- Cloud Functions for Firebase (Angular)
- Codelab: Querying and Visualising Location Data in BigQuery using Google Maps API
- Compute Engine & Kubernetes (Container Engine)
- Compute the Cosmos with Google Compute Engine
- Configure an Uptime Check and Alerting Policy
- Continuous Delivery to Kubernetes Using Spinnaker
- Control Nest Devices using a Web App
- Control a PLAYBULB candle with Web Bluetooth
- Convert an app to Workbox from sw-precache and sw-toolbox
- Crafting a Character: Design an engaging Assistant app
- Create Hello-CMake with Android Studio
- Create Hello-JNI with Android Studio
- Create a Managed MySQL database with Cloud SQL
- Create a watchface for Android Wear
- Create custom rendered native ads
- Creating Virtual Controllers with Nearby Connections
- Creating a Persistent Disk
- Creating a Virtual Machine
- Creating a web application with App Maker
- Creating and Linking AdWords and Merchant Center Sub-accounts
- Creating your first AMP Component
- Customize Network Topology with Subnetworks
- Dart + Angular: Try the Tech Stack Powering the Next Generation of AdWords
- Data Visualization Using Polymer and WebGL
- Debugging Service Workers
- Deeper Content Integration with the New Android TV Home Screen
- Deploy ASP.NET Core app to Kubernetes on Google Kubernetes Engine
- Deploy ASP.NET app to Windows Server on Compute Engine
- Deploy Instances and Apps by Console and Command-Line
- Deploy Microsoft SQL Server to Compute Engine
- Deploy Node.js Express Application in App Engine
- Deploy Spring Boot Application in App Engine standard
- Deploy Windows Server with ASP.NET Framework to Compute Engine
- Deploy Your Infrastructure Using Deployment Manager
- Deploy a Java application to Kubernetes on Google Kubernetes Engine
- Deploy a Ruby on Rails app to App Engine Flexible Environment
- Deploy an ASP.NET Core app to App Engine
- Deploying a Python Flask Web Application to App Engine Flexible
- Deprecated: Echo with Android Howie Library
- Detect Labels, Faces, and Landmarks in Images with the Cloud Vision API
- Developing an Accessibility Service for Android
- Displaying Video and UI in Daydream
- Distributed tracing with Spring Cloud Sleuth and Stackdriver Trace
- Dynamic configuration for Spring Boot applications using Spring Cloud GCP Config starter
- Easy Checkout Forms with Autofill & <gold-elements>
- Enable Deep Linking to your App
- Enabling auto sign-in with the Credential Management API
- Encrypt a Java application with Cloud KMS
- End-to-end Machine Learning with Tensorflow on GCP
- Entity, Sentiment, and Syntax Analysis with the Natural Language API
- Exposing data to watch face Complications on Android Wear
- Extending messaging apps for cars and Wear
- Face Detection with the Mobile Vision API
- Facts about You: Build a conversational app for the Google Assistant
- Federated Clusters and Global Ingress with Kubernetes
- Find and Fix Web App Performance Issues
- Firebase Android Codelab
- Firebase App Indexing Android API: Logging User Actions and Getting Personal Content into Search
- Firebase App Quality Codelab Objective-C
- Firebase App Quality Codelab Swift
- Firebase Web Codelab
- Firebase for Flutter
- Firebase iOS Codelab Objective-C
- Firebase iOS Codelab Swift
- Frictionless payment with Payment Request API
- GCS (Google Cloud Storage) Demo Lab
- Get your app ready for Doze and App Standby
- Getting Started with App Engine (Python)
- Getting Started with Chatbase chatbot analytics
- Getting Started with Cloud KMS
- Getting Started with Cloud Shell & gcloud
- Getting Started with Endpoints Frameworks on App Engine
- Getting Started with Happy and Weave
- Getting started with VR View for Android
- Getting started with VR view for HTML
- Getting your app ready for Android N
- Gmail Add-ons
- Going Places with Android
- Good App Citizenship with Intents
- Google Cast Game Manager API Codelab
- Google Cast Remote Display Plugin For Unity Codelab
- Google Cloud Speech API : Node.js example
- Google Maps Web Services Proxy for Mobile Applications
- Hands-on with Google Apps Script: accessing Google Sheets, Maps & Gmail in 4 lines of code!
- Hangouts Chat bot with Apps Script
- Hello Istio Codelab (with Google Kubernetes Engine)
- Hello Node Kubernetes Codelab
- Hello, Beacons! Proximity & Context-aware Apps
- High performance video for the mobile web
- How to Contribute to the Web Components ecosystem
- IMA SDK for HTML5 Codelab
- Image Classification Transfer Learning with Inception v3
- Image Classification Using Cloud ML Engine & Datalab
- Image Styling with Web Components
- Inicie Cloud Datalab en Español
- Install and use Cloud Tools for PowerShell
- Install and use Cloud Tools for Visual Studio
- Instrumenting your Android App with Google Analytics for Firebase
- Integrating Android Pay on Mobile Web
- Interact with Bluetooth devices on the Web with Polymer
- Interacting with data using the <firebase-element>
- Interacting with the Daydream Controller Touchpad
- Intro to Dart for Java Developers
- Introduction to ARCore in Unity
- Introduction to Cloud Dataproc: Hadoop and Spark on Google Cloud Platform
- Introduction to Permissions API
- Keep Sensitive Data Safe and Private
- Launch Cloud Datalab
- Learning to use Blockly iOS
- Learning to use Blockly on the Web
- Load and Analyze Data in BigQuery
- Looking at campaign finance with BigQuery
- Making More Waves - Sampler
- Making Waves Part 1 - Build a Synthesizer
- Manage your APIs using Apigee Edge - Protect your API from Traffic Spikes
- Manage your Pivotal Cloud Foundry App's using Apigee Edge
- Mapping the NYC Subway
- Measuring Critical Performance Metrics with Google Analytics
- Media streaming with ExoPlayer
- Messaging with Spring Integration and Google Cloud Pub/Sub
- Monetization from Good to Great with Firebase, in 10 mins
- Monitoring Cloud Infrastructure with Stackdriver
- Navigation and Actions with Wear 2.0
- Nest Cam & TensorFlow Codelab
- Nest – 10 tips for your successful integration
- Network Manager In Your App
- Networking 101
- Networking 102
- Notification Channels and Badges (Java)
- Notification Channels and Badges (Kotlin)
- Open an Account and Manage Billing and Projects
- Open an Account and Manage Billing and Projects
- Optimize your app for autofill
- Optimizing 3D data with Draco Geometry Compression
- Optimizing video quality with VP9 video compression
- Orchestrating the Cloud with Kubernetes
- PRPL with Custom Elements and Firebase
- Performant Expand & Collapse Animations
- Personalize your Android App with Firebase User Management
- Personalize your iOS App with Firebase User Management
- Picking, Pushing, and Throwing with the Daydream Controller
- Play Game Services in Unity
- Playing music on cars and wearables
- Provision Services with Cloud Launcher
- Provisioning and Using a Managed Hadoop/Spark Cluster with Cloud Dataproc (Command Line)
- Query Github Data Using BigQuery
- Query the Wikipedia dataset in BigQuery
- Quickstart: Get started with multi-cloud billing
- Quickstart: Get started with white-label marketplaces
- Raise engagement on Android TV by integrating with the Play Next row
- Reading and Writing Files with Spring Resource Abstraction for Google Cloud Storage
- Real time communication with WebRTC
- Real-time Asset Tracking
- Removing dependencies on background services
- Run a Big Data Text Processing Pipeline in Cloud Dataflow
- Running Node.js on a Virtual Machine
- Running Windows Containers on Compute Engine
- Running WordPress on App Engine Flexible Environment
- Running a Container in Kubernetes with Container Engine
- Running a MongoDB Database in Kubernetes with StatefulSets
- Running a Node.js Container in Kubernetes with Container Engine
- Running a Spark Application with OpenCV on Cloud Dataproc
- Scale and Load Balance Instances and Apps
- Seamless Sign In with Smart Lock
- Secure Instances and Apps with Custom Networks
- Secure On-premise to Hybrid LAMP Stack Migration
- See and Understand Text using OCR with Mobile Vision Text API for Android
- Serverless Machine Learning
- Setup Network and HTTP Load Balancers
- Simple Store Locator with Google Maps
- Simulating a Thread network using OpenThread
- Slides API
- Speaking with a Webpage - Streaming speech transcripts
- Speech to Text Transcription with the Cloud Speech API
- Speedy Mobile Checkout with Android Pay
- Spin Up Instances and Check Connectivity
- Spring Pet Clinic using Cloud SQL
- Stackdriver: Qwik Start
- Structured Data Regression Using Cloud ML Engine & Datalab
- Taking Advantage of Kotlin
- TensorFlow For Poets
- TensorFlow and deep learning, without a PhD
- TensorFlow for Poets 2: Optimize for Mobile
- TensorFlow for Poets 2: TFLite
- Testing a Unity Project with Firebase Test Lab for Android
- Track Deep Link Referrals
- Translate Text with the Translation API
- Transport Tracker Backend
- Transport Tracker Map
- Understand your Place in this World -- Getting Started with the Places API on Android
- Understand your Place in this World -- Getting Started with the Places API on iOS
- Upload Objects to Cloud Storage
- Use Google Sheets as your application's reporting tool
- Use gsutil to Perform Operations on Buckets and Objects
- Using Cloud Vision with Node.js
- Using Firebase Test Lab to Improve the Quality of your Mobile Apps
- Using Google Cloud Test Lab to improve the quality of your mobile apps
- Using Google Stackdriver Debug, Traces, Logging and Logpoints
- Using Ruby on Rails with Cloud SQL for PostgreSQL
- Using Stackdriver's monitoring and logging to get better visibility into your application's health
- Using the Natural Language API from Google Docs
- Using the Natural Language API with Ruby
- Using the Vision API with Python
- Using the Vision API with Ruby
- Wearable Maps
- Web Animations Transitions and Playback Control
- Works with Nest API Quick Start Guide
- Write a Material Design AngularDart Web App
- Writing apps that access G Suite APIs: displaying the first 100 files & folders in your Google Drive
- YouTube in Your App
- Your First Progressive Web App
- clasp - The Apps Script CLI
- reCAPTCHA - Protect your website from spam and abuse
- 🎉 Migrate your site to a Progressive Web App 🐲