text:
---
layout: default
---

# 1993-11-23 - digital voice board at Comdex

## Header Data

From<EMAIL_ADDRESS>(Phil Karn)

To<EMAIL_ADDRESS>Message Hash: 82148509caa5973a6d8150a31ae2d2a4dd280057a989f9e5ee702746d531ca66

Message ID: \<199311230525.VAA00688@servo\>

Reply To: _N/A_

UTC Datetime: 1993-11-23 05:27:44 UTC

Raw Date: Mon, 22 Nov 93 21:27:44 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Phil Karn)
Date: Mon, 22 Nov 93 21:27:44 PST
To<EMAIL_ADDRESS>Subject: digital voice board at Comdex
Message-ID: <199311230525.VAA00688@servo>
MIME-Version: 1.0
Content-Type: text/plain

Last week at Comdex, I happened across Digicom Systems' booth. They're
selling a PC board with a programmable DSP chip from Analog Devices
that can be programmed to act as a sound card or as any of several
dial modems up to V.32bis. AND... it can be programmed with the GSM
vocoder algorithm (approx 13 kb/s).

The price was reasonable, too...in the $100 range, as I recall.

This could be the enabling product for a homebrew secure telephone.
The board can't act as a vocoder and modem simultaneously, so you'll
need either two boards, or one board plus a conventional modem. But a
vocoder that operates within dialup modem rates has been the roadblock
so far in a secure telephone. Anyone interested?

The address on Digicom Systems' flyer is 188 Topaz St, Milpitas CA
95035.  Voice:<PHONE_NUMBER>. Fax<PHONE_NUMBER>.

Naturally, I have no connection with this company other than as a
prospective customer.

--Phil

{% endraw %}
```

## Thread

+ Return to [November 1993](/archive/1993/11)

+ Return to<EMAIL_ADDRESS>(Phil Karn)](/authors/karn_at_qualcomm_com_phil_karn_)"

+ 1993-11-23 (Mon, 22 Nov 93 21:27:44 PST) - digital voice board at Comdex -<EMAIL_ADDRESS>(Phil Karn)_


text:
## Introduction

`Peacock.jl` - or the **P**lane-wave **E**xpansion **A**pproach to **C**haracterising **O**ptical **C**rystals in **k**-space - is a Julia package for studying photonic crystals using the Plane Wave Expansion Method.

Photonic crystals are materials whose optical properties arise from the structuring of the material when the size of the structures are comparable to the wavelengths of light. `Peacock.jl` is named for the irridescent colours of peacock feathers which arise not from pigmentation but from their photonic crystal structure, as shown below.

![Different zooms of a Peacock](zoom.png)
Credits: Peacock by allanlau2000 from pixabay. Feather by suju from pixabay. Electron microscope image of photonic crystal structure from Zi, Jian, et al. "Coloration strategies in peacock feathers.",  *Proceedings of the National Academy of Sciences* 100.22 (2003): 12576-12578. Copyright (2003) National Academy of Sciences.

As well as occuring naturally as in animals such as peacocks, advances in nanofabrication mean that 'designer' photonic crystals can now be manufactured for unprecedented control over the flow of light, with applications ranging from optical fibers to photonic circuitry. Photonic crystals are also a promising platform for more exotic materials like topological insulators.

* Solve for...
	* Transverse electric (TE) and transverse magnetic (TM) modes of 2D photonic crystals
	* Non-orthogonal unit cells
	* Inhomogeneous permittivity and/or permeability
	* Chern numbers of topological photonic crystals using built-in Wilson loop methods

* Focused on ease of use
	* Install with one line in Julia's package manager
	* Simple visualisation of geometry, fields, and fully labelled band diagrams

## Example usage

### Installation

The package can be installed using the built-in Julia package manager
```julia
using Pkg
Pkg.add("Peacock")
```

After installation, the package can be loaded in Julia
```julia
using Peacock
```

This example will also use `PyPlot` to control our figures, and the `Parameters` package to unpack some tuples.
```julia
using Pkg
Pkg.add("PyPlot")
Pkg.add("Parameters")
using PyPlot
using Parameters
```

### Defining a photonic crystal in real space

A photonic crystal is defined using the `Geometry` constructor, which requires the optical properties of the crystal, lattice vectors, and resolution. Here we demonstrate how to define the photonic crystal used in figures 2 and 3 of chapter 5 of _Photonic crystals: molding the flow of light_ by Joannopoulos (see further reading).
```julia
# Permittivity
function epf(x,y)
    if x^2+y^2 < 0.2^2
        return 8.9
    else
        return 1
    end
end

# Permeability
function muf(x,y)
    return 1
end

# Lattice vectors
a1 = [1, 0]
a2 = [0, 1]

# Real-space resolution
d1 = d2 = 0.01

geometry = Geometry(epf, muf, a1, a2, d1, d2)
plot(geometry)
```
> ![Plot of the example geometry](figures/example_plot_geometry.png)

### Defining the solver

The `Solver` approximates the geometry using a truncated Plane Wave Expansion (see further reading). The number of plane waves is determined by the cutoff. Increasing the cutoff will increase the accuracy of the solution, but low-contrast photonic crystals can be well approximated with a relatively low number of plane waves.

```julia
fourier_space_cutoff = 7
solver = Solver(geometry, fourier_space_cutoff)
plot(solver)
```
> ![Plot of the example solver](figures/example_plot_solver_cutoff=7.png)

### Plotting the band structure of a photonic crystal

Band structures can be generated using `plot_band_diagram(solver, ks, polarisation)`. If the elements of `ks` are instances of `BrillouinZoneCoordinate` then the band diagram will be fully labelled.

```julia
G = BrillouinZoneCoordinate(  0,   0, "Γ")
X = BrillouinZoneCoordinate(1/2,   0, "X")
M = BrillouinZoneCoordinate(1/2, 1/2, "M")
ks = [G,X,M,G]

figure(figsize=(4,3))
plot_band_diagram(solver, ks, TE, color="red",
            bands=1:4, dk=0.1, frequency_scale=1/2pi)
plot_band_diagram(solver, ks, TM, color="blue",
            bands=1:4, dk=0.1, frequency_scale=1/2pi)
ylim(0,0.8)
```
> ![Plot of a band structure](figures/example_plot_band_diagram.png)

This reproduces figure 2 of chapter 5 of Joannopoulos *et al* 2008.

### Plotting the modes

A `Mode` can be visualised using `plot(mode)`. By default the full Bloch wave is plotted - set `bloch_phase=false` to plot the cell-periodic part of Bloch mode.

The out of plane field component is plotted - for TE and TM polarisations this will be the magnetic and electric fields, respectively. The titles of the figures are set automatically using the `label` of the `Mode` object.

```julia
modes = solve(solver, X, TM)
plot(modes[2], bloch_phase=true)
plot(modes[2], bloch_phase=false)
```

> ![Plot of some modes](figures/example_plot_modes.png)

This reproduces figure 3 of chapter 5 of Joannopoulos *et al* 2008. Note that `Peacock.jl` doesn't fix the phase of the solutions and your results may differ by a random phase.

### The `Peacock.Zoo` submodule

The `Peacock.Zoo` module contains some of the photonic crystals that I have studied. Each `make_*` function returns a `NamedTuple` containing the geometry, solver, polarisation, and high symmetry points of the crystal. For example, the topological photonic crystal first introduced by Wu *et al* 2015 can be reproduced using `make_wu_topo`.

```julia
using Peacock.Zoo

# Load photonic topological insulator from Wu et al 2015
@unpack geometry, solver, polarisation, G, K, M = make_wu_topo(fourier_space_cutoff)

# Preview the crystal
plot(geometry)
```

> ![Plot of a crystal from the Zoo](figures/example_zoo_geometry.png)

Here I used the `@unpack` macro from the `Parameters` package to unpack the named tuple.

```julia
# Plot the first six bands
figure(figsize=(3,4))
plot_band_diagram(solver, [K,G,M], polarisation,
        bands=1:6, frequency_scale=1/2pi, dk=0.1)
```

> ![Plot of some bands from the Zoo](figures/example_zoo_bands.png)

### Topology of photonic bands

Recently there has been a spike of interest in photonic crystals as a platform for topological photonics (Blanco de Paz 2020). We provide methods to identify the topological phase of a photonic crystal using Wilson loops. A winding in the Wilson loop spectrum can indicate a non-trivial topological phase, with the Chern number given by the winding. In this example we reproduce results that demonstrate the photonic crystal with 'fragile' band topology that was introduced by Blanco de Paz et al (Blanco de Paz 2019).

```julia
using Peacock.Zoo

# Load the fragile photonic topological insulator from Blanco de Paz et al 2018
@unpack solver, polarisation = make_dePaz_frag(fourier_space_cutoff)

# The Wilson loops are (by default) along b2, so we define a straight
# path from Γ to Γ+b1 - we will scan along this path
ks = [
    BrillouinZoneCoordinate(0.0, 0.0, "Γ"),
    BrillouinZoneCoordinate(0.5, 0.0, "M"),
    BrillouinZoneCoordinate(1.0, 0.0, "Γ")
]

# Wilson loop of all three valence bands
figure(figsize=(3,2))
plot_wilson_loop_winding(solver, ks, polarisation, 1:3, dk=0.25)
title("Bands 1-3")

