text:
Redi
----------

Pooled redis, add a layer of indirection between server pool and key ring

The idea comes from http://blog.zawodny.com/2011/02/26/redis-sharding-at-craigslist/

- - -
Install
----------
    gem install redi

Configure
----------
The configuration should look like a normal redis configuration with the addition of a buckets key.
This tells redi how many buckets it should hash keys to before mapping them to the configured server.

redi.yml:

    development:
      - :host: <IP_ADDRESS>
        :port: 6379
        :db: 0
        :buckets: 0 - 64
      - :host: <IP_ADDRESS>
        :port: 6380
        :db: 0
        :buckets: 65 - 127

In the example above, it is possible to scale the 2 configured servers up to 128 servers without
re-keying.
- - -

Adding a new server can be done as follows:

* start a new server process, call it r3.
* identify buckets to move to r3 from existing server r2.
* setup r3 as slave to replicate from r2.
* update configuration to point buckets to r3

<pre>
production:
 - :host: <IP_ADDRESS> # r1
   :port: 6379
   :db: 0
   :buckets: 0 - 64
 - :host: <IP_ADDRESS> # r2
   :port: 6380
   :db: 0
   :buckets: 65 - 95
 - :host: <IP_ADDRESS> # r3
   :port: 6380
   :db: 0
   :buckets: 96 - 127
</pre>

* use bucket key prefixes to prune old keys from r2.

  How you do this can vary depending on your application, but something like the pseudo code below is the idea:

    96..127.times do|i| # NOTE: using redis here not redi as we want to talk to r2 explicitly
      redis.del(redis.keys("n#{i}*"))
    end


text:
# Monitoring
## Prometheus
Get prometheus image
```
docker pull prom/prometheus
```
Set configuration of prometheus in prometheus.yml
```
# my global config
global:
  scrape_interval:     15s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
  evaluation_interval: 15s # Evaluate rules every 15 seconds. The default is every 1 minute.
  # scrape_timeout is set to the global default (10s).

# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
rule_files:
  # - "first_rules.yml"
  # - "second_rules.yml"

# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:
  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
  - job_name: 'prometheus'
    # metrics_path defaults to '/metrics'
    # scheme defaults to 'http'.
    metrics_path: '/actuator/metrics'
    scrape_interval: 5s
    static_configs:
    - targets: ['<IP_ADDRESS>:9090']

  - job_name: 'spring-actuator'
    metrics_path: '/actuator/prometheus'
    scrape_interval: 5s
    static_configs:
    - targets: ['HOST_IP:8080']
```
Run docker image
```
docker run -d \
    --name=prometheus \
    -p 9090:9090 \
    -v <PATH_TO_prometheus.yml_FILE>:/etc/prometheus/prometheus.yml \
    prom/prometheus \
    --config.file=/etc/prometheus/prometheus.yml
```
in my case this is
```
docker run -d \
    --name=prometheus \
    -p 9090:9090 \
    -v /home/bvpelt/Develop/mybatch/src/main/resources/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml \
    prom/prometheus \
    --config.file=/etc/prometheus/prometheus.yml
```
View prometheus at http://localhost:9090/

## Add grafana
```
docker run -d --name=grafana -p 3000:3000 grafana/grafana
```
View grafana at http://localhost:3000

Find network information of running prometheus container

```
docker inspect prometheus -f "{{json .NetworkSettings.Networks }}" | jq '.'
{
  "bridge": {
    "IPAMConfig": null,
    "Links": null,
    "Aliases": null,
    "NetworkID": "44061eb2412c4b4edc2f597860389a8a993aaf539a54e4d9ed1397b910588f1f",
    "EndpointID": "4a50ac0aef2e2bc21a7ca33da5d91acb42e052572a725c9e61445f0468700242",
    "Gateway": "<IP_ADDRESS>",
    "IPAddress": "<IP_ADDRESS>",
    "IPPrefixLen": 16,
    "IPv6Gateway": "",
    "GlobalIPv6Address": "",
    "GlobalIPv6PrefixLen": 0,
    "MacAddress": "02:42:ac:11:00:02",
    "DriverOpts": null
  }
}
```
Use the ipaddress of prometheus in grafana datasource configuration

license: MIT

repository: bvpelt/mybatch

branch_name: refs/heads/master

extension: md

gha_language: Java

gha_license_id: MIT

license_type: permissive

repo_name: bvpelt/mybatch


