text:
---
sidebar: ue4guide
---

# What's the diff between a.ParallelAnimEvaluation & a.ParallelAnimUpdate?

From <https://twitter.com/ikrimae/with_replies>>\*

Anim graphs are evaluated in three phases: tick, update, evaluate \[1/N]

From <https://twitter.com/ikrimae/status/816803788933591040>>\*

tick is always game thread due to potentially touching other objs. \[2/N]

update actually ticks the nodes and determines final weights / active players for sync groups/etc... \[3/N]

*From <https://twitter.com/ikrimae/status/816803788933591040>*

repository: ikrima/gamedevguide

gha_language: PowerShell

repo_name: ikrima/gamedevguide


text:
---
title: libssh2
homepage: http://www.libssh2.org/
source-repository: https://github.com/libssh2/libssh2/
license: "[BSD style](http://www.libssh2.org/license.html)"
first-release:
    date: 2004-12-08    # version 0.1, initial release, date from repository
latest-release:
    version: 1.7.0
    date: 2016-02-23
changelog: http://www.libssh2.org/changes.html
client: yes
server: no
library: client

protocols:
    cipher:
        - aes128-ctr    # not documented; enabled if using OpenSSL >= 0.9.7, or libgcrypt, but not with Windows CNG
        - aes192-ctr    # not documented; enabled if using OpenSSL >= 0.9.7, or libgcrypt, but not with Windows CNG
        - aes256-ctr    # not documented; enabled if using OpenSSL >= 0.9.7, or libgcrypt, but not with Windows CNG
        - aes256-cbc
        -<EMAIL_ADDRESS>        - aes192-cbc
        - aes128-cbc
        - blowfish-cbc
        - arcfour128
        - arcfour
        - cast128-cbc
        - 3des-cbc
    compression:
        - zlib
        -<EMAIL_ADDRESS># added in 1.4.3
        - none
    hostkey:
        - ssh-rsa
        - ssh-dss
    kex:
        - diffie-hellman-group14-sha1
        - diffie-hellman-group-exchange-sha1
        - diffie-hellman-group1-sha1
        - diffie-hellman-group-exchange-sha256
    mac:
        - hmac-sha2-256
        - hmac-sha2-512
        - hmac-sha1
        - hmac-sha1-96
        - hmac-md5
        - hmac-md5-96
        - hmac-ripemd160
        -<EMAIL_ADDRESS>    userauth:
        - password
        - publickey
        - hostbased
        - keyboard-interactive
---
* C library for clients.
* Not to be confused with the unrelated [libssh](/impls/libssh.html)

repository: kruton/ssh-comparison

branch_name: refs/heads/gh-pages

extension: md

gha_language: SCSS

license_type: permissive

repo_name: kruton/ssh-comparison


text:
---
layout: default
---

# 1996-03-07 - Re: Looking for code to run an encrypted mailing list

## Header Data

From: Bill Stewart<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 4f9e56c5124257331bc2f7ffba22f085c4627f4773ddefeb7e2348a8a0fbaff4

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-03-07 14:33:14 UTC

Raw Date: Thu, 7 Mar 1996 22:33:14 +0800

## Raw message

```
{% raw  %}From: Bill Stewart<EMAIL_ADDRESS>Date: Thu, 7 Mar 1996 22:33:14 +0800
To<EMAIL_ADDRESS>Subject: Re: Looking for code to run an encrypted mailing list
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

>John Pettitt<EMAIL_ADDRESS>wrote:
>> Poster cryptes mail with pgp using list exploder key. List exploder decrypts
>> mail and recrypts with keys for all current list members and then sends the
>> mail.

At 09:24 PM 3/4/96 -0800<EMAIL_ADDRESS>(Alan Bostick)
suggested having the mailing list handler decrypt the session key
using its private key, and re-encrypt with the public keys of the
list members, but not do the IDEA decryption and re-encryption N times
of the message body.  This has the further advantage that the cleartext message
body is never sitting around on the server where it might end up in swap space
or file system leftover blocks.

On the other hand, it really only costs you one IDEA encryption if you
want to use the multiple-recipients options to PGP.  With the current PGP,
this means you don't have to hack your own crypto code; the toolkits in PGP 3.0
will make that easier, though.

>> [I don't want all the list members to need to know every other list members
>> public key]

The multiple-recipients PGP doesn't give away everyone's public keys,
only their keyIDs.  If you want to remain pseudonymous, just create a
public key that you use only for subscribing to the list.

(Hmmm - multiple recipient support probably makes stealth-PGP harder to
implement...)

{% endraw %}
```

## Thread

+ Return to [March 1996](/archive/1996/03)

+ Return to<EMAIL_ADDRESS>(Alan Bostick)](/authors/abostick_at_netcom_com_alan_bostick_)"
+ Return to "[Bill Stewart <stewarts@ix.netcom.com>](/authors/bill_stewart_stewarts_at_ix_netcom_com_)"
+ Return to "["James Black (CS)" <black@eng.usf.edu>](/authors/james_black_cs__black_at_eng_usf_edu_)"

+ 1996-03-07 (Thu, 7 Mar 1996 22:33:14 +0800) - Re: Looking for code to run an encrypted mailing list - _Bill Stewart<EMAIL_ADDRESS>  + 1996-03-08 (Sat, 9 Mar 1996 06:00:38 +0800) - [Re: Looking for code to run an encrypted mailing list](/archive/1996/03/3e391f0132e2f821cf20b23dd004adbdcbad1eedd9dba4ffe5645fbe91f2bd2b) -<EMAIL_ADDRESS>(Alan Bostick)_
    + 1996-03-09 (Sun, 10 Mar 1996 04:00:56 +0800) - [Re: Looking for code to run an encrypted mailing list](/archive/1996/03/68b4ee4948da8a10c6abfb5d9df76be4c394e793da5bd478cce3f123912090bc) - _"James Black (CS)"<EMAIL_ADDRESS>

license: MIT

branch_name: refs/heads/master

gha_license_id: MIT


text:
---
layout: default
title: System tokens & theme tokens
nav: Language
permalink: /language/system-tokens-and-theme-tokens/
sidenav: language-side-nav
---
# {{ page.title }}
{: .bixal-font-serif}

- System tokens are the complete set of name/value pairs defined in USWDS.
- They provide a lot of flexbility but are generally intended to be used as a foundation for a more limited palette of options.
- Theme tokens are the more limited palette intended for general use in a project.
- For example, the color system tokens include 10 grades for 25 different hues of the color wheel. You probably don't need 250 colors available for immediate use in your project. The theme color tokens use a handful of grades for specific purposes like `primary`, `secondary`, `accent-cool`, `accent-warm`, and `base`. This provides a more practical and useful palette.
- For typography, there are 21 preset systems tokens, but a theme set of 9 options with sizes ranging from `3xs` to `3xl`.
- The default values of the theme tokens reference the system token names.
- The theme and system tokens concept primarily applies to color and type size.