# Wilson loop of just the second and third bands
figure(figsize=(3,2))
plot_wilson_loop_winding(solver, ks, polarisation, 2:3, dk=0.25)
title("Bands 2&3")
```

> ![Plot some Wilson loop examples](figures/example_wilson_loops.png)

In the first figure, the Wilson loops through the Hilbert spaces of bands 2&3 are seen to wind with Chern numbers ±1. The second figure shows that including the (trivial) acoustic band in the Wilson loop calculation removes the topological winding, and consequently bands 2&3 are said to be 'fragilely topological'.

## Further reading

Plane Wave Expansion Method
- Rumpf, Raymond. "Design and optimization of nano-optical elements by coupling fabrication to optical behavior." (2006)
- http://emlab.utep.edu/academics.htm

Photonic crystals
- Joannopoulos, John D., et al. "Photonic crystals: molding the flow of light. 2008." *Princeton Univ Pr* (freely available online at http://ab-initio.mit.edu/book/)

Topological photonics
- Wu, Long-Hua, and Xiao Hu. "Scheme for achieving a topological photonic crystal by using dielectric material." Physical review letters 114.22 (2015): 223901.
- Blanco de Paz, María, et al. "Engineering fragile topology in photonic crystals: Topological quantum chemistry of light." *Physical Review Research* 1.3 (2019): 032005.
- Blanco de Paz, María, et al. "Tutorial: computing topological invariants in 2D photonic crystals." *Advanced Quantum Technologies* 3.2 (2020): 1900117.

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# CyberYetiOne
Slack App for submitting ski reports to slack channels for people.

Eats skiers, shits snow.

Shows fridged camera from top.

Massages the overly optimistic ski report and puts it out daily.

- `cyberyetione.rb` - pulls "top of the mountain" picture and posts to slack channel.
- `coolaid.rb` - pulls snow report from Cannon's website and posts to a slack channel.
- `loonaid.rb` - pulls ski report from Loon's website and posts to slack channel

# install
run like this

1. `bundle install`
2. `bundle exec [ruby] file_name.rb`

OR

1. `ruby ./cyberyetione.rb` or `ruby ./coolaid.rb`
2. wait for ruby gem fails from require
3. install gems with `gem install missing_ruby_gem`
4. go to 1

# reads from cyberyeti.config
format should is YAML config for where to post what.
slack_channels is an array of URLs to post to
```
---
:slack_channels:
- 'https://hooks.slack.com/services/AAAAAAAAA/AAAAAAAAA/AAAAA2utdcRn3SFi4RyLeKLY'
- 'https://hooks.slack.com/services/BBBBBBBBB/AAAAAAAAA/AAAAA2utdcRn3SFi4RyLeKLY'
```

repository: nobletrout/cyberyetione

gha_language: Ruby

repo_name: nobletrout/cyberyetione


text:
# Measuring the tangle of three-qubit states

Code at: [https://github.com/qiboteam/qibo/tree/master/examples/3_tangle](https://github.com/qiboteam/qibo/tree/master/examples/3_tangle).

Based in the paper [Entropy 2020, 22(4), 436](http://dx.doi.org/10.3390/e22040436). In this `README.md` file you can see a short
set of instructions for the usage of the example and brief explanations.

#### What this example does?

This example provides a variational strategy to compute the tangle of an unknown three-qubit state, given many copies of it.
It is based on the result that local unitary operations cannot affect the entanglement of any quantum state. In particular,
any three-qubit state can be transformed with local operations acting on every qubit into
a canonical form. From this canonical form, it is immediate to perform measurements that return an estimate of the tangle.
See [Phys. Rev. Lett. 85, 1560](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.85.1560) for more details.

The strategy is simple. An unknown three-qubit state is received, and then one unitary gate is applied in every qubit. The
exact gates are obtained following a minimization procedure. The set of gates chosen is such that minimizes the number
of outcomes of the states |001>, |010> and |011>. It is guaranteed that this quantity can be exactly zero for any state
for noiseless devices. The circuit is just

![circuit](images/circuit.png)

with

![canonical](images/canonical.png)

The tangle is computed through

![tangle](images/tangle.png)

#### Usage
In this example there are only two files
- `canonizator.py` contains all functions that are needed to run the experiment.
- `main.py` is the file calling all other functions. The action of every line of code is commented in the source code.

The parameters to be fixed for a run of the experiment are
- `N`: Number of random states considered
- `p`: probability of occurring an error
- `shots`: shots for measuring the optimized tangle
- `post_selection`: whether we discarded bad outcomes or not, useful for noisy devices

#### Results

This example looks for the difference between the exact and the measured tangles. Plots pop up at the end of the `main.py`
file. For completeness, we present here some results as obtained in the main reference. The black line in the figure below
represents the optimal performance of the algorithm, that is, the measured tangle is equal to the exact one. At the top,
no errors are considered, at the bottom there is noise in the device. Red plots consider post-selection, while green ones
do not. As expected, less noise and post-selection lead to more accurate estimates of the tangle.

![results](images/results.png)

_Note_: The number of random state for this example is 100. This may lead to a long run in terms of execution time.
Consider decreasing the number of points.

repository: qiboteam/qibo

gha_language: Python

repo_name: qiboteam/qibo


text:
# The Quaffa backup job configuration file

Quaffa backup job configuration files are in yaml format and must have a .yaml extention. All .yaml files in the job config directory are parsed.

The minimum required fields are `jobName`, `include` and `timeSchedule`.

Arrays can be written as a json array
```javascript
include: [
    '/home',
    '/root'
]
```
or as a dashed list
```yaml
include:
- /home
- /root
```
## Option list

### `bandwidthLimit`
_Integer_ Default: `0`
The bandwidth limit in KBytes per second, passed as an option to rsync when connecting to a remote server. Zero for no limit.

### `connectionCheckTimeout`
_Integer_ Default: `120`
Timout in seconds for the SSH connection check to a remote server
### `debug`
_Boolean_ Default: `false`
Overide the default logging level for this job and log verbosely

### `description`
_String_ Default: `''` (empty string)
Free text description of the backup job.

### `diskSpaceWarn`
_Integer_ Default: `85`
Disk space warning limit expressed as a percentage. If the target disk is full over this percentage a warning will be shown on the command line, in the logs and in email notifications.

### `extraEmailNotifications`
_Array_ Default: `[]` (empty array)
Email notifications will be sent to the adresses in this list in addition to the global administrator email address. The administrator email address and other email configuration options are available in the application configuration file config.yaml.

### `exclude`
_Array_ Default: `[]` (empty array)
A list of paths to exclude from the backup.

### `include`
**REQUIRED** _Array_ Default: [] (empty array)
A list of paths to backup.

### `jobName`
**REQUIRED** _String_ Default: `''` (empty string)
The name of the job. No white space or caracters not allowed in a file name.

### `keepDaily`
_Integer_ Default: `7`
The number of daily backups to keep. See Backup retention.

### `keepMonthly`
_Integer_ Default: `12`
The number of monthly backups to keep. See Backup retention.

### `keepScheduled`
_Integer_ Default: `1`
The number of scheduled backups to keep. See Backup retention.

### `keepWeekly`
_Integer_ Default: `4`
The number of weekly backups to keep. See Backup retention.

### `keepYearly`
_Integer_ Default: `2`
The number of yearly backups to keep. See Backup retention.

### `localNice`
_Integer_ Default: `0`
Value passed to the nice binary on the backup server to proiritise the cpu usage of the rsync process. -20 = top priority, +19 = lowest priority.

### `postJobCommand`
_String_ | _Array_ Default: `[]` (empty array)

Name(s) of script(s) in the scripts folder. Scripts must be executable. The scripts are run on the local quaffa server after the rsync backup has completed.

### `postJobCommandRemote`
_Array_ Default: `[]` (empty array)
Name(s) of script(s) in the scripts folder. Scripts must be executable. The scripts are run on the remote server after the rsync backup has completed.

### `preJobCommand`
_Array_ Default: `[]` (empty array)
Name(s) of script(s) in the scripts folder. Scripts must be executable. The scripts are run on the local quaffa server before the rsync backup has completed.

### `preJobCommandRemote`
_Array_ Default: `[]` (empty array)
Name(s) of script(s) in the scripts folder. Scripts must be executable. The scripts are run on the remote server before the rsync backup has completed.
_Commonly used to run a database dump to be included in the backup_.

### `remoteAuthorizedKeysFile`
_String_ Default: "/root/.ssh/authorized_keys"
Path to the authorized_keys file on the remote server. Commonly `authorized_keys` or `authorized_keys2`.

### `remoteHostName`
_String_ Default: `''` (empty string)
Hostname or IP address of the remote server to back up. An empty string is interpreted as `localhost`.

### `remoteNice`
_Integer_ Default: `0`
Value passed to the nice binary on the remote server to proiritise the cpu usage of the rsync process. -20 = top priority, +19 = lowest priority.

### `remoteNiceBinary`
_String_ Default: `/bin/nice`
Path to the nice binary on the remote server.

### `remoteRsyncBinary`
_String_ Default: `/usr/bin/rsync`
Path to the rsync binary on the remote server.

### `remoteUser`
_String_ Default: `root`
SSH username with which to connect to the remote server.

### `rootDir`
_String_ Default: `/var/quaffa`
Directory on the quaffa backup server that will contain the backups.

### `rsyncCompress`
_Boolean_ Default: `true`
Activates compression in the rsync data transfer.

### `rsyncInplace`
_Boolean_ Default: `true`
This option changes how rsync transfers a file when the file's data needs to be updated: instead of the default method of creating a new copy of the file and moving it into place when it is complete, rsync instead writes the updated data directly to the destination file.

WARNING: you should not use this option to update files that are being accessed by others, so be careful when choosing to use this for a copy.

This option is useful for transfer of large files with block-based changes or appended data, and also on systems that are disk bound, not network bound.

### `#rsyncOptions`
_String_ Default: `''` (empty string)
Any extra rsync options that you wish to use. The following options are already used by default:
`--archive --hard-links --stats --delete-during --ignore-errors --delete-excluded --relative --partial --numeric-ids --link-dest`

### `rsyncRemote`
_String_ Default: `/usr/bin/rsync`
Path to rsync on the remote server.

### `rsyncTimeout`
_Integer_ Default: `900`
Timeout for the rsync command in seconds.

### `sshOpts`
_String_ Default: `''` (empty string)
Extra options passed to the SSH command. The following options are already used by quaffa: `CheckHostIP StrictHostKeyChecking HostKeyAlias UserKnownHostsFile`

### `sshPort`
_Integer_ Default: `22`
The port for SSH connection to the remote server.

### `enabled`
_Boolean_ Default: `true`
Enable or disable the backup job.

### `timeSchedule`
**REQUIRED** _String_ | _Array_ Default: `'0000'` (midnight)
The time or times to run the backup. Expressed as HHMM.

repository: quayph/quaffa

branch_name: refs/heads/main

repo_name: quayph/quaffa


text:
# Ryanair shares rise amid reports of groundings

Published at: **2019-11-06T21:51:30+00:00**

Author: **By Geoff Percival**

