text:
Running the SDP Prototype stand-alone
=====================================

Prerequisites
-------------

### Kubernetes

You will need Kubernetes installed. [Docker for
Desktop](https://www.docker.com/products/docker-desktop) includes a
workable one-node Kubernetes installation - just need to activate it
in the settings. Alternatively, you can install
[Minikube](https://minikube.sigs.k8s.io) or
[microk8s](https://microk8s.io).

#### Docker and Minikube

Docker runs containers in a VM on Windows and macOS, and by default Minikube
does this on all systems. The VM needs at least 3 GB of memory to run the
SDP prototype. In Docker this can be found in the settings. For Minikube you
need to specify the amount of memory on the command line when starting a new
instance:

```bash
    $ minikube start --memory='4096m'
```

#### Micro8ks

Canonical supports **microk8s** for Ubuntu Linux distributions - and it
is also available for many other distributions (42 according to
[this](https://github.com/ubuntu/microk8s#accessing-kubernetes)). It
gives a more-or-less 'one line' Kubernetes installation

- To install type `sudo snap install microk8s --classic`
    -   Make you to install 1.15 version. This can be done using
        `snap refresh --classic --channel=1.15/stable microk8s`
- `microk8s.start` will start the Kubernetes system
- `microk8s.enable dns` is required for the SDP prototype
- `microk8s.status` should show that things are active
- microk8s will install `kubectl` as `microk8s.kubectl`. Unless you have
  another Kubernetes installation in parallel you may wish to set up an
  alias with `sudo snap alias microk8s.kubectl kubectl`

If you have problems with pods not communicating, you may need to do
`sudo iptables -P FORWARD ACCEPT` (`microk8s.inspect` should be able
to diagnose this for you).

### Helm

Furthermore you will need to install the Helm utility. It is available
from most typical package managers, see [Using
Helm](https://helm.sh/docs/using_helm/). You can use either version 2
or version 3 of Helm. Instructions are given below for both.

It may be available in the 'snap' installation system (eg. on
recent Ubuntu installations)

If you are using Helm 2, you will typically need to initialise it
(this will create the 'Tiller' controller):

```bash
    $ helm init
```

Helm 3 does not use Tiller, but if you are using it for the first time,
you need to add the stable chart repository:

```bash
    $ helm repo add stable https://kubernetes-charts.storage.googleapis.com/
```

Deploying SDP
-------------

### Install the etcd operator

We are not creating an etcd cluster ourselves, but instead leave it to
an 'operator' that needs to be installed first. For Helm 2, simply
execute:

```bash
    $ helm install stable/etcd-operator -n etcd
```

or for Helm 3:

```bash
    $ helm install etcd stable/etcd-operator
```

If you now execute:

```bash
    $ kubectl get pod --watch
```

You should eventually see an pod called
`etcd-etcd-operator-etcd-operator-[...]` in 'Running' state (yes,
Helm is exceedingly redundant with its names). If not wait a bit, if
you try to go to the next step before this has completed there's a
chance it will fail.

### Deploy the SDP components

At this point you should be able to deploy the SDP components. First go
to the charts directory:

```bash
    $ cd [sdp-prototype]/charts
```

Then for Helm 2, execute:

```bash
    $ helm install sdp-prototype -n sdp-prototype
```

or for Helm3, execute:

```bash
    $ helm install sdp-prototype sdp-prototype
```

You can again watch the fireworks using `kubectl`:

```bash
    $ kubectl get pod --watch
```

Pods associated with Tango might go down a couple times before they
start correctly, this seems to be normal. You can check the logs of
pods (copy the full name from `kubectl` output) to verify that they
are doing okay:

```bash
    $ kubectl logs sdp-prototype-tangods-[...] sdp-subarray-1
    2019-11-21 16:49:01,097 | INFO    | Initialising SDP Subarray: mid_sdp/elt/subarray_1
    ...
    2019-11-21 16:49:01,104 | INFO    | SDP Subarray initialised: mid_sdp/elt/subarray_1
    $ kubectl logs sdp-prototype-processing-controller-[...]
    ...
    DEBUG:main:Waiting...
    $ kubectl logs sdp-prototype-helm-deploy-[...]
    ...
    INFO:main:Found 0 existing deployments.
```

Just to name a few. If it's looking like this, there's a good chance
everything has been deployed correctly.

Testing it out
--------------

### Connecting to the configuration database

The deployment scripts should have exposed the SDP configuration
database (i.e. etcd) via a NodePort service. For Docker Desktop, this
should automatically expose the port on localhost, you just need to
find out which one:

```bash
    $ kubectl get service sdp-prototype-etcd-nodeport
    NAME                          TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
    sdp-prototype-etcd-nodeport   NodePort   <IP_ADDRESS>   <none>        2379:32234/TCP   3h56m
```

Set the environment variable `SDP_CONFIG_PORT` according to the
second part of the `PORTS(S)` column:

```bash
    $ export SDP_CONFIG_PORT=32234
```

For Minikube, you need to set both `SDP_CONFIG_HOST` and
`SDP_CONFIG_PORT`, but you can easily query both using
`minikube service`:

```bash
    $ minikube service --url sdp-prototype-etcd-nodeport
    http://<IP_ADDRESS>:32234
    $ export SDP_CONFIG_HOST=<IP_ADDRESS>
    $ export SDP_CONFIG_PORT=32234
```

This will allow you to connect with the `sdpcfg` utility:

```bash
    $ pip install -U ska-sdp-config
    $ sdpcfg ls -R /
    Keys with / prefix:
```

Which correctly shows that the configuration is currently empty.

### Start a workflow

Assuming the configuration is prepared as explained in the previous
section, we can now add a processing block to the configuration:

```bash
    $ sdpcfg process realtime:testdask:0.1.0
    OK, pb_id = realtime-20191121-0000
```

The processing block is created with the `/pb` prefix in the
configuration:

```bash
    $ sdpcfg ls values -R /pb
    Keys with /pb prefix:
    /pb/realtime-20191121-0000 = {
      "parameters": {},
      "pb_id": "realtime-20191121-0000",
      "sbi_id": null,
      "scan_parameters": {},
      "workflow": {
        "id": "testdask",
        "type": "realtime",
        "version": "0.1.0"
      }
    }
    /pb/realtime-20191121-0000/owner = {
      "command": [
        "testdask.py",
        "realtime-20191121-0000"
      ],
      "hostname": "realtime-20191121-0000-workflow-7bf947687f-9h9gz",
      "pid": 1
    }
```

The processing block is detected by the processing controller which
deploys the workflow. The workflow in turn deploys the execution engines
(in this case, Dask). The deployments are requested by creating entries
with `/deploy` prefix in the configuration, where they are detected by
the Helm deployer which actually makes the deployments:

```bash
    $ sdpcfg ls values -R /deploy
    Keys with /deploy prefix:
    /deploy/realtime-20191121-0000-dask = {
      "args": {
        "chart": "stable/dask",
        "values": {
          "jupyter.enabled": "false",
          "scheduler.serviceType": "ClusterIP",
          "worker.replicas": 2
        }
      },
      "deploy_id": "realtime-20191121-0000-dask",
      "type": "helm"
    }
    /deploy/realtime-20191121-0000-workflow = {
      "args": {
        "chart": "workflow",
        "values": {
          "env.SDP_CONFIG_HOST": "sdp-prototype-etcd-client.default.svc.cluster.local",
          "env.SDP_HELM_NAMESPACE": "sdp",
          "pb_id": "realtime-20191121-0000",
          "wf_image": "nexus.engageska-portugal.pt/sdp-prototype/workflow-testdask:0.1.0"
        }
      },
      "deploy_id": "realtime-20191121-0000-workflow",
      "type": "helm"
    }
```

The deployments associated with the processing block have been created
in the `sdp` namespace, so to view the created pods we have to ask as
follows:

```bash
    $ kubectl get pod -n sdp
    NAME                                                    READY   STATUS    RESTARTS   AGE
    realtime-20191121-0000-dask-scheduler-6c7cc64c7-jfczn   1/1     Running   0          113s
    realtime-20191121-0000-dask-worker-7cb8cdf6bd-mtc9w     1/1     Running   3          113s
    realtime-20191121-0000-dask-worker-7cb8cdf6bd-tdzkp     1/1     Running   3          113s
    realtime-20191121-0000-workflow-7bf947687f-9h9gz        1/1     Running   0          118s
```

### Cleaning up

Finally, let us remove the processing block from the configuration:

```bash
    $ sdpcfg delete /pb/realtime-[...]
```

If you re-run the commands from the last section you will notice that
this correctly causes all changes to the cluster configuration to be
undone as well.

Accessing Tango
---------------

By default the chart installs the iTango shell pod from the tango-base
chart. You can access it as follows:

```bash
    $ kubectl exec -it itango-tango-base-sdp-prototype /venv/bin/itango3
```

You should be able to query the SDP Tango devices:

```bash
    In [1]: lsdev
    Device                                   Alias                     Server                    Class
    ---------------------------------------- ------------------------- ------------------------- --------------------
    mid_sdp/elt/master                                                 SDPMaster/1               SDPMaster
    sys/tg_test/1                                                      TangoTest/test            TangoTest
    sys/database/2                                                     DataBaseds/2              DataBase
    sys/access_control/1                                               TangoAccessControl/1      TangoAccessControl
    mid_sdp/elt/subarray_1                                             SDPSubarray/1             SDPSubarray
```

This allows direction interaction with the devices, such as querying and
and changing attributes and issuing commands:

```bash
    In [2]: d = DeviceProxy('mid_sdp/elt/subarray_1')

    In [3]: d.obsState
    Out[3]: <obsState.IDLE: 0>

    In [4]: d.state()
    Out[4]: tango._tango.DevState.OFF

    In [5]: d.adminMode = 'ONLINE'
    In [6]: d.AssignResources('')
    In [7]: d.state()
    Out[7]: tango._tango.DevState.ON

    In [8]: d.obsState
    Out[8]: <obsState.IDLE: 0>

    In [9]: d.Configure('{ "configure": { "id": "xyz", "sbiId": "xyz", "workflow": { "type": "realtime", "version": "0.1.0", "id": "vis_receive" }, "parameters": {}, "scanParameters": { "1": {} } } }')
    In [10]: d.obsState
    Out[10]: <obsState.READY: 2>

    In [11]: d.StartScan()
    In [12]: d.obsState
    Out[12]: <obsState.SCANNING: 3>

    In [13]: d.EndScan()
    In [14]: d.obsState
    Out[14]: <obsState.READY: 2>
```

Troubleshooting
---------------

## etcd doesn't start (DNS problems)

Something that often happens on home set-ups is that `sdp-prototype-etcd`
doesn't start, which means that quite a bit of the
SDP system will not work. Try executing `kubectl logs` on the pod to
get a log. You might see something like this as the last three lines:

```bash
    ... I | pkg/netutil: resolving sdp-prototype-etcd-9s4hbbmmvw.k8s-sdp-prototype-etcd.default.svc:2380 to <IP_ADDRESS>:2380
    ... I | pkg/netutil: resolving sdp-prototype-etcd-9s4hbbmmvw.k8s-sdp-prototype-etcd.default.svc:2380 to <IP_ADDRESS>:2380
    ... C | etcdmain: failed to resolve http://sdp-prototype-etcd-9s4hbbmmvw.sdp-prototype-etcd.default.svc:2380 to match --initial-cluster=sdp-prototype-etcd-9s4hbbmmvw=http://sdp-prototype-etcd-9s4hbbmmvw.sdp-prototype-etcd.default.svc:2380 ("http://<IP_ADDRESS>:2380"(resolved from "http://sdp-prototype-etcd-9s4hbbmmvw.sdp-prototype-etcd.default.svc:2380") != "http://<IP_ADDRESS>:2380"(resolved from "http://sdp-prototype-etcd-9s4hbbmmvw.sdp-prototype-etcd.default.svc:2380"))
```

This informs you that `etcd` tried to resolve its own address, and for
some reason got two different answers both times. Interestingly, the
`<IP_ADDRESS>` address is not actually in-cluster, but from the Internet,
and re-appears if we attempt to `ping` a nonexistent DNS name:

```bash
    $ ping does.not.exist
	Pinging does.not.exist [<IP_ADDRESS>] with 32 bytes of data:
    Reply from <IP_ADDRESS>: bytes=32 time=25ms TTL=242
```

What is going on here is that that your ISP has installed a DNS server
that redirects unknown DNS names to a server showing a 'helpful' error
message complete with a bunch of advertisements. For some reason this
seems to cause a problem with Kubernetes' internal DNS resolution.

How can this be prevented? Theoretically it should be enough to force
the DNS server to one that doesn't have this problem (like Google's
`<IP_ADDRESS>` and `<IP_ADDRESS>` DNS servers), but that is tricky to get working.
Alternatively you can simply restart the entire thing until it works.
Unfortunately this is not quite as straightforward with `etcd-operator`,
as it sets the `restartPolicy` to `Never`, which means that any `etcd`
pod only gets once chance, and then will remain `Failed` forever. The
quickest way I have found is to delete the `EtcdCluster` object, then
`upgrade` the chart in order to re-install it:

```bash
    $ kubectl delete etcdcluster sdp-prototype-etcd
    $ helm upgrade sdp-prototype sdp-prototype
```

This can generally be repeated until by pure chance the two DNS resolutions
return the same result and `etcd` starts up.

repository: ska-telescope/sdp-prototype

repo_name: ska-telescope/sdp-prototype


text:
# nxIpc
This is a simple header-only library for hosting IPC services on switch.

The main purpose is building simple homebrew services without having to include libstratosphere, that's why this library is very barebones and only supports a limited set of the HOS ipc system, capabilities may or may not be extended in the future.

# Credits
The ipc server over at [sys-clk](https://github.com/retronx-team/sys-clk/) was a great documentation on implementing an IPC service

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
---
sidebar: auto
---

# Code of Conduct

## Prologue

The Vue.js community is incredibly warm and welcoming. However, we live in a world where as the community grows larger, there is always the risk that something will threaten that safe and nurturing environment we all value. So even though it'd be great if we lived in a world where this wasn't an issue, Code of Conducts are required to ensure that everyone can attend events without reservations.

## Introduction

VueMeetups is dedicated to providing a harassment-free community for everyone, regardless of sex, gender identity or expression, sexual orientation, disability, physical appearance, age, race, nationality, or religious beliefs. We do not tolerate harassment of community members in any form. Participants violating these rules may be sanctioned or expelled from the community at the discretion of the VueMeetups organizers.

All attendees, speakers, sponsors, instructors, and volunteers at our events are required to agree with the following code of conduct. Leadership will enforce this code at all times. We expect cooperation from all participants to help ensure a safe environment for everybody.

If you have questions or feedback about this Code of Conduct please contact the organizers.

### Meetups

Our meetups are dedicated to providing a harassment-free conference experience for everyone, regardless of gender, gender identity and expression, age, sexual orientation, disability, physical appearance, race, ethnicity, religion (or lack thereof), or technology choices.

 Sexual language and imagery is not appropriate for any VueMeetups event or communication channel. Community members asked to stop any harassing behavior are expected to comply immediately.

If a community member engages in harassing behavior, the VueMeetups organizers may take any action they deem appropriate, including warning the offender, expulsion from the VueMeetups community, and/or removal from an event. If you are being harassed, notice that someone else is being harassed, or have any other concerns, please contact an VueMeetups organizer immediately, or as soon as you feel comfortable doing so.

### Workshops

Our workshops are also dedicated to providing a harassment-free conference experience for everyone, regardless of gender, gender identity and expression, age, sexual orientation, disability, physical appearance, race, ethnicity, religion (or lack thereof), or technology choices.

However, the reason for this section is that there are some specific things we'd like to address there are a few special addendums that we felt was necessary to address as well.

#### Instructors

All workshop instructors are expected to provide a safe environment for all participants of the workshop.

#### Participants

1.  **Only provide feedback when a fellow participant requests it**. Not everyone wants to hear feedback from people other than the instructor. Please respect this.

2.  **When providing feedback, be constructive.** Trollish, kurt, or huffy interactions will be broken up. We are all friends here.

3.  **Don't share other participant' work unless they explicitly say that it is ok.** You can and should ask!

4.  **Refrain from posting antagonizing words and work.** This includes hostile posts and art on topics of ethnicity, gender orientation, religion; unwanted sexual advances; being a troll; leaving hurtful and nasty feedback for other participants.

    * If you're upsetting someone, you will get a warning to Knock It Off and correct your behavior and/or remove your work (or we will do it for you). There are no second warnings. If someone complains a second time, you will be asked to leave, no complaints, no tears.

    * For particularly hopeless and offensive people, we reserve the right to take action without issuing a warning to preserve the peace. Once again, no complaints or tears.

5.   We can and will intervene. Don't try to be a hero and bottle it up inside. Friction between two participants can disrupt the entire class's dynamic. The sooner it's addressed, the healthier and happier all participants will be. Contact us at [@vuejs_events](https://twitter.com/vuejs_events), and we will privately hear you out.

## Template

The hardest part of getting a Code of Conduct up and running is writing one. So we've made that much easier for you.

::: tip Help Wanted
For those who can help translate, we would love your help creating other templates for other groups to use!
:::

### English

Setting this up is simple.

1.  Copy and paste the following into a markdown file
2.  Replace all references to {{ GROUP_NAME }} with your group name
3.  Update {{ GROUP_NAME_CONTACT_INFO }} with a method of contact

```
# Code of Conduct

{{ GROUP_NAME }} is dedicated to providing a harassment-free community for everyone, regardless of sex, gender identity or expression, sexual orientation, disability, physical appearance, age, race, nationality, or religious beliefs. We do not tolerate harassment of community members in any form. Participants violating these rules may be sanctioned or expelled from the community at the discretion of the {{ GROUP_NAME }} organizers.

All attendees, speakers, sponsors, instructors, and volunteers at our events are required to agree with the following code of conduct. Leadership will enforce this code at all times. We expect cooperation from all participants to help ensure a safe environment for everybody.

If you have questions or feedback about this Code of Conduct please contact the organizers.

## Meetups

Our meetups are dedicated to providing a harassment-free conference experience for everyone, regardless of gender, gender identity and expression, age, sexual orientation, disability, physical appearance, race, ethnicity, religion (or lack thereof), or technology choices.

 Sexual language and imagery is not appropriate for any {{ GROUP_NAME }} event or communication channel. Community members asked to stop any harassing behavior are expected to comply immediately.

If a community member engages in harassing behavior, the {{ GROUP_NAME }} organizers may take any action they deem appropriate, including warning the offender, expulsion from the {{ GROUP_NAME }} community, and/or removal from an event. If you are being harassed, notice that someone else is being harassed, or have any other concerns, please contact an {{ GROUP_NAME }} organizer immediately, or as soon as you feel comfortable doing so.

## Workshops

Our workshops are also dedicated to providing a harassment-free conference experience for everyone, regardless of gender, gender identity and expression, age, sexual orientation, disability, physical appearance, race, ethnicity, religion (or lack thereof), or technology choices.

However, the reason for this section is that there are some specific things we'd like to address there are a few special addendums that we felt was necessary to address as well.

### Instructors

All workshop instructors are expected to provide a safe environment for all participants of the workshop.

### Participants

1.  **Only provide feedback when a fellow participant requests it**. Not everyone wants to hear feedback from people other than the instructor. Please respect this.

2.  **When providing feedback, be constructive.** Trollish, kurt, or huffy interactions will be broken up. We are all friends here.

3.  **Don't share other participant' work unless they explicitly say that it is ok.** You can and should ask!

4.  **Refrain from posting antagonizing words and work.** This includes hostile posts and art on topics of ethnicity, gender orientation, religion; unwanted sexual advances; being a troll; leaving hurtful and nasty feedback for other participants.

    * If you're upsetting someone, you will get a warning to Knock It Off and correct your behavior and/or remove your work (or we will do it for you). There are no second warnings. If someone complains a second time, you will be asked to leave, no complaints, no tears.

    * For particularly hopeless and offensive people, we reserve the right to take action without issuing a warning to preserve the peace. Once again, no complaints or tears.

5.   We can and will intervene. Don't try to be a hero and bottle it up inside. Friction between two participants can disrupt the entire class's dynamic. The sooner it's addressed, the healthier and happier all participants will be. Contact us at {{ GROUP_NAME_CONTACT_INFO }}, and we will privately hear you out.
```

## Acknowledgements

A special thanks goes out to [Rachel Nabors](https://twitter.com/rachelnabors) for being the inspiration for this initiative!

And many thanks to both [Rachel Nabors](https://twitter.com/rachelnabors) and [Mike Roberts](https://twitter.com/mikebroberts) for providing examples that have served as the basis for the Code of Conduct on this page.

repository: vuejs/events

branch_name: refs/heads/main

gha_language: Vue

repo_name: vuejs/events


text:
# MyfitnesspalStats

Myfitnesspal_Stats is a ruby module that allows you to programmatically access your daily nutritional information from [Myfitnesspal.com](http://www.myfitnesspal.com/). It gives you the ability to access your nutritional totals for a specified date, as well as the break down of each meal & food logged for that day.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'myfitnesspal_stats'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install myfitnesspal_stats

## Usage

**Getting Started:** Once installation of this gem is complete, initialize a new web scraper:
```ruby
include 'myfitnesspal_stats'

# Insert your username and password for Myfitnesspal
# WARNING: DO NOT HARDCODE THIS INTO YOUR SCRIPT IF IT IS A PUBLIC SCRIPT. FUTURE REVISIONS WILL MAKE SURE TO SOLVE THIS PROBLEM.
scraper = Scraper.new('username', 'password')
```

**Accessing nutritional information:** To access nutritional information for a specified date, create a new `Day` instance and then call the `.nutrition_totals` on that day:
```ruby
# The year, month, and day should all be numbers. Although a string will still work
scraper.get_date(year, month, day)

# Numbers do not have to be padded with zeros, it can be 01 or just 1.
day = scraper.get_date(2015, 01, 15)
# ==> #<Day:<object id>

# Note: The nutrients that are returned depend on which nutrients you specified to track in your Myfitnesspal settings.
# The returned hash is formatted like so:
# :<nutrient> => [how much you ate, your goal, the difference between the two].
pp day.nutrition_totals
# ==>
{:Date=>"Thursday, 15 January 2015",
 :Calories=>["2,399", "2,390", "-9"],
 :Fat=>["49", "50", "1"],
 :Carbs=>["296", "290", "-6"],
 :Fiber=>["45", "35", "-10"],
 :Protein=>["197", "195", "-2"],
 :"Potass."=>["2,476", "4,000", "1,524"]}
```

**How to retrive data from the hash:** This is simple ruby practice, but in order to save any frustration I will outline the process here:
```ruby
day = scraper.get_date(2015, 01, 15)
nutrition_data = day.nutrition_totals

pp nutrition_data[:Date]
pp nutrition_data[:Calories]
pp nutrition_data[:Calories][0]
pp nutrition_data[:Fiber][1]
pp nutrition_data[:Carbs][1, 2]

#### OUTPUT:

# ==> "Thursday, 15 January 2015"
# ==> ["2,399", "2,390", "-9"]
# ==> "2,399"
# ==> "35"
# ==> ["290", "-6"]

```

## Contributing

1. Fork it ( https://github.com/hgducharme/myfitnesspal_stats/fork )
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create a new Pull Request

[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/hgducharme/myfitnesspal_stats/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

gha_language: Ruby


text:
# Pyracer
A simple racing game using `Pygame` and `Python`.

## Index

- [Screenshots](https://github.com/diego-asterisk/pyracer#screenshots)
- [Game Features](https://github.com/diego-asterisk/pyracer#game-features)
  - [To Play](https://github.com/diego-asterisk/pyracer#to-play)
  - [Controls](https://github.com/diego-asterisk/pyracer#controls)
- [Contributing](https://github.com/diego-asterisk/pyracer#contributing)
- [Issues](https://github.com/diego-asterisk/pyracer#issues)
- [License](https://github.com/diego-asterisk/pyracer#license)

## Screenshots

[[Back to top]](https://github.com/diego-asterisk/pyracer#index)

| ![Screen 1](http://misosguar.com.ar/games/runner01.png) | ![Screen 2](http://misosguar.com.ar/games/runner02.png) |
|---------------------------------------------|---------------------------------------------|
| ![Screen 3](http://misosguar.com.ar/games/runner03.png) | ![Screen 4](http://misosguar.com.ar/games/runner04.png) |

## Game Features

[[Back to top]](https://github.com/diego-asterisk/pyracer#index)

- Score board to show how you are doing later
- Eight random enemies
- 1 live per game
- Fun to play :)

## To Play

Just run `python3 racer.py`

## Controls

[[Back to top]](https://github.com/diego-asterisk/pyracer#index)

|              | Button              |
|--------------|---------------------|
| Move Left    | left     |
| Move right   | right    |
| Quit game    | Esc      |

## Contributing

[[Back to top]](https://github.com/diego-asterisk/pyracer#index)

This game was written in one day, so the coding standards might not be up the mark. Don't be shy to make a Pull request :)

For details, please refer [the Contributing page](https://github.com/diego-asterisk/pyracer/blob/master/CONTRIBUTING.rst)

## Issues

[[Back to top]](https://github.com/diego-asterisk/pyracer#index)

You can report the bugs at the [issue tracker](https://github.com/diego-asterisk/pyracer/issues)

## License

[[Back to top]](https://github.com/diego-asterisk/pyracer#index)

Built with ♥ by [Diego Mañas](https://github.com/diego-asterisk) under [MIT License](https://xn--diegomaas-r6a.mit-license.org/)

You can find a copy of the License at http://diegomañas.mit-license.org/

repository: diego-asterisk/pyracer

repo_name: diego-asterisk/pyracer


text:
# Metadata

## Design of metadata support

DataFrames.jl allows you to store and retrieve metadata on table and column
level. This is supported using the functions defined by the DataAPI.jl interface:

* for table-level metadata: [`metadata`](@ref), [`metadatakeys`](@ref),
  [`metadata!`](@ref), [`deletemetadata!`](@ref), [`emptymetadata!`](@ref);
* for column-level metadata: [`colmetadata`](@ref), [`colmetadatakeys`](@ref),
  [`colmetadata!`](@ref), [`deletecolmetadata!`](@ref), [`emptycolmetadata!`](@ref).

Additionally you might find the
[TableMetadataTools.jl](https://github.com/JuliaData/TableMetadataTools.jl)
package useful. This package defines several convenience functions for
performing typical metadata operations.

Assume that we work with a data frame-like object `df` that has a column `col`
(referred to either via a `Symbol`, a string or an integer index).

Table-level metadata are key-value pairs that are attached to `df`.
Column-level metadata are key-value pairs that are attached to
a specific column `col` of `df` data frame.

To check whether some key `key` is present in table-level metadata of data frame `df`
you can write `key in metadatakeys(df)`. Similarly to check whether key `key` is present
in column-level metadata of data frame `df` for column `col` write
`key in colmetadatakeys(df, col)`.

Additionally each metadata key-value pair has a style information attached to
it.
In DataFrames.jl the metadata style influences how metadata is propagated when
`df` is transformed. The following metadata styles are supported:

* `:default`: Metadata having this style is considered to be attached to a concrete
  state of `df`. This means that any operation on this data frame
  invalidates such metadata and it is dropped in the result of such operation.
  Note that this happens even if the operation eventually does not change
  the data frame: the rule is that calling a function that might alter a data
  frame drops such metadata; in this way it is possible to statically determine
  whether metadata of styles other than `:note` is dropped after a function call.
  Only two functions are exceptions that keep non-`:note`-style metadata, as these
  operations are specifically designed to create an identical copy of the source
  data frame:
    - [`DataFrame`](@ref) constructor;
    - [`copy`](@ref) of a data frame;
* `:note`: Metadata having this style is considered to be an annotation of
  a table or a column that should be propagated under transformations
  (exact propagation rules of such metadata are described below).
* All other metadata styles are allowed but they are currently treated as having
  `:default`-style (this might change in the future if other standard metadata
  styles are defined).

All DataAPI.jl metadata functions work with [`DataFrame`](@ref),
[`SubDataFrame`](@ref), [`DataFrameRow`](@ref)
objects, and objects returned by [`eachrow`](@ref) and [`eachcol`](@ref)
functions. In this section collectively these objects will be called
*data frame-like*, and follow the rules:

* objects returned by
  [`eachrow`](@ref) and [`eachcol`](@ref) functions have the same metadata
  as their parent `AbstractDataFrame`;
* [`SubDataFrame`](@ref) and [`DataFrameRow`](@ref) only expose metadata from
  their parent `DataFrame` whose style is `:note`.

Notably, metadata is not supported for [`GroupedDataFrame`](@ref) and you can't
add, modify, nor view metadata through the [`GroupedDataFrame`](@ref) itself.
It is possible only through its `parent`.

!!! note

    DataFrames.jl allows users to extract out columns of a data frame
    and perform operations on them. Such operations will not affect
    metadata. Therefore, even if some metadata has `:default` style it might
    no longer correctly describe the column's contents if the user mutates
    columns directly.

### DataFrames.jl-specific design principles for use of metadata

DataFrames.jl supports storing any object as metadata values. However,
it is recommended to use strings as values of the metadata,
as some storage formats, like for example Apache Arrow, only support
strings.

For all functions that operate on column-level metadata, an `ArgumentError` is
thrown if passed column is not present in a data frame.

If [`metadata!`](@ref) or [`colmetadata!`](@ref) is used to add metadata
to a [`SubDataFrame`](@ref) or a [`DataFrameRow`](@ref) then:

* using metadata that has style other than `:note` throws an error;
* trying to add key-value pair for which a mapping for key already exists
  with style other than `:note` in the parent data frame throws an error.

DataFrames.jl is designed so that there is no performance overhead due to metadata support
when there is no metadata in a data frame. Therefore if you need maximum performance
of operations that do not rely on metadata call `emptymetadata!` and
`emptycolmetadata!` before running these operations.

Processing metadata for `SubDataFrame` and `DataFrameRow` has more overhead
than for other types defined in DataFrames.jl that support metadata, because
they have a more complex logic of handling it (they support only `:note`-style
metadata, which means that other metadata needs to be filtered-out).

## Examples

Here is a simple example how you can work with metadata in DataFrames.jl:

```jldoctest dataframe
julia> using DataFrames

julia> df = DataFrame(name=["Jan Krzysztof Duda", "Jan Krzysztof Duda",
                            "Radosław Wojtaszek", "Radosław Wojtaszek"],
                      date=["2022-Jun", "2021-Jun", "2022-Jun", "2021-Jun"],
                      rating=[2750, 2729, 2708, 2687])
4×3 DataFrame
 Row │ name                date      rating
     │ String              String    Int64
─────┼──────────────────────────────────────
   1 │ Jan Krzysztof Duda  2022-Jun    2750
   2 │ Jan Krzysztof Duda  2021-Jun    2729
   3 │ Radosław Wojtaszek  2022-Jun    2708
   4 │ Radosław Wojtaszek  2021-Jun    2687

julia> metadatakeys(df)
()

julia> metadata!(df, "caption", "ELO ratings of chess players", style=:note);

julia> collect(metadatakeys(df))
1-element Vector{String}:
 "caption"

julia> "caption" in metadatakeys(df)
true

julia> metadata(df, "caption")
"ELO ratings of chess players"

julia> metadata(df, "caption", style=true)
("ELO ratings of chess players", :note)

julia> emptymetadata!(df);

julia> metadatakeys(df)
()

julia> colmetadatakeys(df)
()

julia> colmetadata!(df, :name, "label", "First and last name of a player", style=:note);

julia> colmetadata!(df, :date, "label", "Rating date in yyyy-u format", style=:note);

julia> colmetadata!(df, :rating, "label", "ELO rating in classical time control", style=:note);

julia> "label" in colmetadatakeys(df, :rating)
true

julia> colmetadata(df, :rating, "label")
"ELO rating in classical time control"

julia> colmetadata(df, :rating, "label", style=true)
("ELO rating in classical time control", :note)

julia> collect(colmetadatakeys(df))
3-element Vector{Pair{Symbol, Base.KeySet{String, Dict{String, Tuple{Any, Any}}}}}:
   :date => ["label"]
 :rating => ["label"]
   :name => ["label"]

julia> [only(names(df, col)) =>
        [key => colmetadata(df, col, key) for key in metakeys] for
        (col, metakeys) in colmetadatakeys(df)]
3-element Vector{Pair{String, Vector{Pair{String, String}}}}:
   "date" => ["label" => "Rating date in yyyy-u format"]
 "rating" => ["label" => "ELO rating in classical time control"]
   "name" => ["label" => "First and last name of a player"]

julia> emptycolmetadata!(df);

julia> colmetadatakeys(df)
()
```

## Propagation of `:note`-style metadata

An important design feature of `:note`-style metadata is how it is handled when
data frames are transformed.

!!! note

    The provided rules might slightly change in the future. Any change to
    `:note`-style metadata propagation rules will not be considered as breaking
    and can be done in any minor release of DataFrames.jl.
    Such changes might be made based on users' feedback about what metadata
    propagation rules are most convenient in practice.

The general design rules for propagation of `:note`-style metadata are as follows.

For operations that take a single data frame as an input:
* Table level metadata is propagated to the returned data frame object.
* For column-level metadata:
  - in all cases when a single column is transformed to
    a single column and the name of the column does
    not change (or is automatically changed e.g. to de-duplicate column names or
    via column renaming in joins)
    column-level metadata is preserved (example operations of this kind are
    `getindex`, `subset`, joins, `mapcols`).
  - in all cases when a single column is transformed with `identity` or `copy` to a single column,
    column-level metadata is preserved even if column name is changed (example
    operations of this kind are `rename`, or the `:x => :y` or
    `:x => copy => :y` operation specification in `select`).

For operations that take multiple data frames as their input two cases are distinguished:

- When there is a natural main table in the operation (`append!`, `prepend!`,
  `leftjoin`, `leftjoin!`, `rightjoin`, `semijoin`, `antijoin`, `setindex!`):
  - table-level metadata is taken from the main table;
  - column-level metadata for columns from the main table is taken from main table;
  - column-level metadata for columns from the non-main table is taken only for
    columns not present in the main table.
- When all tables are equivalent (`hcat`, `vcat`, `innerjoin`, `outerjoin`):
  - table-level metadata is preserved only for keys which are defined
    in all passed tables and have the same value;
  - column-level metadata is preserved only for keys which are defined
    in all passed tables that contain this column and have the same value.
In all these operations when metadata is preserved the values in the key-value
pairs are not copied (this is relevant in case of mutable values).

!!! note

    The rules for column-level `:note`-style metadata propagation are designed
    to make the right decision in common cases. In particular, they assume that if
    source and target column name is the same then the metadata for the column is
    not changed. While this is valid for many operations, it is not always true
    in general. For example the `:x => ByRow(log) => :x` transformation might
    invalidate metadata if it contained unit of measure of the variable. In such
    cases user must either use a different name for the output column,
    set metadata style to `:default` before the operation,
    or manually drop or update such metadata from the `:x` column
    after the transformation.

### Operations that preserve `:note`-style metadata

Most of the functions in DataFrames.jl only preserve table and column metadata
whose style is `:note`.
Some functions use a more complex logic, even if they follow the general rules
described above (in particular under any transformation all non-`:note`-style
metadata is always dropped). These are:

* [`describe`](@ref) drops all metadata.
* [`hcat`](@ref): propagates table-level metadata only for keys which are defined
  in all passed tables and have the same value;
  column-level metadata is preserved.
* [`vcat`](@ref): propagates table-level metadata only for keys which are defined
  in all passed tables and have the same value;
  column-level metadata is preserved only for keys which are defined
  in all passed tables that contain this column and have the same value;
* [`stack`](@ref): propagates table-level metadata and column-level metadata
  for identifier columns.
* [`unstack`](@ref): propagates table-level metadata and column-level metadata
  for row keys columns.
* [`permutedims`](@ref): propagates table-level metadata and drops column-level
   metadata.
* broadcasted assignment does not change target metadata;
  under Julia earlier than 1.7 operation of kind `df.a .= s` does not drop non-`:note`-style
  metadata; under Julia 1.7 or later this operation preserves only `:note`-style
  metadata
* broadcasting propagates table-level metadata if some key is present
  in all passed data frames and value associated with it is identical in all
  passed data frames; column-level metadata is propagated for columns if some
  key for a given column is present in all passed data frames and value
  associated with it is identical in all passed data frames.
* `getindex` preserves table-level metadata and column-level metadata
  for selected columns
* `setindex!` does not affect table-level and column-level metadata
* [`push!`](@ref), [`pushfirst!`](@ref), [`insert!`](@ref) do not affect
  table-level nor column-level metadata (even if they add new columns and pushed row is
  a `DataFrameRow` or other value supporting metadata interface)
* [`append!`](@ref) and [`prepend!`](@ref) do not change table and column-level
  metadata of the destination data frame, except that if new columns are added
  and these columns have metadata in the appended/prepended table then this
  metadata is preserved.
* [`leftjoin!`](@ref), [`leftjoin`](@ref): table and column-level metadata is
  taken from the left table except for non-key columns from right table for which
  metadata is taken from right table;
* [`rightjoin`](@ref): table and column-level metadata is taken from the right
  table except for non-key columns from left table for which metadata is
  taken from left table;
* [`innerjoin`](@ref), [`outerjoin`](@ref): propagates table-level metadata only for keys
  that are defined in all passed data frames and have the same value;
  column-level metadata is propagated for all columns except for key
  columns, for which it is propagated only for keys that are defined
  in all passed data frames and have the same value.
* [`semijoin`](@ref), [`antijoin`](@ref): table and column-level metadata is
  taken from the left table.
* [`crossjoin`](@ref): propagates table-level metadata only for keys
  that are defined in both passed data frames and have the same value;
  propagates column-level metadata from both passed data frames.
* [`select`](@ref), [`select!`](@ref), [`transform`](@ref),
  [`transform!`](@ref), [`combine`](@ref): propagate table-level metadata;
  column-level metadata is propagated if:
  a) a single column is transformed to a single column and the name of the column does not change
     (this includes all column selection operations), or
  b) a single column is transformed with `identity` or `copy` to a single column
     even if column name is changed (this includes column renaming).

gha_language: Julia

gha_license_id: NOASSERTION


text:
## Speech Recognition project: data collection for the Malagasy language

This is a repository for the data collection project for the Malagasy language which is a language spoken by the people from Madagascar. The data contains 1 file of the encoded text of all sessions and 101 folders made up of about 20 wav files with their  corresponding JSON metadata and text file for each folder. The total of the audio recordings is approximately 3h which is recorded from [this source.](http://biblio.univ-antananarivo.mg/pdfs/lantonirinaThonnyF_ENS_CPN_15.pdf)  by using an android app called [lig-aikuma](https://lig-aikuma.imag.fr) .

NOTE: notice that the audio recordings sometimes have background noise due to the noisy environment and  they may  also contain some corrupted wav files which is an error from the app.

## Problems encountered
* Problem related to the installation of the app : we should install the right version of the app to be adapted with the Android version of the phone.
* Problem related to the recordings : we should pay attention when doing the recording to not repeat to record each sentence more than one to not have an app error.
## Comment
For the preparation of the text to record, it takes time to give the right format putting "##" after each sentence. It should be better if the app recognized each line to be a sentence of the recording.

## Contribution

This project is contributed by:

* R. Hasina Angelina<EMAIL_ADDRESS>
* A. Rabetokotany<EMAIL_ADDRESS>

## License

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

repository: besacier/AMMIcourse

gha_language: Jupyter Notebook

repo_name: besacier/AMMIcourse


text:
| English | [简体中文](README.md) |

# [112. Path Sum](https://leetcode-cn.com/problems/path-sum/)

## Description

Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.

Note: A leaf is a node with no children.

Example:

Given the below binary tree and sum = 22,

      5
     / \
    4   8
   /   / \
  11  13  4
 /  \      \
7    2      1

return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.

## Related Topics

- [Tree](https://leetcode-cn.com/tag/tree)
- [Depth-first Search](https://leetcode-cn.com/tag/depth-first-search)

## Similar Questions

- [Path Sum II](../path-sum-ii/README_EN.md)
- [Binary Tree Maximum Path Sum](../binary-tree-maximum-path-sum/README_EN.md)
- [Sum Root to Leaf Numbers](../sum-root-to-leaf-numbers/README_EN.md)
- [Path Sum III](../path-sum-iii/README_EN.md)
- [Path Sum IV](../path-sum-iv/README_EN.md)

repository: KivenCkl/LeetCode

repo_name: KivenCkl/LeetCode


text:
---
scapolite:
    class: rule
    version: '0.51'
id: service_pcscd_enabled
id_namespace: org.ssgproject.RHEL-8
title: Enable the pcscd Service
rule: <see below>
rationale: <see below>
description: <see below>
applicability:
  - system: org.scapolite.xccdf.applicability
    severity: medium
  - system: https://scap.nist.gov/schema/cpe/2.2
    cpes:
      - cpe:/a:machine
implementations:
  - relative_id: '01'
    title: Automated fix
    automations:
      - system: urn:xccdf:fix:script:sh
        href: service_pcscd_enabled.sh
        complexity: low
        disruption: low
  - relative_id: '02'
    title: Automated fix
    automations:
      - system: urn:xccdf:fix:script:ansible
        href: service_pcscd_enabled.ansible
        complexity: low
        disruption: low
checks:
  - relative_id: '01'
    automations:
      - system: http://oval.mitre.org/XMLSchema/oval-definitions-5
        idref: oval:ssg-service_pcscd_enabled:def:1
        href: service_pcscd_enabled.oval.xml
  - relative_id: '02'
    automations:
      - system: http://scap.nist.gov/schema/ocil/2
        idref: ocil:ssg-service_pcscd_enabled_ocil:questionnaire:1
        href: service_pcscd_enabled.ocil.xml
crossrefs:
  - system: https://nvd.nist.gov/cce/index.cfm
    idref: CCE-80881-6
    relation: ''
  - system: http://iase.disa.mil/stigs/cci/Pages/index.aspx
    idref: CCI-001954
    relation: ''
  - system: http://iase.disa.mil/stigs/os/general/Pages/index.aspx
    idref: SRG-OS-000375-GPOS-00160
    relation: ''
  - system: org.scapolite.unknown
    idref: SRG-OS-000377-VMM-001530
    relation: ''
  - system: https://nvd.nist.gov/cce/index.cfm
    idref: CCE-80881-6
    relation: ''
---

## /rule

Enable the pcscd Service

## /rationale

Using
an authentication device, such as a CAC or token that is separate from
the information system, ensures that even if the information system is
compromised, that compromise will not affect credentials stored on the
authentication device.

Multifactor solutions that require devices separate from information
systems gaining access include, for example, hardware tokens providing
time-based or challenge-response authenticators and smart cards such as
the U.S. Government Personal Identity Verification card and the DoD
Common Access Card.

## /description

The `pcscd` service can be enabled with the following command:

```
$ sudo systemctl enable pcscd.service
```


text:
# Rocket.Chat.Dropbox.Paper
📦 Dropbox Paper App for Rocket.Chat - create and share live documents in your Rocket.Chat channel

![](docs/screenshot_01.png)

## Usage
### Commands
This App supports two commands right now:

#### Create
`/dropbox-paper-create [Title of Paper] (optional)`

This will create a new paper and share the secret link with the room.

![](docs/screenshot_02.png)

#### Search
`/dropbox-paper-search [Search term]`

This will list the papers that contain the search term

![](docs/screenshot_03.png)

## Planned features
See the [issues list](https://github.com/cardoso/Rocket.Chat.Dropbox.Paper/issues)

gha_language: TypeScript

gha_license_id: MIT


text:
# Change Log

## [v0.2.0](https://github.com/auth0/node-oauth2-jwt-bearer/tree/v0.2.0) (2021-10-14)
[Full Changelog](https://github.com/auth0/node-oauth2-jwt-bearer/compare/v0.1.0...v0.2.0)

**⚠ BREAKING CHANGES**
- [SDK-2827] Update some error status codes and descriptions [\#27](https://github.com/auth0/node-oauth2-jwt-bearer/pull/27) ([adamjmcgrath](https://github.com/adamjmcgrath))

## [0.1.0](https://github.com/auth0/node-oauth2-jwt-bearer/releases/tag/v0.1.0-express) (2021-07-14)

**Added**

- Add support for Access Tokens signed with a symmetric secret [#21](https://github.com/auth0/node-oauth2-jwt-bearer/pull/21) ([adamjmcgrath](https://github.com/adamjmcgrath))


text:
# stock-market-investment-tools

## data:
* dow.csv - data got from wikipedia (1/nov/2018)
* sp500.csv - data got from wikipedia (1/nov/2018)
* nasdaq100.csv - data got from wikipedia (1/nov/2018)
* symbols.csv - put here a list of the symbols of your portfolio

## data/hist:
* some historical data from yahoo finance

## notebooks:
* get_market_data_csv: Merges data from dow.csv, sp500.csv and nasdaq100.csv with data provided for free by [IEX](https://iextrading.com/developer). View [IEX’s Terms of Use](https://iextrading.com/api-exhibit-a/).
* first_simulation: Simulates the purchase of a share every day and shows its performance. It works for a list of tickers.

## scripts:
* get_data.py: run it to get stocks.csv, stocks.xls and portfolio_stats.xls with lot of data

repository: sturrion/stock-market-investment-tools

repo_name: sturrion/stock-market-investment-tools


text:
# bosh-lite-release-compiler

[![license](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)

A [Concourse](https://concourse.ci/) pipeline task for automatically compiling new releases against new stemcells.

The standalone pipeline example watches S3 for new release/stemcell versions, then starts a new bosh-lite instance (via [aws-bosh-lite-resource](https://github.com/dpb587/aws-bosh-lite-resource)), compiles the release on the stemcell, and then publishes the compiled release to S3.

    # add release settings, s3 credentials, and bosh-lite settings
    $ vim example/pipeline.config.yml

    # set the pipeline
    $ fly set-pipeline \
      --pipeline acme:widgetpro-release:ubuntu-compiler \
      --config example/standalone.yml \
      --load-vars-from example/standalone.config.yml

## `compile.yml`

Task which receives the release and stemcell, uploads them, generates a deployment manifest, and exports the release.

Inputs:

 * `release` - with a release tarball
 * `stemcell` - with a stemcell tarball
 * `bosh-lite` - with director-targeting information
 * `bosh-lite-release-compiler` - with `compile.sh` (this repository)

Parameters:

 * `compilation_workers` - number of concurrent compilations to perform (default: `4`)
 * `target_file` - a file with the IP of the BOSH director to use for compilations (default: `bosh-lite/target`)

Outputs:

 * `compiled-release` - with a compiled release tarball named like `release-{release_name}-{release_version}-on-{os_name}-{os_version}-stemcell-{stemcell_version}-compiled-{compilation_version}.tgz`

## License

[MIT License](./LICENSE)


text:
# plomino-slack-archive

Import Slack JSON export to a Plomino app

This is a very quick and dirty import of Slack's JSON archive export (request
an export from https://TEAM.slack.com/services/export where TEAM is the name of
your team).

To use this, create a Plomino db in a local Plone site, browse to the _Design_
interface, and specify the directory where you cloned this to import
_From server folder_. To import to a remote Plomino db, start from the local
one.

Currently, this app doesn't make it very convenient to import the JSON. You
need to unzip the export, and import users, channels, and then messages per
channel separately. Messages are archived as a JSON file per month. You can
select all the files for a channel at once.

Limitations include:

- Plomino formulas don't have access to regular expressions, so markdown-style
  formatting in messages is very basic.
- Plomino formulas can't deal with zip files, so you need to unzip the archive
  first.

repository: jean/plomino-slack-archive

repo_name: jean/plomino-slack-archive


text:
[![Angular Logo](https://www.vectorlogo.zone/logos/angular/angular-icon.svg)](https://angular.io/) [![Electron Logo](https://www.vectorlogo.zone/logos/electronjs/electronjs-icon.svg)](https://electronjs.org/)

# Introduction

This is an Electron / Angular sorting visualization application.

Electron Template credit: https://github.com/maximegris/angular-electron

[![Sorting Image](http://<IP_ADDRESS>/sort.png)](https://usncoder.com/sorting)

## Getting Started

Clone this repository locally :

``` bash
git clone https://github.com/finleysa/Sorting-Visualization.git
```

Install dependencies with npm :

``` bash
npm install
```

There is an issue with `yarn` and `node_modules` when the application is built by the packager. Please use `npm` as dependencies manager.

## To build for development

- **in a terminal window** -> npm start

## Included Commands

|Command|Description|
|--|--|
|`npm run ng:serve:web`| Execute the app in the browser |
|`npm run build`| Build the app. Your built files are in the /dist folder. |
|`npm run build:prod`| Build the app with Angular aot. Your built files are in the /dist folder. |
|`npm run electron:local`| Builds your application and start electron
|`npm run electron:build`| Builds your application and creates an app consumable based on your operating system |

**Your application is optimised. Only /dist folder and node dependencies are included in the executable.**

repository: finleysa/Sorting-Visualization

repo_name: finleysa/Sorting-Visualization


text:
# Development work-flow

When developing roles there is a certain work-flow in place that needs
to be respected, otherwise things can go astray.

There are some points that need to be considered before you can start:

1. All in-house developed roles have a branch `prd` that is the
   production branch, a acceptance branch `acc` and a development branch
   called `dev`.
1. The `setup` repository (containing the `roles.yml`) has a branch
   `master` indicating the production environment in the Ansible
   environment.
1. The `prd` and `acc` branches should/cannot be pushed to directly. Changes
   should flow to these branches from the `dev` branch through the pull-request
   / review / merge process.

## Role development

### Improving existing roles

1. Ensure you have the latest code role you wish to edit by checking out or
   pulling the latest `dev` branch from the `git server`.
1. Optionally create a new branch, *not* called `prd`, `acc` or `dev`.
1. Develop your code and test against local Vagrant boxes or test
   servers.
1. If satisfied: (merge,) commit and push your code to `dev` branch on the
   `git` server.
1. When this is the final stage of your code, and it can go into
   acceptance/production, create a *pull-request* against the `acc` branch, on
   the `git` server and select at least one reviewer.
1. Keep an eye on your pull-request and try to follow up with any questions or
   remarks the reviewer might have.
1. After your *pull-request* has been accepted and merged you can remove any
   feature branch(es) you have created.

**Note**: You can run into a permission issue when trying to push changes you
made to a pre-existing role to the `git` server. The `pull` script supplied by
the `setup` role makes use of the `ansiget` user who has `read` permissions
only. To push changes you should make use of the SSH transport and the `git`
user. You could alter the remote URLs of each role you edit, or you edit your
 `.gitconfig` and add the following:

```
# Enforce SSH
[url<EMAIL_ADDRESS>    insteadOf =<EMAIL_ADDRESS>```

This rewrites the remote HTTPS URI you get by default to a SSH transport and
uses the `git` user for all "remotes" that fit the string in the `insteadOf`
field.

### Developing new roles
New roles can be created to add functionality or improve granularity.
The process is rather similar to improving and existing role with the added
steps than you will need to add your role to `roles.yml` and perform more
extensive testing as described in the next heading.

1. Create new role by creating the appropriate directory structure. A script
   is present to perform these tasks for you: A new role skeleton (directory
   tree, short `README.md` and git branches) can be created with the
   `bin/newrole <name>` command.
1. Develop your role, and make sure you keep the
   [Coding Style](http://ansible.prd.example.net/docs/devel/codingstyle/) in
   mind.
1. Test your code often on a Vagrant box or local VM.
1. Ensure the `README.md` of your new role is complete and up-to-date.
1. When you are ready to start deployment and testing your creation in the
   real environment submit your code repository to the `git` server. Again
   keep the naming conventions in mind.
1. Test your code by following the *Testing your changes on the development
   hosts* paragraph below. TODO: or follow the deployment instructions

### Testing your changes on the development hosts
When your code is ready to be deployed you can do so on the development
environment.

TODO: fix instructions below or point to deployment and update that!

1. As you are not allowed to deploy test code in production, it's required
   to have a separate environment for your code tests.
1. Go to the `setup` module and create a new branch, not being
   `prd`, `acc`, `dev` or `master`. This branch could be called something like
   the ticket-number for this changes, the developer of this change, or
   any other short, descriptive name.
1. Change the `roles.yml` to reflect your changed role(s), so that
   *Ansible Galaxy* will pick up the changes.\
   This means that the `version:` tag points to your new branch.
1. Commit and push this branch and test against the newly created
   environment.
1. To deploy to the `dev` environment, have a look at
   [deployment](deployment.md)

## Useful commands

After installing the Ansible development environment, some extra
commands become available:

`pull`
: Clone or refresh all *on-site* developed roles

`push`
: Push all *on-site* developed roles to the git server

`newrole <new_role>`
: Create a new role skeleton.

repository: one-role/docs

gha_language: Shell

repo_name: one-role/docs


text:
### [CVE-2021-31181](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-31181)
![](https://img.shields.io/static/v1?label=Product&message=Microsoft%20SharePoint%20Enterprise%20Server%202016&color=blue)
![](https://img.shields.io/static/v1?label=Product&message=Microsoft%20SharePoint%20Foundation%202013%20Service%20Pack%201&color=blue)
![](https://img.shields.io/static/v1?label=Product&message=Microsoft%20SharePoint%20Server%202019&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=15.0.0%3C%2015.0.5345.1000%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Version&message=16.0.0%3C%2016.0.10374.20000%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Version&message=16.0.0%3C%2016.0.5161.1000%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Vulnerability&message=Remote%20Code%20Execution&color=brighgreen)

### Description

Microsoft SharePoint Remote Code Execution Vulnerability

### POC

#### Reference
- http://packetstormsecurity.com/files/163208/Microsoft-SharePoint-Unsafe-Control-And-ViewState-Remote-Code-Execution.html

#### Github
- https://github.com/ARPSyndicate/cvemon
- https://github.com/H0j3n/EzpzSharepoint
- https://github.com/pwntester/ysoserial.net

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
---
layout: post
title: How To Move Critical Windows Folders to Other Local Disks
excerpt: "If you've ever needed or tried to move the C:\Users directory or other default Windows directories to another place other than the default one, you know it can be quite difficult."
modified: 2013-05-31
tags: [folders, geeky, tutorial, hard links, symlinks, system, Windows 7, windows administration]
comments: true
image:
  feature: Windows.jpg

---

Overview

*  Auto generated table of contents
{:toc}

![Moving Users and Prog Files][1]

If you’ve ever needed or tried to move the C:\Users directory or other default Windows® directories to another place other than the default one, you know it can be quite difficult.

I’ve tried to Google this, and talk to others about doing it. What seemed to be such a simple request also seemed to be difficult to pull off. That’s when a brilliant (nearly the smartest man I know) told me about [Hard Links and Junctions](http://msdn.microsoft.com/en-us/library/windows/desktop/aa365006(v=vs.85).aspx) hard links & junction links in windows. Think of them like symbolic links in Mac or *nix systems.

* C:\dira linked to C:\dirb
* D:\dir1\ to C:\dir2\dir3

The great thing about using hard links in Windows is that it acts as if the data is still there. In the example above, when you're browsing C:\dira the system will act as if you’re really in that directory when in all reality you're browsing C:\dirb. Even the address bar will show that.

Thanks to an almost 3-year-old post on [Move the Users Directory in Windows 7](http://lifehacker.com/5467758/move-the-users-directory-in-windows-7), I accomplished what I thought was only possible with tons of registry tweaking and tons of time spent in Safe Mode with a potentially unstable system afterward.

### Real Reason Why

So the real reason I needed to so this is that I wanted to totally rebuild my system. New parts, new paint. Start from scratch and make this new Windows 7 installation as fast as it could be. Thanks to a good friend, I was given a small 30GB SSD. Now I could have run Windows on this just fine and had some programs installed there and others installed on another disk. Maybe even copied my music, downloaded programs, etc… to this other disk. But that requires that every time an installer runs I have to pay close attention to where it’s going. Every time a program wants to move data into the “My Documents” folder, I have to be mindful that I’m only dealing with about 18GB free after a clean install. That’s simply not enough. I’d run out in less than a few weeks and many times probably forget that these installers are putting all their files into the C:\Program Files directory.

### Step-By-Step

So here’s the step-by-step instructions to moving just about any folder to another disk, especially those special Windows ones.

#### Install & Create Restore Point

1.  Install a fresh copy of Windows 7 (or XP or 8, whatever you want)
2.  Dont do anything else. Just leave it fresh and clean.
3.  Create a Restore Point (just to play it safe)
    1.  Right Click “My Computer” and choose Properties
    2.  Choose “System Protection”
    3.  Select the “System Protection” Tab
    4.  Click Create
    5.  Type a description for this Restore
    6.  Click Create

#### System Recovery

1.  Boot back up with the install DVD
2.  Choose the appropriate language, currency & keyboard and click Next
3.  At the screen where there is a large “Install Now” button, look just below it and click “Repair your computer”
4.  You might be asked if you want to “Repair and Restart”, choose No.
5.  Make sure that the OS that system recovery found is the one you just installed and that it’s selected. Click Next.
6.  You’ll be presented with a few options…choose “Command Prompt”

Now here’s where we really get our hands dirty. Well, not really, but just a bit.

Find out which drives are what.

* Install Drive: DVD
* OS Drive: Source
* Secondary Drive: Destination

On my computer, it was:

* X: DVD Install Drive
* E: Actual OS SSD Drive
* D: Secondary Hard Drive

#### Copy Data & Create Hard Links

So at this point, you need to copy all the source data to the destination drive and create the hard links.

Using my drive letters above, here is how its done.

1.  robocopy /copyall /mir /xj E:\Users D:\Users
2.  robocopy /copyall /mir /xj “E:\Program Files” “D:\Program Files”
3.  robocopy /copyall /mir /xj “E:\Program Files (x86)” “D:\Program Files (x86)”

/mir tells Robocopy to mirror the directories. This will copy all files and their permissions
 /xj is very important as well as it tells Robocopy to now follow any junctions points it might meet when browsing these locations. Don’t Forget This

Now as long as no files failed to copy, we can proceed.

In order to create junctions or hard links, the source folder must not exist. This means that we now have to delete those directories we just copied.

1.  rmdir /S /Q E:\Users
2.  rmdir /S /Q “E:\Program Files”
3.  rmdir /S /Q “E:\Program Files (x86)”

Now we create the NTFS Junction/symlinks

1.  mklink /J E:\Users D:\Users
2.  mklink /J “E:\Program Files” “D:\Program Files”
3.  mklink /J “E:\Program Files (x86)” “D:\Program Files (x86)”

Now you’ve just moved all three of these folders from the Windows system disk to another disk.

### Prove it to yourself

Now comes the proof. Change directories to E:\. Type dir and see what you see. You should see ” Users [D:\Users]”

Now restart your computer and you're done.

Congratulations!

### Update

A while after doing this Windows Update started failing on a few updates. I kept receiving the following error: Windows update error 80070011

I found that Microsoft® isn’t following those symlinks properly when it comes to certain security updates. I think had I only moved the “Users” directory all would be fine.

Google is my friend and I found out what needed to change in order for security updates to continue.
Basically, there are a few registry keys you’ll need to point to the “real” location of the Program Files directory because it wont follow the junction link.

Make these changes to:
`HKEY_LOCAL\_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\`

| Key Name | Old Data Value | New Data Value |
| -------- | -------------- | -------------- |
| CommonFilesDir | C:\Program Files\Common Files | D:\Program Files\Common Files |
| CommonFilesDir (x86) | C:\Program Files (x86)\Common Files |  D:\Program Files (x86)\Common Files|
| CommonW6432Dir | C:\Program Files\Common Files | D:\Program Files\Common Files |
| ProgramFilesDir | C:\Program Files | D:\Program Files |
| ProgramFilesDir (x86) | C:\Program Files (x86) | D:\Program Files (x86) |
| ProgramW6432Dir | C:\Program Files | D:\Program Files |

After these changes are made, Windows should be able to update successfully.
{: .notice}

[1]: http://i1.wp.com/www.tquizzle.com/uploads/2012/12/Moving-Users-and-Prog-Files.png

repository: tquizzle/vtechify-dep

branch_name: refs/heads/gh-pages

gha_language: JavaScript

repo_name: tquizzle/vtechify-dep


text:
# Scheduling Tasks in JavaScript

While investigating some performance issues with intense data loading at Robinhood, we noticed some interesting performance implications with various ways to schedule tasks in JavaScript. This document compiles the list of task scheduling functions and their behavioral differences.

## Tasks vs microtasks

Understanding the difference between tasks and microtasks would be really helpful to follow the rest of the article. A good read can be found at [here](https://developer.mozilla.org/en-US/docs/Web/API/HTML_DOM_API/Microtask_guide)

## setTimeout / setInterval

These two functions offer the typical method to append a task to the task queue.

> An interesting note is setTimeout(callback, 0) doesn't execute the callback immediately as it is [clamped](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout#Reasons_for_delays_longer_than_specified) to a minimum wait time of 4ms.

## queueMicrotask or promises

Append to microtask queue. The microtasks are usually executed immediately following the current task.

> The microtask has one special feature that would potentially cause performance issue. If a mirotask adds more microtasks to the queue, the newly added microtasks execute BEFORE the task next task is run. In practice, if a microtasks (promise) keep queuing more microtasks, the main thread would be blocked.

## requestIdleCallback

A ["silver bullet"](https://developers.google.com/web/updates/2015/08/using-requestidlecallback) to schedule background tasks of various priorities. RequestIdleCallback will schedule work when there is free time at the end of a frame, or when the user is inactive.

By specifying a [timeout](https://developers.google.com/web/updates/2015/08/using-requestidlecallback#guaranteeing_your_function_is_called), it gives the flexibity to make sure the callback is executed after the specified time.

> In practice, requestIdleCallback is a better fit to schedule background tasks than microtasks because queuing more idle callbacks won't overwhelm the main thread like microtasks.

## requestAnimationFrame

RequestAnimationFrame callback is called right before the browser paints a new frame. It is perfect for animation but also useful for [throttling](https://developer.mozilla.org/en-US/docs/Web/API/Document/scroll_event#Scroll_optimization_with_window.requestAnimationFrame) some high rate events like scroll.

One caveat with requestAnimationFrame is its callbacks are paused in most browsers when running in background tabs or hidden.

> Also in Firefox's [performance tips](https://developer.mozilla.org/en-US/docs/Mozilla/Firefox/Performance_best_practices_for_Firefox_fe_engineers), it's fine perform DOM writes inside rAF, but not recommended to put queries for layout or style information.

## setImmediate

While this function does what it name says, it's considered a non-standard feature among browsers. It is very useful to breakup long running tasks in node.

Here's an good [answer](https://stackoverflow.com/questions/15349733/setimmediate-vs-nexttick#:~:text=Use%20setImmediate%20if%20you%20want,already%20in%20the%20event%20queue.&text=nextTick%20to%20effectively%20queue%20the,after%20the%20current%20function%20completes.) for setImmedaite vs nextTick in node.

## React Scheduler

React actually has a more sophisticated scheduler with more controls over requestAnimationFrame and requestIdleCallback [here](https://github.com/facebook/react/blob/43a137d9c13064b530d95ba51138ec1607de2c99/packages/react-scheduler/src/ReactScheduler.js).

repository: cain-wang/archive

repo_name: cain-wang/archive


text:
---
# Display name
title: Dr Ryan Cardenas

# Username (this should match the folder name)
authors:
- admin

# Is this the primary user of the site?
superuser: true

# Role/position
role: Postdoc - Bioinformatics

# Organizations/Affiliations
organizations:
- name: University of East Anglia
  url: "https://people.uea.ac.uk/r_cardenas"

# Short bio (displayed in user profile at end of posts)
bio: Bio

interests:
- Epigenetics
- Bioinformatics
- Cancer
- Statistics and modelling
- Containerisation technologies

# Social/Academic Networking
# For available icons, see: https://sourcethemes.com/academic/docs/page-builder/#icons
#   For an email link, use "fas" icon pack, "envelope" icon, and a link in the
#   form<EMAIL_ADDRESS>or "#contact" for contact widget.
social:
- icon: envelope
  icon_pack: fas
  link: '/#contact'
- icon: twitter
  icon_pack: fab
  link: https://twitter.com/ryancardz
- icon: graduation-cap  # OR `google-scholar`
  icon_pack: fas  # OR `ai`
  link: https://scholar.google.com/citations?hl=en&user=tMSL9U0AAAAJ
- icon: github
  icon_pack: fab
  link: https://github.com/R-Cardenas
- icon: linkedin
  icon_pack: fab
  link: https://www.linkedin.com/in/ryan-cardenas-200694187/
# Link to a PDF of your resume/CV from the About widget.
# To enable, copy your resume/CV to `static/files/cv.pdf` and uncomment the lines below.
# - icon: cv
#   icon_pack: ai
#   link: files/cv.pdf

# Enter email to display Gravatar (if Gravatar enabled in Config)
email: ""

# Organizational groups that you belong to (for People widget)
#   Set this to `[]` or comment out if you are not using People widget.
user_groups:
- Bioinformatics

---

I completed my PhD in 2017 at the University of Nottingham in Cancer biology where I utilised the TCGA resources to investigate potential therapeutic microRNA targets to be tested on cell lines in the lab. This was followed by a postdoctoral position at the University of Birmingham which focused upon characterising the non-coding parts (lncRNA, eRNA, etc) of the genome utilising zebrafish as a model organism. This position facilitated my understanding in a wide range of sequencing technologies and analyses; including CAGE, ChIP, ATAC and RNA-seq. Since starting my position at UEA, I have continued to develop my skills in bioinformatics and analysing samples for DNA variants. Facilitating this, I have developed skills in pipelining programming languages including Nextflow and Snakemake, with integration into containerisation technology such as Singularity.

{{
}}
|Publications   |
|------------|
|de Brot, S., Ntekim, A., **Cardenas, R.**, James, V., Allegrucci, C., Heery, D.M., Bates, D.O., Ødum, N., Persson, J.L. and Mongan, N.P., 2015. ***Regulation of vascular endothelial growth factor in prostate cancer. Endocrine-related cancer***, 22(3), pp.R107-R123.           |
|Nepal, C., Hadzhiev, Y., Balwierz, P., Tarifeño-Saldivia, E., **Cardenas, R.**, Wragg, J.W., Suzuki, A.M., Carninci, P., Peers, B., Lenhard, B. and Andersen, J.B., 2020. ***Dual-initiation promoters with intertwined canonical and TCT/TOP transcription start sites diversify transcript processing. Nature communications***, 11(1), pp.1-16.        |
|Ramilowski, J.A., Yip, C.W., Agrawal, S., Chang, J.C., Ciani, Y., Kulakovskiy, I.V., Mendez, M., Ooi, J.L.C., Ouyang, J.F., ***... Cardenas, R.P***, ... Parkinson, N. and Petri, A., 2020. ***Functional annotation of human long noncoding RNAs via molecular phenotyping. Genome Research***, 30(7), pp.1060-1072.         |
|Shah, M., ***Cardenas, R.***, Wang, B., Persson, J., Mongan, N.P., Grabowska, A. and Allegrucci, C., 2017. ***HOXC8 regulates self-renewal, differentiation and transformation of breast cancer stem cells. Molecular cancer***, 16(1), p.38.        |
|Mok, G.F., ***Cardenas, R.***, Anderton, H., Campbell, K.H. and Sweetman, D., 2014. ***Interactions between FGF18 and retinoic acid regulate differentiation of chick embryo limb myoblasts. Developmental biology***, 396(2), pp.214-223.           |
{{
}}

repository: R-Cardenas/uea-website

repo_name: R-Cardenas/uea-website


text:
# site

[![Build Status](https://travis-ci.org/electron-react-boilerplate/site.svg?branch=master)](https://travis-ci.org/electron-react-boilerplate/site)
[![Netlify Status](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Fdeveloper.oswaldlabs.com%2Fnetlify-status%2F09eae66b-2119-45c4-9672-dfbd388f1d20)](https://app.netlify.com/sites/electron-react-boilerplate/deploys)

The website for [electron-react-boilerplate](https://github.com/electron-react-boilerplate/electron-react-boilerplate)

## Setup

```sh
# Install dependencies
$ yarn
# Start the site
$ yarn start
```

## Project Stucture and Contributing

For details, see [`./website/README.md`](https://github.com/electron-react-boilerplate/site/blob/master/website/README.md)

repository: muscaiu/site

repo_name: muscaiu/site


text:
# Algo Visualizer 🔮

This project was developed to help people learn and view the inner working of various sorting algorithms. You can access it here. [algovizz.netlify.app](https://algovizz.netlify.app/).

## Features.

1. Control the size of randomly generated array.
2. Control the visualization speed.
3. Reset to original unsorted array.
4. Compare the no. of swaps and comparison made by each sorting algorithm.

## Algorithms Visualized

1. Bubble Sort
2. Insertion Sort
3. Selection Sort
4. Merge Sort
5. Quick Sort
6. Random Quick Sort

## Contributing

If you would like to add more algorithms or want to improve upon the project, pull requests are welcomed!


text:
# Releasing new versions

The central [Android-Password-Store] repository houses three subprojects that are released separately from each other and with different methods.

## Library modules

The `autofill-parser` and `openpgp-ktx` libraries are available on the [APS JCenter] repository. The process for creating a new release is as follows:

1. Bump the version number for the library in `$projectDir/gradle.properties`

2. Push a new tag following the format `$projectDir-v$version`, for example, `v4.0.0` for `autofill-parser` needs a `autofill-parser-v4.0.0` tag.

## Password Store app

Releasing a new major version of the app is a slightly more involved process.

1. Each release is accompanied by a [milestone], so go ahead and close it. This will set off a GitHub Action that will generate a pull request with the changelog and the version updated.

2. Merge the pull request, and note the target branch against which it was created.

3. Tag the new state of the aforementioned branch following the exact semantic version as in the milestone. This means the tag should be `v1.2.0`, not `1.2.0` or `1.2` or `v1.2`.

4. Push the tag to GitHub, and allow CI to generate artifacts and a draft release that can then be reviewed and made public.

5. The maintainer in charge of Play Store deployment then takes the generated binaries from this GitHub release and uploads them to Play Store. In the future this manual step should be eliminated in favour of a Gradle-backed automatic deployment setup, using tools like [Gradle-Play-Publisher].

[android-password-store]: https://github.com/android-password-store/Android-Password-Store
[aps jcenter]: https://bintray.com/android-password-store
[gradle-play-publisher]: https://github.com/Triple-T/gradle-play-publisher
[milestone]: https://github.com/android-password-store/Android-Password-Store/milestones


text:
# Media Compressor

Client-side: HTML, CSS, JavaScript, jQuery

Server-side: Node.js, Express

Demo here: https://juliarainto.com/apps/mediapakkaaja

## Start application

Start
```
npm install -g http-server
```
Server:
```
cd .\server
npm install
npm start
```
Client:
```
cd .\client
http-server
open browser to: http://localhost:8080
```
Build:
```
npm build
```
# Applications installation to webserver

This installation is tested to work on Ubuntu 16.04 system and Nginx software.

## SYSTEM REQUIREMENTS AND RECOMMENDATIONS

Server should have at least 4GB RAM, so that the program will run smoothly.

Client folders files should all be minified.

Gzip is recommended to be installed on the server, to assure faster content loading.

Client folders main.js and video.js files that uses ECMAScript 6 should first be run through Babel (https://babeljs.io/repl), Choose only the following settings:

* SETTINGS: Line Wrap and Minify

* PRESETS: es2015 and stage-2

## APPLICATION CONFIGURATION

To secure data travel SSL protocol is required.

* Enable sslEnabled to true. These options can be found in server.js, main.js and vid-eo.js. Make sure all of them is set true.

* Replace your own server URL to POST routes, your_address.com. Change these in server.js, main.js and video.js. Make sure all of them has the right URL.

* SSL certificate path needs to be defined in server.js. Replace path: “/var/www/certs/” with your own path where your SSL certificates are located.

## REQUIRED INSTALLATIONS

### NodeJS

Remove old Node.js:

```
sudo -i
apt-get remove nodered -y
apt-get remove nodejs nodejs-legacy -y
exit
```
Install curl and n, that will install latest Node.js:

```
sudo apt-get install curl
curl -L https://git.io/n-install | bash
```
* Installation asks y/N, push y

* Installation asks at the end the following: IMPORTANT: OPEN A NEW TERMINAL TAB/WINDOW or run `. /root/.bashrc` before using n and Node.js. Write the following command:

```
. /root/.bashrc
```

Verify that installation worked:

```
node -v
npm -v
```
Node version should be v.10.6.0 (or the newest)
Npm version should be v.6.1.0 (or the newest)

### FFmpeg

Install FFmpeg:

```
sudo apt-get install ffmpeg
```
### Babel

Install Babel

```
npm install -g babel-cli
```
### pm2

Install pm2:

```
npm install pm2 -g
```

Run following command:

```
pm2 startup
```

## WEB SERVER

If you don’t have web server installed follow these steps, otherwise skip to web server configuration.

Install nginx:

```
sudo apt-get install nginx
```
Test if nginx works by going going to your URL address.

### Web server configuration

Navigate to PATH:

```
cd /var/www/html
```

Create new folder if needed using following command and replacing apps with the desired folder name:

```
sudo mkdir apps
```

Give the following PATH: cd /var/www/html Read/Write permissions, using following command:

```
sudo chmod -R 777 apps
```

## START APPLICATION

Insert Client- folder content to wanted PATH or the one created by nginx, using file transfer protocol (FTP).

Nginx example:

```
cd /var/www/html/apps
```

At the server folder run the command `npm install` and after that, run the pm2 command and replace mediacompressor with desired folder name:

```
pm2 start --watch --interpreter babel-cli server.js --name apps mediacompressor
```
After installation run command:
```
pm2 save
```
Delete Read/Write permissions from the path: cd /var/www/html with following command:

```
sudo chmod -R 755 apps
```

Navigate web-server URL where client-side was copied and the program should start.

repository: juliarainto/MediaApplication

repo_name: juliarainto/MediaApplication


text:
# How to send and receive Waves

## **How to send Waves**

**Step 1.** Open up your [iOS wallet](https://itunes.apple.com/us/app/waves-wallet/id1233158971)

At the bottom of the interface, click on the **Send** button.

![](/_assets/waves_transfers_ios_01.jpg)

The following window will appear.

**Step 2. **Fill in the sending form.

![](/_assets/waves_transfers_ios_02.jpg)

* **To**: Enter the recipient Waves address.
* **Amount**: Define a number of Waves you want to send or click on the Use total balance ... minus fee if you want to send all Waves.
* **Fee**: Default fee is 0.001 Waves. This is sufficient fee for most cases.
* **Attachment**: Optional. You can write a message for the recipient in the Attachment field.
* **Note**: Some exchanges require users to include description when depositing assets. Otherwise, they cannot credit your account.

**Step 3. **After you have entered all necessary information, re-check entered data and click on the **Submit** button.

**Step 4.**Then unlock your wallet by entering the wallet password and click on the **OK** button to complete the process.

![](/_assets/waves_transfers_ios_03.jpg)

## **How to receive Waves**

Waves receiving is very straightforward. Just copy your Waves address and hand it to the person who wants to send you Waves.

**Step 1. **Open up your iOS wallet, on the main page find the WAVES box and tap on it.

![](/_assets/waves_transfers_ios_04.jpg)

**Step 2. **After that, tap on the **Receive** button.

![](/_assets/waves_transfers_ios_05.jpg)

**Step 3. **The following window will appear. There you can tap on the QR code to copy your Waves address.

Also you can put some amount in the **Amount** box and generate QR code with this sum and your Waves address and then share it with someone via **Share** button.

![](/_assets/waves_transfers_ios_06.jpg)


text:
# Getting started

<Video url="https://www.youtube.com/embed/909CE7EY0xI" />

AEUX is a set of panels for Figma, Sketch and After Effects. Transfer layers as you need them with the least amount of friction between visual design and motion.

Formerly known as Sketch2AE, AEUX is designed to keep up with the newest ways people are designing for screens. Spell it out or say it like A-Yo.


text:
[![](resources/999442FE3ECE3C8B9178A541F42895EC.jpg)](https://2.bp.blogspot.com/-GbTdUjYPXJ8/Vccw2RYLThI/AAAAAAAAARs/GQ3QeteA2as/s1600/Ribbon-Banner-PSD-File.jpg)

***File Types***

 -b  - block device file Example: HDD and pen drive

 -d - directory file

 - - common file

 c - Character device file Example: terminal

 l - Linked file

Linking means reflecting to the original file, In case of copy command updating is not possible after copying the file from the source to destination. In link updating is possible for both the files.

**HARD Link**

**SOFT Link**

1.The destination file is exact image of the source file.

1.The destination file size is length of the source file name

2. If source got deleted also even we can access the destination file

2. if source got deleted we can’t access destination file

3. inode numbers of source and destination are same

3\. inode numbers of source and destination are different

4. We can’t put the hard link to different file system (partitions) because it will different.

4\. we can put a link between different file systems

5. Ex: cp –l \<source\> \<destination\>

Ex: cp –s \<source\> \<destination\>

[![](resources/044150CB321F123058CC8FEC325B5459.png)](https://2.bp.blogspot.com/-_5fDnKUt11Y/VccaPgHvDpI/AAAAAAAAARQ/fXQLWjThzyM/s1600/links.png)

repository: mtint/STFC-SCD-OPENSTACK

path: /HOWTO/File Links.md

filename: File Links.md

repo_name: mtint/STFC-SCD-OPENSTACK


text:
1. Assume there are two terminal objects t1 and t2. Because t1 is terminal there
   must be a unique morphism from t2 to t1 and vice versa for t2. This yields
   our unique isomorphism between t1 and t2.
2. The smaller element of the two. The morphisms between the two follow
   immediately. Factorizing follows by transivity of the ordering relation.
3. The larger element of the two. Reverse argument of 2.
4. sealed trait in Scala. More generally we can use Scott encoding.
5. m :: Either Int Bool -> Int
   m Left i = i
   m Right True = 0
   m Right False = 1
   m factorizes.
6. You have a conflict with 0 and 1. In particular when choosing a factorizing
   function m you need to decide how to map 0 and 1 from Int to Either Int Bool,
   but any choice you make will fail to factorize either i or j.
7. This is also a valid coproduct. It is uniquely isomorphic to Either via the
   obvious construction.
8. Overly ambitious either. Either Int (Either Int Bool). This yields