text:
# kuromoji-zeit
Zeit server that serves [kuromoji](https://github.com/takuyaa/kuromoji.js) data.

## Starting
This is a simple Nodejs Project:

```
$ npm install
added 7 packages in 1.582s

$ npm start
Tokenizer built!
Listening for requests.
```

## Usage

Simply send a request like `/?input=黒文字` and it will return JSON data with the kuromoji information.

## Example

The latest version of kuromoji-zeit is published online at https://kuromoji-zeit.now.sh

Try this in your browser:
 https://kuromoji-zeit.now.sh/?input=%E9%BB%92%E6%96%87%E5%AD%97

## License
MIT

repository: KadeerCanada/kuromoji-zeit

repo_name: KadeerCanada/kuromoji-zeit


text:
@PLUGIN@
========

The @PLUGIN@ plugin provides a mechanism to manage tasks which need to be
performed on changes. The @PLUGIN@ plugin creates a common place where tasks
can be defined, along with a common way to expose and query this information.
Task definition includes defining which changes each task applies to, and how
to determine the status for each task. Tasks are organized hierarchically.
This hierarchy is considered for task applicability and status.

An important use case of the @PLUGIN@ plugin is to have a common place for CI
systems to define which changes they will operate on, and when they will do
so. This makes it possible for independent and unrelated teams to setup
entirely independent CI systems which operate on different sets of changes,
all while exposing these applicability relations to Gerrit and other teams and
users. This also makes it possible for work for a single change to be split
across multiple cooperating CI systems so that assessments can be staged and
gated upon various other tasks or assessments first completing (or passing).

Exposing task applicability information helps users determine via Gerrit which,
if any, system will "take care" of their changes. Users can thus figure this
out without having the knowledge of "how to", or even "the ability to" query
the configuration of external CI systems. This also makes it possible for
conflicting systems to more easily be detected in cases when more than one
system is mistakenly configured to be responsible for the same changes.

Exposing task hierarchy information via Gerrit helps users understand the
workflow that is expected of their changes. It helps them visualize task
requirements and which tasks are expected to be completed before another task
will even be attempted. It helps them understand how their changes are, or
are not progressing through the outlined stages.

Exposing task status information helps users and CI systems determine via
Gerrit when it is appropriate for them to take action (to perform their task).
It helps them identify blocking tasks. It helps them figure out what they
can do, or perhaps who they need to talk to to ensure that their changes do
make progress through all their hoops.

Task definitions can be split up across multiple files/refs, and even
across multiple projects. This splitting of task definitions allows the
control of task definitions to be delegated to different entities. By
aligning ref boundaries with controlling entities, the standard gerrit ref
ACL mechanisms may be used to control who can define tasks on which changes.

Task Status
-----------
Task status is used to indicate either the readiness of a task for execution
if it has not yet completed execution, or the outcome of the task if it has
completed execution. Tasks generally progress from `WAITING` to `READY` as
their subtasks complete, and then from `READY` to `PASS` once the task itself
completes.

A task with a `WAITING` status is not yet ready to execute. A task in this
state is blocked by its subtasks which are not yet in the `PASS` state.

 All of its subtasks are
in the `PASS` state.

A task with a `PASS` status meets all the criteria for `READY`, and has
executed and was successful.

A task with a `FAIL` status has executed and was unsuccessful.

A task with a `INVALID` status has an invalid/missing definition or an
invalid query.

Tasks
-----
Tasks can either be root tasks, or subtasks. Tasks are defined in the
`All-Projects` project, on the `refs/meta/config` branch, in a file named
`task.config`. This file uses the gitconfig format to define tasks. The
special "True" keyword may be used as any query definition to indicate
an always matching query. The following keys may be defined in any
task section:

`applicable`

: This key defines a query that is used to determine whether a task is
applicable to each change. Since tasks are defined hierarchically, the
applicability of subtasks is inherently limited by the applicability of
all tasks above them in the hierarchy.

Example:
```
    applicable = status:open
```

`fail`

: This key defines a query that is used to determine whether a task has
already executed and failed for each change.

Example:
```
    fail = label:verified-1
```

`in-progress`

: This key defines a query that is used to determine whether a task is
currently in-progress or not. A CI system may use this to ensure that it
only runs one verification instance for a specific change. Either a pass
or fail key is mandatory for leaf tasks. A task with a fail criteria,
but no pass criteria, will pass if it otherwise would be ready. Setting
this to "True" is useful for defining blocking criteria that do not
actually have a task to execute.

Example:
```
    in-progress = label:patchset-lock,user=jenkins
```

`pass`

: This key defines a query that is used to determine whether a task has
already executed and passed for each change. Either a pass or fail key is
mandatory for leaf tasks. Tasks with no defined pass criteria and with
defined subtasks are valid, but they are only applicable when at least
one subtask is applicable. Setting this to "True" is useful for defining
informational tasks that are not really expected to execute.

A task with a `fail` key but no pass key has an implied `pass` key which is
the opposite of the `fail` key as if the fail had a `NOT` in front of it.
Such tasks can only pass, fail, or be waiting for their subtasks, they
can never be ready! If they have not failed, and their subtasks have
passed, they have passed also.

Example:
```
    pass = label:verified+1
```

`ready-hint`

: This key defines a hint when a task is `READY` describing what
accomplishing the tasks entails. This is meant to be a hint for humans
and may be used as a tool-tip.

Example:
```
    ready-hint = Needs to be verified by Jenkins
```

`fail-hint`

: This key defines a hint when a task is in the `FAIL` state describing why
the task is failing. This is meant to be a hint for humans and may be used
as a tool-tip.

Example:
```
    fail-hint = Blocked by a negative review score
```

`preload-task`

: This key defines a task whose attributes will be preloaded into the current
task before the current task's attributes are set. Most attributes defined
in the preload-task will be loaded first, and will be overridden by attributes
from the current task if they redefined in the current task. Attributes
which are lists (such as subtasks) or maps (such as properties), will be
preloaded by the preload-task and then extended with the attributes from the
current task. See [Optional Tasks](#optional_tasks) for how to define optional
preload-tasks.

Example:
```
    preload-task = Base Jenkins Verification # has a pass criteria and hints
```

`subtask`

: This key lists the name of a subtask of the current task. This key may be
used several times in a task section to define more than one subtask for a
particular task. See [Optional Tasks](#optional_tasks) for how to define
optional subtasks.

Example:

```
    subtask = "Code Review"
    subtask = "License Approval"
    ...
    [task "Code Review"]
    ...
    [task "License Approval"]
    ...
```

`subtasks-factory`

: A subtasks-factory key specifies a task-factory, which generates zero or more
tasks that are subtasks of the current task.  This key may be used several times
in a task section to reference tasks-factory sections.

Example:

```
    subtasks-factory = "static tasks factory"
    ...
    [tasks-factory "static tasks factory"]
    ...
```

`subtasks-external`

: This key defines a file containing subtasks of the current task. This
key may be used several times in a task section to define more than one file
containing subtasks for a particular task. The subtasks-external key points
to an external file defined by external section. Note: all of the tasks in
the referenced file will be included as subtasks of the current task!

Example:

```
    subtasks-external = my-external
```

`subtasks-file`

: This key defines a file containing subtasks of the current task. This
key may be used several times in a task section to define more than one file
containing subtasks for a particular task. The subtasks-file key points to
a file under the top level task directory in the same project and ref as the
current task file. Note: all of the tasks in the referenced file will be
included as subtasks of the current task!

Example:

```
    subtasks-file = common.config  # references the file named task/common.config
```

Root Tasks
----------
Root tasks typically define the "final verification" tasks for changes. Each
root task likely defines a single CI system which is responsible for verifying
and possibly submitting the changes which are managed by that CI system.
`applicable` queries for all root tasks should generally be defined in a non
overlapping fashion.

Root tasks are defined using "root" sections. A sample task.config which
defines 3 non overlapping CI systems might look like this:

```
[root "Jenkins Build"]
   applicable = status:open AND (project:a OR project:b) AND -branch:master
   ...

[root "Jenkins Build and Test"]
   applicable = status:open AND (project:a OR project:b) AND branch:master
   ...

[root "Buildbot"]
   applicable = status:open AND project:c
   ...
```

Subtasks
--------
Subtasks define tasks that must pass before their parent task state is
considered `READY` or `PASS`. Subtasks make it possible to define task
execution dependencies and ordering. Subtasks typically define all the
things that are required for change submission except for the final criteria
that will be assessed by the final verification defined by the change's root
task. This may include tasks that need to be executed by humans, such as
approvals like `code-review`, along with automated tasks such as tests, or
static analysis tool executions.

Subtasks are defined using a "task" section. An example subtask definition:

```
[task "Code Review"]
    pass = label:code-review+2
    fail = label:code-review-2
```

<a id="optional_tasks"/>
Optional Tasks
--------------
To define a task that may not exist and that will not cause the task referencing
it to be INVALID, follow the task name with pipe (`|`) character. This feature
is particularly useful when a property is used in the task name.

```
    preload-task = Optional Subtask {$_name} |
```

To define an alternate task to load when an optional task does not exist,
list the alterante task name after the pipe (`|`) character. This feature
may be chained together as many times as needed.

```
    subtask = Optional Subtask {$_name} |
              Backup Optional Subtask {$_name} Backup |
              Default Subtask # Must exist if the above two don't!
```
Tasks-Factory
-------------
A tasks-factory section supports all the keys supported by task sections.  In
addition, this section must have a names-factory key which refers to a
names-factory section.  In conjunction with the names-factory, a tasks-factory
section creates zero or more task definitions that look like regular tasks,
each with a name provided by the names-factory, and all using the task definition
set in the tasks-factory.

A tasks-factory section is referenced by a subtasks-factory key in a "task"
section.  A sample task.config which defines a tasks-factory section might look
like this:

```
[task "static task list"]
    subtasks-factory = static tasks factory
    ...

[tasks-factory "static tasks factory"]
    names-factory = static names factory list
    ...
```

Names-Factory
-------------
A names-factory section defines a collection of name keys which are used to
generate the names for task definitions.  The section should contain a "type"
key that specifies the type.

A names-factory section is referenced by a names-factory key in a "tasks-factory"
section.  A sample task.config which defines a names-factory section might look like
this:

```
[names-factory "static names factory list"]
    name = my a task
    name = my b task
    type = static
```

The following keys may be defined in any names-factory section:

`changes`

: This key defines a query that is used to fetch change numbers which will be used
as the names of the task(s).

Example:
```
    changes = change:1 OR change:2
```

`name`

: This key defines the name of the tasks.  This key may be used several times
in order to define more than one task. The name key can only be used along with
names-factory of type `static`.

Example:
```
    name = my a task
    name = 12345
```

`type`

: This key defines the type of the names-factory section.  The type
can be either `static` or `change`. For names-factory of type `static`,
`name` key(s) should be defined where as names-factory of type `change`
needs a `change` key to be defined.

Example:
```
    type = static
    type = change
```

External Entries
----------------
A name for external task files on other projects and branches may be given
by defining an `external` section in a task file. This later allows this
external name to then be referenced by other definitions. The following
keys may be defined in an external section. External references are limited
to files under the top level task directory.

`file`

: This key defines the name of the external task file under the
task directory referenced.

Example:

```
    file = common.config  # references the file named task/common.config
```

`user`

: This key defines the username of the user's ref in the `All-Users` project
of the external file referenced.

Example:

```
    user = first-user # references the sharded user ref refs/users/01/1000001
```

Properties
----------
The task plugin supplies the following properties which may be used anywhere in
a task, tasks-factory, or names-factory definition.

```
    ${_name}            represents the name of the current task
    ${_change_number}   represents the change number of the current change
    ${_change_id}       represents the change id of the current change
    ${_change_project}  represents the project of the current change
    ${_change_branch}   represents the branch of the current change
    ${_change_status}   represents the status of the current change
    ${_change_topic}    represents the topic of the current change
```

Examples:
```
    fail-hint = {$_name} needs to be fixed
    fail-hint = {$_change_number} with {$_change_status} needs to be fixed
    fail-hint = {$_change_id} on {$_change_project} and {$_change_branch} needs to be fixed
    changes = parentof:${_change_number} project:${_change_project} branch:${_change_branch}
```

Custom properties may be defined on a task using the following syntax:
```
    set-<property-name> = <property-value>
```

Subtasks inherit all custom properties from their parents, however
subtasks may override inherrited properties and give them new values.

Example:
```
    [task "foo-project"]
        set-project-name = foo
        subtask = sub-project
        subtask = common-to-many-projects

    [task "sub-project"]
        set-project-name = sub-foo # Overrides value from 'foo-project'
        subtask = common-to-many-projects

    [task "common-to-many-projects"]
        fail-hint = ${project-name} needs to be fixed
        ...
```

It is possible to define a custom property value and to export that value
to the json on the current task by using the following syntax:
```
    export-<property-name> = <property-value>
```

Example:
```
    [task "foo"]
        export-ci-system = jenkins
```

```
     "subTasks" : [
        {
           "exported" : {
              "ci-system" : "jenkins"
           },
           ...
           "name" : "foo",
           ...
        }
     ]
```

Change Query Output
-------------------
It is possible to add a task section to the query output of changes using
the task plugin switches. The following switches are available:

**\-\-@PLUGIN@\-\-applicable**

This switch is meant to be used to determine the state of applicable
tasks for each change, it outputs applicable tasks for a change.

**\-\-@PLUGIN@\-\-all**

This switch is meant as a debug switch, it outputs all tasks visible to the
calling user, whether they apply to a change or not. When this flag is used,
an additional 'applicable' property is included in each task output to
indicate whether the task actually met its applicability criteria or not.

**\-\-@PLUGIN@\-\-preview**

This switch is meant as a debug switch for previewing changes to task configs.
This switch outputs tasks as if the supplied change were already merged. This
makes it possible to preview the effect of proposed changes before going live
with them. Multiple changes may be previewed together.

**\-\-@PLUGIN@\-\-invalid**

This switch is meant as a debug switch to help find mis-configured tasks,
it causes only invalid tasks and the tasks in the tree hierarchy above them
to be output. To verify task validity, this change runs all queries defined
for a task, no matter what the tasks state is; this makes it possible to
detect some additional configuration problems which may not be detected when
running normally. If all tasks are properly configured, this switch should
not output anything. This switch is particularly useful in combination
with the **\-\-@PLUGIN@\-\-preview** switch.

**\-\-@PLUGIN@\-\-task\-\-evaluation-time**

This switch is meant as a debug switch to evaluate task performance. This
switch outputs an elapsed time value on every task indicating how much time
it took to evaluate a task and its subtasks.

When tasks are appended to changes, they will have a "task" section under
the plugins section like below:

```
  $ ssh -x -p 29418 example.com gerrit query change:123
  change I9fdfb1315610a8e3d5c48e4321193b7c265f30ae
  ...
  plugins:
    name: task
    roots:
      name: Jenkins Build and Test
      inProgress: false
      status: READY
      subTasks:
        name: code review
        status: PASS
```

Examples
--------
See [task_states](test/task_states.html) for a comprehensive list of examples
of task configs and their states.

See what the results will look when [previewing](test/preview.html) a change
to those states.


text:
# whatwg-url

whatwg-url is a full implementation of the WHATWG [URL Standard](https://url.spec.whatwg.org/). It can be used standalone, but it also exposes a lot of the internal algorithms that are useful for integrating a URL parser into a project like [jsdom](https://github.com/tmpvar/jsdom).

## Current Status

whatwg-url is currently up to date with the URL spec up to commit [a62223](https://github.com/whatwg/url/commit/a622235308342c9adc7fc2fd1659ff059f7d5e2a).

## API

### The `URL` Constructor

The main API is the [`URL`](https://url.spec.whatwg.org/#url) export, which follows the spec's behavior in all ways (including e.g. `USVString` conversion). Most consumers of this library will want to use this.

### Low-level URL Standard API

The following methods are exported for use by places like jsdom that need to implement things like [`HTMLHyperlinkElementUtils`](https://html.spec.whatwg.org/#htmlhyperlinkelementutils). They operate on or return an "internal URL" or ["URL record"](https://url.spec.whatwg.org/#concept-url) type.

- [URL parser](https://url.spec.whatwg.org/#concept-url-parser): `parseURL(input, { baseURL, encodingOverride })`
- [Basic URL parser](https://url.spec.whatwg.org/#concept-basic-url-parser): `basicURLParse(input, { baseURL, encodingOverride, url, stateOverride })`
- [URL serializer](https://url.spec.whatwg.org/#concept-url-serializer): `serializeURL(urlRecord, excludeFragment)`
- [Host serializer](https://url.spec.whatwg.org/#concept-host-serializer): `serializeHost(hostFromURLRecord)`
- [Serialize an integer](https://url.spec.whatwg.org/#serialize-an-integer): `serializeInteger(number)`
- [Origin](https://url.spec.whatwg.org/#concept-url-origin) [serializer](https://html.spec.whatwg.org/multipage/browsers.html#serialization-of-an-origin): `serializeURLOrigin(urlRecord)`
- [Set the username](https://url.spec.whatwg.org/#set-the-username): `setTheUsername(urlRecord, usernameString)`
- [Set the password](https://url.spec.whatwg.org/#set-the-password): `setThePassword(urlRecord, passwordString)`
- [Cannot have a username/password/port](https://url.spec.whatwg.org/#cannot-have-a-username-password-port): `cannotHaveAUsernamePasswordPort(urlRecord)`

The `stateOverride` parameter is one of the following strings:

- [`"scheme start"`](https://url.spec.whatwg.org/#scheme-start-state)
- [`"scheme"`](https://url.spec.whatwg.org/#scheme-state)
- [`"no scheme"`](https://url.spec.whatwg.org/#no-scheme-state)
- [`"special relative or authority"`](https://url.spec.whatwg.org/#special-relative-or-authority-state)
- [`"path or authority"`](https://url.spec.whatwg.org/#path-or-authority-state)
- [`"relative"`](https://url.spec.whatwg.org/#relative-state)
- [`"relative slash"`](https://url.spec.whatwg.org/#relative-slash-state)
- [`"special authority slashes"`](https://url.spec.whatwg.org/#special-authority-slashes-state)
- [`"special authority ignore slashes"`](https://url.spec.whatwg.org/#special-authority-ignore-slashes-state)
- [`"authority"`](https://url.spec.whatwg.org/#authority-state)
- [`"host"`](https://url.spec.whatwg.org/#host-state)
- [`"hostname"`](https://url.spec.whatwg.org/#hostname-state)
- [`"port"`](https://url.spec.whatwg.org/#port-state)
- [`"file"`](https://url.spec.whatwg.org/#file-state)
- [`"file slash"`](https://url.spec.whatwg.org/#file-slash-state)
- [`"file host"`](https://url.spec.whatwg.org/#file-host-state)
- [`"path start"`](https://url.spec.whatwg.org/#path-start-state)
- [`"path"`](https://url.spec.whatwg.org/#path-state)
- [`"cannot-be-a-base-URL path"`](https://url.spec.whatwg.org/#cannot-be-a-base-url-path-state)
- [`"query"`](https://url.spec.whatwg.org/#query-state)
- [`"fragment"`](https://url.spec.whatwg.org/#fragment-state)

The URL record type has the following API:

- [`scheme`](https://url.spec.whatwg.org/#concept-url-scheme)
- [`username`](https://url.spec.whatwg.org/#concept-url-username)
- [`password`](https://url.spec.whatwg.org/#concept-url-password)
- [`host`](https://url.spec.whatwg.org/#concept-url-host)
- [`port`](https://url.spec.whatwg.org/#concept-url-port)
- [`path`](https://url.spec.whatwg.org/#concept-url-path) (as an array)
- [`query`](https://url.spec.whatwg.org/#concept-url-query)
- [`fragment`](https://url.spec.whatwg.org/#concept-url-fragment)
- [`cannotBeABaseURL`](https://url.spec.whatwg.org/#url-cannot-be-a-base-url-flag) (as a boolean)

These properties should be treated with care, as in general changing them will cause the URL record to be in an inconsistent state until the appropriate invocation of `basicURLParse` is used to fix it up. You can see examples of this in the URL Standard, where there are many step sequences like "4. Set context object’s url’s fragment to the empty string. 5. Basic URL parse _input_ with context object’s url as _url_ and fragment state as _state override_." In between those two steps, a URL record is in an unusable state.

The return value of "failure" in the spec is represented by the string `"failure"`. That is, functions like `parseURL` and `basicURLParse` can return _either_ a URL record _or_ the string `"failure"`.

repository: nektos/act

gha_language: Go

repo_name: nektos/act


text:
# BugReporter

[![CI Status](http://img.shields.io/travis/eaceto/BugReporter.svg?style=flat)](https://travis-ci.org/eaceto/BugReporter)
[![Version](https://img.shields.io/cocoapods/v/BugReporter.svg?style=flat)](http://cocoapods.org/pods/BugReporter)
[![License](https://img.shields.io/cocoapods/l/BugReporter.svg?style=flat)](http://cocoapods.org/pods/BugReporter)
[![Platform](https://img.shields.io/cocoapods/p/BugReporter.svg?style=flat)](http://cocoapods.org/pods/BugReporter)
[![Twitter](https://img.shields.io/badge/twitter-@eaceto-blue.svg?style=flat)](http://twitter.com/eaceto)

BugReporter is a simple and elegant bug reporting tool for you apps.

- [Features](#features)
- [How to setup](#how-to-setup)
- [What BugReporter is not](#what-bugreporter-is-not)
- [Requirements](#requirements)
- [Communication](#communication)
- [Installation](#installation)
- [Usage](#usage)
- [Author](#author)
- [License](#license)

## Features

- [x] Detect 'take screenshot' event and fire a report
- [x] Create a report with information about the device and the application
- [x] Send report using email as channel
- [x] Send report using UIActivityViewController as channel
- [x] User can select how to send reports
- [x] User can dismiss sending a report
- [x] Load configuration from a property file (plist)
- [x] Notify reporting life cycle
- [ ] Detect shake gesture and fire a report
- [ ] Attach multiple images to a report
- [ ] Save report into file system if cannot be sent
- [ ] Send report to a backend

## What BugReporter is not

- BugReporter **is not** a crash reporting tool (like Crashlytics).
- BugReporter **will not** take screenshots of your app unless the user triggers a report event.

## How to setup

Include a file named *BugReporterSettings.plist* inside your project. The content of this property file should have at least one property called **applicationId** with a non-empty string value. This property will be used in future versions when integrating with a backend.

### reportsEMail
This property lets you specify a list of emails, used as default addresses when sending a report through email.

### Example file

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
    <plist version="1.0">
    <dict>
    	<key>applicationId</key>
    	<string>YOUR-APP-ID</string>
    	<key>reportEMails</key>
    	<array>
<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>
    	</array>
    </dict>
    </plist>

## Requirements

- iOS 8.0+
- Xcode 8.1+
- Swift 3.0+

## Communication

- If you **need help**, write me an e-mail
- If you **found a bug**, open an issue.
- If you **have a feature request**, open an issue.
- If you **want to contribute**, submit a pull request.

## Installation

BugReporter is available through [CocoaPods](http://cocoapods.org). To install
it, simply add the following line to your Podfile:

```ruby
pod "BugReporter"
```

## Usage

To run the example project, clone the repo, and run `pod install` from the Example directory first.

## Author

Ezequiel Aceto, ezequiel.aceto (at) gmail.com

## License

BugReporter is available under the MIT license. See the LICENSE file for more info.

repository: eaceto/BugReporter

gha_language: Swift

repo_name: eaceto/BugReporter


text:
---
layout: session
title: Introduction to Debugging
instructor: Stephane Ethier
instructor_title:  Principal Computational Physicist
instructor_affiliation: Princeton Plasma Physics Laboratory (PPPL)
---

Debugging is often the most time-consuming step of code development. Fortunately, there are several tools available to users to speed up this task and the ARM DDT debugger is probably the most advanced among them. While debugging a single processor code is already a daunting task, dealing with a large multi-processor code becomes a true challenge. Luckily, the DDT debugger can handle multi-processor codes as easily as single-processor ones. This presentation will give the participants practical knowledge of code debugging using DDT as well as other straightforward methods based on experience and good software development practices.

[Instructor bio]({{ site.baseurl }}/bios/stephane-ethier/)

## Session Materials ##
[Slides]({{ site.baseurl }}/sessions/debugging/Parallel_debugging_bootcamp_Oct2018.pdf)

repository: PrincetonUniversity/PUbootcamp

repo_name: PrincetonUniversity/PUbootcamp


text:
# infrastructure

Create a development environment of rankforce on Vagrant.

Need to install:
* VirtualBox
* Vagrant
* Ansible

## build
This environment is build for Dockerfile.

## test
This environment is unit test and integration test for rankforce.

## License
Licensed under the MIT
http://www.opensource.org/licenses/mit-license.php

repository: rankforce/infrastructure

repo_name: rankforce/infrastructure


text:
---------------------------------------------------------------------------------------------------------------------

by Batuhan Alkan submitted on August 2021

---------------------------------------------------------------------------------------------------------------------

# CarND-Path-Planning-Project
Self-Driving Car Engineer Nanodegree Program

### Simulator.
You can download the Term3 Simulator which contains the Path Planning Project from the [releases tab (https://github.com/udacity/self-driving-car-sim/releases/tag/T3_v1.2).

To run the simulator on Mac/Linux, first make the binary file executable with the following command:
```shell
sudo chmod u+x {simulator_file_name}
```

### Goals
In this project your goal is to safely navigate around a virtual highway with other traffic that is driving +-10 MPH of the 50 MPH speed limit. You will be provided the car's localization and sensor fusion data, there is also a sparse map list of waypoints around the highway. The car should try to go as close as possible to the 50 MPH speed limit, which means passing slower traffic when possible, note that other cars will try to change lanes too. The car should avoid hitting other cars at all cost as well as driving inside of the marked road lanes at all times, unless going from one lane to another. The car should be able to make one complete loop around the 6946m highway. Since the car is trying to go 50 MPH, it should take a little over 5 minutes to complete 1 loop. Also the car should not experience total acceleration over 10 m/s^2 and jerk that is greater than 10 m/s^3.

#### The map of the highway is in data/highway_map.txt
Each waypoint in the list contains  [x,y,s,dx,dy] values. x and y are the waypoint's map coordinate position, the s value is the distance along the road to get to that waypoint in meters, the dx and dy values define the unit normal vector pointing outward of the highway loop.

The highway's waypoints loop around so the frenet s value, distance along the road, goes from 0 to 6945.554.

## Basic Build Instructions

1. Clone this repo.
2. Make a build directory: `mkdir build && cd build`
3. Compile: `cmake .. && make`
4. Run it: `./path_planning`.

Here is the data provided from the Simulator to the C++ Program

#### Main car's localization Data (No Noise)

["x"] The car's x position in map coordinates

["y"] The car's y position in map coordinates

["s"] The car's s position in frenet coordinates

["d"] The car's d position in frenet coordinates

["yaw"] The car's yaw angle in the map

["speed"] The car's speed in MPH

#### Previous path data given to the Planner

//Note: Return the previous list but with processed points removed, can be a nice tool to show how far along
the path has processed since last time.

["previous_path_x"] The previous list of x points previously given to the simulator

["previous_path_y"] The previous list of y points previously given to the simulator

#### Previous path's end s and d values

["end_path_s"] The previous list's last point's frenet s value

["end_path_d"] The previous list's last point's frenet d value

#### Sensor Fusion Data, a list of all other car's attributes on the same side of the road. (No Noise)

["sensor_fusion"] A 2d vector of cars and then that car's [car's unique ID, car's x position in map coordinates, car's y position in map coordinates, car's x velocity in m/s, car's y velocity in m/s, car's s position in frenet coordinates, car's d position in frenet coordinates.

## Details

1. The car uses a perfect controller and will visit every (x,y) point it recieves in the list every .02 seconds. The units for the (x,y) points are in meters and the spacing of the points determines the speed of the car. The vector going from a point to the next point in the list dictates the angle of the car. Acceleration both in the tangential and normal directions is measured along with the jerk, the rate of change of total Acceleration. The (x,y) point paths that the planner recieves should not have a total acceleration that goes over 10 m/s^2, also the jerk should not go over 50 m/s^3. (NOTE: As this is BETA, these requirements might change.

2. There will be some latency between the simulator running and the path planner returning a path, with optimized code usually its not very long maybe just 1-3 time steps. During this delay the simulator will continue using points that it was last given, because of this its a good idea to store the last points you have used so you can have a smooth transition. previous_path_x, and previous_path_y can be helpful for this transition since they show the last points given to the simulator controller with the processed points already removed. You would either return a path that extends this previous path or make sure to create a new path that has a smooth transition with this last path.

## Tips

A really helpful resource for doing this project and creating smooth trajectories was using http://kluge.in-chemnitz.de/opensource/spline/, the spline function is in a single hearder file is really easy to use.

---

## Dependencies

* cmake >= 3.5
  * All OSes: [click here for installation instructions](https://cmake.org/install/)
* make >= 4.1
  * Linux: make is installed by default on most Linux distros
  * Mac: [install Xcode command line tools to get make](https://developer.apple.com/xcode/features/)
  * Windows: [Click here for installation instructions](http://gnuwin32.sourceforge.net/packages/make.htm)
* gcc/g++ >= 5.4
  * Linux: gcc / g++ is installed by default on most Linux distros
  * Mac: same deal as make - [install Xcode command line tools]((https://developer.apple.com/xcode/features/)
  * Windows: recommend using [MinGW](http://www.mingw.org/)
* [uWebSockets](https://github.com/uWebSockets/uWebSockets)
  * Run either `install-mac.sh` or `install-ubuntu.sh`.
  * If you install from source, checkout to commit `e94b6e1`, i.e.
    ```
    git clone https://github.com/uWebSockets/uWebSockets
    cd uWebSockets
    git checkout e94b6e1
    ```

## Editor Settings

We've purposefully kept editor configuration files out of this repo in order to
keep it as simple and environment agnostic as possible. However, we recommend
using the following settings:

* indent using spaces
* set tab width to 2 spaces (keeps the matrices in source code aligned)

## Code Style

Please (do your best to) stick to [Google's C++ style guide](https://google.github.io/styleguide/cppguide.html).

## Project Rubric
**Compilation**

**1-The code compiles correctly.**

![](/bild1.png)

**2- Valid trajectories**

I ran the simulator for 6.70 miles without an incident.

**3- Speed and Acceleration Limits**

No speed limit red message was seen.

Car does not have collisions.

**4- Staying in the Lane**

The car stays in its lane most of the time, but may change lanes or stop in the middle lane due to traffic.

![](/gerade.gif)

**5- Lane Change**

The car can easily change lanes when it makes sense, e.g. B. behind a slower moving car and when there is no other traffic in a neighboring lane.

![](/uberholen.gif)

## Reflection

The path planning algorithms and Sensor Fusion algorithms start at src/main.cpp. A helper function (spline.h) is added for this project.

***The Path Planning module is broken down into the following set of 3 sub-modules:***

![](/bild2.png)

  -  **Prediction:** Prediction of the trajectories of the surrounding detected objects.
 in this Project **Lines between 69-152** in main.cpp commense with to get data from sensor fusion including localization data in order to predict the positions for the surrounding cars.It basically checks whether there are cars in other lanes. This step is critical to avoid collision.Each lane is divided into 3 segments of 30 m and each segment contains information about the vehicle speed and the vehicle value. The road matrix is filled with corresponding values from sensor fusion data so that the behavior planning module can see the road situation for 90 m ahead for 3 lanes and plan the vehicle behavior accordingly. A 3x3 matrix was used for simplicity. A larger matrix with shorter segments (like 5m) depicting a road situation around the car could be used to produce more advanced behavior.

  - **Behavior:** Defines a set of possible high-level targets for the tool to follow. In this Project **Lines 154-184** in main.cpp determine whether the ego car should accelerate / brake or change lanes. The reference speed is also set here in order to prevent the speed limit from being exceeded. When a car is detected in the same lane up to 30 meters ahead, it checks the 1st and 2nd segments of other lanes to find the lane with less traffic. When all lanes are occupied, the vehicle reduces its speed and holds the lane waiting while the adjacent lane is available again. If the distance quickly decreases to 15 m or less, the behavior planner applies an “emergency brake” to avoid a possible collision.

   - **Trajectory:** An exact path is calculated for each possible high-level target. For each trajectory, costs (based on feasibility, safety, legality, convenience, and efficiency) are derived and the trajectory with the lowest cost is selected. In this Project **Lines 187 through 295 in main.cpp**are the orbital creation part. This section essentially creates the trajectories using the output of the behavior planning section. It is very important that the trajectory created is smooth. Otherwise, undesirable accelerations can occur. For this purpose, past trajectory points are copied and waypoints filled with splines. The acceleration depends on each point on the trajectory to maintain dynamic decision making as traffic conditions can change abruptly. Therefore, the ego car can change its speed when changing lanes.

 ![](/seiten.gif)

## Coordinate transforms

Before going into the main.cpp file details, discuss process models, mentioning "Frenet coordinates", which are a more intuitive representation of the position on a street than traditional (x, y) Cartesian coordinates. With Frenet coordinates, the variables s and d are used to describe the position of a vehicle on the road. The s-coordinate represents the distance along the road (also known as longitudinal displacement) and the d-coordinate represents the lateral position on the road.

 ![](/oben.gif)

repository: Wankelb/ND-Highway-Driving-

branch_name: refs/heads/main

repo_name: Wankelb/ND-Highway-Driving-


text:
# laravel-imap

## Install

1. In your terminal via composer:

``` bash
composer require Frnwtr/laravel-imap
```

2. Add this provider to your config/app.php :
```
Frnwtr\LaravelImap\Providers\LaravelServiceProvider::class,
```

3. Publish config file
```
php artisan vendor:publish --provider="Frnwtr\LaravelImap\Providers\LaravelServiceProvider"
```
then Define host, username, password, etc in your ``` config/imap.php ```.

## Usage

Example usage:

```php
use Frnwtr\LaravelImap\Client;
use Frnwtr\LaravelImap\Mailbox;

// ...

$client = new Client();
$client->connect();

$mailboxes = $client->getFolders();
foreach($mailboxes as $mailbox) {
    dump($mailbox->getMessages());
}
```

## Change log

Please see [CHANGELOG](CHANGELOG.md) for more information what has changed recently.

## Security

If you discover any security related issues, please email<EMAIL_ADDRESS>instead of using the issue tracker.

## Credits

- [Frnwtr](http://github.com/Frnwtr)

## License

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

[link-author]: https://github.com/Frnwtr

repository: frnwtr/laravel-imap

repo_name: frnwtr/laravel-imap


text:
Common Go regex patterns
========

A collection of common regex patters for Go.

## Usage

```
import (
	"fmt"
	"github.com/jsimnz/go-pattern"
)

func main() {
	url := "http://github.com"
	if pattern.Url.Match(url) {
		fmt.Println("Corret URL!")
	} else {
		fmt.Println("Sorry, invalid URL!")
	}
}

// The overall pattern for the regex common package
// is to call Match(s string) on any given pattern
// Ex
//    pattern.<Pattern>.Match(s string) bool
//
// Look below for available patterns

```

## Patterns

```
Numeric 				- 	Numeric values.
Alpha 					-	Characters and letters (upper and lower case).
AlphaNumeric 			- 	Numbers and letters (upper and lower case).
AlphaCapsOnly			-	Upper case characters only.
AlphaNumericCapsOnly	-	Numeric values and upper case only characters.
Url 					-	Match a url patter. Can match http, https, ftp, ftps, no-scheme, no www. (See test).
Email 					-	Match an email pattern<EMAIL_ADDRESS>HashtagHex				-	Match hexidecimal prefixed with '#' (IE #afe), commonly used for colors.
ZeroXHex				-	Match C syntax 0x hexidecimal typing (IE 0xAF, only upper characters or only lower).
IPv4					-	Match an IPv4 address, (IE. <IP_ADDRESS>)
IPv6					-	Match an IPv6 address,

More to come...
```

## Create your own pattern

Each pattern is defined on a simple Pattern struct, and uses the standard syntax pattern.<Pattern>.Match(string) bool
```
YouPattern := pattern.New("regex-pattern")
// Then you can use it as normal
YouPattern.Match(string)
```

## Install
```
go get github.com/jsimnz/go-pattern
```

## Status
Currently still under development, breaking changes may be introduced untill otherwise stated, do not use for production.

## Contribute
- Fork It
- Add your own Pattern in top 'var' block
- Create pull request
- Be happy! :smile:

## Author
- [jsimnz](https://github.com/jsimnz)

## LICENCE
The MIT License (MIT)

Copyright (c) 2014 John-Alan Simmons

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

repository: jsimnz/go-pattern

repo_name: jsimnz/go-pattern


text:
---
layout: default
---

# 1992-10-26 - entropy, with code

## Header Data

From: Eric Hughes<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 5f88f40e56048dc684e34fc31f79e7a1a73f66a8cecc1c82fe0173e912f60644

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1992-10-26 19:58:58 UTC

Raw Date: Mon, 26 Oct 92 12:58:58 PPE

## Raw message

```
{% raw  %}From: Eric Hughes<EMAIL_ADDRESS>Date: Mon, 26 Oct 92 12:58:58 PPE
To<EMAIL_ADDRESS>Subject: entropy, with code
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

The entropy-calculating code is at the end of this message.  I took
the opportunity to calculate some sample entropies:

entropy.c	5.283772	the source code
entropy.asc	6.052222	entropy.c, encrypted and armored
entropy.as2	6.012493	entropy.asc, with the wrappers removed
entropy.pgp	7.830532	entropy.c, encrypted alone
entropy.obj	6.112890
entropy.exe	6.947111
randseed.bin	4.584963	from pgp, 24 bytes long
pubring.pgp	7.754017	my public key ring

The entropy of the source code is in the high end of the range for
English, which is not surprising given the amount of symbols in
ordinary C code.  The entropy increases with the object and the
executable, each of which has less overt structure to it.

The entropy of the encrypted and ascii armored source code is within
1% of 6 bits, just as predicted.  And with the wrappers removed, it's
even closer!  The binary version of the encrypted message has the
highest entropy of all these tests.

In randseed.bin, the entropy is much less than 8.  But the length of
the file is 24 bytes and log_2 24 = 4.584963, indicating that there
are no duplicate bytes in the file.  Hence the warning:  entropy
calculations with small samples _will_ be misleading.

Note that the entropy subroutine can be used to calculate the
frequencies of any distribution.  This will allow all you code-writing
cypherpunks to measure bit entropies, digram entropies, etc.

Eric

----------------------------------------------------------------

/* entropy.c -- Calculate monogram entropies of standard input.
 */

#include <stdio.h>
#include <math.h>

/* This next define is to counteract the foolish C 7.00 runtime mapping
 * of \x1A to EOF
 */
#define STUPID_NEWLINE_TRANSLATE	1

#ifdef STUPID_NEWLINE_TRANSLATE
#include <io.h>
#include <fcntl.h>
#endif

/*--------------------------------------*/
#define NUMBER_OF_BYTES		256
long byte_freq[ NUMBER_OF_BYTES ] ;

void
main()
{
	int c, verbose = 0 ;
	unsigned int j ;
	double entropy( long *, int ) ;

#if STUPID_NEWLINE_TRANSLATE
	_setmode( _fileno( stdin ), _O_BINARY ) ;
#endif

	for ( j = 0 ; j < NUMBER_OF_BYTES ; ++j ) {
		byte_freq[ j ] = 0 ;
	}

	while ( EOF != ( c = getchar() ) ) {
		++ byte_freq[ (unsigned int) c ] ;
	}

	if ( verbose ) {
		for ( j = 0 ; j < NUMBER_OF_BYTES ; ++j ) {
			printf( "%3d=%-3d ", j, byte_freq[ j ] ) ;
			if ( j % 8 == 7 ) printf( "\n" ) ;
		}
	}

	printf( "%lf\n", entropy( byte_freq, NUMBER_OF_BYTES ) ) ;
}

/*--------------------------------------*/
/* Calculates the entropy of the distribution given in list v of n elements.
 * The list v gives counts.  v is summed, and frequencies are assigned
 * as v[i]/sum(v).
 *
 * Uses the following definitions and identities:
 *   A = \Sum_{i=0}^{n-1} v_i
 *   p_i = v_i / A
 *   H = \Sum_{i} - p_i \log p_i
 *	   = log A - 1/A \Sum_{i} v_i \log v_i
 *   lim_{x \rightarrow 0} x \log x = 0
 */

double
entropy( long *v, int n )
{
	double h ;
	long sum ;
	int j ;

	/* first sum the array
	 */
	sum = 0 ;
	for ( j = 0 ; j < n ; ++j ) {
		sum += v[ j ] ;
	}

	/* next calculate the entropy function
	 */
	h = 0 ;
	for ( j = 0 ; j < n ; ++ j ) {

		/* If the frequency is zero, the entropy contribution is zero
		 */
		if ( v[ j ] == 0 ) continue ;

		h -= v[ j ] * log( v[ j ] ) ;
	}
	h /= sum ;
	h += log( sum ) ;

	/* Now adjust the base of the logarithm to base 2
	 */
	h /= log( 2 ) ;

	return h ;
}

{% endraw %}
```

## Thread

+ Return to [October 1992](/archive/1992/10)

+ Return to "[Eric Hughes <hughes@soda.berkeley.edu>](/authors/eric_hughes_hughes_at_soda_berkeley_edu_)"

+ 1992-10-26 (Mon, 26 Oct 92 12:58:58 PPE) - entropy, with code - _Eric Hughes<EMAIL_ADDRESS>


text:
# Getting started

Please see the data sheet for information on the feather board and associated pin out.

In addition to the technical document, please refer to the MSP432P401R bootloader uploading instructions from Texas Instruments that can be found below.

MSP432 bootloader instructions

path: /technical documentation/readme.md


text:
---
layout: post
title:  "Git - The Fire of the Gods"
date:   2020-07-28
excerpt: "Git is ubiquitous in technology development - why is it so important?"
description: "Git is ubiquitous in technology development - why is it so important?"
image: "/img/prometheus_git.png"
sitemap: true
show: true
---
## Git - the main enabler for technology development.

This article discusses Git, the main technology underpinning all software development which allows software developers to effortlessly employ a 4, 6 or more eyes principle when making changes. Git is a version control and change control system for storing code, enabling technical teams to freely and safely work together. How, why and when should less technical teams use Git and a real programming language for their own competitive benefit?

Many important business decisions are based on flawed spreadsheet documents prepared by domain professionals. We cripple the performance and value of these professionals by expecting their output in the form of spreadsheets. These processes, simulations, business cases & calculations almost always suffer from hidden errors, logical flaws, etc. as the volume and complexity of data exponentially grows.

This gap can be overcome by teaching these professionals a programming language and a collaborative development process based on Git. Giving them the power of effortless change management and peer review will dramatically reduce the rate of errors and improve individual performance. Python is an easy choice as a programming language, it is easy to learn, powerful and by far the most popular programming language in the world today.

Python Skill Sprints are an intense two week program to teach a pair of less-technical people basic Python software development by getting them to immediately deliver something to their team. The participants are led by an external expert who teaches, coaches and supports their journey into new ways of working with Python and Git.

## Tech Teams and Git

Today, it feels like “Tech” as an industry, group or concept is somehow losing its way. The technical community is climbing higher and higher into more and more esoteric technologies such as blockchain or artificial intelligence. Tech has raced ahead from the society which it supposedly endeavors to serve.

One problem that tech does not have however, is change management. With all their assets written in code and stored in the version control system “Git” - these organisations are able to rapidly change whilst still maintaining operational efficiency. Software developers are able to make changes to their codebase in a safe way with comprehensive but effortless processes for peer reviewed changes. Git it truly the source of power for technology teams.

Git is a bit of a weird animal - sometimes obscure and difficult to use. The team behind the Linux kernel - the core part of the Android smartphone operating system and the majority of the world internet facing servers - created Git to track changes to this humongous project. It is now ubiquitous in software development.

Similar to Google Drive or Dropbox which synchronise the contents of a folder on our computers to a cloud server, a Git repository allows us to synchronize our files to a cloud server with *very* precise controls. It can have virtually unlimited people working with the repository - all making their own changes within their branches. One person can check out the work of another with a couple of clicks or simple commands. Git is the ultimate collaboration tool from which the tech industry stems its power.

### Distributed Git

The Linux Kernel team is very distributed with thousands of members sitting in every country of the world  - so Git had to be a distributed system. Every developer has a full copy of the project on their local machines with only the changes they make pushed to one or more central “Git servers”.

### Committing Git

Whilst we can store any kind of file in Git such as Microsoft Office documents - the full change control functionality only works with raw text. All programming languages and a lot of interesting data storage formats are raw text.

Within Git - our code is stored as a series of 'commits'. Each commit is a record of lines added or deleted and a reference to the previous commit. In the diagram below we can see three commits. The green lines are additions and the red lines deletions. The digits indicate line numbers.

So git provides us with line-by-line atomistic change control, access control and versioning. We can access any commit or check out our colleagues´ branches with a single click or command. And we haven't even started talking about Git Operations (GitOps) yet.

### Branching Git

Branches can be somewhat difficult to understand. We can think of them as a kind of linked copy of the live ‘master’ code. Someone can create a branch from the master branch and safely make changes there. When they have something working they can ‘merge’ their code back into the master branch.

Here we can see a concrete example. Amanda is able to finish off the nursery rhyme whilst protecting the integrity of the live version in the master branch. At commit ‘x’ Amanda and Keith are able to see the whole poem with the new lines and are able to make a decision if it should be merged or if further changes should be made.

## Why is Git so important to tech

There are around 10 core programming languages and hundreds of thousands of libraries, modules that enhance the capabilities of the programming language. Development teams have incredible choice in the tools they use, apart from one thing. Git.

Git can be very complex, difficult to use and probably impossible to master. Most developers will freely admit the shallowness of their understanding. They have all got themselves into a pickle with it at some point. But all developers are productive with it and learn to appreciate its power. Git provides these teams with incredible flexibility and safety enabling them to develop complex systems extremely quickly. With spreadsheets we scrape in the mud, trapped into the eternal servitude of copy and paste. To rise above - we must steal this fire from the gods and harness its power.

## Skill Sprints

A Skill Sprint is an intense real-world learning experience for teams looking to embrace new technologies. During a Skill Sprint the participants learn new skills by directly delivering something to their organisation.

Further Reading - The Peril of Shadow IT

	The liabilities that Excel exposes us to are only getting worse as our jobs become more and more data orientated and the volume and complexity of this data increases exponentially. How can Python and Git deliver us from the copy and paste quagmire?

repository: mooperd/darwinist-website

repo_name: mooperd/darwinist-website


text:
---
layout: page-no-title
title: "Resume"
comments: false
sharing: false
---

## Education

**Stanford University**
PhD Candiate in Biophysics
_in progress_

**UC San Diego Class of 2014**
B.S. Bioinformatics, Minor in Mathematics

Biochemistry, physical chemistry,
molecular and cellular biology, organic chemistry, algorithms, statistics, bioinformatics, numerical analysis,
linear algebra and more

Graduate-level computational chemistry, physical chemistry, and numerical methods

## Computer Skills

**Languages:  ** C, Python, C++, Perl, Bash, FORTRAN, MPI, OpenMP, CUDA, Java, mySQL, LaTeX

**Operating Systems:  ** Linux, Unix, Windows, Apple

**Software:  ** AMBER, Maestro, Gaussian, GAMESS, ADF, Visual Studio, many others

**Libraries:  ** netCDF, video4Linux, OpenMP, MPI, VMD, CUDA

## Employment

_2011-2014  _**San Diego Supercomputer Center  **Member of the Walker Molecular Dynamics Lab, developer for AMBER MD software

_2013  _**Amgen Scholars Program  **Worked with Dr. Simpson Joseph to perform FRET analysis of influenza and host protein interaction

_2012-2013  _**Pfizer, Inc  **Cataloged protein-ligand interactions into searchable database for evaluating reliability of docked poses for potential drug molecules

_2010-2011  _**Calit2  **Programmer for Scalable City experimental game project

_2010  _**National Oceanic and Atmospheric Administration  **Created mathematical model of ocean temperatures to predict coral reef bleaching location and severity

## Teaching
_2016  _**Robot Programming  **_Stanford Pre-Collegiate Summer Institute  _Teaching Assistant

_2015  _**Physical Biology of the Cell  **_Stanford  _Teaching Assistant

_2015  _**Cell Biology  **_UC San Diego  _Teaching Assistant

_2013  _[**Bioinformatics Algorithms Coursera**](https://www.coursera.org/course/bioinformatics)  _Coursera  _Community Teaching Assistant

_2013  _**Metabolic Biochemistry  **_UC San Diego  _Teaching Assistant

_2012  _**Molecular Biology  **_UC San Diego  _Teaching Assistant

## Awards

+ **NSF Graduate Research Fellow  **_2014_
+ **DOE Computational Science Graduate Fellow** (declined)  _2014_
+ **Best Paper and Best Presentation, IEEE SE-CSE  **_2013_
+ **Amgen Scholar  **_2013_
+ **Calit2 Undergraduate Fellow**
+ **IEEExtreme Programming Competition**
+ **NCWIT Award for Aspirations in Computing**

repository: Eigenstate/octopress

extension: markdown

repo_name: Eigenstate/octopress


text:
# mw-speechsynth

JavaScript drop-in to provide
[Speech Synthesis](https://dvcs.w3.org/hg/speech-api/raw-file/tip/speechapi.html#tts-section)
support for Mediawiki content.

# Todos

1. Express as real library with initialization code
    1. Allow for supplying of custom selectors to ignore (removing the ones currently added for bahai.works)


text:
# cogbot
A collection of [discord.py](https://github.com/Rapptz/discord.py) wrappers and extensions.

You can [run a bot](#running-a-bot) without writing any code. All you need are the [dependencies](#dependencies) and some [configuration](#configuration) options.

## Dependencies
* [Python](https://www.python.org/) 3.6+
* See [requirements.txt](./requirements.txt)

## Running a bot
See [examples/run.sh](./examples/run.sh) for an example script that runs a bot using one of the sample configuration files. You can copy and run it, replacing arguments as necessary. Note that you will need to provide **your own bot token**.

### Configuration
These are the generic configuration options available for bots. They may be defined in the state file (specified by `--state`) or passed into the bot state object programmatically.

| Option                        | Type  | Default   | Description
| ----------------------------- | ----- | --------- | -----------
| command_prefix                | str   | `'>'`     | The message prefix used by the bot to detect commands.
| description                   | str   | `''`      | A description of the bot, displayed by the help command.
| managers                      | list  | `[]`      | A list of user ids who are allowed to manage the bot.
| staff_roles                   | list  | `[]`      | A list of role ids that should be given elevated access (admins, moderators, etc).
| recovery_delay                | float | `10`      | The number of seconds until the bot will attempt to recover after crashing.
| notify_on_recovery            | bool  | `True`    | Whether to notify managers after the bot recovers from a crash.
| hide_help                     | bool  | `False`   | Whether the built-in help command should be hidden.
| react_to_command_cooldowns    | bool  | `False`   | Whether to send a reaction to the user when they are being rate limited.
| react_to_unknown_commands     | bool  | `False`   | Whether to send a reaction to the user when they enter an unknown command.
| extensions                    | list  | `[]`      | A list of [bot extensions](#extensions) to use.
| extension_state               | dict  | `{}`      | A mapping of extension name to [extension-specific state](#extension-configuration).

### Extensions
Extensions are specialized Python scripts that integrate with the bot to provide additional functionality. On startup, they are loaded in the same order as defined in the bot configuration `extensions` list.

There are several extensions already available in this repository, however none of them are loaded by default.

### Extension configuration
Some extensions may be provided with their own specific configuration, by defining an entry in the `extension_state` mapping.

See [examples/with_extension_state.json](./examples/with_extension_state.json) for a complete example.

repository: Arcensoth/cogbot

gha_language: Python

repo_name: Arcensoth/cogbot


text:
# ChessPGN
This repository contains a collection of select chess games in PGN format.  Games are selected based on games annotated in popular chess books.

## Usage
The PGNs in this repository are intended to be used as a companion to it's corresponding book.  While working through a book of chess games you can view selected games in your preferred chess software for further analysis or what-if situations.

## PGN Collection
* Fischer, Bobby. My 60 Memorable Games. New York, Simon & Schuster, 1969
* Tal, Mikhail.  The Life and Games of Mikhail Tal.  RHM, 1976

## Copyright Notice
I'm not a lawyer and laws vary from country to country. Here are my thoughts and understanding:

* Events like chess (and other sports) cannot be copyrighted
* Thus, there is no copyright infringement in copying the moves of a game (this does not apply to commentary or analysis) from a book into PGN format
* Audio or video broadcast of a game can be copyrighted
* Comments or analysis of a game can be copyrighted
* Fair use allows you to cite a book where games appeared

Source: https://copyrightlately.com/chess-and-copyright/#:~:text=Chess%20has%20been%20around%20for,of%20play%20over%20the%20years.

repository: brianerdelyi/ChessPGN

repo_name: brianerdelyi/ChessPGN


text:
# Week 3 MVP - Project Manager Notes
---

### All hail our new leader, Material Design.

This week's overall goal will be mostly UI/UX-focused. We have a nearly fully working app at this point, we just want to ensure that the experience in using it is plesant for our users. We that in mind, we're making a seismic shift towards using Material Design to improve the app's look and feel.

Please take a quick moment to review the [PDF of Sprint 3's design](../Images/octo_week3_mat_design.pdf).

*Note: I'm not sure why the buttons on the pdf have a strange white boxing effect. Refer to these additional screen shots to understand what the icons should look like (the provided assets will be correct):

1. [Main Screen](../Images/main_view_ss.png)
2. [Operation List](../Images/operation_list_ss.png)
3. [Preview View](../Images/preview_view_ss.png)

### What is Material Design?

It's a design guide put together by Google covering every single UI/UX element and aspect of an app. We don't need to adhere to all of the guidelines they put forth, but they are usually very good guiding rules in how to design an app with a compelling user experience. Well, a Google-y experience.

Material design's details are extensive, and we're just going to focus on a few elements: colors, fonts, layout, buttons, and shadows.

### [Color](https://material.google.com/style/color.html): Purple Palette & Teal Accent

In material design, it's suggested that you use three colors from a primary palette along with a single, accent color from a secondary palette. The accent color is mostly used to denote some sort of action or interaction. Here's a screenshot of our main color palette for this app:

![Purple Palette](../Images/purple_palette_ss.png)

To get the proper values of the colors, see [Colors](https://material.google.com/style/color.html). The TechLead will fill you in on how to properly manage the color palettes, but we also eventually want to give people the ability to "download" additional color options - maybe even some paid.

Though we're going to be using Purple 500 (Primary, #9C27B0), Purple 700 (Primary Dark, #7B1FA2), and Purple 100 (Primary Light, #E1BEE7). For the accent color, we'll be relying on A200 Teal (#69F0AE).

### Roboto Font
Adding in this font is straightforward from what I understand from the tech lead; I believe you can download it from [here](https://material.google.com/resources/roboto-noto-fonts.html) and read about it [here](https://fonts.google.com/specimen/Roboto)

But what's really important is how we're handling the fonts themselves in terms of point sizes, arrangement and opacity.

Black text comes in 3 opacities that corresponds to their usage (this is directly from material design guidelines):

| Opacity | Usage |
| :-----: | :---: |
|   87%   |Primary|
|   54%   |Secondary|
|   38%   | Hints |

White text, similarly, has 3:

| Opacity | Usage |
| :-----: | :---: |
|   100%   |Primary|
|   70%   |Secondary|
|   50%   | Hints |

You can read about the theory if you're intereted, but here are the specs we need:

| Element | Location | Color | Opacity | Font Size | Font Weight | Font Style |
| :--- | :---: | :---: | :---: | :---: | :---: | :---: |
| Message Text | Main View | White | 100% | 56pt | Light | Headline |
| Message Subtitle | Main View | White | 70% | 34pt  | Regular | SubHeadline |
| Operation Name | List View | White | 100% | 34pt | Regular | Title |
| Preview Text | Preview View | White | 100% | 24pt | Light | Body |
| Text Labels | Preview View | Black | 100% | 18pt | Medium | Label |
| Placeholder Text | Preview View | Black | 34% | 13pt | Regular | Placeholder |
| Settings Labels | Settings Menu | Black | 87% | 18pt | Regular (ALL CAPS) | Settings |
| On/Off | Settings Menu | Black | 87% | 14pt | Regular (ALL CAPS) | Caption 1 |
| App Info | Settings Menu | Black | 34% | 12pt | Regular (ALL CAPS) | Caption 2 |

### Layout

Here are some examples of the layout. I'd recommend using your best judgement for the majority of the elements, attempting to get as close to the design spec as possible. If you have time/are interested, contact me for the `.sketch` file. You will need to download [Sketch](https://www.sketchapp.com/). It's $99 for a license but also comes with a free trial period that will be long enough to complete this project.

| Location | Items | Relation |
| --- | --- | --- |
| Main Screen | Message Text, Message Subtitle | 28 - 48pt from last baseline of text to first baseline of subtitle |
| Main Screen | Message Text + Message Subtitle | Centered Y - 16pt margin from top of button |
| Main Screen | All | 16pt leading, trailing |
| Main Screen | Disclosure indicator | 8pt from bottom, centered X |
| Main Screen | Button | 32pt from trailing, 48pt from bottom |
| Operation List | Cell | 64pt height |
| Operation List | Cell Text | 34pt font, 16pt from leading, 8pt from bottom |

### Buttons

![Elevation example - Google](https://material-design.storage.googleapis.com/publish/material_v_9/0B6Okdz75tqQsTVdGcm1LX0dVeGM/whatismaterial_3d_elevation1.png)

You may want to read up on [material design's take on elevation](https://material.google.com/material-design/elevation-shadows.html) for this one, in order to try to get the shadows as close to correct as possible. Basically:

1. All views are 1pt thick in the z-dimension
2. The z-dimension extends from 0pt height ("bottom" layer of app) to 24pt ("ceiling" layer of app)
3. Depending on the element, there are "heights" that each view should normally occupy.
4. For interactive elements, like buttons, their "heights" change when in their active state.

#### Example of button elevation:
**(left: active, right: inactive)**

![Button States](../Images/button_states.png)

### Settings Menu Details

From the main screen, we want to be able to either tap on the disclosure indicator or perform a swipe up to reveal the settings menu below it. We can start with a simple animation that moves the top view up in a linear transition that lasts somewhere between `.10` and `.40` seconds... whatever you think works best.

![settings_menu_show](../Images/settings_menu_show.png)

Right now the settings menu will have two selection components (color palette, profanity filter), 4 share options (copy/paste, save to photoroll, facebook, twitter), and two text labels (app version, your email).

The color palette should allow users to swipe left/right between color choices, and when a choice is made the app's colors should update to use that color's palette (so that color's 100, 500, and 700 values). For testing, use blue, green and a default of purple. To make it clear that users need to swipe to make a change, we should add an alpha gradient so that the edges fade out entirely, but reveal a partial color swatch.

Facebook/twitter integration will wait until next week. But hook up your existing work on copy/paste and screenshoting to their appropriate buttons.

Not sure how we're going to update the version or the message at the bottom. Check with the tech lead on that one.

### Keyboard changes
For details on this one, check in with your tech lead. But we'd like for the views to animate along with the keyboard in terms of timing and animation curves. The overall effect should appear as a smooth keyboard show/hide with the bottom of the view moving exactly with the top of the keyboard.

![keyboard smooth](../Images/keyboard_appearance.png)

### Removing the navigation bar
Design decided that the app is so simple that it doesn't make sense to have a bulky navigation bar. So we're replacing it in favor of simple gestures and buttons. Check in with the tech lead on thoughts on how to best accomplish this.

### Textfield Design Changes (UPDATE 1/15/17)
We've adapted the design of the text fields so as to avoid different shadowing layers in the preview view. I hear from your tech lead that it isn't an easy implementation for such a minor UI feature. Maybe in the future... but for now, here's the updated design. Your tech lead will be taking point on the textfield code I believe.

![Updated Textfields](../Images/updated_textfields.png)

repository: AccessLite/BoardingPass

path: /Week 3 - MVP/PM_Notes/README.md

repo_name: AccessLite/BoardingPass


text:
---
layout: post
title:  "Volunteering at the Central Texas Food Bank"
date:   2016-04-06
excerpt: "We Provide occasional volunteering opportunities in partnership with the Central Texas Food Bank"
project: true
tag:
- volunteering
comments: false
---

Bowls of Hope, in partnership with the Central Texas Food Bank, provides occasional volunteering opportunities. These are filled on a first come, first serve basis, and due to the popularity of volunteering at the Central Texas Food Bank, we typically only are able to reserve a small number of spots.

These volunteering opportunities will be emailed to club memebrs. If you want to join, please fill out the form on the "about" page.

Any questions can be directed to<EMAIL_ADDRESS>or contact one of us in person/at school.

<iframe src="https://docs.google.com/forms/d/e/1FAIpQLSdhR8qJpg9iGLbJn4To3W-2_iKzYiUyGrOVA4t8aqoGtEeO5w/viewform?embedded=true" width="640" height="1324" frameborder="0" marginheight="0" marginwidth="0">Loading…</iframe>


text:
snRNA-seq reveals a subpopulation of adipocytes that regulates thermogenesis
============================================================================

  [@wikidata:Q101051363]

# Highlights

Here we
use single-nucleus RNA-sequencing (snRNA-seq) analysis in mice and humans to characterize adipocyte heterogeneity. We identify a rare subpopulation of adipocytes in mice that increases in abundance at higher temperatures, and we show that this subpopulation regulates the activity of neighbouring adipocytes through acetate-mediated modulation of their thermogenic capacity

It comprises approximately 20–30% mature adipocytes5,6
, as well as the stromal vascular fraction
(SVF), which includes different cell types7
. Adipocytes in turn are cat-
egorized into three different cell types: white adipocytes store energy, whereas brown adipocytes, and a related, less thermogenically effi- cient population referred to as beige or brite adipocytes, dissipate energy through non-shivering thermogenesis.

In rodents, classical
brown adipocytes are located within distinct areas, whereas beige or brite cells arise in response to cold stimulation within various WAT depots7

. In rodents, classical
brown adipocytes are located within distinct areas, whereas beige or brite cells arise in response to cold stimulation within various WAT depots7

--> Promoter-defined cell type

Canonical adipocyte markers and brown adipocyte markers15
were expressed in all groups
(Extended Data Fig. 1c), albeit at varying levels. Preadipocyte markers (Ly6a and Cd34; Extended Data Fig. 1c) were found in cluster C2, indicat- ing that these could be differentiating precursor cells16

Trajec- tory analysis identified three main states of cells that correspond to the three temperature conditions, whereas P4 cells were in the early stage of each progression (Extended Data Fig. 2c).

). Quantification revealed that approxi- mately 10% of all adipocytes within iBAT and 20% within subscWAT expressed CYP2E1 (Extended Data Fig. 4b). An analysis comparing the expression of P4 marker genes (Aldh1a1, Nrip1, Auts2, Atp2b4, Cyp2e1 and so on) with bulk RNA expression data from iBAT, subscWAT and inguinal WAT (ingWAT) did not reveal any overlap with any of the three depots, indicating that these P4 cells cannot be classified according to existing categories (Extended Data Fig. 4c–e). In accordance with our single-nucleus data, we observed that the number of CYP2E1+
cells
decreased after cold exposure and increased under thermoneutral conditions

In human adipose tissue from the deep-neck region, both multi- locular and unilocular cells stained positive for CYP2E1, suggesting that these cells constitute a subpopulation that can acquire different morphologies (Extended Data Fig. 4n–p).

CYP2E1+ adipocytes control thermogenesis

--> Gene-based alias

To study the thermogenic capacity of P4 cells in more detail, we dif- ferentiated the SVF from iBAT and ingWAT in a dish and—in accordance with the in vivo data—observed a heterogeneous mixture of differenti- ated adipocytes, with approximately 17% of iBAT-derived and 23% of ingWAT-derived adipocytes expressing both ALDH1A1 and CYP2E1 (Fig. 4a, Extended Data Fig. 8a, b)

--> Expression-based characterization

In conclusion, we provide here an in-depth single-cell analysis of
mature brown and white adipocytes in both mice and humans. The CYP2E1+
ALDH1A1+ population of cells that we have identified controls
the thermogenic function of other adipocytes in a paracrine manner by modulating the levels of the short-chain fatty acid acetate. This mechanism is likely to have evolved to preserve energy under thermon- eutral conditions, and might be leveraged to modulate the thermogenic capacity of adipose tissue.

--> Interesting that they call it a "population" and not a cell type. The combination with present tense ("controls") illustrates that the intended meaning is not descriptive, but generalizative.

# Comments

# Links

 * [Scholia Profile](https://scholia.toolforge.org/work/Q101051363)
 * [Wikidata](https://www.wikidata.org/wiki/Q101051363)
 * [TABernacle](https://tabernacle.toolforge.org/?#/tab/manual/Q101051363/P921%3BP4510)

license: Unlicense

gha_license_id: NOASSERTION


text:
# Tinkey

This utility allows generating and manipulating Tink keysets. It can encrypt or
decrypt keysets with master keys residing in a remote key management service
(KMS). Out of the box it supports AWS KMS and Google Cloud KMS. Adding support
for other KMS is easy, and doesn't require modifying Tinkey.

Tinkey requires Java 8 or later to run.

## Install from prebuilt binaries

Download the latest version of Tinkey from
https://storage.googleapis.com/tinkey/tinkey-1.5.0.tar.gz. This version should
work well on Linux, macOS and Windows.

## Install with Homebrew

```sh
brew tap google/tink https://github.com/google/tink
brew install tinkey
```

## Build from source

-   Install [Bazel](https://docs.bazel.build/versions/master/install.html)

-   Check out the code

```shell
git clone https://github.com/google/tink.git
```

-   Build

```shell
cd tink/tools
bazel build tinkey
```

The binary is located at `bazel-bin/tinkey/tinkey`.

## Usage

`tinkey <command> [<args>]`

Available commands:

*   `add-key`: Generates and adds a new key to a keyset.
*   `convert-keyset`: Changes format, encrypts, decrypts a keyset.
*   `create-keyset`: Creates a new keyset.
*   `create-public-keyset`: Creates a public keyset from a private keyset.
*   `list-key-templates`: Lists all supported key templates.
*   `delete-key`: Deletes a specified key in a keyset.
*   `disable-key`: Disables a specified key in a keyset.
*   `enable-key`: Enables a specified key in a keyset.
*   `list-keyset`: Lists keys in a keyset.
*   `promote-key`: Promotes a specified key to primary.
*   `rotate-keyset`: Performs a key rotation in a keyset.

To obtain info about arguments available/required for a command, run `tinkey
<command>` without further arguments.

-   Generate a keyset, and write it to `private-keyset.cfg`

```shell
tinkey create-keyset --key-template ECDSA_P256 --out private-keyset.cfg
```

-   Add a new key to a keyset

```shell
tinkey add-key --key-template ECDSA_P384 --in private-keyset.cfg \
--out private-keyset.cfg
```

-   Rotate a keyset by adding a primary key

```shell
tinkey rotate-keyset --key-template ED25519 --in private-keyset.cfg \
--out private-keyset.cfg
```

-   List metadata of keys in a keyset:

```shell
tinkey list-keyset --in private-keyset.cfg
```

-   Create a public keyset from a private keyset

```shell
tinkey create-public-keyset --in private-keyset.cfg --out public-keyset.cfg
```

## Work with Key Management System (KMS)

Tinkey can encrypt or decrypt keysets with master keys residing in remote KMSes.
In this mode, users first create a master key in the KMS and tell Tinkey where
the master key is via the `--master-key-uri` option. To create a master key in
Google Cloud KMS, see https://cloud.google.com/kms/docs/quickstart. To create a
master key in AWS KMS, see
http://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html.

### Master key URI

Every master key URI starts with a unique prefix that identifies its KMS. The
prefix for AWS KMS is `aws-kms://`, and Google Cloud KMS `gcp-kms://`. AWS KMS
master key URIs are in this format
`aws-kms://arn:aws:kms:<region>:<account-id>:key/<key-id>`, and Google Cloud KMS
`gcp-kms://projects/*/locations/*/keyRings/*/cryptoKeys/*`.

### Credentials

Tinkey needs credentials to connect to AWS KMS or Google Cloud KMS. Users tell
Tinkey where/how to load credentials via the `--credential` option. If
`--master-key-uri` is specified, `--credential` specifies the credentials file
path. Google Cloud credentials are service account JSON files that can be
created and downloaded from Google Cloud Console. AWS credentials are properties
files with the AWS access key ID is expected to be in the `accessKey` property
and the AWS secret key is expected to be in the `secretKey` property.

If `--credential` is missing Tinkey will attempt to load the default
credentials:

*   AWS KMS:
    http://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default

*   Google Clous KMS:
    https://developers.google.com/identity/protocols/application-default-credentials.

### Examples

Please replace
`gcp-kms://projects/tink-examples/locations/global/keyRings/foo/cryptoKeys/bar`
in the following examples with appropriate key URIs.

-   Generate a keyset, encrypt, and write it to `encrypted-keyset.cfg`, using
    default credentials

```shell
tinkey create-keyset --key-template AES128_GCM --out encrypted-keyset.cfg \
--master-key-uri gcp-kms://projects/tink-examples/locations/global/keyRings/foo/cryptoKeys/bar
```

-   Generate a keyset, encrypt and write it to `encrypted-keyset.cfg`, using
    credentials in `credentials.json`

```shell
tinkey create-keyset --key-template AES128_GCM --out encrypted-keyset.cfg \
--master-key-uri gcp-kms://projects/tink-examples/locations/global/keyRings/foo/cryptoKeys/bar
--credential credential.json
```

-   List metadata of keys in an encrypted keyset, using credentials in
    `credentials.json`

```shell
tinkey list-keyset --in encrypted-keyset.cfg \
--master-key-uri gcp-kms://projects/tink-examples/locations/global/keyRings/foo/cryptoKeys/bar
--credential credential.json
```

-   Decrypt a keyset, and write the cleartext keyset to `cleartext-keyset.cfg`,
    using default credentials

```shell
tinkey convert-keyset --in encrypted-keyset.cfg --out cleartext-keyset.cfg \
--master-key-uri gcp-kms://projects/tink-examples/locations/global/keyRings/foo/cryptoKeys/bar
```

-   Encrypt a keyset, write the encrypted keyset to `encrypted-keyset.cfg`,
    using default credentials

```shell
tinkey convert-keyset --in cleartext-keyset.cfg --out encrypted-keyset.cfg \
--new-master-key-uri gcp-kms://projects/tink-examples/locations/global/keyRings/foo/cryptoKeys/bar
```

-   Add a new key to an encrypted keyset, using default credentials

```shell
tinkey add-key --key-template AES256_GCM --in encrypted-keyset.cfg \
--out encrypted-keyset.cfg \
--master-key-uri gcp-kms://projects/tink-examples/locations/global/keyRings/foo/cryptoKeys/bar
```

-   Rotate an encrypted keyset by adding a primary key

```shell
tinkey rotate-keyset --key-template AES256_GCM --in encrypted-keyset.cfg \
--out encrypted-keyset.cfg \
--master-key-uri gcp-kms://projects/tink-examples/locations/global/keyRings/foo/cryptoKeys/bar
```

repository: thaidn/tink

repo_name: thaidn/tink


text:
megam_buildmonkey
=================

Build monkeys for megam platform (support for sbt, mvn, npm, bundler). Integrates with megam_akka

* `sbt `
* `mvn`
* `bundler`
* `npm`

### Requirements

>
[Scala 2.10.2 +](http://www.scala-lang.org)

#### Tested on Ubuntu 13.04, AWS - EC2

## Usage

###

### Prepare your program

We are glad to help if you have questions, or request for new features..

[twitter](http://twitter.com/indykish<EMAIL_ADDRESS>
#### TO - DO

*
*

# License

|                      |                                          |
|:---------------------|:-----------------------------------------|
| **Author:**          | Rajthilak<EMAIL_ADDRESS>|		               | KishorekumarNeelamegam<EMAIL_ADDRESS>| **Copyright:**       | Copyright (c) 2012-2013 Megam Systems.
| **License:**         | Apache License, Version 2.0

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.


text:
# express-pdf

[![Build Status](https://travis-ci.org/tanhauhau/express-pdf.svg?branch=master)](https://travis-ci.org/tanhauhau/express-pdf)
[![npm version](https://badge.fury.io/js/express-pdf.svg)](https://badge.fury.io/js/express-pdf)
[![Dependency status](https://david-dm.org/tanhauhau/express-pdf.svg)](https://david-dm.org)
[![Downloads](https://img.shields.io/npm/dt/express-pdf.svg)](https://www.npmjs.com/package/express-pdf)
[![Donate](https://img.shields.io/gratipay/user/tanhauhau.svg)](https://gratipay.com/~tanhauhau/)

## Installation

```bash
npm install --save express-pdf
```

```javascript
var express = require('express'),
        app = express(),
        pdf = require('express-pdf');

//previously app.use(pdf())
app.use(pdf); // or you can app.use(require('express-pdf'));

app.use('/pdfFromHTML', function(req, res){
    res.pdfFromHTML({
        filename: 'generated.pdf',
        html: path.resolve(__dirname, './template.html'),
        options: {...}
    });
});

app.use('/pdfFromHTMLString', function(req, res){
    res.pdfFromHTML({
        filename: 'generated.pdf',
        htmlContent: '<html><body>ASDF</body></html>',
        options: {...}
    });
});

app.use('/pdf', function(req, res){
    res.pdf(path.resolve(__dirname, './original.pdf'));
})
```

## Options

This library is built on top of [html-pdf](https://www.npmjs.com/package/html-pdf).

Read [this](https://www.npmjs.com/package/html-pdf#options) for the full list of options available when generating the pdf from html.

## License

The MIT License (MIT)

Copyright (c) 2016 Tan Li Hau

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

gha_language: JavaScript


text:
[![Build Status](https://secure.travis-ci.org/proem/proem.png)](http://travis-ci.org/proem/proem)
# pro·em

> –noun
> an introductory discourse; introduction; preface; preamble.

> Origin:
> 1350–1400; < L prooemium < Gk prooímion prelude (pro- pro-2 + oím(ē) song + -ion dim. suffix);
> r. ME proheme < MF < L, as above

http://proemframework.org

## DESCRIPTION

A lightweight, simple MVC for PHP5.4

The main objective here is to create a lightweight, simple & fast MVC implementation using PHP5.4

## INSTALLATION

http://proemframework.org/docs/current/installation.html

## DOCUMENTATION

http://proemframework.org/docs/current

## CONTRIBUTING

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Added some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

## FEEDS & IRC
Proem has a dedicated twitter feed http://twitter.com/proem which will automatically post any commits as well as news. If you plan on helping out, you should follow this.

Also available is an irc channel (#proem) on freenode. Join if you have any questions.

repository: proem/proem

branch_name: refs/heads/develop

gha_language: PHP

repo_name: proem/proem


text:
# Sink

Sink is a CLI **synchronisation** tool that enables a user to synchronise
local system files and folders with their **Google Drives**. It follows
a git CLI like approach to facilitate straight-forward and easy synchronsiation.
It uses the Google Drive API to interact with the Google Drive and OAuth to verify clients.

## Installation

### Install from zip file:

Download and extract the `drive-sink-main` folder to a suitable directory and run the following
commands in that folder. (It is advised to install in a virutal environment)

```bash
  cd drive-sink-main
  pip install .
```

### Install by cloning:

Set up a new folder and then clone the repo into the folder.

```bash
  git clone https://github.com/thakreyn/drive-sink.git
  cd drive-sink-main
  pip install .
```

After installation, run the command `sink` from the environment to use the tool.

![Sink-main](assets/sink-main.png)

## Script Setup

In case of a virtual environment, one might use the script inside `scripts` folder by replacing the path inside the `sink.bat` with the path of `sink.exe` inside your env/scripts. And then add this script to your environment variables.

Assuming the path of env/scripts is : `D:\Projects\trial\env\Scripts\sink.exe`

```batch
@echo off

:: Replace the <path> with the absolute path of your env/scripts folder
:startsink
D:\Projects\trial\env\Scripts\sink.exe %*
```

(NOTE: Above is applicable for windows only. Linux and Mac users need to create separate scripts)

## Google Drive API Setup

As the application is based on the Google Drive API, in order to use it, you need to activate the Google Drive API for your account. Following are the steps to do so :

[Enable Drive API for your account](https://developers.google.com/drive/api/v3/enable-drive-api)

After enabling the Drive API, you need to generate credentials for your account, the following article explains the steps to generate the credentials for your account.

[Generate credentials for your account](https://support.google.com/cloud/answer/6158849?hl=en)

After generating the credentials, download the `.json` file with credentials and rename it to `credentials.json` and paste it in the config folder 'after' initialising a directory.

## Documentation

You can type in `sink` in your terminal or `sink --help` to see all the available commands available.
* `sink init` : Initialise the folder and config details
* `sink initdrive` : Verify credentials and sync files to drive
* `sink scan` : Scans the directory for changes in files and folders
* `sink sync` : Updates/commits the changes to the drive
* `sink log` : Shows the commit log
* `sink status` : Shows general config information
* `sink clean` : Cleans (untracks) the given folder with option to delete drive folder as well

For further options for each command, type `sink <command-name> --help`

## Usage Demo

1. In order to initialise a directory for synchronisation, we need to use the command `sink init`
![Sink init2](assets/sink-init2.png)
2. (optional) You can list the files to be ignored in the `ignore.txt inside `.sink` folder. For ignoring folders, just use an '!' before the name.
    ![Sink ignore](assets/sink-ignore.png)
2. Then we paste the `credentials.json` file generated by Google inside the config folder in .sink.
![Sink Cred](assets/sink-cred.png)
3. Then run `sink initdrive` to verify your credentials and initialise the directory on your drive.
![sink initdrive](assets/sink-initdrive2.png)
5. For just scanning the changes in the directory, we use `sink scan`
![Sink scan](assets/sink-scan.png)
6. For syncing/commiting the changes to drive, we use the command `sink sync`. We can also the `-m` option along with `sink sync` to log a commit message.
![Sink sync](assets/sink-sync2.png)
7. To view commit messages, we can use the command `sink log`. Sink log can take in number of lines as an option (defalut = 5).
![Sink log](assets/sink-log2.png)
8. `sink status` can be used to see te config details for the current directory
![Sink status](assets/sink-status2.png)
## License

[MIT](https://choosealicense.com/licenses/mit/)

## Authors

- Yash Thakre : [@thakreyn](https://www.github.com/thakreyn)

## Contributing

Contributions are always welcome! Your feedback will help me grow as a developer and help me build better and more usable apps.

repository: thakreyn/drive-sink

repo_name: thakreyn/drive-sink