Original: [Breaking News](https://www.breakingnews.ie/business/ryanair-shares-rise-amid-reports-of-groundings-962350.html)

Ryanair shares inched higher yesterday despite the airline confirming some of its fleet have been taken out of service to repair cracks in its older planes.
However, the airline has dismissed as “rubbish” claims by the Guardian in the UK, that it has grounded three planes due to concerns over wing safety and failed to disclose the problem.
The Guardian reported that Ryanair grounded at least three of its existing Boeing 737s due to ‘pickle fork’ cracks, affecting the component connecting wings to the main body of an aircraft. The cracking problem has, reportedly, affected 50 planes from a number of airlines including Qantas, Korean Air and Southwest.
“[The] report on the ‘pickle fork’ issue in the Guardian newspaper is rubbish. Ryanair has already inspected over 70 of its oldest aircraft in full compliance with the Airworthiness Directive, and our rate of findings is less than the industry-wide 5% confirmed by Boeing recently,” Ryanair said.
The airline said that the “tiny number” of damage findings — on which repairs are being carried out by Boeing — will not affect its operating fleet nor flights, as it has already moved to its winter schedule.
“Ryanair will continue to inspect the remainder of its fleet, in full compliance with the Airworthiness Directive, and we are confident that the tiny number of pickle- fork cracks, if any, will not affect either Ryanair’s fleet, its flights, or its schedules,” the airline said.
Ryanair’s shares rose by over 1.6%.
Earlier this week, the airline said it only expects 20 of its due Boeing 737-Max jets to be delivered next March or April at the earliest, but said the risk of further delay is rising.

        Kerry Group shares rise almost 3% on earnings outlook

license: Unlicense

repository: dsadlollioygjmzvcxv/tdc-exported

repo_name: dsadlollioygjmzvcxv/tdc-exported


text:
# Exercises
---
Please perform the following exercise.

Since httpd has been configured on each server in the exercise, please execute the following command to clear the environment. You can also use this command to clear the environment in the middle of the exercise.

`cd ~/working`{{execute}}

`ansible web -b -m yum -a 'name=httpd state=absent'`{{execute}}

`ansible web -b -m file -a 'path=/var/www/html/index.html state=absent'`{{execute}}

`ansible web -b -m yum -a 'name=epel-release state=absent'`{{execute}}

`ansible web -b -m yum -a 'name=nginx state=absent'`{{execute}}

## Question 1
---
Please create a role `httpd_myip` with the following functions.

- The directory for the role should be placed in `~/working/roles/httpd_myip`.
- This role will install httpd and make it ready to start.
- Place index.html on the top page, and configure this page to display the IP address of the configured host.

## Question 2
---
Please create a role `nginx_lb` with the following functions.

- The directory of the role should be placed in `~/working/roles/nginx_lb`.
- The role will take a list of IP addresses in the variable `backend_server_list`.
  - The default value for `backend_server_list` is an empty list `[]`.
- This role will install `nginx` on the server and configure the following.
  - The package used for the installation should be obtained from EPEL.
- It will run as a load balancer to port 80 of the IP address set in the `backend_server_list`.

## Question 3
---
Please create a Playbook `~/working/lb_web.yml` with the following settings using the `httpd_myip` and `nginx_lb` roles.

- Configure the three exercise environments as follows.
  - Apply `httpd` to two of them and configure them as web servers.
  - Apply `rp_nginx` to one of them and configure it as a load balancer.
  - Edit the inventory file if necessary for the above settings (not required).
- The load balancer performs load balancing for two web servers.
  - When accessing the load balancer, the pages of the alternate web servers should be displayed.

## Sample Answers
---
- [httpd_myip](https://github.com/irixjp/katacoda-scenarios/blob/master/master-course-data/assets/solutions/roles/httpd_myip)
- [nginx_lb](https://github.com/irixjp/katacoda-scenarios/blob/master/master-course-data/assets/solutions/roles/nginx_lb)
- [lb_web.yml](https://github.com/irixjp/katacoda-scenarios/blob/master/master-course-data/assets/solutions/lb_web.yml)

repository: irixjp/katacoda-scenarios

gha_language: Shell

gha_license_id: MIT

repo_name: irixjp/katacoda-scenarios


text:
#<%= appName %>
<%= appDescription %>

### Developer Suite
* Angular
* Webpack
* Karma
* Jasmine/Sinon
* Node 6.x

### Style Guides
* [javascript (es6)](https://github.com/airbnb/javascript)
* [angular 1.x style guide](https://github.com/johnpapa/angular-styleguide/blob/master/a1/README.md)
* [component architecture](https://slides.com/johnnyazee/angularmoderncomponentarch)
* [git flow](http://nvie.com/posts/a-successful-git-branching-model)

The following steps are required in order to contribute to this application

### Install nvm
```
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.30.1/install.sh | bash
nvm install 6
nvm use 6
```
**NOTE: Ensure that you ```nvm use 6``` whenever you start a new terminal.

**NOTE: You may optionally persist this setting using `nvm alias default 6`.**

## Installation

1. Install pre-requisites
```
npm install -g karma karma-cli webpack webpack-dev-server
```
2. Clone this repo
```
git clone <%= appGitRepo %>
cd <%= appName %>
```
3. Install Application Dependencies
Make sure you ran `nvm 6`

```
npm install
```

## Development

### develop mode
This mode starts a webpack-dev-server on your local machine for development purposes. Once running, navigate to *http://localhost:8000*.

You may need to setup your browser to allow for CORS
```
npm run develop
```

Sample `.env`
```
API_URL="https://SOME-THIRD-PARTY-API"
```

#### CORS Override
This is an **optional** step that launches the Chrome browser in a special mode to allow CORS bypass when using dev-serve development mode. It is useful when testing against external third-party APIs.
These aliased commands can be run from the command line.

1. Add the following to your ~/.bash_profile:

```
alias chromekiller="pkill Google Chrome"
alias dangerchrome="open -a 'Google Chrome.app' --args --disable-web-security --allow-running-insecure-content --user-data-dir=''"
```

2. Then:
 ```
 source ~/.bash_profile
 ```

## Distribute Build (Production Ready and CI)
Performs several optimizations such as: minification, compress, de-dupe, chunk and css theme separation.

Generates a ```/distribute``` directory can then be statically hosted using your favorite http server or used in CI for installing the app to production.
```
npm run distribute
```

### Supplemental Information
In distribute mode, the theme (CSS) is split form the main bundle-<hash>.js a theme.css file. The final structure of the index.html will resemble this:

```
<head>
...
<link href="theme.css" rel="stylesheet"></head> //faster than inline css (bundle.js) - loaded in parallel with JS bundles

<body ng-cloak>
<section class="app-wrapper" ui-view="main"></section>
<script src="bundle-0ce882.js"></script> // agility ui runtime and vendors
</body>
```

*Note that js bundles are hashed for uniqueness so browsers refresh their cache*

## Unit Testing
### Full test suite without (no watch)
Runs all Tests without watching. Useful for automation with CI Tools.

#### Headless
Runs tests in PhantomJS only
```
npm run test
```

#### Browser-based
Runs tests in Chrome, Firefox, and PhantomJS
```
npm run test-browsers
```

### TDD Testing
Runs the app in TDD mode. Allows you to watch the code and tests for changes with you TDD.

#### Test Suite by Specific File Path
Runs all the tests for a test  in TDD mode. This is the fastest way to TDD when working on a single file
```
npm run test-tdd -- -f spec/app/components/file.test.js
```

#### Test Suite by Angular Module
Runs all the tests for a single module in TDD mode. Slower than a single file, but useful for multiple tests

For example:
```
npm run test-tdd -- -m AppContext
```
For this mode to work an index.tests.js file must exist in the Module base directory.

#### Test Suite in Browser
Runs tests in specified browsers (Chrome, Firefox, and PhantomJS are supported)
```
npm run test-tdd -- --browsers Chrome,Firefox
```

#### Full Test Suite
Runs all the tests in TDD mode. This mode is very slow but is the complete test suite should you need to TDD this way.
```
npm run test-tdd
```

### Code Coverage Reporting
All tests must be passing for the report to generate. A separate browser window will pop up with the Coverage Report.
*Submitting Code with less than 100% coverage will result in a Build failure.*
```
npm run test-coverage
```

## Maintenance Modes
By default, the node-updates and node-upgrade commands are set to filter out npm-shrinkwrap, to lock it to v200+.
```
npm run node-packages - list installed packages
npm run node-updates - list node that may be outdated.
npm run node-upgrade - updates all the node versions in node.json.
npm run node-purge - removes your node_modules folder.
npm run node-reinstall - removes your node_modules folder and does a npm install.
npm run node-killall - kills all node processes - useful if your webpack-dev-server address is in use
npm run stats - generates build stats that can be analyzed @ http://webpack.github.io/analyse/#hints
```

## Notes

### New Node Modules
If you or someone on the team adds a new node module, you will need to run an `npm install` in order to get the latest node modules. This will not pull down all the node modules, just the ones that were added or updated.

## PR Process

repository: digitalbs/slush-angular-pack

gha_language: JavaScript

repo_name: digitalbs/slush-angular-pack


text:
# Known Issues

## Tests getting stuck on launch on Linux (CentOS based)

This is likely due to a missing dependency on ChromeDriver that runs underneath. If such a scenario occurs, we recommend installing the Chrome browser rpm, since it depends on all the required libraries.

## VS Code Version Support & Backward Compatibility

Extension Tester currently supports the latest 5 minor releases of VS Code (subject to change if VS Code 2.x ever comes out). Additionally, the oldest release of VS Code that can be successfully used with Extension Tester is `1.37.0`. Older versions of VS Code might not work at all.

Versions older than the supported 5 latest releases, but still newer than `1.37.0` will most likely work just fine. However, if they stop working over time, there will be no more fixes to make them work. Unless you'd like to contribute these.

## MacOS known limitations of native objects

The macOS has limitations due to its platform specific native components used also by Visual Studio Code. These components are not at this moment supported on side of vscode-extension-tester / page-objects library. The mentioned not supported components are:

- **native modal dialogs** (e.g. file/folder dialogs)
- **native context menus** (e.g. click on vscode Manage button)
- **native menu title bar** (e.g. navigation in menu as File > New File...)

We are trying to bring some solution or workarounds, because currently there is no other option.

1. in case you need to use **dialogs**, please use simple dialogs in vscode (see [wiki using dialogs](https://github.com/redhat-developer/vscode-extension-tester/wiki#using-dialogs))
2. for **context menus** and **title bar**, please use command equivalents from vscode command palette

## Migrating to ExTester 4.0.0+

### ExTester API

In the 4.0 update, the `ExTester` API was revamped. If you are not using the API to launch your tests, no action is needed here.
The methods `setupRequirements`, `runTests` and `setupAndRunTests` have had their arguments changed from the long telescope list to structured objects.

The new signatures now involve `SetupOptions` and `RunOptions` objects respectively:

- `setupRequirements(options: SetupOptions)`
- `runTests(options: RunOptions)`
- `setupAndRunTests(testFilesPattern: string, vscodeVersion: string = 'latest', setupOptions: SetupOptions, runOptions: RunOptions)` (though here the options don't include vscode version)

- Both interfaces are exported and contain the list of options you would use as arguments in their respective methods. Any argument that used to have a default value is marked as optional in the interfaces.

### Page Objects

A few page objects have had slight changes to their API. Others have had their inner workings changed that may influence tests with tight timeouts.

- Context Menus now wait for all their items to load before you can manipulate them
  - this will not affect any APIs, but will slow down tests, so be careful if your test timeouts are tight
- Settings Editor waits for the whole page to finish loading when searching for a setting
  - once again, test time is going to increase, care about timeouts
- Action Bar & its items methods are now all asynchronous
  - `ActionBar` methods `getViewControl` and `getGlobalAction` are now async, make sure to await them
  - `ViewControl` and `ActionsItem` method `getTitle` is now async, make sure to await
  - `ViewControl` and `ActionsItem` constructors were changed to take a `WebElement` directly, instead of a title
    - hopefully, no one was using these directly, but if you do, use `ActionBar#getViewControl` or `getGlobalAction` instead to get the proper object

gha_language: TypeScript


text:
# HowTo: `<a href="...">`

## `click` on an `<a href="...">`

To navigate the user can click on the content inside a link with a pointer device.
This will generate a `click` event that bubbles upwards.
`click` events are composed by default, and will thus pass across shadowDom borders of custom elements.
But, `click` events *do not* pass by `<iframe>` document borders.

The `click` event's `target` is the innermost HTML *element* pointed to when clicking. [WHATWG](https://html.spec.whatwg.org/multipage/interaction.html#dom-click-dev);
In the example below, `<a id="one">` wraps around a text node.
`<a id="two">` wraps around a another HTML element, a `<div>`.

```html
<a id="one" href="#YesWeCan">Can we ever get enough of HTML examples?</a>

<a id="two" href="https://outside.com"><div style="border: 2px solid black">think</div></a>
```

When clicked on, the `target` of the `click` event would be:
1. the `<a id="one">` element (as the text node is only an HTML node, and not an element), and
2. the `<div>` element inside the `<a id="two">` element. [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Event/target) [WHATWG](https://dom.spec.whatwg.org/#dom-event-target)

`click` events can also be generated:
 * from JS script using either
   * `HTMLElement.click()` [MDN](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/click)
    [WHATWG](https://html.spec.whatwg.org/multipage/webappapis.html#fire-a-synthetic-mouse-event)
   * `HTMLElement.dispatchEvent(new MouseEvent("click", {bubbles: true, composed: true, cancelable: true}))`.[MDN](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/dispatchEvent) [WHATWG](https://dom.spec.whatwg.org/#dom-eventtarget-dispatchevent)
 * using a shortcut specified with the [`accesskey`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/accesskey)
   ([spec](https://html.spec.whatwg.org/multipage/interaction.html#the-accesskey-attribute))
   attribute on an element.
   For example, `<a href="#down" accesskey="d">scroll down</a>` will trigger a `click` event
   when the user presses `alt`+ `d`.
 * Pressing `Enter` on the keyboard while a link `<a href="...">` or a child of a link is in `.focus()`.

> Tips: In Chrome, no `keypress` is generated by the 'Enter-on-focus' nor `accesskey` combination,
> only a `keydown`, `click` and `keyup`. Firefox also dispatch the `keypress` event before the `click`.

## Separating navigating clicks from other clicks

To identify which `click` events are navigating events,
the browser must analyze all `click` events that has completed bubbling.
`click` events has completed bubbling when the event has either: [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Event/bubbles) [WHATWG](https://dom.spec.whatwg.org/#dom-event-bubbles)
 * bubbled past the `window` object,
 * a `.bubbles` value of `false` (ie. `.stopPropagation()` has been called on it), or
 * bubbled past the `document` object in an `<iframe>`, `<frame>`, or `<object>`.

```html
<a id="blue" href="#blueTarget">blue stopPropagation()</a>
<a id="red" href="#redTarget">red preventDefault()</a>
<a id="yellow" href="#yellowTarget">yellow normal</a>

<h1 id="blueTarget" style="margin-top: 100vh;">blueTarget</h1>
<h1 id="redTarget" style="margin-top: 100vh;">redTarget</h1>
<h1 id="yellowTarget" style="margin-top: 100vh;">yellowTarget</h1>

<script>
  document.querySelector("#blue").addEventListener("click", e => e.stopPropagation());
  document.querySelector("#red").addEventListener("click", e =>  e.preventDefault());
</script>
```
`click` events are `.composed` by default and should propagate past shadowDOM borders.
[MDN](https://developer.mozilla.org/en-US/docs/Web/API/Event/composed)
[WHATWG](https://dom.spec.whatwg.org/#dom-event-composed)

When a `click` event has completed bubbling,
the browser will examine the event to see if the `click` event:
1. has [`.defaultPrevented`](https://developer.mozilla.org/en-US/docs/Web/API/Event/defaultPrevented) ([spec.](https://dom.spec.whatwg.org/#dom-event-defaultprevented)) is false,
2. is from a left or middle mouse button click, ie. not a right context menu button click,
3. has no `shift` or `ctrl` key pressed, and
4. has a `target` with an `<a href=" ">` ancestor that comes before a link blocking element
(such as `<body>`). [WHATWG](https://html.spec.whatwg.org/multipage/webappapis.html#event-firing)

If all these criteria are met, then the `click` event is considered a navigating event and will cause
the browser to que a navigation task in the micro-task que.
(or in the event loop?? todo Test this using messages).
This will cause the browser to load a new document.

### `ismap`, not `usemap`

When I said there is nothing you can do with `<a href>` links, I meant *almost* nothing.
If you wrap an `<a href>` element around an `<img>` element, and then add the `ismap` attribute [WHATWG](https://html.spec.whatwg.org/multipage/embedded-content.html#attr-img-ismap) to
the `<img>`element.
When you click on the image with a pointing device,
the coordinates of the pointer will be appended to the `href` of the link on the format of `?x,y`.

```html
<a href="inYourDreams.html">
  <img src="http://maps.com/world.jpg" width="450px" height="360px" ismap alt="the place to be">
</a>
```
In the example above, if the user clicks with his pointing device at the center of the linked image,
then the `href` in the navigating `click` event will be interpreted to be `inYourDreams.html?222,180`.

## No nested links

Do *not* wrap `<a>` elements around [interactive elements](https://html.spec.whatwg.org/multipage/dom.html#interactive-content-2)
such as `<form>` and `<select>`,
and do *not* [nest `<a>` elements](https://www.kizu.ru/nested-links/).
It is [not allowed](https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-a-element).
When you nest links around other interactive elements,
the browser will most often assume you have made a typo and create a different DOM than you specify.

```html
  <head>
  <a href="#headLink">the browser will simply delete this element (< head> doesn't work in codepen)</a>
</head>
<body>
  <a id="blueLink" href="#blue" style="border: 2px solid blue">
  <div id="blue">blue</div>
  <!--at this point the browser will very likely assume you have forgotten an </a> and therefore simply close off the #blueLink element.-->
  <a id="redLink" href="#red" style="border: 2px solid red">
    <div id="red">red</div>
  </a>
  <div id="blueToo">blueToo</div>
</a>
<a href="#yellow" id="yellowLink">
  <form action="#green">
    <select name="test" id="testSelect">
      <option value="a">a</option>
      <option value="b">b</option>
      <option value="c">c</option>
    </select>
    <a href="#purple">
      <button id="purpleButton" type="submit">go purple</button>
    </a>
    <button id="greenButton" type="submit">go green</button>
  </form>
</a>
<script>
  window.addEventListener("hashchange", e => console.log(e.newURL));
  /*
  var headLink = document.querySelector("#headLink");  //headLink === undefined
  document.querySelector("#blueLink").click();    //#blue
  document.querySelector("#redLink").click();     //#red
  document.querySelector("#blue").click();        //#blue
  document.querySelector("#red").click();         //#red
  document.querySelector("#blueToo").click();     //not wrapped by a link in the DOM
  document.querySelector("#purpleButton").click();//nothing happens
  document.querySelector("#testSelect").click();  //#yellow
  document.querySelector("#greenButton").click(); //nothing happens
  */
  </script>
</body>
```
In short: nested links will be clickable, but the DOM will likely be altered and
the page therefore behave in a chaotic way. You cannot nest links.

## References

 *
 * [MDN: `MouseEvent`](https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent)
 * [MDN: `KeyboardEvent`](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent)
 * [MDN: `<a>` in SVG](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/a)
 * [MDN: `<area>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/area)
 * [WHATWG: `<a>` in HTML](https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-a-element)
 * [MDN: `<a>` in SVG](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/a)
 * [Whatwg: Interactive elements](https://html.spec.whatwg.org/multipage/interactive-elements.html)
 * [MDN: `.focus()`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus)

 *
// * [w3.org: Interactive content](https://www.w3.org/TR/html5/dom.html#interactive-content)

repository: orstavik/JoiEvents

repo_name: orstavik/JoiEvents


text:
# The Shkop Approach
DiArg supports the Shkop approach to abstract argumentation.
This tutorial explains the approach *hands-on*.

A key question in abstract argumentation is how to determine the extensions of an argumentation framework.
To answer this question, the Shkop approach first simplifies the problem by assuming that any argumentation process is
sequential, *i.e.*, that instead of one argumentation framework, we resolve a *sequence of argumentation frameworks* and
that given an argumentation framework sequence AFS = <AF0, ..., AFn>, AF0 contains
exactly one argument and each AFi, 0 < i ≤ n, has the following properties:

* AFi is a normal expansion of AFi-1;
* AFi contains exactly one more argument than AFi-1.

We call any argumentation framework sequence with these properties a *Shkop sequence*. The first argumentation framework
in any Shkop sequence can be resolved by determining the unique grounded extension (because the framework contains
exactly one argument, the unique grounded extension is empty in case of a self-attack; otherwise, it contains the only
argument). Then, we proceed as follows, starting with i=1:

2. Check if the currently inferred set of arguments passes the *Shkop test*, given the current argumentation framework.
   As a 'pre-test' to the Shkop-test, we check if an upstream attacker is added to the argumentation framework
   (ignoring self-attacking arguments). If this is the case, the pre-test fails, which implies failure of the Shkop
   test. The default Shkop test checks if the set of arguments is conflict-free with the grounded extension of the
   current argumentation framework, from which all self-attacking arguments, as well as all already
   'discarded' upstream arguments have been removed (custom Shkop tests can be implemented). If the argument fails the
   Shkop test, we need to reject the current extension, *i.e.* we set the new extension to *null*; to mitigate the null
   pointer, we may swap the new argument with its 'predecessor' in the Shkop sequence, and start anew. If our inferred
   set of arguments passes the Shkop test, we add the new argument to the inference set, if it does not have any
   conflicts with this set.
3. If i < n, set i := i+1 and go to 1.

We call this approach *sequential Shkop*.
With DiArg, we can create and resolve Shkop sequences as follows, for example:

```java
AFSequence shkopSequence = new AFSequence(SequenceType.SHKOP, ResolutionType.SHKOP, new Semantics(SemanticsType.SHKOP),
                           true);

DungTheory framework0 = new DungTheory();
DungTheory framework1 = new DungTheory();
DungTheory framework2 = new DungTheory();

Argument a = new Argument("a");
Argument b = new Argument("b");
Argument c = new Argument("c");

framework0.add(a);

framework1.add(a);
framework1.add(b);
framework1.add(new Attack(a, b));
framework1.add(new Attack(b, a));

framework2.add(framework1);
framework2.add(c);
framework2.add(new Attack(b,c));
framework2.add(new Attack(c,a));

shkopSequence.addFramework(framework0);
shkopSequence.addFramework(framework1);
shkopSequence.addFramework(framework2);

shkopSequence.resolveFrameworks();

```

To turn the Shkop approach into an abstract argumentation semantics, we proceed as follows, given any argumentation
framework AF = (AR, AT):

1. Determine all permutation sequences of the set of arguments AR.
2. For every permutation sequence <a0, ..., am>, proceed as follows:
    2.1.  Generate a Shkop sequence <AF0, ..., AFm>, where for any AFj,
          0 ≤ j ≤ m, AFj is the restriction of AF to the set of arguments in
          <a0, ..., aj>.
    2.2.  Determine the *Shkop resolution* of the Shkop sequence by applying the sequential Shkop approach.
3. Return the set of all *Shkop resolutions* as the argumentation framework's extensions, ignoring the Shkop
   resolutions that are *null*.

With DiArg, the Shkop extensions of an argumentation framework can be determined as follows, for example:

```java
SimpleShkopReasoner shkopReasoner = new SimpleShkopReasoner();

DungTheory framework = new DungTheory();

framework.add(a);
framework.add(b);
framework.add(c);
framework.add(new Attack(a, b));
framework.add(new Attack(b, a));
framework.add(new Attack(b, c));
framework.add(new Attack(c, c));

Collection<Extension> extensions = shkopReasoner.getModels(framework);
```

To customize the Shkop test, we can use the abstract ShkopTest class and implement our ShkopTest analogously to the
[GroundedShkopTest](./src/main/java/diarg/GroundedShkopTest.java) class. Then, we can set the custom ShkopTest as
follows:

```java
ShkopTest shkopTest = new MyShkopTest();
shkopReasoner.setShkopTest(shkopTest);
```

repository: Interactive-Intelligent-Systems/diarg

gha_language: Java

repo_name: Interactive-Intelligent-Systems/diarg


text:
# Arduino / ESP driven RGB LED Fireplace

You can find the basic code with comments in the ESPFireplace11Base directory.
This is the most basic, not WiFi enabled code, it just drives the LEDs.
You need Arduino IDE and also the ESP8266 Core for Arduino installed, see here:
https://github.com/esp8266/Arduino

I used a NodeMCU (0.9) board.
The code should be easily adaptable also to Arduino boards (UNO/Nano/Mini/etc).

The connection to the RGB LED strip (WS2812B, 60 LEDs/meter, 1 meter) is in the code comments, but it's very easy:
The LED strip requires 5V power, while the NodeMCU outputs a 3.3V signal, but this was enough in practice.
It is also recommended to connect a capacitor (1000 uF, 6.3V or higher) close to the RGB LED strip, across the + and GND wires.

NodeMCU (ESP) pin | WS2812 LED pion
------------ | -------------
D7 | D
VCC (USB PWR) | +5V
GND | GND

![Wiring guide](LEDFireplaceWiring.png)

For any ideas for improvement, feedback, patches, email to:
johnzero AT johnzero DOT hu


text:
# spfx-detokenize

An package to help de-tokenizing values within our source code when building or debugging SPFx solutions, avoiding having some information hardcoded in the code or relaying on environment variables.

## Installation

Install the package and save it as a dev dependency on top of a SPFx solution.

``` shell
npm i --save-dev spfx-detokenize
```
Now you are all set up and ready to start using the package.

## Setting-up the tokens information

Update the `gulpfile.js` with the following:

1. Import the module.

``` javascript
const detokenize = require("SPFx-detokenize");
```
2. Before the `build.initialize(gulp);` line, pass an array of `Token Object` to the `detokenize()` function and then pass the returned task to the `build.rig.addBuildTasks()` function.

``` javascript
const replaceTask = detokenize([{
    paramName: "welcomeText",
    token: "$WELCOME_TEXT$",
    files: ["webparts/helloWorld/components/HelloWorld.tsx"]
}]);

build.rig.addBuildTasks(replaceTask);
```

The `detokenize()` function accepts an **array of 'Token objects'** and a **name(__optional__)** as parameters.

### Token Object
The properties for the token object are:

|Property|Type|Required/Optional|Description|
|--------|----|-----------------|-----------|
|**paramName**|string|Required|Name of the parameter specified in the build command line.|
|**paramDescription**|string|Optional|Friendly name for the parameter to be used when prompting the user in case the parameter hasn't been specified though the command line|
|**token**|string|Required|Token to be replaced by the specified value within the specified files.|
|**files**|string[]|Required|Files where the Token is to be replaced.|

### Full Example
Here is an example of the final version of a `gulpfile.js` using the de-tokenizer module.

``` javascript
'use strict';

const gulp = require('gulp');
const build = require('@microsoft/sp-build-web');
const detokenize = require("SPFx-detokenize");

const replaceTask = detokenize([{
    paramName: "appId",
    token: "$AD_APP_ID$",
    files: ["webparts/helloWorld/components/HelloWorld.tsx"]
}, {
    paramName: "resourceURL",
    paramDescription: "Azure Resource URL",
    token: "$RESOURCE_URL$",
    files: [
        "webparts/helloWorld/HelloWorldWebPart.ts",
        "webparts/helloWorld/components/HelloWorld.tsx"
    ]
}, {
    paramName: "welcomeText",
    token: "$WELCOME_TEXT$",
    files: ["webparts/helloWorld/components/HelloWorld.tsx"]
}]);

build.rig.addBuildTasks(replaceTask);

build.initialize(gulp);

```
## Usage

After finishing with all the set-up in the `gulpfile.js`, you can either run the gulp task and pass the values along, or simply run the task without any values and then provide the vales when prompted.

### Passing Parameters on Command line

The values should be provided after the name of the gulp task(`serve`, `build`) with the following format ` --paramName "VALUE" `.
``` shell
#build
gulp build --appId "0ae21bb6-5a8f-44ca-95fe-4dd2c05be1c8"
            --welcomeText "Welcome to JS 231 SP!!!"
            --resourceURL "https://js231sp.com/"
            --ship
# Serve
gulp serve --appId "0ae21bb6-5a8f-44ca-95fe-4dd2c05be1c8"
            --welcomeText "Welcome to JS 231 SP!!!"
            --resourceURL "https://js231sp.com/"
```

### Without Passing Parameters on Command line

If there is a missing parameter or no parameter has been provided at all, the task will pause and prompt the user for the missing values.

![SPFx de-tokenizer request parameter](https://raw.githubusercontent.com/DariuS231/spfx-detokenize/master/images/SPFX-Detokenizer-request-parameter.png "SPFx de-tokenizer request parameter")

## Result
After running the task, the tokens in the code within the specified files will be replaced by the provided values.

![SPFx de-tokenizer result](https://raw.githubusercontent.com/DariuS231/spfx-detokenize/master/images/SPFX-Detokenizer-result.png "SPFx de-tokenizer result")


text:
# UnityOpenSphericalCamera

Support OSC API v1.0 on Unity.
Take a picture and Load the texture.

![Alt Text](http://img.f.hatena.ne.jp/images/fotolife/n/noshipu/20170221/20170221035242.png)

## How to use
1. Add component "OSCController"
2. Set camera IP address.
Gear360:<IP_ADDRESS> / Bublcam:<IP_ADDRESS> / RICOH THETA S or SC:<IP_ADDRESS>
3. Connect to camera by WiFi.
4. Call OSCController.ExecTakePictureAndLoadImage()
5. You can take a picture and load the image texture.

Sample script is here!
https://github.com/noshipu/UnityOpenSphericalCamera/blob/master/Assets/UnityOpenSphericalCamera/_Demo/Scripts/TakePictureManagerSample.cs

## Third party
This project uses LitJson to read Json format. https://lbv.github.io/litjson/ Thank you very much.

## License
MIT License
Copyright (c) 2017 noshipu

repository: noshipu/UnityOpenSphericalCamera

repo_name: noshipu/UnityOpenSphericalCamera


text:
# History

## 2.0.0 (2020-10-16)

- Uses a newer version of `python-wostools` that adds support to scopus.
- Now you can mix and match ISI and Scopus RIS files in your trees.

## 1.0.2 (2020-08-15)

- Fixed small styling issue on the template.

## 1.0.1 (2020-08-15)

- Fixed bug with `template.html` distribution.

## 1.0.0 (2020-08-15)

- Added a new Jupyter visualization.
- Updated the python wostools dependency to the new version.
- Got the API at production level.

## 0.1.1 (2020-05-20)

- New stable API.

## 0.1.0 (2020-01-26)

- First release on PyPI.

repository: coreofscience/python-sap

gha_language: Jupyter Notebook

repo_name: coreofscience/python-sap


text:
# Op Codes
## Memory Address
A memory references a location on the stack. The value is an absolute offset from the start of the last stack frame.

## Operations
### Store Operation
This operation stores an immediate value inside the specified location.

```
store <size> <destination>, <immediate>
```

### Copy Operation
This operation copies the value of the source location to the destination location.

```
copy <size> <destination>, <source>
```

### Branch Operations
```
op <offset>
```

#### Arguments
##### Available Operations
- `jmp`: An unconditional jump.
- `jmp_false`: Jumps if the test register is equal to `0`.
- `jmp_true`: Jumps if the test register is not equal to `0`.

##### Offset
The offset is relative to the end of the branch instruction in bytes.

### With 2 Operands
```
op <size> <op1>, <op2>
```

#### Arguments
##### Available Operations
- `add`, `fadd`
- `sub`, `fsub`
- `mul`, `fmul`
- `sdiv`, `udiv`, `fdiv`
- `srem`, `urem`, `frem`: Remainder.
- `and`, `or`, `xor`: Bitwise operations.
- `eq`, `neq`, `lt`, `leq`, `gt`, `geq`: All standard comparison functions that yield a boolean. The final result is stored inside the test register.

##### Available Sizes
- `8`, `16`, `32`, `64`

##### First Operand
*op1* must be a memory address. The result of the operation is store here if not specified otherwise.

##### Second Operand
*op2* must be either a memory address or an immediate.

## Examples
The following examples demonstrate the use of the op codes. The actual compiler may optimize the code.

In Bia:

```bia
let x = 0
let y = x + 0
let z = 1 + y
```

```
store 32 x, 0

cp 32 y, x
add 32 y, 0

store 32 z, 1
add 32 z, y
```

repository: bialang/bia-wiki

path: /docs/Engine/Op Codes.md

filename: Op Codes.md

repo_name: bialang/bia-wiki


text:
# AFIRM project's list of contacts

These are the mental health contacts used by Floria, the AFIRM project's core bot.

## Contacts

### Suicide Call Back Service
website_url: "https://www.suicidecallbackservice.org.au/"
description: "Suicide Call Back Service provides 24/7 support if you or someone you know is feeling suicidal."
author_name: "Mental Health Help Line"
author_website_url: "https://www.suicidecallbackservice.org.au/"
author_icon_url: "https://i.imgur.com/xfocDnV.png"
thumbnail_url: "https://i.imgur.com/xfocDnV.png"
fields:
  - name: "Phone"
	value: "1300 659 467"
footer_text: "Open 24/7"

### QLife
website_url: "https://qlife.org.au/"
description: |
  QLife provides nationwide telephone and web-based services to support
  lesbian, gay, bisexual, transgender and intersex (LGBTI) people of all ages.
author_name: "Mental Health Help Line"
author_website_url: "https://qlife.org.au/"
author_icon_url: "https://i.imgur.com/huk43uW.png"
thumbnail_url: "https://i.imgur.com/huk43uW.png"
fields:
  - name: "Phone"
	value: "1800 184 527"
footer_text: "3pm-12am (midnight) AEST / 7 days a week"

### Butterfly Foundation's National Helpline
website_url: "https://thebutterflyfoundation.org.au/our-services/helpline/over-the-phone/"
description: |
  ED HOPE, is a free, confidential service that provides information, counselling and treatment referral
  for people with eating disorders, and body image and related issues.
author_name: "Mental Health Help Line"
author_website_url: "https://thebutterflyfoundation.org.au/our-services/helpline/over-the-phone/"
author_icon_url: "https://i.imgur.com/BYzgxVa.png"
thumbnail_url: "https://i.imgur.com/BYzgxVa.png"
fields:
  - name: "Phone"
	value: "1800 650 890"
footer_text: "8am-midnight AEST / 7 days a week"

## eheadspace
website_url: "https://headspace.org.au/eheadspace/"
description: |
  eheadspace provides mental health and wellbeing support, information and services
  to young people aged 12 to 25 years and their families.
author_name: "Mental Health Help Line"
author_website_url: "https://headspace.org.au/eheadspace/"
author_icon_url: "https://i.imgur.com/NT1YKMc.png"
thumbnail_url: "https://i.imgur.com/NT1YKMc.png"
fields:
  - name: "Phone"
	value: "1800 33 4673"
footer_text: "8am-midnight AEST / 7 days a week"

### Kids Help Line
website_url: "https://kidshelpline.com.au/"
description: |
  Kids Helpline is Australiaâ€™s only free 24/7 confidential and private counseling service
  specifically for children and young people aged 5 to 25.
author_name: "Mental Health Help Line"
author_website_url: "https://kidshelpline.com.au/"
author_icon_url: "https://i.imgur.com/mnvvDRQ.png"
thumbnail_url: "https://i.imgur.com/mnvvDRQ.png"
fields:
  - name: "Phone"
	value: "1800 55 1800"
footer_text: "Open 24/7"

### Lifeline
website_url: "https://www.lifeline.org.au/"
description: "Lifeline provides 24-hour crisis counselling, support groups and suicide prevention services."
author_name: "Mental Health Help Line"
author_website_url: "https://www.lifeline.org.au/"
author_icon_url: "https://i.imgur.com/84dYdDv.png"
thumbnail_url: "https://i.imgur.com/84dYdDv.png"
fields:
  - name: "Phone"
	value: "13 11 14."
footer_text: "Open 24/7"

### MensLine Australia
website_url: "https://mensline.org.au/"
description: |
  MensLine Australia is a professional telephone and online support and information service for Australian men.
author_name: "Mental Health Help Line"
author_website_url: "https://mensline.org.au/"
author_icon_url: "https://i.imgur.com/ldayfoE.png"
thumbnail_url: "https://i.imgur.com/ldayfoE.png"
fields:
  - name: "Phone"
	value: "1300 78 99 78"
footer_text: "Open 24 hours / 7 days a week"

### MindSpot
website_url: "https://mindspot.org.au/"
description: |
  MindSpot is a free telephone and online service for people with stress, worry, anxiety, low mood or depression.
  It provides online assessment and treatment for anxiety and depression.
  MindSpot is not an emergency or instant response service.
author_name: "Mental Health Help Line"
author_website_url: "https://mindspot.org.au/"
author_icon_url: "https://i.imgur.com/G8Cz800.png"
thumbnail_url: "https://i.imgur.com/G8Cz800.png"
fields:
  - name: "Phone"
	value: "1800 61 44 34"
footer_text: "AEST, 8am-8pm (Mon-Fri), 8am-6pm (Sat)"

url: https://raw.githubusercontent.com/KGBicheno/KGB_Agora/70ea95c9d38ab2f31abbd510691bb4c050a6cb3b/Mental Health/Mental Health Contacts/AFIRM project's list of Mental Health Contacts.md


text:
# rpgiv-xml
jEdit mode for freeform RPG IV

I use [jEdit editor](http://jedit.org) as a remote editor to develop freeform [RPG IV](https://www.ibm.com/support/knowledgecenter/ssw_ibm_i_73/rzasd/sc092508.pdf)
code (UTF-8) on the IBM i in the Integrated File System (IFS) via the jEdit FTP Plugin.

This project provides a (minimal, so far) jEdit edit mode for RPG IV intended for that environment.

* Currently does not support old-style control specs.
* Recognizes keywords but is indiscriminate in highlighting about anything starting with `*` or anything that looks like a function.

Much more could be done, feel free to fork for pull request, I'd be glad for the help!

Jack Woehr
2017-07-28

repository: jwoehr/rpgiv-xml

repo_name: jwoehr/rpgiv-xml


text:
# How to release new versions

This shows how to do it locally. This should all be wrapped up in a GitHub action so it can
happen automatically.

 1. Get a GitHub personal access token from GitHub. It needs the ability to write to
    the KubeWise GitHub repo.
 2. Log in to Docker so that the `docker` CLI has the permissions to publish images to
    Docker Hub. This may require getting a Docker Hub access token and manually logging
    in with `docker login --username`.
 3. Set the GitHub token in the environment with `export GITHUB_TOKEN=<my-token>`.
 4. Release with: `./bin/release.sh  {major|minor|patch}`
 5. Package the Helm chart: `helm package ./helm_chart`.
 6. Move it to the helm repos: `mv kubewise-*.tgz $PATH_TO_HELM_REPO`
 7. Add and commit that repo to publish the chart automatically.


text:
## Dropout

Dropout is a [regularization](../R/regularization.md) technique or a hyperparameter for Neural Networks that prevents overfitting.

It prevents network from overfitting by removing a random selection of a fixed number of the units in a network layer for a single gradient step. Dropout can be interpreted in various ways, such as randomly sampling from an exponential number of different networks.

### Related Paper and Summary
1. Dropout: A Simple Way to Prevent Neural Networks from
Overfitting [Paper](../paper/) and [Summary]()
2.


text:
# macOS-Admin-Scripts
Scripts for macOS administration.

## BootstrapFailedAppleUpdates.sh

Used for putting Munki into bootstrap mode when an Apple security update fails to install.
Details: https://www.kevinmcox.com/2019/03/working-around-failed-apple-software-updates-with-munki/

## ReposadoNotification.sh

Automate Reposado downloads, testing and get notified via Slack.
Details: https://www.kevinmcox.com/2019/04/automating-reposado-with-slack-notifications/

repository: kevinmcox/macOS-Admin-Scripts

repo_name: kevinmcox/macOS-Admin-Scripts


text:
Grunt Polymer workflow
======================

If you want to start using Google Polymer without having to deal with more files to import this is the project you have to start with.

![Grunt Polymer Workflow](https://copy.com/avrfzxMfIaAEKSBH)

## Usage
```shell
$ git clone https://github.com/michaelgenesini/grunt-polymer-workflow.git
$ cd grunt-polymer-workflow
$ npm install
$ bower install
$ grunt server
```

## Requirements

**Requires Sass, which can be installed with** `gem install sass`

**Requires Grunt Cli, which can be installed with** `sudo npm install -g grunt-cli`

**Requires Bower, which can be installed with** `sudo npm install -g bower`

## Author
Michael Genesini

repository: michaelgenesini/grunt-polymer-workflow

repo_name: michaelgenesini/grunt-polymer-workflow


text:
**2019-06-06**
  - Updated the p4 submit to catch any exception with reading the file diff into the P4 changelist.  If reading the file fails, the changelist will no longer fail. It will now report that the change text failed to load and that the file may be a binary file.
  - Added a new setting `git-p4.skipSubmitFileDiff` If this is set, then the File Diff will not be included changelist. (This is removed when the changelist is submitted anyway.)

**2019-06-05**
Make the following changes:
  - Changed the default format for the diffcmd in p4 submit method. Added the `--git-dir` and `--work-tree` parameters to the git command. Before this command is executed, the directory is changed, and the git repository cannot be located.
  - Added a check for `core.autocrlf` if patching fais and the Operating System is Windows. This will show a helpful message suggesting that it be set.
  - Added a new hook - `p4-pre-edit-changelist` that allows for a hook that will modify the generated changelist document prior to showing it for edit.
  - Added a new method `pathJoin` that will strip off quotes if a portion of the path is escaped.
  - Moved the code for running a hook to `runHook` to allow for more generalization and executing other hooks (like the p4-pre-edit-changelist noted above.)

**2019-06-04**

  - Added a Visual Studio 2019 project. This is optional and provided for Windows Debugging.


text:
# The Adapter Pattern
The Adapter Pattern is very useful when an existing code/interface exports data formated in a specific format (XML for example) and helps to convert it into JSON to another part of the application be able to deal with the data;

Another good usage is when a part of the code is depending of a third party library that can be changed in the future and to avoid the headache of a code tightly coupled an adapter can be very usefull providing the same way to pass the data independendly of the library that is running under the hood;

To run the example just type `yarn adapter` or `npm run adapter`;

To see the code just click [here](/structural/adapter/example.js);

repository: EduardoModel/design-patterns

repo_name: EduardoModel/design-patterns


text:
# Augmentation
*A technique to increase the **diversity** of training set by applying random (but realistic) **transformations**.*

This repo contains implemenatation of major data augmentations and dataloaders related to
- vision(image)
- audio(speech)
- text(language)

## Dependencies:
- [PyTorch](https://pytorch.org/)
- [opencv-python](https://pypi.org/project/opencv-python/)

---
## Vision
---
### [CutOut]():
Cutout augmentation is a kind of regional dropout strategy in which a random patch from an image is zeroed out (replaced with black pixels). Cutout samples suffer from the decrease in information and regularization capability.

- Usage:
  ```python
  from vision import CutOut

  cutout = CutOut(num_holes=1, max_h=100, max_w=100, fill_value=0, p=0.5)
  # img: torch image tensor of shape [ch, h, w]
  augmented = cutout(img)

  # Image level augmentation -> can be used inside custom dataloader
  from torchvision.utils.data import Dataset

  class CustomDataset(Dataset):
    def __init__(self, ):
      ...
      self.cutout = CutOut()
      ...

    def __len__(self, ):
      ...

    def __getitem__(self, idx):
      ...
      augmented = self.cutout(images[idx])
      ...
      return augmented

  ```

### [MixUP](https://arxiv.org/pdf/1710.09412.pdf)
In Mixup augmentation two samples are mixed together by linear interpolation of their images and labels. Mixup samples suffer from unrealistic output and ambiguity among the labels and hence cannot perform well on tasks like image localization and object detection.

- Usage:
  ```python
  from vision import MixUp

  mixup = MixUp(p=0.5)
  # img: torch batch of image tensor of shape [bs, ch, h, w]
  augmented = mixup(batch_of_images)

  # Batch level augmentation -> Cannot be used inside Custom loader
  #                          -> Use inside train loop

  for data, target in Dataloader:
    augmented_data, augmentated_target = mixup(data, target)
    ...

  ```

### [CutMix](https://github.com/clovaai/CutMix-PyTorch)
In CutMix augmentation we cut and paste random patches between the training images. The ground truth labels are mixed in proportion to the area of patches in the images. CutMix increases localization ability by making the model to focus on less discriminative parts of the object being classified and hence is also well suited for tasks like object detection.

- Usage:
  ```python
  from vision import CutMix

  cutmix = CutMix(p=0.5)
  # img: torch batch of image tensor of shape [bs, ch, h, w]
  augmented = cutmix(batch_of_images)

  # Batch level augmentation -> Cannot be used inside Custom loader
  #                          -> Use inside train loop

  for data, target in Dataloader:
    augmented_data, augmentated_target = cutmix(data, target)
    ...
  ```

| | | |
|:-------------------------:|:-------------------------:|:-------------------------:|
| CutOut | CutMix | MixUp |

### [BYOL](https://arxiv.org/pdf/2006.07733.pdf)
- random cropping: a random patch of the image is selected, with an area uniformly sampled between 8%
- optional left-right flip;
- color jittering: the brightness, contrast, saturation and hue of the image are shifted by a uniformly random
  offset applied on all the pixels of the same image. The order in which these shifts are performed is randomly
  selected for each patch;
- color dropping: an optional conversion to grayscale. When applied, output intensity for a pixel (r, g, b)
  corresponds to its luma component, computed as 0.2989r + 0.5870g + 0.1140b;
- Gaussian blurring: for a 224×224 image, a square Gaussian kernel of size 23×23 is used, with a standard
  deviation uniformly sampled over [0.1, 2.0];
- solarization: an optional color transformation x 7→ x · 1{x<0.5} + (1 − x)· 1{x≥0.5} for pixels with values in [0, 1].
- check [```vision_dataset.py```](./vision_dataset.py)

Usefull links:
- [TORCHVISION.TRANSFORMS](https://pytorch.org/vision/stable/transforms.html)

---
## Audio
---
### [DFT](https://en.wikipedia.org/wiki/Fourier_transform)
- [3Blue1Brown - Explaination of Fourier Transform](https://www.youtube.com/watch?v=spUNpyF58BY)

### [Mel Spectogram]()
### Augmentations
- waveform augmentations
- spectrogram augmentations
### Sample Dataloader

---
## Text
---

## Citations
```bibtex
@misc{grill2020bootstrap,
      title={Bootstrap your own latent: A new approach to self-supervised Learning},
      author={Jean-Bastien Grill and Florian Strub and Florent Altché and Corentin Tallec and Pierre H. Richemond and Elena Buchatskaya and Carl Doersch and Bernardo Avila Pires and Zhaohan Daniel Guo and Mohammad Gheshlaghi Azar and Bilal Piot and Koray Kavukcuoglu and Rémi Munos and Michal Valko},
      year={2020},
      eprint={2006.07733},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}
```

```bibtex
@misc{yun2019cutmix,
      title={CutMix: Regularization Strategy to Train Strong Classifiers with Localizable Features},
      author={Sangdoo Yun and Dongyoon Han and Seong Joon Oh and Sanghyuk Chun and Junsuk Choe and Youngjoon Yoo},
      year={2019},
      eprint={1905.04899},
      archivePrefix={arXiv},
      primaryClass={cs.CV}
}
```

```bibtex
@misc{zhang2018mixup,
      title={mixup: Beyond Empirical Risk Minimization},
      author={Hongyi Zhang and Moustapha Cisse and Yann N. Dauphin and David Lopez-Paz},
      year={2018},
      eprint={1710.09412},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}
```
```
@article{Park_2019,
   title={SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition},
   url={http://dx.doi.org/10.21437/Interspeech.2019-2680},
   DOI={10.21437/interspeech.2019-2680},
   journal={Interspeech 2019},
   publisher={ISCA},
   author={Park, Daniel S. and Chan, William and Zhang, Yu and Chiu, Chung-Cheng and Zoph, Barret and Cubuk, Ekin D. and Le, Quoc V.},
   year={2019},
   month={Sep}
}
```

repository: girishdhegde/augmentation

repo_name: girishdhegde/augmentation


text:
#### [Home](Home.md)
#### Getting started
- [Introduction](getting-started/Introduction.md)
- [Setting up a study](getting-started/Setup-study.md)
- [Create a form](getting-started/Create-form.md)
- [Preview a form](getting-started/Preview-form.md)
- [Administer a form](getting-started/Administer-form.md)

#### Form builder
- [Introduction](form-builder/Introduction.md)
- [Form types](form-builder/FormTypes.md)
- [Form sections](form-builder/Sections.md)
- [Form pages](form-builder/Pages.md)
- [Form questions](form-builder/Questions.md)
  - [Question types](form-builder/Question-types.md)
  - [Question parameters](form-builder/Question-parameters.md)
  - [Conditions](form-builder/Conditions.md)
  - [Interpolated values](form-builder/InterpolatedValues.md)

#### Locations
- [Search](locations/Search.md)
- [Location info](locations/Geo-info.md)
- [Map](locations/Map.md)
- [Location types](location/LocationTypes.md)

#### Respondents
- [Search](respondents/Search.md)
- [Add a new respondent](respondents/Add-new-respondent.md)
- [Respondent info](respondents/RespondentInfo.md)

#### Sync
- [Introduction](sync/Introduction.md)
- [Admin](sync/Admin.md)

#### Reports
- [Introduction](reports/Introduction.md)
- [Importing](reports/Importing.md)
- [Survey reports](reports/SurveyReports.md)
- [Respondent reports](reports/RespondentReport.md)
- [Location reports](reports/LocationReport.md)
- [Interview reports](reports/InterviewReport.md)
- [Edge reports](reports/EdgeReport.md)
- [Action reports](reports/ActionReport.md)
- [Respondent location reports](reports/RespondentLocationReport.md)
- [Metadata reports](reports/MetadataReports.md)

### General
- [Server Configuration](admin/ServerConfiguration.md)
- [Permissions](admin/Permissions.md)
- [Studies](Studies)
- [Devices](devices/Devices.md)
  - [Registering devices](devices/RegisterDevice.md)
- [Logs](admin/Logs.md)
- [Information](admin/Information.md)

##### [Glossary](Glossary.md)

repository: ezzooozz/trellis-app

repo_name: ezzooozz/trellis-app


text:
---
layout: default
title: Integration rewards
parent: Getting started
nav_order: 3
permalink: /getting-started/integration-rewards/
---

# Integration rewards

We encourage you to apply for integration rewards (up to **$20,000**) once your project
is successfully integrated with OSS-Fuzz. Please see the details in our blog post
[here](https://opensource.googleblog.com/2017/05/oss-fuzz-five-months-later-and.html).

Rewards are based on the quality of integration with OSS-Fuzz, which is evaluated using
the following criteria:
* Upstream integration of the fuzz targets and build support.
* Performance of the fuzz targets and code coverage achieved with fuzzing.
* Regression testing in the upstream repository using fuzz targets and OSS-Fuzz corpora.
  Enabling [CIFuzz](https://google.github.io/oss-fuzz/getting-started/continuous-integration/)
  is the easiest way to address this.
* Discretion bonus to recognize outstanding work.

For each of the points above, the OSS-Fuzz rewards panel first sets up a cap of up to $5,000.
Then, the panel decides the actual reward amount (ranging from $0 up to the cap) for each
criteria, depending on how well the criteria is satisfied.

The highest cap values ($5,000) are awarded only to projects of a critical importance for the
global infrastructure and/or widely used products, devices, or services.

repository: Google-Autofuzz/oss-fuzz

repo_name: Google-Autofuzz/oss-fuzz


text:
## Prepare Positions for Canonical and Methylation Calling

The NA12878 genome is commonly used as a benchmark for several DNA and RNA sequencing experiments.
* ENCODE - "An integrated encyclopedia of DNA elements in the human genome).
* Nanopore assembly and Methylation calling - "Nanopore sequencing and assembly of a human genome with ultra-long reads".

Use bisulfite sequencing data from ENCODE (https://www.encodeproject.org/experiments/ENCSR890UQO/) to generate high confidence methylated cytosines and high confidence canonical bases.

### Process Bisulfite Data
#### Step1: Download

All data can be found https://www.encodeproject.org/experiments/ENCSR890UQO/.
* Two isogenic replicates.
    * Replicate 1: https://www.encodeproject.org/biosamples/ENCBS232JAP/
        * methylation state at CHG: 2.51 GB
            * https://www.encodeproject.org/files/ENCFF721BJM/@@download/ENCFF721BJM.bed.gz
        * methylation state at CpG: 636 MB
            * https://www.encodeproject.org/files/ENCFF279HCL/@@download/ENCFF279HCL.bed.gz
        * methylation at CHH: 7.98 GB
            * https://www.encodeproject.org/files/ENCFF448RTC/@@download/ENCFF448RTC.bed.gz
    * Replicate 2: https://www.encodeproject.org/biosamples/ENCBS232JAP/
        * methylation state at CHG: 2.47 GB
            * https://www.encodeproject.org/files/ENCFF349NNL/@@download/ENCFF349NNL.bed.gz
        * methylation state at CpG: 635 MB
            * https://www.encodeproject.org/files/ENCFF835NTC/@@download/ENCFF835NTC.bed.gz
        * methylation at CHH: 7.88 GB
            * https://www.encodeproject.org/files/ENCFF038HXQ/@@download/ENCFF038HXQ.bed.gz

* Bed file format
    1. Reference chromosome or scaffold
    * Start position in chromosome
    * End position in chromosome
    * Name of item
    * Score from 0-1000. Capped number of reads
    * Strandedness, plus (+), minus (-), or unknown (.)
    * Start of where display should be thick (start codon)
    * End of where display should be thick (stop codon)
    * Color value (RGB)
    * Coverage, or number of reads
    * Percentage of reads that show methylation at this position in the genome

#### Step2: Compare and Aggregate
* Plot the correlation between these bed files in order to get an idea of our confidence levels of the "gold standard" of bisulfite sequencing.
* Aggregate data
    * Create file with both CpG files aggregated together
    * Create file with both CHG files aggregated together
    * Create file with both CHH files aggregated together
    * Create file with CHH and CHG files aggregated together
    * Create file with all files aggregated together

#### Step3: Generate desired files
* Isolated Canonical Positions on Chr21
* CpG high confidence calls on Chr21
* mC high confidence calls on Chr21

Note: "Although DNA methylation occurs mostly in the CG context, it may also occur at CHG and CHH sites (where H can be any nucleotide other than G)." - https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3903047/


text:
# Server Routing

## Description

This repository contains a `docker-compose.yml`, which is used to spawn [Traefik][traefik] and [Consul][consul] instances on a hosted server.
They take care of routing and certificate management on the server.

[traefik]: https://docs.traefik.io/
[consul]: https://www.consul.io/

repository: DahlitzFlorian/server-routing

repo_name: DahlitzFlorian/server-routing


text:
# AREP - LAB 1

A program to calculate the mean and standard deviation of a set of n real numbers. The program reads the n real numbers from a file.

## Getting Started

### Pre-requisites

You need to have installed on your PC:

- JDK
- Maven
- Git

### Installing

Open a command prompt on the folder that you are going to save this project and copy:

```
git clone https://github.com/CarlosGomez380/arep-lab1.git
```

![](https://github.com/CarlosGomez380/arep-lab1/blob/master/img/clone.PNG)

Once finish this process, open the project on the terminal with

```
cd arep-lab1
```

And copy:

```
mvn package
```

![](https://github.com/CarlosGomez380/arep-lab1/blob/master/img/package.PNG)

## Running the tests

To run test, open the folder of this project and a command prompt on this location and copy:

```
mvn test
```

![](https://github.com/CarlosGomez380/arep-lab1/blob/master/img/test.PNG)

![](https://github.com/CarlosGomez380/arep-lab1/blob/master/img/runnigTest.PNG)

## Deployment

To deploy this project open the folder of this project and a command prompt on this location and copy:

```
mvn exec:java -Dexec.mainClass="edu.escuelaing.arep.lab1.App"
```

![](https://github.com/CarlosGomez380/arep-lab1/blob/master/img/deploy.PNG)

## Documentation JavaDoc

To see the javadoc generated copy:

```
mvn javadoc:javadoc
```

This document will be located in /target/site

## Built With

- [Maven](https://maven.apache.org/) - Dependency Management

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details


text:
# docker-multirun

Run a docker container via docker-run multiple times. Works like docker-compose by keeping the container and reusing the volumes.

There are many cases where you run a task repeatedly, but do not want to throw away the whole container. One frequent task is running tests in a docker container. You want to keep the installed node_modules files and then run the tests multiple times.

`docker-multirun` is like [docker-run](https://docs.docker.com/engine/reference/run/), but reuses the volumes of the already-existing container. This way, generated files from the previous run are kept. This behavior is also known from [docker-compose](https://docs.docker.com/compose/).

## Install

```bash
# npm
$ npm install docker-multirun

# Yarn
$ yarn add docker-multirun
```

## Usage

```bash
# Using yarn
$ npx docker-multirun node:12 bash -c "npm ci && npm test"

# Using npm
$ yarn docker-multirun node:12 bash -c "yarn --frozen-lockfile && yarn test"

# Mounting volumes
$ yarn docker-multirun node:12 -v $(pwd):/app -v /app/node_modules bash -c "yarn --frozen-lockfile && yarn test"
[1/4] 🔍  Resolving packages...
[2/4] 🚚  Fetching packages...
[3/4] 🔗  Linking dependencies...

# Run it again
$ yarn docker-multirun node:12 -v $(pwd):/app -v /app/node_modules bash -c "yarn --frozen-lockfile && yarn test"
[1/4] 🔍  Resolving packages...
success Already up-to-date.

# That was the fast lane!
```

### Custom container name
You can give your container a custom name by using the `--name` option, which is part of [docker-run](https://docs.docker.com/engine/reference/run/).

## Contribute

Are you missing something or want to contribute? Feel free to file an [issue](https://github.com/dword-design/docker-multirun/issues) or a [pull request](https://github.com/dword-design/docker-multirun/pulls)! ⚙

## Support

Hey, I am Sebastian Landwehr, a freelance web developer, and I love developing web apps and open source packages. If you want to support me so that I can keep packages up to date and build more helpful tools, you can donate here:

   If you want to send me a one time donation. The coffee is pretty good 😊.

   Also for one time donations if you like PayPal.

   Here you can support me regularly, which is great so I can steadily work on projects.

Thanks a lot for your support! ❤

## License

[MIT License](https://opensource.org/licenses/MIT) © [Sebastian Landwehr](https://sebastianlandwehr.com)

repository: dword-design/docker-multirun

gha_license_id: NOASSERTION

repo_name: dword-design/docker-multirun


text:
# Dothidella aristidae (Schwein.) Ellis & Everh., 1892 SPECIES

#### Status
SYNONYM

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

#### Published in
N. Amer. Pyren. (Newfield) 607 (1892)

#### Original name
Sphaeria aristidae Schwein., 1832

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Sordariomycetes/Phyllachorales/Phyllachoraceae/Phyllachora/Phyllachora aristidae/ Syn. Dothidella aristidae/README.md

repo_name: mdoering/backbone


text:
Parallel Coordinate Plots for GeoJSON Feature Collections
=========================================================

This is an extremely simple plug-in for D3 that generates an SVG-based parallel coordinate plot for a [GeoJSON][geojson] [Feature Collection][geojsonfc].

This code was heavily influenced by [Jason Davies'][davies] [Parallel Coordinates][daviespcp] example. In fact, you might even say I just straight-up copied the code and changed it to meet my needs. Because, that's exactly what I did. Thank you, Jason, for this example.

Again, this is an extremely simple implementation of a Parallel Coordinate Plot. If you need something more complex or detailed, I suggest you take a look at Syntagmatic's [Parallel Coordinates][syntagmaticpcp] plug-in.

## API

# d3.**pcpGeoJson**(_collection_[, _options_])

Creates a parallel coordinate plot for the properties, with values of type _Number_, of each [Features][geojsonf] in a [Feature Collection][geojsonfc]. Returns a reference to

The _collection_ parameter is required and **must** be a GeoJSON Feature collection. Behavior is undefined if this parameter is not a Feature Collection.

The _options_ parameter is an optional object that allows you to define the following properties:

* _id_      : [String] The ID of the container for the PCP, defaults to 'body'
* _keys_    : [Array] List of all property names to be used as dimensions of the PCP, defaults to all properties in the first feature that has data of type Number
* _buffers_ : [Array] Array of numbers, must specify all; [top, right, bottom, left], defaults to [30, 10, 10, 10]
* _width_   : [Number] Width of the plot, defaults to 960
* _height_  : [Number] Height of the plot, defaults to 500
* _linker_  : [Function] Details to come...

### Linking Functionality

Details to come.

### Example Usage

```HTML

<html lang="en">
<head>
  <script src="//d3.v3.min.js" charset="utf-8"></script>
  <script src="//d3.pcpGeoJson.min.js"></script>
  <link href="//d3.pcpGeoJson.css" rel='stylesheet' />
</head>
<body>
  <script type="text/javascript">
    d3.json('collection.json', function (error, collection) {
      if (error) {
        return console.warn(error);
      }

      d3.pcpGeoJson(collection);
    })
  </script>
</body>
</html>

```

[davies]: https://www.jasondavies.com/
[daviespcp]: http://bl.ocks.org/jasondavies/1341281
[geog461w]: http://bulletins.psu.edu/undergrad/courses/G/GEOG/461W
[geog461wfp]: http://www.geovista.psu.edu/resources/geog461w.html
[geojson]: http://geojson.org/
[geojsonf]: http://geojson.org/geojson-spec.html#feature-objects
[geojsonfc]: http://geojson.org/geojson-spec.html#feature-collection-objects
[syntagmaticpcp]: https://github.com/syntagmatic/parallel-coordinates

repository: RyanMullins/pcpGeoJson

repo_name: RyanMullins/pcpGeoJson


text:
---
layout: post
title:  "Today's Dojo"
date:   2016-09-10
category: dojo
author: eugene
---

## Newbies

Today, we continue our march through Code.org's first course by using our creativity plus computational thinking to create a story.

[Create a Story][1] - Code.org, Course 1, Stage 16

Time permitting, we'll try to finish the course with Stage 18's artist loops.

[Artist Loops][5] - Code.org, Course 1, Stage 18

As before, our mentors will throw names into a hat, and pair-up the students. One student drives and one navigates. After each step, the students switch roles and work through the same step with a different Chrome user. Then move on to the next step.

## Hackers

Today, we try to finish the [MySQL][2] database Sushi cards, [Beginner Databases][3].

As before, students work in pairs. One drives and one navigates. After each card, the students switch roles and work through the same card using their own database (via the `USE` command we discussed in last week's [dojo][4]). Then move on to the next card.

Below are some MySQL commands that may come in handy today.

### Backup Database

MySQL includes a program called `mysqldump` to create backups. It *dumps* the content of your database into a backup file.

1. Click the `Shell` button on the XAMPP Control Panel to launch the shell.
2. Backup the database into a file, type `mysqldump -u root Spongebob > Spongebob.sql`. (Don't be silly, replace `Spongebob` with the name of *your* database!)

### Restore Database

To restore a database, we create a new database, then load it with the backup `.sql` file we created. This backup file is just a list of SQL commands (just like the ones we type in MySQL monitor).

1. Now launch the MySQL monitor, type `mysql -u root`.
2. Create your new database, type `create database Spongebob;`.
3. Switch to it, type `use Spongebob;`.
4. Now load it with the backup, type `source dump.sql`.

[1]: https://studio.code.org/s/course1/stage/16/puzzle/1
[2]: https://en.wikipedia.org/wiki/MySQL
[3]: http://kata.coderdojo.com/wiki/Beginner_Databases
[4]: http://dojosamoa.org/dojo/2016/08/27/todays-dojo.html
[5]: http://studio.code.org/s/course1/stage/18/puzzle/1

license: MIT,Unlicense

repository: genebarker/dojosamoa

detected_licenses: MIT Unlicense

repo_name: genebarker/dojosamoa