## Recommended Resources
- Watch a recording of a [USWDS Monthly Call](https://www.youtube.com/watch?v=l1u3umf5YXo&list=PLd9b-GuOJ3nGqDYCNsCMHCQ9MdD5jfB01&index=32) on Design Tokens.

license: Unlicense,MIT

repository: pglevy/uswds-design-tokens-guide

branch_name: refs/heads/main

detected_licenses: Unlicense MIT

repo_name: pglevy/uswds-design-tokens-guide


text:
# Watermelon Heart :watermelon: :heart:

This is my blog. Hopefully, there will be something here soon.

## :watermelon: Interesting Stuff

The theme for the blog is taken from [here](https://github.com/dbtek/dbyll).

:exclamation: To run this blog locally, please use the master branch.

:warning: To run this blog on ```github.io``` use the gh-pages branch.


text:
# Node.js Logging Support for Cloud Foundry

[![Version npm](https://img.shields.io/npm/v/cf-nodejs-logging-support.svg?style=flat-square)](https://www.npmjs.com/package/cf-nodejs-logging-support)
[![npm Downloads](https://img.shields.io/npm/dm/cf-nodejs-logging-support.svg?style=flat-square)](https://www.npmjs.com/package/cf-nodejs-logging-support)
[![Build Status](https://img.shields.io/travis/SAP/cf-nodejs-logging-support/v4.0.0.svg?style=flat-square)](https://travis-ci.org/SAP/cf-nodejs-logging-support)
[![REUSE status](https://api.reuse.software/badge/github.com/SAP/cf-nodejs-logging-support?style=flat-square)](https://api.reuse.software/info/github.com/SAP/cf-nodejs-logging-support)

## Summary

This is a collection of support libraries for node.js applications running on Cloud Foundry that serve two main purposes: It provides (a) means to emit *structured application log messages* and (b) instrument parts of your application stack to *collect request metrics*.

For details on the concepts and log formats, please look at the sibling project for [java logging support](https://github.com/SAP/cf-java-logging-support).

#### Version 2.0 introduced logging without Winston and changed custom fields to be parsed and reported as strings regardless of original type.
#### Version 3.0 introduced dynamic log level thresholds, sensitive data redaction and a redesigned field configuration system
#### Version 4.0 changed winston transport api
#### Version 5.0 introduced convenient logging methods
#### Version 6.0 added contextual loggers and custom field registration

## Features

  * Network logging (http requests) for CloudFoundry
  * Custom message logging
  * Logging levels
  * Dynamic logging level threshold (per request)
  * Extendable field configuration
  * Sensitive data redaction
  * Can be bound to [Winston](https://github.com/winstonjs/winston) as transport

## Requirements
To take full advantage of cf-nodejs-logging-support in your application, you need to fulfill following requirements:
  * App to be deployed on Cloud Foundry
  * Use [express](https://expressjs.com/), [connect](https://www.npmjs.com/package/connect), [restify](http://restify.com/) or [plain http](https://nodejs.org/api/http.html) server framework
  * Installed [npm](https://docs.npmjs.com/) package manager
  * Use [node.js](https://nodejs.org/) version 8.0 or higher

## Installation

```bash
npm install cf-nodejs-logging-support
```

## Usage

### Minimal Example
```js
var express = require('express');
var log = require('cf-nodejs-logging-support');
var app = express();

// Set the minimum logging level (Levels: off, error, warn, info, verbose, debug, silly)
log.setLoggingLevel("info");

// Bind to express app
app.use(log.logNetwork);

app.get('/', function (req, res) {
    // Context bound custom message
    req.logger.info("Hello World will be sent");

    res.send('Hello World');
});

app.listen(3000);

// Formatted log message without request context
log.info("Server is listening on port %d", 3000);
```

### Other Server Frameworks

The logging library defaults to express middleware behaviour, but it can be forced to work with other server frameworks as well:

#### With connect:
```js
var connect = require('connect');
var http = require('http');
var log = require('cf-nodejs-logging-support');

var app = connect();

// Force logger to run the connect version. (default is express, forcing express is also legal)
log.forceLogger("connect");

// Add the logger middleware, so each time a request is received, it is will get logged.
app.use(log.logNetwork);

// Create node.js http server and listen on port
http.createServer(app).listen(3000);

// Same usage as express logger, see minimal example above
```

#### With restify:
```js
var restify = require('restify');
var log = require('cf-nodejs-logging-support');
var app = restify.createServer();
// Force logger to run the restify version. (default is express, forcing express is also legal)
log.forceLogger("restify");

// Add the logger middleware, so each time a request is received, it is will get logged.
app.use(log.logNetwork);

// Same usage as express logger, see minimal example above
```

#### With nodejs http:
```js
var log = require("cf-nodejs-logging-support");
const http = require('http');

// Force logger to run the http version.
log.forceLogger("plainhttp");

const server = http.createServer((req, res) => {
    // Binds logging to the given request for request tracking
    log.logNetwork(req, res);

    // Context bound custom message
    req.logger.info("request bound information:");
    res.end('ok');
});

server.listen(3000);
```

### Request logs

The library can be attached as middleware to log all incoming requests as follows:
```js
app.use(log.logNetwork);
```

When using a plain Node.js http server it is necessary to call the middleware method directly:
```js
http.createServer((req, res) => {
  log.logNetwork(req, res);
  ...
});
```

#### Request log level

You can set the level, with which request logs will be written:

```js
log.setRequestLogLevel("verbose");
```
The default log level for request logs is ``info``.

### Message logs

In addition to request logging this library also supports logging application messages. Following common node.js logging levels are supported:

- `error`
- `warn`
- `info`
- `verbose`
- `debug`
- `silly`

In addition there is an `off` logging level available, which disables logging output completely. This can come in handy for testing. There are so called *convenient methods* for all supported logging levels, which can be called to log a message using the corresponding level. It is also possible to use standard format placeholders equivalent to the [util.format](https://nodejs.org/api/util.html#util_util_format_format_args) method.

Simple message
```js
info("Hello World");
// ... "msg":"Hello World" ...
```

With additional numeric value
```js
info("Listening on port %d", 5000);
// ... "msg":"Listening on port 5000" ...
```

With additional string values
```js
info("This %s a %s", "is", "test");
// ... "msg":"This is a test" ...
```

With an additional json object to be embedded in to the message (nothing will be added to custom_fields).
```js
info("Test data %j", {"field" :"value"}, {});
// ... "msg":"Test data {\"field\": \"value\"}" ...
```

In some cases you might want to set the actual logging level from a variable. Instead of using conditional expressions you can simply use following method, which also supports format features described above.
```js
var level = "debug";
logMessage(level, "Hello World");
// ... "msg":"Hello World" ...
```

### Logging contexts

In general there are two types of logging contexts: *global* and *request* contexts.

#### Global context
Each application has a *global* context, which has no correlation to specific requests. Use the globally defined ```log``` object to log messages in *global* context:

```js
var log = require("cf-nodejs-logging-support");
...
log.info("Server is listening on port %d", 3000);
```

#### Request context
The library adds context bound functions to request objects, if the library has been attached as middleware. Use the locally defined ```req.logger``` object to log messages in *request* context:

```js
app.get('/', function (req, res) {
    req.logger.info("This message is request correlated");
    ...
});
```

In addition to a message logged using the *global* context these messages will automatically include following request correlated fields:
- correlation_id
- request_id
- tenant_id
- tenant_subdomain

### Child loggers
You can create child loggers, which share the context of their parent (global or reqest).
```js
app.get('/', function (req, res) {
    var logger = req.logger.createLogger(); // equivalent to req.createLogger();
    ...
    logger.logMessage("This message is request correlated, but logged with a child logger");
});
```

The main reason why you probably want to use child loggers is, that they can have their own set of custom fields, which will be added to each message.
```js
var logger = req.logger.createLogger();
logger.setCustomFields({"field-a" :"value"})
// OR
var logger = req.logger.createLogger({"field-a" :"value"});
```

You can also use this feature from the global logging context like so:
```js
log = require("cf-nodejs-logging-support");

var subLogger = log.createLogger();
subLogger.setCustomFields({"field-a" :"value"})
// OR
var subLogger = log.createLogger({"field-a" :"value"});
```

### Check log severity levels
In some cases it can be useful to check if messages with a specific severity level would be logged. You can check if a logging level is active as follows:

```js
var isInfoActive = log.isLoggingLevel("info");
if (isInfoActive) {
 log.info("message logged with severity 'info'");
}
```

There are convenient methods available for this feature:
```js
var isDebugActive = log.isDebug();
```

### Custom fields

You can use the custom field feature to add custom fields to your logs.

If you use this library with SAP Application Logging Service,
you need to register your custom fields.
This is necessary, because the custom fields will be reported in a fixed order, so they can be ingested correctly in elasticsearch.

```js
log.registerCustomFields(["field"]);
info("Test data", {"field" :"value"});
// ... "msg":"Test data"
// ... "#cf": {"string": [{"k":"field","v":"value","i":"0"}]}...
```
As of version 6.5.0, this library will automatically detect, which logging service you are bound to and will set the logging format accordingly.

For local testing purposes, you can still enforce a specific format like this:
```js
log.overrideCustomFieldFormat("application-logging");
possible values:
"disabled", "all", "application-logging", "cloud-logging", "default"
```

You can now log messages and attach a key-value object as stated in the message logs section.
```js
logger.info("My log message", {"field-a" :"value"});
```

Another way of adding custom fields to log messages, is to set them for a logger instance. All logs, that are logged by this logger, contain the specified custom fields and values.
```js
logger.setCustomFields({"field-a": "value"})
logger.info("My log message");
```

You can also set custom fields globally, by calling the same function on the global `log` instance. All logs, including request logs, will now contain the specified custom fields and values.
```js
log.setCustomFields({"field-b": "test"});
```

When using child loggers, the custom fields of the parent logger will be inherited. In case you have set a field for a child logger, that is already set for the parent logger, the value of the child logger will be used.

Example for custom field inheritance:
```js
// Register all custom fields, that can occure.
log.registerCustomFields(["field-a", "field-b", "field-c"]);

// Set some fields, that should be added to all messages
log.setCustomFields({"field-a": "1"});
log.info("test");
// ... "custom_fields": {"field-a": "1"} ...

// Define a child logger, that adds another field
var loggerA = log.createLogger({"field-b": "2"});
loggerA.info("test");
// ... "custom_fields": {"field-a": "1", "field-b": "2"} ...

// Define a child logger, that overwrites one field
var loggerB = log.createLogger({"field-a": "3"});
loggerB.info("test");
// ... "custom_fields": {"field-a": "3", "field-b": "2"} ...

// Request correlated logger instances inherit global custom fields and can overwrite them as well.
app.get('/', function (req, res) {
    req.logger.setCustomFields({"field-b": "4", "field-c": "5"});
    req.logger.info("test");
    // ... "custom_fields": {"field-a": "1", "field-b": "4", "field-c": "5"} ...
});

```

### Sensitive data redaction
Version 3.0.0 and above implements a sensitive data redaction system, which deactivates the logging of sensitive fields. The field will contain 'redacted' instead of the original content.

Following fields will be *redacted* by default: remote_ip, remote_host, remote_port, x_forwarded_for, remote_user, referer.

In order to activate normal logging for all or some of these fields, you have to setup environment variables with the following names:

| Environment Variable                      | Optional fields                                                           |
|-------------------------------------------|---------------------------------------------------------------------------|
| ```LOG_SENSITIVE_CONNECTION_DATA: true``` | activates the fields remote_ip, remote_host, remote_port, x_forwarded_for |
| ```LOG_REMOTE_USER: true```               | activates the field remote_user                                           |
| ```LOG_REFERER: true```                   | activates the field referer                                               |

This behavior matches with the corresponding mechanism in the [CF Java Logging Support](https://github.com/SAP/cf-java-logging-support/wiki/Overview#logging-sensitive-user-data) library.

### Dynamic logging level threshold
Sometimes it is useful to change the logging level threshold for a specific request. This can be achieved using a special header field or setting directly within the corresponding request handler. Changing the logging level threshold only affects the presence of logs but not their individual logging levels.

#### Change logging level threshold via header field
You can change the logging level threshold for a specific request by providing a JSON Web Token ([JWT](https://de.wikipedia.org/wiki/JSON_Web_Token)) via the request header. This way it is not necessary to redeploy your app for every logging level threshold change.

##### 1 Creating a JWT
JWTs are signed claims, which consist of a header, a payload and a signature. You can create JWTs by using the [TokenCreator](https://github.com/SAP/cf-nodejs-logging-support/tree/master/tools/token-creator) from the tools folder.

Basically, JWTs are signed using RSA or HMAC signing algorithms. But we decided to support RSA algorithms (RS256, RS384 and RS512) only. In contrast to HMAC algorithms (HS256, HS384 and HS512), RSA algorithms are asymmetric and therefore require key pairs (public and private key).

The tool mentioned above takes a log level, creates a key pair and signs the resulting JWT with the private key. The payload of a JWT looks like this:
```js
{
  "issuer": "<valid e-mail address>",
  "level": "debug",
  "iat":<PHONE_NUMBER>,
  "exp":<PHONE_NUMBER>
}
```

This library supports seven logging levels: *off*, *error*, *warn*, *info*, *verbose*, *debug* and *silly*. Make sure that your JWT specifies one of them in order to work correctly. It is also important to make sure that the JWT has not been expired, when using it.

##### 2 Providing the public key
The logging library will try to verify JWTs attached to incoming requests. In order to do so, the public key (from above) needs to be provided via an environment variable called *DYN_LOG_LEVEL_KEY*:
```
DYN_LOG_LEVEL_KEY: <your public key>
```

Redeploy your app after setting up the environment variable.

##### 3 Attaching JWTs to requests
Provide the created JWTs via a header field named 'SAP-LOG-LEVEL'. The logging level threshold will be set to the provided level for the request (and also corresponding custom log messages).

Note: If the provided JWT cannot be verified, is expired or contains an invalid logging level, the library ignores it and uses the global logging level threshold.

If you want to use another header name for the JWT, you can specify it using an enviroment variable:
```
DYN_LOG_HEADER: MY-HEADER-FIELD
```

#### Change logging level threshold within request handlers
You can also change the log level for all requests of a specific request handler by calling:
```js
req.setDynamicLoggingLevel("verbose");
```

### Request correlation_id
In order to get the correlation_id of a request, you can use the following method:
```js
app.get('/', function (req, res) {
    // Get correlation_id from logger bound to request
    var id = req.logger.getCorrelationId();

    res.send('Hello World');
});
```

It is also possible to change the correlation_id to a valid UUIDv4:
```js
app.get('/', function (req, res) {
    // Set correlation_id via logger bound to request
    req.logger.setCorrelationId("cbc2654f-1c35-45d0-96fc-f32efac20986");

    res.send('Hello World');
});
```

Be aware that changing the correlation_id for a logger, will also affect ancestor and descendant loggers within the same request context, especially the network log for this request will contain the new correlation_id.

### Request tenant_id
In order to get the tenant_id of a request, you can use the following method:
```js
app.get('/', function (req, res) {
    // Get tenant_id from logger bound to request
    var tenantId = req.logger.getTenantId();

    res.send('Hello World');
});
```

It is also possible to change the tenant_id to any value:
```js
app.get('/', function (req, res) {
    // Set tenant_id via logger bound to request
    req.logger.setTenantId("cbc2654f-1c35-45d0-96fc-f32efac20986");

    res.send('Hello World');
});
```

Be aware that changing the tenant_id for a logger, will also affect ancestor and descendant loggers within the same request context, especially the network log for this request will contain the new tenant_id.

### Request tenant_subdomain
The tenant_subdomain is not determined automatically, instead you can set it per request as follows:
```js
app.get('/', function (req, res) {
    // Set tenant_subdomain via logger bound to request
    req.logger.setTenantSubdomain("my-subdomain");

    res.send('Hello World');
});
```

Be aware that changing the tenant_subdomain for a logger, will also affect ancestor and descendant loggers within the same request context, especially the network log for this request will contain the new tenant_subdomain.

### Human readable output
Setup an output pattern to get a human-readable output instead of json. Use '{{' and '}}' to print log parameters.
```js
log.setLogPattern("{{written_at}} - {{msg}}");
```

### Fixed Values for Network Logging (will impact log parsing if used incorrectly)
Possibility to tailor logs to your needs, you can for example change the msg field for Network-logs to find them in the Human readable format:
```js
log.overrideNetworkField("msg", YOUR_CUSTOM_MSG);
```
This will replace the value of the previously not existing msg field for network logs with YOUR_CUSTOM_MSG.
If the overridden field is already existing, it will be overridden by YOUR_CUSTOM_MSG for ALL subsequent network logs, until you
remove the override with:
```js
log.overrideNetworkField("msg", null);
```
If you use this override feature in conjunction with a log parser, make sure you will not violate any parsing rules.

## Tracing
### SAP_passport
example:
```
2a54482a0300e60000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002a54482a
```

SAP Passport is an end to end tracing technology used in many SAP products.
It is a binary format encoded in hex notation.
Applications can add the whole SAP Passport in this field or give its constituents in the respective fields.

to read up on the possible fields, please look at [fields](https://github.com/SAP/cf-java-logging-support/blob/master/cf-java-logging-support-core/beats/app-logs/docs/fields.asciidoc).

### Custom sink function
Per default the library writes output messages to `stdout`. For debugging purposes it can be useful to redirect the output of the library to another sink (e.g. `console.log()`). You can set a custom sink method as follows:
```js
log.setSinkFunction(function(level, output) {
 console.log(output);
});
```
A custom sink function should have two arguments: `level` und `output`. You can redirect or filter output messages based on their logging level.

Note: If a custom sink function is set, the library will no longer output messages to the default sink (stdout).

### Winston Transport
This logging library can be used in conjunction with Winston. Logging via Winston transport is limited to message logs. Network activity can not be tracked automatically. Example:
```js
var express = require('express');
var log = require('cf-nodejs-logging-support');
var winston = require('winston');

var app = express();

var logger = winston.createLogger({
    // Bind transport to winston
    transports: [log.createWinstonTransport()]
});

app.get('/', function (req, res) {
    res.send('Hello World');
});

app.listen(3000);

// Messages will now be logged exactly as demonstrated by the message logs paragraph
logger.log("info", "Server is listening on port %d", 3000);
```

## Sample Apps

  * [Express & Restify Sample](https://github.com/SAP/cf-nodejs-logging-support/blob/master/sample/cf-nodejs-shoutboard)
  * [Winston Sample](https://github.com/SAP/cf-nodejs-logging-support/blob/master/sample/winston-sample)

## Licensing

Please see our [LICENSE](LICENSE) for copyright and license information. Detailed information including third-party components and their licensing/copyright information is available via the [REUSE](https://api.reuse.software/info/github.com/SAP/cf-nodejs-logging-support) tool.

repository: sergioRozenszajn/customerApprouter

repo_name: sergioRozenszajn/customerApprouter


text:
# [Basketball Association facts](http://alexa.amazon.com/#skills/amzn1.echo-sdk-ams.app.00a1e2b0-dc5b-43f7-bf62-70afc1676775)
![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png) 0

To use the Basketball Association facts skill, try saying...

* *Alexa, open basketball facts*

* *Alexa, start basketball facts*

* *Alexa, begin basketball facts*

facts about NBA

***

### Skill Details

* **Invocation Name:** basketball facts
* **Category:** null
* **ID:** amzn1.echo-sdk-ams.app.00a1e2b0-dc5b-43f7-bf62-70afc1676775
* **ASIN:** B01I76E2JI
* **Author:** John Wu
* **Release Date:** July 19, 2016 @ 01:57:30
* **In-App Purchasing:** No


text:
# Docker Documentation

## Installation

### Docker

` curl -fsSL get.docker.com -o get-docker.sh `
` sh get-docker.sh `

### Docker Machine

	``  base=https://github.com/docker/machine/releases/download/v0.14.0 &&
		  curl -L $base/docker-machine-$(uname -s)-$(uname -m) >/tmp/docker-machine &&
	    sudo install /tmp/docker-machine /usr/local/bin/docker-machine)) ``

### Docker Compose

	`
	curl -L https://github.com/docker/compose/releases/download/1.21.2/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
	chmod +x /usr/local/bin/docker-compose
	`

## Images vs Containers

1. An image is the binaries and source code that make up a container
2. A container is an instance of that image running as a process

### Running a Container

#### NGINX

`` docker container run --publish 80:80 nginx ``

This command pulls down the nginx image from the server if it does not exist \
locally. Then it runs it in a new container publishing port 80 to the HOSTS \
port 80

We can also run

`` docker container run --publish 80:80 --detach nginx ``

This runs the container in the background.
The --name switch also allows us to specify our own name for the container

We can check the logs for a container by using the command

` docker container logs <container_name> `

Stopping containers can be acheived by using ` docker container stop <ID> `

Removing containers can be acjieved with ` docker container rm <ID> `

`docker container top <name>` - Lists the conainers running processes

` docker container inspect <name> ` - Shows config JSON

` docker container stats ` - Live performance data on all containers

## Interacting with Containers Via Terminal

It is also possible to run a shell inside your containers so that you can run an interactive /
shell inside the container to make changes.

To do this we use the **-it** command i.e.

`docker container run -it --name webserver nginx bash `

	**NB** Always remember to specify what terminal emulator you want to use

### Starting an existing container interactively

It is also possible to interact with a pre-existing terminal by using **-ai** or
attach, interactively (see below)

` docker container start -ai <container_name> `

In order to run a command in an already running container we use

` docker container exec -it <program to run> `

## Docker Network Concepts for Private/Public Comms

To see what port(s) are exposed on a running containernwe use.

`docker container port <container_name> `

Network settings such as IP address can be descovered using the **--inspect** command as below.

	``
	docker container inspect --format \{\{ .NetworkSettings.IPAddress \}\} webhost
	``

**NOTE** inspect returns a json object and --format is used to select nodes in the response.

## Docker Networks: Cli Management

1. Show networks - ` docker network ls `
2. Inspect a network - ` docker network inspect `
3. Create a network - ` docker network create --driver `
4. Attech a network to container - ` docker network connect `
5. Detach a network from a container - ` docker network disconnect `

#### Creatings networks & adding containers

We can create a new network which uses the default network driver of bridge with the command

` docker network create my_app_net `

and then add a new container to it with

` docker container run -d --name new_nginx --network my_app_net nginx `

#### Add existing container to a new netowrk

We can add existing containers to newly created networks with **docker network connect** as follows

` docker network connect <network_id> <container_id> `

Once part of a network containers can talk to each other by using the container name

` docker container run -d exec -it  <container_name1> ping <container_name_2> `

#### DNS ALIASES

Docker allows you to have dns aliases whereby two or more different containers running within a virtual docker network can all be qieries using the same DNS name.

Use the **--net-alias** command to set the same alias on duplicate containers on your network.

`docker run container -d --network <network_name> --net-alias <alias> --name <container_name> ubuntu:latest `

## Docker Images

### Commands

`docker image ls `
`docker history <name>:<tag>`
`docker image inspect <name>:<tag>`

### Image Dockerfile Basics

Docker files are recipies for creating docker images and consist of a base os, app installs, command to be run, file copies and configurations, which all make up a desired image.

The most common Docker actions are as follows;

FROM - This is the distribution wich makes the base of the image, debian, centos, alpine etc..
ENV - The is where you declare any enviroment vriable to be used lated in the file
RUN - This specifies bash commands to be run such as apt-get update as well as file copies and other such actions
EXPOSE - This is used to expose ports accessable by the host os
CMD - This can be used to run any command you want when the container first boots

#### Building images from dockerfile

In order to build an image from a dockerfile run,

`docker build -t <tag_name> .`

This means build from the current directory and tag it. Docker will detect the dockerfile and executed the steps within it

repository: moringaman/dev-wiki

repo_name: moringaman/dev-wiki


text:
# NanoXLSX4j

[![Maven Central](https://maven-badges.herokuapp.com/maven-central/ch.rabanti/nanoxlsx4j/badge.svg)](https://maven-badges.herokuapp.com/maven-central/ch.rabanti/nanoxlsx4j) ![license](https://img.shields.io/github/license/rabanti-github/picoXlsx4j.svg)

NanoXLSX4j is a small Java library to create and read XLSX files (Microsoft Excel 2007 or newer) in an easy and native way. The library is originated form [PicoXLSX4j](https://github.com/rabanti-github/PicoXLSX4j) and has basic support of reading spreadsheets. PicoXLSX4j and thus NanoXLSX4j are direct ports of [PicoXLSX for C#](https://github.com/rabanti-github/PicoXLSX)

* No need for an installation of Microsoft Office
* No need for Office interop/DCOM or other bridging libraries
* No need for 3rd party libraries
* Pure usage of standard JRE

Project website: [https://picoxlsx.rabanti.ch](https://picoxlsx.rabanti.ch)

## Modules

* NanoXLSX4l.Lib : Contains the actual library as basis for the Maven artefact
* NanoXLSX4j.Demo : Contains usage examples of the library

See the **[Change Log](https://github.com/rabanti-github/NanoXLSX4j/blob/master/Changelog.md)** for recent updates.

## What's new in version 2.x

There are some additional functions for workbooks and worksheets, as well as support of further data types.
The biggest change is the full capable reader support for workbook, worksheet and style information. Also, all features are now fully unit tested. This means, that nanoXLSX is no longer in Beta state. Some key features are:

* Full reader support for styles
* Copy functions for worksheets
* Advance import options for the reader
* Several additional checks, exception handling and updated documentation

## Road map
Version 2.x of NanoXLSX4j was completely overhauled and a high number of (partially parametrized) unit tests with a code coverage of >97% were written to improve the quality of the library.
However, it is not planned as a LTS version. The upcoming v3.x is supposed to introduce some important functions, like in-line cell formatting, better formula handling and additional worksheet features.
Furthermore, it is planned to introduce more modern OOXML features like the SHA256 implementation of worksheet passwords.

## Reader Support

The reader of NanoXLS4j follows the principle of "What You Can Write Is What You Can Read". Therefore, all information about workbooks, worksheets, cells and styles that can be written into an XLSX file by NanoXLSX, can also be read by it.
There are some limitations:

* A workbook or worksheet password cannot be recovered, only its hash
* Information that is not supported by the library will be discarded
* There are some approximations for floating point numbers. These values (e.g. pane split widths) may deviate from the originally written values
* Numeric values are cast to the appropriate Java types with the best effort. There are import options available to enforce specific types
* No support of other objects than spreadsheet data at the moment
* Due to the potential high complexity, custom number format codes are currently not automatically escaped on writing or un-escaped on reading

## Requirements

NanoXLSX4j was initially created with Java 8 and currently build with OpenJDK 11
The only requirement for development is an up-to-date Java environment (OpenJDK 11 or higher recommended)

## Installation

### As JAR

Simply place the NanoXLSX4j jar file (e.g. **nanoxlsx4j-2.2.0.jar**) into the lib folder of your project and create a library reference to it in your IDE.

### As source files

Place all .java files from the NanoXLSX4j [source folder](https://github.com/rabanti-github/NanoXLSX4j/tree/master/NanoXLSX4j.Lib/src/main/java/ch/rabanti/nanoxlsx4j) into your project. The folder structure defines the packages. Please use refactoring if you want to relocate the files.

### Maven

Add the following information to your POM file within the ```<dependencies>``` tag:

```xml
<dependency>
    <groupId>ch.rabanti</groupId>
    <artifactId>nanoxlsx4j</artifactId>
    <version>2.2.0</version>
</dependency>
```

**Important:** The version number may change.
Please see the version number of Maven Central [![Maven Central](https://maven-badges.herokuapp.com/maven-central/ch.rabanti/nanoxlsx4j/badge.svg)](https://maven-badges.herokuapp.com/maven-central/ch.rabanti/nanoxlsx4j)
 or check the [Change Log](https://github.com/rabanti-github/NanoXLSX4j/blob/master/Changelog.md) for the most recent version. The keywords ```LATEST```  and ```RELEASE``` are only valid in Maven 2, not 3 and newer.

## Usage

### Quick Start (shortened syntax)

```java
 Workbook workbook = new Workbook("myWorkbook.xlsx", "Sheet1");         // Create new workbook with a worksheet called Sheet1
 workbook.WS.value("Some Data");                                        // Add cell A1
 workbook.WS.formula("=A1");                                            // Add formula to cell B1
 workbook.WS.down();                                                    // Go to row 2
 workbook.WS.value(new Date(), BasicStyles.Bold());                     // Add formatted value to cell A2
 try{
   workbook.save();                                                     // Save the workbook as myWorkbook.xlsx
 } catch (Exception ex) {}
```

### Quick Start (regular syntax)

```java
 Workbook workbook = new Workbook("myWorkbook.xlsx", "Sheet1");       // Create new workbook with a worksheet called Sheet1
 workbook.getCurrentWorksheet().addNextCell("Some Data");             // Add cell A1
 workbook.getCurrentWorksheet().addNextCell(42);                      // Add cell B1
 workbook.getCurrentWorksheet().goToNextRow();                        // Go to row 2
 workbook.getCurrentWorksheet().addNextCell(new Date());              // Add cell A2
 try {
   workbook.Save();                                                   // Save the workbook as myWorkbook.xlsx
 } catch (Exception ex) {}
```

### Quick Start (read)

```java
try
{
    Workbook wb = Workbook.load("basic.xlsx");                      // Read the workbook
    System.out.println("contains worksheet name: " + wb.getCurrentWorksheet().getSheetName());
    wb.getCurrentWorksheet().getCells().forEach((k, v) -> {         // Iterate through data
        System.out.println("Cell address: " + k + ": content:'" + v.getValue() + "'");
    });
}
catch (Exception ex)
{
 System.out.println("Error: " + ex);
}
```

## Further References

See the full <b>API-Documentation</b> at: [https://rabanti-github.github.io/NanoXLSX4j/](https://rabanti-github.github.io/NanoXLSX4j/).
The [Demo module](https://github.com/rabanti-github/NanoXLSX4j/tree/master/NanoXLSX4j.Demo) contains 14 simple use cases. You can also look at the full API documentation or the Javadoc annotations in the particular .java files.

Hint: You will find most certainly any function, and the way how to use it, in the [Unit Test Section](https://github.com/rabanti-github/NanoXLSX4j/tree/master/NanoXLSX4j.Lib/src/test/java/ch/rabanti/nanoxlsx4j)


text:
Nutris

Web App to calculate parenteral diets. [See old version running here!👀](https://nutris.web.app/)

## Stack

This project uses:

- [Vue ❤](https://vuejs.org/) - Awesome JS Framework!
- [TypeScript](https://www.typescriptlang.org/) - To build a secure code and avoid bugs.
- [Sass](https://sass-lang.com/) - CSS Pre-processor with nice approach.
- [Jest](https://jestjs.io/docs/en/getting-started) - To create unit test and avoid bugs.
- [Venice](https://github.com/juntossomosmais/venice) - We have been using [Juntos Somos Mais](https://github.com/juntossomosmais) Design System as inspiration.
- [Vue-i18n](https://github.com/intlify/vue-i18n-next) - To create a multi idiom project.

This project also uses [Husky](https://github.com/typicode/husky) to prevent commit and push messy and wrong code.

## Commands

#### Install (*WITH* Open-ish's access)

- Generate a token at GitHub
- Create a `.npmrc` file, using `.npmrc.example` as example

```sh
npm install
```

#### Install (*WITHOUT* Open-is's access)

- Remove `@open-ish/nutris-roles` dependency from `package.json` file (at the future, we will create a mock function to it).

```sh
npm install
```

#### Usage

```sh
npm start
```

#### Build

```sh
npm run build
```

It'll be running at: http://localhost:1993/

## Authors

👤 [@tassioFront](https://github.com/tassioFront)
👤 [@lupy100](https://github.com/lupy100)
👤 [@pehlse](https://github.com/pehlse)

- Github: [@open-ish](https://github.com/open-ish)

## 🤝 Contributing

Contributions, issues and feature requests are welcome!
Feel free to check [issues page](https://github.com/open-ish/nutris/issues).

## 📝 License

Copyright © 2020 [@open-ish](https://github.com/open-ish)

repository: open-ish/nutris

gha_language: Vue

repo_name: open-ish/nutris


text:
# <img<EMAIL_ADDRESS>width="48" height="48"/> [unchecky](https://chocolatey.org/packages/unchecky)

Have you ever felt, while installing software, that the installer tries to push additional unwanted programs at all cost? Ever missed a checkbox, and spent hours afterwards removing adware? Ever opened your browser after an installation, only to find out that you have a new homepage, a new search engine, or even a new browser?

__Unchecky aims to keep potentially unwanted programs out of your computer.__

![Unchecky](https://i.imgur.com/DTUlrjq.png)

### Notes

* This package always installs the latest version of the application, regardless of the version specified in the package.
* This program automatically updates itself.

repository: DigitalWhitewater/Powershell

repo_name: DigitalWhitewater/Powershell


text:
# How to contribute

Pull-requests and discussions are essential for any open-source project. Any contribution to this project will be considered lovely. Here's just a quick guide to help you in this journey.

Please have in mind that nothing can be considered 100% truth and immutable (including this statement). This project will not adhere to any `strict` way of development.

## Pull-Requests

Github has two great GREAT articles about contributing: [Contributing to Open Source on GitHub](https://guides.github.com/activities/contributing-to-open-source/) and [Using pull requests](https://help.github.com/articles/using-pull-requests/). Please make sure to read it in your lifetime (everyone that reads became a better person).

> Oh man, [guides.github.com](https://guides.github.com/) and [help.github.com](https://help.github.com) are astonishing!

Please, try to keep your commit messages as communicative as possible. There is a good [reference](https://github.com/erlang/otp/wiki/Writing-good-commit-messages) for it as well :blush:.

> I usually think in the commit itself as an implicit subject of commit message.
>For example: `[This commit] Add .gitignore`

Communication is _always_ handy! If you have any doubt or would like to discuss your thoughts, you are more than welcome to send me a message! Please comment directly on the code, open an issue, submit a pull request, mention me anywhere... I think GitHub has good tools to help developers communicate and share experiences.

### Code Guidelines

- Two spaces, no tabs - _It's a personal choice, I know... but it's good considering multiline alignment_ :smiling_imp:
- No trailing whitespace. Blank lines should not have any space
- Operators should be wrapped by spaces (`a = b`, `a + b`, ... and not `a=b`)
- Parenthesis and brackets should not be wrapped by spaces, especially in function call/declaration (`plot(x, y)` and not `plot (x, y)`, `plot( x, y )`)
- Commas should be followed by a space (`plot(x, y)` and not `plot(x,y)`)
- I usually appreciate the code as shorter as possible, and I like 'one-line' `if`s, `for`s, etc... - _Hatters gonna hate_
- Follow the conventions you see used in the source already - _The best tip so far_ :kissing_heart:

Please have a look at [Matlab Style Guidelines](https://sites.google.com/site/matlabstyleguidelines/home), it is a really nice reference. I usually don't follow all the rules, but I'm very inspired by them.

As MATLAB borrow so many thing from Java, I think using `camelCase` for variable name is fine, but I just don't like this convention for function or method names... In this case, I usually prefer `lowercase` and short names, normally with **mnemonics** to abbreviate, like `sendstr`. **Mnemonics** are perfectly fine (come on... everybody loves unix shell interface...).

Short examples:

    thisPropName
    ClassName
    thisfunc
    CONST_NAME

## Reporting a Bug

- Update to the most recent master release if possible. Someone may have already fixed your bug (such a wonderful scenario!)
- Search for similar issues. It's possible somebody has encountered this bug already. In this case comment your experience too!
- Clearly describe the issue including steps to reproduce when it is a bug and preferably send a script that does so. Try to keep all the things fully operational with the exception of the bug you want to demonstrate. (Ok, I admit this is boring, but is probably the fastest way to get thing working).
- Keep up to date with feedback from the project team, maybe you can help us to test ;)
- If possible, submit a Pull Request with a failing test. It would be wonderful to increase the test coverage!
- Consider the challenge of fixing the bug, I'm sure it can be funny or at least very aggrandizing :stuck_out_tongue_winking_eye:

## Requesting a Feature

- Search Issues for similar feature requests. It's possible somebody has already asked for this feature or provided a pull request that we're still discussing.
- Provide a clear and detailed explanation of the feature you want and why it's important to add. Keep in mind that features should be useful to the majority of users and not just a small subset. If you're just targeting a minority of users, consider writing an add-on library.
- If the feature is complex, consider writing some initial documentation for it. If we do end up accepting the feature it will need to be documented and this will also help us to understand it better ourselves.
- Attempt a Pull Request. If you're at all able, start writing some code. We always have more work to do than time to do it. If you can write some code then that will speed the process along.

## NOTE

This guide was partially copied from
- [ember.js](https://raw.githubusercontent.com/emberjs/ember.js/master/CONTRIBUTING.md)
- [factory_girl](https://raw.github.com/thoughtbot/factory_girl_rails/master/CONTRIBUTING.md)
- [puppet](https://raw.githubusercontent.com/puppetlabs/puppet/master/CONTRIBUTING.md)
- [rails](http://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html#contributing-to-the-rails-documentation)

Please consider reading them. They are just great!

repository: abravalheri/matlab-zmqrpc

repo_name: abravalheri/matlab-zmqrpc


text:
---
layout: post
author: Justin Ball
title: "Mountain Bike Gear Ratios 1x vs 2x setup"
date: 2015-05-04 00:26:40 -0600
tags:
  - Cycling
---

I spent some quality time on my Salsa Beargrease and on my Santa Cruz Blur last week. The Beargrease is an awesome bike. It's a lot of fun to ride and leaves you
giggling as you bounce along the trail. It is however, fat. That doesn't mean it's slow but it is more bike to push up the mountain than your typical mountain bike.
My Blur is a lighter but older bike. I bought it back in 2007. At that time it was high end, super awesome state of the art stuff. However, in it's old age I'm finding
that it just doesn't hold up on the more technical parts of my favorite trail. On my last ride I clipped out 3 times to prevent donating skin and blood to the mountain.
I don't clip out at all on the Fat bike in spite of it's lack of supension.

That's when I decided it's time to examine my options which leads me to the Ibis Ripley - quite possibly the sweetest bit of 29er technology
to ever touch the dirt. It's a lustworthy steed. It will empty your bank account so you'll want to be sure to set it up perfectly before making your final purchase.

When Indiana Jones isn't riding off into the sunsent or piloting the Millenium Falcon he rides an Ibis Ripley. For those of us who will never lay eyes on the Ark of the Covenant
the Ibis Ripley is as close to making the Kessel Run in less than twelve parsecs as we're going to get and that's not a disappointment.

The most difficult part of buying a Ripley is getting it just right. Mountain bikes have achieved a level of scientific perfection that requires long hours hanging out in the bike
shop to fully comprehend. The latest in a long line of innovations is the introduction of "less is more" emboddied by the 1x11 drive train setup. For many years conventional wisdom
was 3 rings up front and 10 in the back. That makes for a lot of gears, a lot of noise and a lot of weight. It turns out that many of those gear ratios are duplicates and so
in the name of simplicity we throw them away which leads to a dilema. Give up one ring? Sure, but give up both and go to 1? Is it a fad or is it worth it to drop a pound?

The Ripley offers the 2x with a 26 and 36 tooth setup up front. The 1x comes with a single 30 tooth gear on the crank.
Both setups use the exact same rear cassette - the XTR CS-M9000 11-speed with the following teeth: 11-13-15-17-19-21-24-27-31-35-40.

      With the only difference the front rings here's a chart showing the ratios using 175mm cranks (courtesy of Sheldon Brown's Gear Calculator):

          Teeth
          26
          30
          36

          11
          5.0
          5.7
          6.9

          13
          4.2
          4.8
          5.8

          15
          3.6
          4.2
          5.0

          17
          3.2
          3.7
          4.4

          19
          2.9
          3.3
          4.0

          21
          2.6
          3.0
          3.6

          24
          2.3
          2.6
          3.2

          27
          2.0
          2.3
          2.8

          31
          1.8
          2.0
          2.4

          35
          1.6
          1.8
          2.2

          40
          1.4
          1.6
          1.9

Let's ignore the teeth for a moment, reduce the duplicates from the 2x setup and just look at the ratios provided:

          1x
          2x

	6.9

	5.8

5.7

	5.0

4.8

	4.4

4.2	4.2

	4.0

3.7

	3.6

3.3

	3.2

3.0

	2.9

	2.8

2.6	2.6

	2.4

2.3	2.3

	2.2

2.0	2.0

	1.9

1.8	1.8

1.6	1.6

	1.4

Compare

It's pretty obvious but the 1x setup ends up with 11 ratios. The 2x setup has 19 unique ratios. It would seem that you now have 8 more ratios available to
    win your next KOM.

However, look closer at the significant differences. With the 1x setup you lose one ratio on the very bottom - the 1.4. On the steepest climbs I always wish I had one more
    gear just lower than the one I'm in. I might miss the 1.4, but I also spend time climbing nasty stuff on a Cyclocross bike with road gearing. The loss of the 1.4 gear ratio
    is probably not a deal killer and besides you save about 1 pound and that should more than make up the difference right?

Throughout the rest of the range you get minor variations. The 1x setup tends to match or settle right between two of the ratios offered by the 2x setup.
    The 26x19 provides a ratio of 2.9 but the 30x21 gives you a close 3.0. Will you notice that you went from a 2.0 directly to a 2.3 and skipped the 2.2?
    Will you miss the 1.9? Is the jump from 1.8 to 2.0 to much? Most riders I've spoken with will tell you no. The biggest loss occurs at the top end where the 36x11 gives you a 6.9.
    The 1x setup's 5.7 almost matches the 2x setup's 5.8.

Conclusion

  Given the similarities across the middle range of the gearing the decision to choose a 1x vs 2x setup comes down to whether or not you need the very top and very bottom gears and
  is it worth packing around an extra chain ring, derailleur and shifter to get them. Oh, and the 1x setup on the Ripley is $1,000 dollars cheaper. That can change also affect
  one's thought process.

extension: markdown


text:
### 2017-07-27
diff between today and yesterday

#### python
* [facebookresearch/DrQA](https://github.com/facebookresearch/DrQA): Reading Wikipedia to Answer Open-Domain Questions
* [521xueweihan/HelloGitHub](https://github.com/521xueweihan/HelloGitHub):  GitHub
* [brightmart/text_classification](https://github.com/brightmart/text_classification): all kinds of text classificaiton models and more with deep learning
* [ExplorerFreda/Structured-Self-Attentive-Sentence-Embedding](https://github.com/ExplorerFreda/Structured-Self-Attentive-Sentence-Embedding): An open-source implementation of the paper ``A Structured Self-Attentive Sentence Embedding'' published by IBM and MILA.
* [python/cpython](https://github.com/python/cpython): The Python programming language
* [plotly/dash](https://github.com/plotly/dash): Interactive, reactive web apps in pure python
* [mame82/P4wnP1](https://github.com/mame82/P4wnP1): P4wnP1 is a highly customizable USB attack platform, based on a low cost Raspberry Pi Zero or Raspberry Pi Zero W.

#### go
* [v2ray/v2ray-core](https://github.com/v2ray/v2ray-core): A platform for building proxies to bypass network restrictions.
* [kudelskisecurity/cdf](https://github.com/kudelskisecurity/cdf):
* [h2non/gentleman](https://github.com/h2non/gentleman): Full-featured, plugin-oriented, composable HTTP client toolkit for Go
* [unidoc/unidoc](https://github.com/unidoc/unidoc): UniDoc is a PDF library for Golang
* [pingcap/tidb](https://github.com/pingcap/tidb): TiDB is a distributed NewSQL database compatible with MySQL protocol
* [stretchr/testify](https://github.com/stretchr/testify): A toolkit with common assertions and mocks that plays nicely with the standard library
* [ExaScience/pargo](https://github.com/ExaScience/pargo): A library for parallel programming in Go
* [campoy/go-tooling-workshop](https://github.com/campoy/go-tooling-workshop): A workshop covering all the tools gophers use in their day to day life

#### cpp
* [MortenSchenk/BHUSA2017](https://github.com/MortenSchenk/BHUSA2017): Content from presentation at BHUSA 2017
* [godotengine/godot](https://github.com/godotengine/godot): Godot Engine  Multi-platform 2D and 3D game engine
* [lsy17096535/face-landmark](https://github.com/lsy17096535/face-landmark): caffe 68 points face-landmark
* [leonardvandriel/caffe2_cpp_tutorial](https://github.com/leonardvandriel/caffe2_cpp_tutorial): C++ transcripts of the Caffe2 Python tutorials and other C++ example code
* [uglide/RedisDesktopManager](https://github.com/uglide/RedisDesktopManager):  Cross-platform GUI management tool for Redis
* [romankisil/eqMac2](https://github.com/romankisil/eqMac2): System-wide Audio Equalizer for the Mac
* [mongodb/mongo](https://github.com/mongodb/mongo): The MongoDB Database
* [shadowsocks/shadowsocks-qt5](https://github.com/shadowsocks/shadowsocks-qt5): A cross-platform shadowsocks GUI client

#### javascript
* [paypal/react-autocompletely](https://github.com/paypal/react-autocompletely):  Primitives to build simple, flexible, WAI-ARIA compliant React autocomplete components
* [smallwins/spacetime](https://github.com/smallwins/spacetime): A lightweight way to handle timezones in js
* [bustle/mobiledoc-kit](https://github.com/bustle/mobiledoc-kit): A toolkit for building WYSIWYG editors with Mobiledoc
* [jxnblk/nano-component](https://github.com/jxnblk/nano-component): Fast & simple React component styles in under 1kb
* [lukeed/ganalytics](https://github.com/lukeed/ganalytics): A tiny (400B) client-side module for tracking with Google Analytics
* [skygear-demo/skypad](https://github.com/skygear-demo/skypad): Skypad
* [TryGhost/Ghost](https://github.com/TryGhost/Ghost): A simple, powerful publishing platform
* [nodejs/node](https://github.com/nodejs/node): Node.js JavaScript runtime
* [LaloMrtnz/Chain](https://github.com/LaloMrtnz/Chain): Dynamic color relations in Sketch.

#### coffeescript
* [taigaio/taiga-front](https://github.com/taigaio/taiga-front): Project management web application with scrum in mind! Built on top of Django and AngularJS (Front)
* [webyom/gulp-html-i18n](https://github.com/webyom/gulp-html-i18n): Html i18n
* [retorquere/zotero-better-bibtex](https://github.com/retorquere/zotero-better-bibtex): Make Zotero effective for us LaTeX holdouts
* [atom/whitespace](https://github.com/atom/whitespace): Atom whitespace package
* [dobtco/formrenderer-base](https://github.com/dobtco/formrenderer-base): Screendoor's client-side form rendering code.
* [abe33/atom-pigments](https://github.com/abe33/atom-pigments): An Atom package to display colors in project and files.
* [ccd0/4chan-x](https://github.com/ccd0/4chan-x): Adds various features to 4chan.
* [Arcath/jekyll-atom](https://github.com/Arcath/jekyll-atom): A collection of tools and snippets for working with Jekyll in Atom
* [JunoLab/atom-julia-client](https://github.com/JunoLab/atom-julia-client): Juno a good IDE?
* [geordanr/xwing](https://github.com/geordanr/xwing): Squad builder for the X-Wing Miniatures game by Fantasy Flight Games.

gha_language: Python


text:
# History

## 0.3.1 (2021-03-05)

This release features various bug fixes and improvements. In particular, we have
added tests for SlidingBoundariesArchive and believe it is ready for more
rigorous use.

### Changelog

- Move SlidingBoundariesArchive out of experimental by adding tests and fixing bugs (#93)
- Added nicer figures to the Sphere example with `grid_archive_heatmap` (#86)
- Added testing for Windows and MacOS (#83)
- Fixed package metadata e.g. description

## 0.3.0 (2021-02-05)

pyribs is now in beta. Since our alpha release (0.2.0), we have polished the
library and added new tutorials and examples to our documentation.

### Changelog

- Added a Lunar Lander example that extends the lunar lander tutorial (#70)
- Added New Tutorial: Illuminating the Latent Space of an MNIST GAN (#78)
- GridArchive: Added a boundaries attribute with the upper and lower bounds of
  each dimension's bins (#76)
- Fixed a bug where CMA-ME emitters do not work with float32 archives (#74)
- Fixed a bug where Optimizer is able to take in non-unique emitter instances
  (#75)
- Fixed a bug where GridArchive failed for float32 due to a small epsilon (#81)
- Fix issues with bounds in the SlidingBoundaryArchive (#77)
- Added clearer error messages for archives (#82)
- Modified the Python requirements to allow any version above 3.6.0 (#68)
- The wheel is now fixed so that it only supports py3 rather than py2 and py3
  (#68)
- Miscellaneous documentation fixes (#71)

## 0.2.0 (2021-01-29)

- Alpha release

## 0.2.1 (2021-01-29)

- Package metadata fixes (author, email, url)
- Miscellaneous documentation improvements

## 0.1.1 (2021-01-29)

- Test release (now removed)

## 0.1.0 (2020-09-11)

- Test release (now removed)

## 0.0.0 (2020-09-11)

- pyribs begins

repository: CodeJirachi/pyribs

repo_name: CodeJirachi/pyribs


text:
---
title: Define custom commands
description: Learn how to extend Nightwatch capabilities by adding custom commands.
---

Define custom commands

### Overview
Most of the time you will need to extend the Nightwatch commands to suit your own application needs. To do so, create a new folder (e.g. `nightwatch/commands`) and start defining your own commands inside, each in its own file.

Then specify the path to that folder in the `nightwatch.json` file, as the `custom_commands_path` property.

nightwatch.json

{
  "custom_commands_path" : "nightwatch/commands"
}

The command name is the name of the file itself.

### Define a custom command

There are two main ways in which you can define a custom command:

#### 1) Class-style commands
This is the recommended style of writing custom commands and it's also how most of the Nightwatch's own commands are written. Your command module needs to export a class constructor with a `command` instance method representing the command function.

All Nightwatch commands are asynchronous which means that custom commands must signal the completion (in the `command` method). This can be achieved in two ways:
1. returning a `Promise`
2. emitting a "complete" event (in this case the class needs to inherit from Node's `EventEmitter`)

Returning a `Promise` is the recommended way. Class-based `command` methods are run in the context (the value of `this`) of the class instance. The `browser` object is available via `this.api`.

The example below performs the equivalent of the `.pause()` command. Note the two variations regarding the completion.

##### The return value
You can also specify a return value, either as the argument with which the Promise will resolve, or as an argument to the "complete" event call.

##### Completion via a Promise

nightwatch/commands/customPause.js

module.exports = class CustomPause {
  command(ms, cb) {
    // If we don't pass the milliseconds, the client will
    // be suspended indefinitely
    if (!ms) {
      return;
    }

    const returnValue = {
      value: 'something'
    };

    return new Promise((resolve) => {
      setTimeout(() => {
        // if we have a callback, call it right before the complete event
        if (cb) {
          cb.call(this.api);
        }

        resolve(returnValue);
      }, ms);
    });
  }
}

The `command` method can also be `async`. In this case, you only need to return a value because `async` methods return a Promise already.

Here's another example:

nightwatch/commands/customCommand.js

module.exports = class CustomCommand {
  async command() {
    let returnValue;
    try {
      returnValue = await anotherAsyncFunction();
    } catch (err) {
      console.error('An error occurred', err);
      returnValue = {
        status: -1,
        error: err.message
      }
    }

    return returnValue;
  }
}

##### Completion via the "complete" event

nightwatch/commands/customPause.js

const Events = require('events');

module.exports = class CustomPause extends Events {
  command(ms, cb) {
    // If we don't pass the milliseconds, the client will
    // be suspended indefinitely
    if (!ms) {
      return;
    }

    const returnValue = {
      value: 'something'
    };

    setTimeout(() => {
      // if we have a callback, call it right before the complete event
      if (cb) {
        cb.call(this.api);
      }

      // This also works: this.complete(returnValue)
      this.emit('complete', returnValue);
    }, ms);
  }
}

### Using Nightwatch protocol actions
Since **v1.4**, you can also directly use the protocol actions (via `this.transportActions`) which Nightwatch uses for its own built-in APIs. These are direct HTTP mappings to [Selenium JsonWire](https://github.com/SeleniumHQ/selenium/wiki/JsonWireProtocol) or [W3C Webdriver](https://www.w3.org/TR/webdriver/) protocol endpoints, depending on which one is currently in use.

Here's an example:

nightwatch/commands/customCommand.js

module.exports = class CustomCommand {
  async command() {
    let returnValue;

    // list all the avaialble transport actions
    // console.log(this.transportActions);

    try {
      returnValue = await this.transportActions.getCurrentUrl();
    } catch (err) {
      console.error('An error occurred', err);
      returnValue = {
        status: -1,
        error: err.message
      }
    }

    return returnValue;
  }
}

### Directly calling Selenium/Webdriver endpoints
Also, since **v1.4** you can (via `this.httpRequest(options)`) directly call the HTTP endpoints available on the Selenium/Webdriver server from custom commands.
This can be a convenient way to extend the provided API protocol, since it is using the same [HTTP request](https://github.com/nightwatchjs/nightwatch/blob/main/lib/http/request.js) interface as for the other protocol actions.

It can be especially useful when using a service which provides additional endpoints, like [Appium](http://appium.io/).

Here's an example:

nightwatch/commands/customCommand.js

module.exports = class CustomCommand {
  async command() {
    let returnValue;

    try {
      returnValue = await this.httpRequest({
        // the pathname of the endpoint to call
        path: '/session/:sessionId/url',

        // the current Selenium/Webdriver sessionId
        sessionId: this.api.sessionId,

        // host and port are normally not necessary, since it is the current Webdriver hostname/port
        //host: '',
        //port: '',

        // the body of the request
        data: {
          url: 'http://localhost/test_url'
        },

        method: 'POST'
      });
    } catch (err) {
      console.error('An error occurred', err);
      returnValue = {
        status: -1,
        error: err.message
      }
    }

    return returnValue;
  }
}

#### 2. Function-style commands
This is a simpler form in which commands can be defined, however they are also quite limited.

The command module needs to export a `command` function, which needs to call at least one Nightwatch api method (such as `.execute()`). This is due to a limitation of how the asynchronous queueing system of commands works. You can also wrap everything in a `.perform()` call. Client commands like `execute` and `perform` are available via `this`.

nightwatch/commands/customCommand.js

module.exports.command = function(file, callback) {
  var self = this;
  var imageData;
  var fs = require('fs');

  try {
    var originalData = fs.readFileSync(file);
    var base64Image = new Buffer(originalData, 'binary').toString('base64');
    imageData = 'data:image/jpeg;base64,' + base64Image;
  } catch (err) {
    console.log(err);
    throw "Unable to open file: " + file;
  }

  this.execute(function(data) {
    // execute application specific code
    App.resizePicture(data);
    return true;
  },
  [imageData], // arguments array to be passed
  function(result) {
    if (typeof callback === "function") {
      callback.call(self, result);
    }
  });

  return this;
};

The example above defines a command (e.g. resizePicture.js) which loads an image file as `data-URI` and calls a method named `resizePicture` (via `.execute()`), defined inside the application.

With this command, the test will look something like:

tests/sampleTest.js

module.exports = {
  "testing resize picture" : function (browser) {
    browser
      .url("http://app.host")
      .waitForElementVisible("body")
      .resizePicture("/var/www/pics/moon.jpg")
      .assert.element(".container .picture-large")
      .end();
  }
};

### Using async/await
You can also use ES6 `async`/`await` syntax inside function-style custom commands. Here's another custom command example:

module.exports = {
  command: async function () {
    this.url('http://nightwatchjs.org');
    this.waitForElementVisible('section#index-container');

    const result = await this.elements('css selector', '#index-container ul.features li');
    this.assert.strictEqual(result.value.length, 7, 'Feature elements number is correct');
  }
};

### Recommended content
- [Define custom assertions](https://nightwatchjs.org/guide/extending-nightwatch/adding-custom-assertions.html)

      ←

          Back
          Override device dimensions

          Next Page
          Define custom assertions

        →

repository: nightwatchjs/nightwatch-docs

repo_name: nightwatchjs/nightwatch-docs


text:
### Things to be done - in no particular order
* create bases classes we can inherit from, for example
    ```javascript
    class BaseOject() {
        location(x, y) : Vector
        size(width, height) : Vector, object literal, or individual width and height
        velocity(x, y) : Vector
        color : p5 color
    }
    ```
    * this should be good starting point to unify our other game things like:
    *box, box-dropper, and platform*

* handle orphaned boxes that have no connection to anything
* handle boxes that have connections beyond threshold *n*
* add commands and/or random events to change direction of the dropper or platform
* do the same for water and/or maybe have it vary itself over time
* drop boxes that can't fit screen on resize
* alternately scale things on resize to a min size

### General code changes
* refactor away duplicated code
* cleanup any TODO or FIXME comments
* improve comments in code so they make sense
* remove comments that are unecessary
* better structure code and files

repository: brooks-builds/stackit

gha_language: JavaScript

repo_name: brooks-builds/stackit


text:
---
title: July Update
date: 2017-07-21 13:41 UTC
author: Nathan
tags: monthly updates
---

Kelsie and Katelin started the month off with another talk for young moms, similar to the one they did back in [April.](https://www.daysinukraine.com/2017/04/april-update-2017/) The main difference was that this was more like a half-day seminar, with three different sessions, whereas last time, there was just one session. And like last time, the event was well-attended and well-received.

![Seminar for mothers](images/2017-07-group.jpg)

> Katelin, Kelsie, and the rest of the group.

##Bible First##

We are continuing to make progress on various aspects of Bible First. Maria Sanchez has basically finished the first draft of the Spanish translation, with only a few spots needing some cleanup. Ralph has been going great guns on converting Bible First text into Markdown format, which is necessary to make it available online. He has recently finished converting the English text, and has now moved on to the Ukrainian and Russian. I'm sure it won't be long before he moves on to the Spanish text!

##Family##

This month will go down in Day Family history as the month of the broken foot. Not long after the aforementioned seminar for young moms, Katelin went to the local market to buy strawberries and rolled her ankle in a pothole. An X-ray revealed that it was a break, not a sprain, so the doctor put Katelin's foot in a cast and told her to wear it for 3.5 weeks. The cast is now off, and Katelin is making steady progress in rehabilitating her foot.

All that to say, it's been a busy month on the home front! When she wasn't resting, Katelin did her best to keep things rolling around the house, but I still spent most of the month being Mr. Mom. It's a good thing that we skipped CMO this summer, because I would have had to bow out almost completely!

![Fountain](images/2017-07-fountain.jpg)

> One of many outings that I took the girls on this month. Briana was playing in a fountain, and I had to keep a tight hold on her, just in case she tried to go for a swim. ;)

gha_language: HTML


text:
# Street Address

The street address is often found at the top of the list of hand-entered data in the bottom half of the records. This field can appear as "No. of Street or Avenue", "House Number", "Premises", and "Location".

![record_street_address_image_1](/images/street_address_1.png)
***
![record_street_address_image_2](/images/street_address_2.png)
***
![record_street_address_image_3](/images/street_address_3.png)
***


text:
# JavaScript: Understanding the Weird Parts

- **Instructors**: Anthony Alicea
- **Length**: 11.5 hr
- **Link**: https://www.udemy.com/understand-javascript/
- **Resources**:

# Course Content

- [Section 01 - Getting Started](./Section%2001%20-%20Getting%20Started)
- [Section 02 - Execution Contexts and Lexical Environments](./Section%2002%20-%20Execution%20Contexts%20and%20Lexical%20Environments)
- [Section 03 - Types and Operators](./Section%2003%20-%20Types%20and%20Operators)
- [Section 04 - Objects and Functions](./Section%2004%20-%20Objects%20and%20Functions)
- [Section 05 - Object-Oriented Javascript and Prototypal Inheritance](./Section%2005%20-%20Object-Oriented%20Javascript%20and%20Prototypal%20Inheritance)
- [Section 06 - Building Objects](./Section%2006%20-%20Building%20Objects)
- [Section 07 - Odds and Ends](./Section%2007%20-%20Odds%20and%20Ends)
- [Section 08 - Examining Famous Frameworks and Libraries](./Section%2008%20-%20Examining%20Famous%20Frameworks%20and%20Libraries)
- [Section 09 - Let's Build a Framework / Library!](./Section%2009%20-%20Let's%20Build%20a%20Framework%20or%20Library!)
- [Section 10 - BONUS Lectures](./Section%2010%20-%20BONUS%20Lectures)
- [Section 11 - BONUS: Getting Ready for ECMAScript 6](./Section%2011%20-%20BONUS%2C%20Getting%20Ready%20for%20ECMAScript%206)
- [Section 12 - Conclusion](./Section%2012%20-%20Conclusion)

# Project Demo

# References

- [PJCHENder 那些沒告訴你的小細節 | [學習筆記目錄] JavaScript: Understanding the Weird Part（JavaScript 全攻略：克服 JS 的奇怪部分）](https://pjchender.blogspot.com/2017/06/javascript-understanding-weird-part.html)
- [那克斯的學習筆記 | [JS] 克服 JS 的奇怪部分](https://disp.cc/b/KnucklesNote?ti=9K9G)
- [2018 iT 邦幫忙鐵人賽 | JavaScript 基礎二三事](https://ithelp.ithome.com.tw/users/20104221/ironman/1403)

# Review

url: https://raw.githubusercontent.com/TheSYNcoder/Udemy-Notes/096c582f126910fe54e35bdd12878e2b3c977148/docs/JavaScript, Understanding the Weird Parts/README.md

repository: TheSYNcoder/Udemy-Notes

repo_name: TheSYNcoder/Udemy-Notes


text:
---
title: Accessing options
---

Options are available on the `options` key of from the object
passed to your part's draft method. You can destructure them for easy access.

```design/src/part.mjs
function draftPart = ({
  // highlight-start
  options,
  // highlight-end
  part
}) {

  const a = options.fitKnee
  const b = options[waistEase]

  return part
}
```

<Note>

Unlike measurements, options come with default values.

</Note>

repository: freesewing/freesewing

branch_name: refs/heads/develop

repo_name: freesewing/freesewing


text:
---
layout: default
---

# 1996-01-28 - Re: OpSec Snooping

## Header Data

From: Alan Horowitz<EMAIL_ADDRESS>To: Anonymous<EMAIL_ADDRESS>Message Hash: aec08d097ce98a8d927026722bc0670ee9233d74540ad50376fd9f9f3ef0a1bd

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1996-01-28 00:46:39 UTC

Raw Date: Sun, 28 Jan 1996 08:46:39 +0800

## Raw message

```
{% raw  %}From: Alan Horowitz<EMAIL_ADDRESS>Date: Sun, 28 Jan 1996 08:46:39 +0800
To: Anonymous<EMAIL_ADDRESS>Subject: Re: OpSec Snooping
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

I would like to see some factual evidence that active-duty or retired spooks
are better than my late grandmother at spotting a liar.

What spooks do have is, no lamer press and no
this-quarter's-numbers-define-my-universe stock analysts limelighting
their work. They can afford to work slowly, carefully, methodically. Being
a spook doesn't prove you do do that; it means you can, if you are
inclined to do so (and your bosswants you to do that).

Alan Horowitz
<EMAIL_ADDRESS>

{% endraw %}
```

## Thread

+ Return to [January 1996](/archive/1996/01)

+ Return to "[Alan Horowitz <alanh@infi.net>](/authors/alan_horowitz_alanh_at_infi_net_)"
+ Return to<EMAIL_ADDRESS>(Anonymous)](/authors/nobody_at_replay_com_anonymous_)"

+ 1996-01-27 (Sat, 27 Jan 1996 22:46:20 +0800) - [OpSec Snooping](/archive/1996/01/c9e347a3340351ee4af9d9438a8d669c5b977ac0f55a5451afc6d2d590099065) -<EMAIL_ADDRESS>(Anonymous)_
  + 1996-01-28 (Sun, 28 Jan 1996 08:46:39 +0800) - Re: OpSec Snooping - _Alan Horowitz<EMAIL_ADDRESS>


text:
# Pseudotremellodendron pusio var. tasmanicum (Lloyd) D.A. Reid, 1957 VARIETY

#### Status
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
null

#### Original name
Pterula tasmanica Lloyd, 1923

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Auriculariales/Tremellodendropsis/Tremellodendropsis flagelliformis/ Syn. Pseudotremellodendron pusio tasmanicum/README.md

repo_name: mdoering/backbone


text:
# Immutable collections

This project contains immutable collections that can be used in older Java projects.

## Usage

No maven or gradle configuration! Just copy the needed source files into your project.

## Collections

### ImmutableList

Implements a decorator for Lists which is immutable.

#### Creation

Use on of these factory methods:

```
    List<String> fromSingleItems = ImmutableList.of("A", "B", "C");
    List<String> fromArray = ImmutableList.of(new String[]{"A", "B", "C"});
```

For Streams you can collect the items:

```
    List<String> collectedFromStream = Stream.of("A", "B", "C")
            .collect(ImmutableList.collect());
```

### ImmutableMap

Implements a decorator for Maps which is immutable.

#### Creation

```
    Map<String, String> fromEntries = ImmutableMap.of(
            ImmutableMap.entry("1", "A"),
            ImmutableMap.entry("2", "B"),
            ImmutableMap.entry("3", "C")
    );

    Map<String, String> fromMap = ImmutableList.of(new HashMap<>());
```

For Streams you can collect the items:

```
    Map<String, String> collectedMap = yourStream
            .collect(
                    ImmutableMap.collect(
                            <keyMapperFunction>,
                            <valueMapperFunction>
                    )
            );
```

### ImmutableSet

Implements a decorator for Sets which is immutable.

#### Creation

Use on of these factory methods:

```
    Set<String> fromSingleItems = ImmutableSet.of("A", "B", "C");
    Set<String> fromArray = ImmutableSet.of(new String[]{"A", "B", "C"});
```

From `Collection`, `Iterable` or `Iterator`:

```
    Collection<String> collection = ImmutableList.of("A", "B", "C");
    Set<String> fromCollection = ImmutableSet.of(collection);

    Iterable<String> iterable = ImmutableList.of("A", "B", "C");
    Set<String> fromIterable = ImmutableSet.of(iterable);

    Set<String> fromIterator = ImmutableSet.of(collection.iterator());
```

For Streams you can collect the items:

```
    Set<String> collectedFromStream = Stream.of("A", "B", "C")
            .collect(ImmutableSet.collect());
```

repository: borisskert/java-immutable-collections

repo_name: borisskert/java-immutable-collections


text:
# Map View

The Map View shows all the location in the game on the game's maps. There are multiple
map views which can be selected by clicking on one of the buttons:

![Map View Selectors](images/map_views.png)

Each location is represented by a colored circle. The circles color indicates a the
availability of checks at that location:

- ![No Checks](images/loc-locked.png) No checks available. Even if some checks are
  complete, the location will be in this state if there are some checks that are
  not yet available.
- ![Some Checks](images/loc-unlocked.png) At least one check is available.
- ![All Checks Completed](images/loc-complete.png) All checks have been completed.
- ![Disabled](images/loc-disabled.png) If there are no checks at the locations
  because all its checks have been disabled by flags, it will not appear on the
  map.

Clicking one of the location circles will bring up the checks pop-up listing all
the checks at that location and their states. The checks are color coded
using the same scheme described in the [Key Item View](./03_02_quick_start_key_item_view.md) section.
Clicking outside the popup will close it.

repository: konkers/pollendina

gha_language: Rust

repo_name: konkers/pollendina


text:
# Multi-Instance Tasks and Batch Shipyard
The focus of this article is to explain how multi-instance tasks work in
the context of Azure Batch, Containers in both the
[Docker](https://www.docker.com/) and [Singularity](https://www.sylabs.io)
contexts, and Batch Shipyard.

## Overview
Multi-instance tasks are a special type of task in Azure Batch that are
primarily targeted for an execution that requires multiple compute nodes in
order to run. The canonical use case for multi-instance tasks are MPI jobs.
MPI jobs are typically run on a cluster of nodes where each node participates
in the execution by performing computation on a part of the problem and
coordinates with other nodes to reach a solution.

Batch Shipyard helps users execute containerized MPI workloads by performing
the necessary steps to stage either a Docker or Singularity container for
the multi-instance (MPI) job.

## MPI Runtime
Most popular MPI runtimes can operate with or without an integrated
distributed resource manager (launcher). In the case of Azure Batch on Linux,
the launcher is via remote shell. As the use of `rsh` is generally deprecated,
launchers typically default to `ssh`. The master node (i.e., the node from
where `mpirun` or `mpiexec` was invoked), will remote shell to all of the
other compute node hosts in the compute pool. In order for the master node to
know which nodes to connect to, runtimes typically require a host or node
list.

Once all of the nodes have been contacted and initialization of the MPI runtime
is complete across all of the nodes, then the MPI application can execute.

### Seamless MPI Runtime Integration
Batch Shipyard, as of version `3.8.0`, provides seamless MPI launch
integration for popular MPI runtimes, including OpenMPI, MPICH, MVAPICH,
and Intel MPI. Users can now specify simply the runtime they wish to use
and if the environment contains the proper runtime, the commandlines for
launching will automatically be populated. In the case of SR-IOV IB/RDMA VMs,
complexity of certain requirements such as exposing the IB PKEY are
automatically handled.

Please see the
[jobs configuration documentation](14-batch-shipyard-configuration-jobs.md)
for more information about the MPI interface available in Batch Shipyard.

## Singularity Containers and MPI
[Singularity](https://www.sylabs.io) containers are built for common
HPC scenarios. Thus, executing an MPI application works seamlessly with
the host - as if you are executing any other program.

### Singularity and MPI Mental Model
Since Singularity containers work as though you are executing any other
distributed program via MPI, there are no extra concepts to grasp.

```
+---------------+
|  MPI Program  |  << Singularity Container
+---------------+
+---------------+------------+
|  MPI Runtime  | SSH Server |
+---------------+------------+
+===============+============+
|     Operating System       |
+============================+
|  Host or Virtual Machine   |
+============================+
```

The MPI program in the Singularity container would be executed using
the host's `mpirun` (or `mpiexec`) command. Thus, the launcher would
take advantage of the host's SSH server and network stack allowing MPI
jobs to run within Singularity containers as if they were running on
the host OS.

## Docker Containers and MPI
Docker images for MPI applications must be carefully crafted such that
the MPI runtime is able to communicate properly with other compute nodes.
Outside of installing the necessary software required for MPI to run, the
difference is that images that use MPI must also install SSH client/server
software and enable the SSH server as the `CMD` with a port exposed to the
host. Remember, the container will be running isolated from the host, so if
you attempt to connect to the SSH server running on the host, the launcher
will attempt to initialize on the host with an MPI runtime that doesn't
exist.

### Docker and MPI Mental Model
Keeping the aforementioned basics in mind, we can construct a mental model
of the layout of how a Dockerized MPI program will execute.

The typical Docker package, distribute, deploy model usually ends up with an
image being run with `docker run`. This is fine for a large majority of  use
cases. However, for multi-instance tasks and MPI jobs in particular, a simple
`docker run` is insufficient because most (all?) MPI runtimes do not know how
to connect and initialize MPI running within a container on other compute
nodes.

```
+---------------+
|  MPI Program  |
|  MPI Runtime  |  << Docker Container
|  SSH Server   |
+---------------+
+---------------+------------+
| Docker Daemon | SSH Server |
+---------------+------------+
+===============+============+
|     Operating System       |
+============================+
|  Host or Virtual Machine   |
+============================+
```

The above layout shows the software stack from the host up through to the
Docker container. The MPI application running inside the container will need
to connect to other identical containers on other compute nodes.

Dockerized multi-instance tasks will use a combination of `docker run` and
`docker exec`. `docker run` will create a running instance of the Docker image
and detach it with the SSH server running. Then the `mpirun` or `mpiexec`
command will be executed inside the running container using `docker exec`.

### Azure Batch Compute Nodes and SSH
By default Azure Batch compute nodes have an SSH server running on them so
users can connect remotely to their compute nodes. Internally, the system
default SSH server is running on port 22. (However, this port is not mapped
through the load balancer as an instance endpoint on port 22). This can lead
to conflicts as described in the next section.

#### Dockerized MPI Applications and Azure Batch Compute Nodes
Because the internally mapped Docker container IP address is dynamic and
unknown to the Azure Batch service at job run time, the Docker image must
be run using the host networking stack so the host IP address is visible
to the running Docker container. This allows Docker MPI applications to
use `AZ_BATCH_HOST_LIST` which the Azure Batch service populates with all
of the IP addresses of other compute nodes involved in the multi-instance
task.

Because of this host networking requirement, there will be a conflict
on the default SSH server port of 22. Thus, in the Dockerfile, the
SSH server in the `CMD` command should be bound to an alternate port such
as port 23, along with the corresponding `EXPOSE` directive.

#### SSH User and Options
Because Docker requires running containers as root, all Batch Shipyard
jobs are invoked with elevated permissions. A side effect is that this
makes setting up the SSH passwordless authentication a bit easier.

The Docker container context, at runtime, should have the proper SSH keys
in the root or user context (if using user identities). These can be either
mounted in from the host OS, copied into the Docker image during build time
via `COPY`, or generated during build time. Note that if you copy or generate
the keys into your Docker image, publishing your Docker image will expose
your private RSA key. Although external users will not be able to SSH into
these running instances by default, as this SSH port is not exposed externally,
it can still be a security risk if a compute node is compromised. If this is
an unacceptable risk for your scenario, you should be mounting in a private
key into the Docker image at runtime which is not published as part of the
image build process.

Additionally, an `authorized_keys` file corresponding to the public key for
the user that will execute the task should be present within the Docker
container. SSH clients will also need to be transparently directed to
connect to the alternate port and ignore input prompts since these
programs will be run in non-interactive mode. If you cannot override your MPI
runtime remote shell options, you can use an SSH `config` file stored in the
respective root or user's `.ssh` directory alongside the keys:

```
Host 10.*
  Port 23
  StrictHostKeyChecking no
  UserKnownHostsFile /dev/null
```

Note the host wildcard, if the virtual network subnet for the Azure Batch
compute nodes does not start with 10.\* then this must be modified. In this
example port 23 is forced as the default for any ssh client connections to
destination hosts of 10.\* which would match the `EXPOSE` port in the Docker
image.

## Containers and Azure Batch Multi-Instance Tasks
Batch Shipyard supports Docker containers in `native` container supported
pools, in non-`native` pools and Singularity containers in non-`native`
pools for multi-instance tasks.

For `native` container supported pools and Singularity containers, Batch
Shipyard executes these tasks as normal multi-instance tasks would as either
Azure Batch natively understands how to handle these executions or that
they work the same as if the task is executing a multi-instance task on
the host.

For non-`native` container supported pools and Docker containers, Batch
Shipyard performs transformations to ensure that such executions are
possible. The following sub-sections explains the details for these
types of executions.

### Multi-Instance Task Coordination Command for non-`native` Docker containers
In an Azure Batch multi-instance task, a coordination command is executed on
all compute nodes of the task before the application command is run. As
described in the mental model above, a combination of `docker run` and
`docker exec` is used to execute an MPI job on Azure Batch with Docker.
The coordination command is the `docker run` part of the process which creates
a running instance of the Docker image. If the `CMD` directive in the Docker
image is not set (i.e., SSH server to execute), then an actual coordination
command should be supplied to Batch Shipyard.

### Multi-Instance Task Application Command for non-`native` Docker containers
The application command is the `docker exec` portion of the Docker MPI
job execution with Batch Shipyard. This is typically a call to `mpirun`
or `mpiexec` or a wrapper script that launches either `mpirun` or `mpiexec`.

### Cleanup for non-`native` Docker containers
As the Docker image is run in detached mode with `docker run`, the container
will still be running after the application command completes. Currently,
there is no "clean" way to perform cleanup from the Azure Batch API.
However, Batch Shipyard will automatically stop and remove these running
Docker containers via job release which will be triggered for any
`jobs term`, `jobs del`, or jobs which have `auto_complete` enabled.

To manually cleanup after multi-instance tasks, there are helper methods in
the Batch Shipyard toolkit. These methods will aid in cleaning up compute nodes
involved in multi-instance tasks in case there was an error in terminating
the Docker containers. Please refer to `jobs cmi` and `jobs cmi --delete`
actions in the [Batch Shipyard Usage](20-batch-shipyard-usage.md) doc.

## Automation!
Nearly all of the Docker or Singularity runtime complexities are taken care of
by Batch Shipyard. The user just needs to ensure that their MPI container
images are either constructed with the aforementioned accommodations and/or
are able to provide sufficient commands to the coordination/application
commands to work with the Azure Batch compute node environment.

As referred to earlier in this guide, Batch Shipyard now provides seamless
MPI runtime integration with popular frameworks.

## Which to choose for MPI? Docker or Singularity?
In the context of Batch Shipyard, both approaches are somewhat similar as
Batch Shipyard takes care of a lot of the complexity. However, if you are
using a Docker image, then you need to ensure that your image contains the
directives to install and start an SSH server (or whatever mechanism your
MPI runtime requires as a launcher).

Since Singularity is inherently easier to use in conjunction with MPI programs,
it may be beneficial to use Singularity to containerize your MPI application
instead of Docker. There is no need to package a launcher with your image
and is handled more elegantly in Batch Shipyard without the need to split
the execution and deal with potential cleanup artifacts if executing in
non-`native` mode. Additionally, there has been
[published research](https://arxiv.org/abs/1709.10140) to indicate that
Singularity outperforms other OS virtualization approaches for certain
benchmarks and is more amenable for HPC applications.

### More Information
For more general information about MPI and Azure Batch, please visit
[this page](https://azure.microsoft.com/documentation/articles/batch-mpi/).

## Example recipes and samples
Please visit the
[recipes directory](https://github.com/Azure/batch-shipyard/tree/master/recipes)
for multi-instance task samples.

repository: Azure/batch-shipyard

repo_name: Azure/batch-shipyard


text:
---
published: false
title: i13
layout: post
author: Yu
categories: v61
hidden: true
---

| 项目 | 具体内容 | 链接 |
|---:|---|---|
| 作者 | Arthur White, Thomas Brendan Murphy| |
| 题目 |BayesLCA: An R Package for Bayesian Latent Class Analysis | [下载地址](http://www.jstatsoft.org/v61/i13/paper) |
| 参考资料 |Vol. 61, Issue 13, Nov 2014 | |
| | 提交日期 2012-06-13, 接收日期 2014-07-11| |
| 类别 | 论文| |
| 摘要 | The BayesLCA package for R provides tools for performing latent class analysis within a Bayesian setting. Three methods for fitting the model are provided, incorporating an expectation-maximization algorithm, Gibbs sampling and a variational Bayes approximation. The article briefly outlines the methodology behind each of these techniques and discusses some of the technical difficulties associated with them. Methods to remedy these problems are also described. Visualization methods for each of these techniques are included, as well as criteria to aid model selection.| |
| 论文 | BayesLCA: An R Package for Bayesian Latent Class Analysis  (application/pdf, 2.2 MB)| [下载地址](http://www.jstatsoft.org/v61/i13/paper) |
| 补充材料 | | |
| |BayesLCA_1.6.tar.gz: R软件包源代码  (application/x-gzip, 29 KB)|  [下载地址](http://www.jstatsoft.org/v61/i13/supp/1) |
| |v61i13.R:            论文的示例程序  (application/octet-stream, 3.1 KB)|  [下载地址](http://www.jstatsoft.org/v61/i13/supp/2) |
| 资源 | [BibTeX](http://www.jstatsoft.org/v61/i13/bibtex) [OAI](http://www.jstatsoft.org/oai?verb=GetRecord&identifier=oai.jstatsoft/v61/i13&prefix=oai_dc)| |
| |  | [返回卷目录]({{site.baseurl}}/volume/v61.html) |

repository: yulijia/jstatsoft

repo_name: yulijia/jstatsoft


text:
# ![rutgers shield](https://github.com/njwest/ru-mmps/blob/master/shieldicon.png) Rutgers 2017 DSW Multimedia Projects (MMPs)

This is the repository for the 2017 Rutgers DSW Multimedia Projects presentation page, containing links to the 15 DSW Class of 2017 multimedia project websites in addition to an embedded Soundcloud playlist of their multimedia project podcasts.

This page was developed by Rutgers School of Social Work Instructional Designer Nick West.

The Rutgers 2017 MMP Page implements:

1. MaterializeCSS & JS
2. Scrollspy
3. vh CSS units(for landing page area)
4. Facebook Comments (currently deactivated, JS & bundle tag remain for quick implementation at program director's discretion)

**All Rutgers University images used in this project are ©2017 Rutgers University**

## To Do:
1. Fix scrollspy landing areas (headers are too low)
2. Beautify code
3. Add background texture, maybe differentiate sections visually

repository: njwest/ru-mmps

repo_name: njwest/ru-mmps


text:
### [CVE-2022-27223](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-27223)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

In drivers/usb/gadget/udc/udc-xilinx.c in the Linux kernel before 5.16.12, the endpoint index is not validated and might be manipulated by the host for out-of-array access.

### POC

#### Reference
- https://cdn.kernel.org/pub/linux/kernel/v5.x/ChangeLog-5.16.12

#### Github
- https://github.com/ARPSyndicate/cvemon

repository: trickest/cve

repo_name: trickest/cve