text:
Node AWS Deploy
=====
This is my attempt at an easy to use and robust deployment and install system to get your Node app up and running, quickly and easily on AWS.
node-aws-deploy is designed to take a web hook HTTP post from a Git repository service or a post generated on a development machine; and then automatically
trigger a deployment across a single or multiple server instances. New servers that are started up will automatically grab the latest changes.
node-aws-deploy typically sits outside your application to avoid clutter but in can live within your application directory just a easily.

Make sure that all the projects that will be using node-aws-deploy have package.json files defined in them as node-aws-deploy relies on these for deployment information.

##How it works
node-aws-deploy has install scripts that install 'Node', 'n', and 'node-aws-deploy'. node-aws-deploy uses upstart to launch node-aws-deploy on the server at startup. Upstart will
relaunch your application if it dies. When the user data is set to deploy:true, on startup, node-aws-deploy does a git pull of the configured git branch of your remote git repository.
It also performs git pulls on each of your dependency directories. It then checks the node
version specified in package.json. This is specified in the 'nodeVersion' field which is ignored by NPM. If the node version specified in package.json does not
match the current node version, node-aws-deploy uses 'n' to switch versions to the one specified. If Nodejs is changed to a different version, the system is restarted.
Next, node-aws-deploy compares the contents of package.json to a local copy (package.copy). If anything has changed, those packages are removed and re-installed using NPM.
Finally, node-aws-deploy changes the working directory to your applications folder, then loads and executes the configured .js file that is your applications entry point.

node-aws-deploy also handles project dependencies. If your project consists of several sub projects, you can configure node-aws-deploy to create separate git repositories
for each dependency, and then use the NPM link feature to create a symbolic link in the main projects node_modules directory. Each one of the dependency projects will have
git pulls and NPM dependency checks performed on them on pull requests or starts when deploy is set to true.

When user data deploy:true is set node-aws-deploy starts a server that listens on a configured port. A webhook can be configured that posts to the node-aws-deploy listener on
Git pushes into your repository. Typically, several servers are configured behind a load balancer. The webhook will be dispatched by the load balancer to one of the
running servers. This server will find all of the other servers of that same type and forward the webhook along. Every server will do a git pull and then update itself.
This allows a git branch to be setup that the servers will operate off of. Whenever a deployment needs to happen, a developer simply merges into that branch and pushes.
Deployment happens automatically. For more control, a developer can locally run the postToAllInstances.js script that will:
    1. Find all the servers that having a matching type in their user data
    2. Send them each one an HTTP request (can be /pull, /restart, or /rebuild) on the configured port
    3. Display the results

    pull - pulls and restarts the server
    restart - restarts the server
    rebuild - re-installs the npm dependencies by deleting the package.copy files

The deployment flow I am using at my company works like this:

    1. Developers work in two week sprints uploading to the development branch
    2. Once a sprint is complete the development branch is merged into the production branch
    3. postToAllInstances.js is called with the parameters: node postPullToAllInstances.js '{"type":"staging", "listensTo": "master", "deploy":true, "secure":true}'
        - This finds all the instances of type production and signals them to pull and restart
    4. Testing is done on this staging server until the code is deemed ready to deploy.
    5. createAMI.js is called to create an deployment AMI off of one of the staging server instances.
    6. launchAMI.js is called to deploy the AMI created above into a scale group that sits behind a load balancer

Rollbacks are performed by calling launchAMI with the previous version of the AMI

Hot fixes are performed by checking out the production branch, performing the fix, deploying to staging, testing, creating a new AMI, and then deploying to the production Load Balancer

node-aws-deploy is great for running on development machines as well. It won't pull changes automatically. (its the developers job to decide when to do that!)
But it will check that all the NPM and Node dependencies are correct and installed / uninstalled when the app is started.

###Setting up the AWS Node Server Manually
====
These instructions are specific to setting up a node.js server on a AWS Amazon Linux Instance. They can be easily adapted to other Linux instances on other cloud
platforms. These instructions below also are written for a MAC interfacing with the AWS EC2 instances. It should work as-is on Linux, at the very least a SSH
program will be needed to run on Windows.

Create an AWS account http://aws.amazon.com/
Launch an EC2 instance (Make sure you have downloaded the ssh key/pair so you can connect to your instance). Make sure it is an Amazon Linux 64 bit AMI. Set the
user data to:

    {"type":"development", "listensTo": "develop", "deploy":true}

Where type, is the instance type. The name only matters in that it should make sense to you and this instance will communicate with others of the same type and it can be used to select command line params out of the 'commandArguments' field. The
'ListensTo' field specifies which branch of your repository it should listen to and automatically pull from when it sees changes.
When deploy is set to true:

1. The node-aws-deploy server is started and listening for /pull, /restart, and rebuild
2. On restarts node-aws-deploy will pull the tip (git pull) from the master project and from any of its dependency list
3. On restarts node-aws-deploy will check node and npm dependencies in the master project and the dependency list and remove or install them as needed

When deploy is set to false:

1. On restarts node-aws-deploy will check node and npm dependencies in the master project and the dependency list and remove or install them as needed

You will likely want deploy set to false in your production deploy but have it set to true in staging and testing builds.

'type' can now also be used to specify a set of command line params. If the 'commandArguments' field specified in the .app-config.json file is an object (example shown below), type is used as a selection field. As an example, if type is equal to 'development', the command line params will be: "--production --httpPort=80 --httpsPort=443".

    "commandArguments": {
        "development": "--production --httpPort=80 --httpsPort=443",
        "production": "--production",
        "debug": "--remoteDB --httpPort=80 --httpsPort=443"
    },

Sometimes for debugging you might need to manually launch the server with a different set of command arguments. To do this easily you can use the 'override' command line parameter. As an example you can SSH into your server, stop your application (sudo stop <app name>), and then restart it with the debug set of command arguments by typing: "sudo node _start.js override=debug". Make sure you do this from the node-aws-deploy directory. This will apply the debug command line parameters listed in the "commandArguments" above.

On Mac, open a terminal and change directory to the folder containing your key pair your are using with the instance

Ensure your key pair has the right permissions (Substitute key_pair_name with the actual name of your file):

    sudo chmod 400 key_pair_name.pem

Launch a secure shell into the ec2 instance (substitute dns_addr with the dns address of the running ec2 instance you just launched)

    ssh -i key_pair_name.pem -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no ec2-user@dns_addr

From the ssh terminal:

    Allow node to execute as a super user by modifying the /etc/sudoers file. Type the following:

        sudo su
        vi /etc/sudoers

    Use the down keyboard arrow to find this line:

        Defaults	requiretty

    press <i> and insert a ‘#’ before the Defaults:

    use the down keyboard arrow to find this line:

        Defaults	secure_path = /sbin:/bin:/usr/sbin:/usr/bin

    press and insert the following at the end of this line:

        :/usr/local/bin

    press <esc> and then type :wq!

    type exit and press enter

Generate a ssh key (use your email address):

    sudo ssh-keygen -t rsa -C<EMAIL_ADDRESS>    press <enter> for the rest of the questions

Install Git and clone the install script:

        sudo yum install git
        sudo git clone https://github.com/schlotg/node-aws-deploy.git
        sudo chmod 777 node-aws-deploy/install_aws
        sudo node-aws-deploy/install_aws

###Using node-aws-deploy

To launch type:

    sudo start <your application name>

To stop type:

    sudo stop <your application name>

To restart type:

    sudo restart <your application name>

To manually launch it so you can see output at the console:

    sudo stop <your application name>
    cd ~/node-aws-deploy
    sudo node _start.js

To manually launch with a different profile specified in the "commandArgumentsField"

    sudo stop <your application name>
    cd ~/node-aws-deploy
    sudo node _start.js overide=debug

To reconfigure you can always relaunch install.js from the ~/node-aws-deploy directory or if you know 'vi' you can manually edit the .app-config.json by typing:

    cd ~/node-aws-deploy
    vi .app-config.json

Your application will now run every time the server is started. On start and restart node-aws-deploy will: grab the latest code from your git repository branch and look for Node and NPM dependency changes.
On a web hook post node-aws-deploy will find all the running AWS instances of this same type and restart them so updates are propagated across the entire scale group.
Additionally you can use the postToAllInstances.js script to trigger pulls from your local machine to your ec2 instances.

Once your application is setup and running correctly, you will want to create a AMI that will be used in your scale group. To create an AMI:

1. Open the AWS console and select EC2
2. Go to instances, and find the instance that was just configured with node-aws-deploy
3. With that volume selected, select actions->create image. Name it appropriately and click create.
4. This new AMI should now be available and listed in the AMI section. Use it to launch new instances, create scale groups, etc...

node-aws-deploy also comes with a createAMI.js script which allows you to create and AMI off of a running instance of the 'type' specified in its user data.
This is an easy way to create AMIs and do deployments from your local machine or even a dedicated server for that matter. All scripts that use AWS
services are dependent upon the .app-config.json having the AWS credentials set up correctly on the machine that the scripts are launched from.

###install.js
To change parameters you can always manually edit the .app-config.json or run the install.js script. install.js asks questions and builds
out the .app-config.json based on the answers. If you press enter on a question, the previous value of that param remains unchanged. This allows
you to quickly change only the parameters you need to change.

###Triggering live updates

####WebHooks
Most Git repositories have a concept of a webhook. This is a mechanism that performs a post or get on a push to your directory. node-aws-deploy only supports pushes at this time. The examples
given below were written for gitHub's web hooks but should be applicable to other remote repositories.

    For a unsecure post on port 8000 with a secret of 'no_limits' the web hook URL would look like (make sure master is always set to true):

        http://mycoolwebapp.com:8000/post/pull?secret=no_limits&master=true

    For a secure post on port 8000 with a secret of 'no_limits' the web hook URL would look like (make sure master is always set to true):

        http://mycoolwebapp.com:8000/post/pull?secret=no_limits&master=true

It is highly recommended that you use a secure post so your secret and information about your code base is not visible to others. The secret can be anything but must be configured on the server
in the .app-config.json (you can use the install.js to set it) and it must match the one posted form your webhook.
If a valid certificate is not configured with node-aws-deploy, a secure webhook cannot be used.

In Github, select JSON for the payload when setting up the webhook. The 'pullField' in .app-config.json should be set to 'ref'.

Make sure that the port being used for the webhook has a path through the load balancer to your servers and is configured correctly on the servers and on the web hook.

####Manually triggering a webhook
You can trigger a web hook manually if you want to test or if you prefer manual triggering. To do so make sure you have run the install.js program locally. Then run the manualWebHook.js you
can trigger it for different branches by passing in the branch like so:

    cd node-aws-deploy
    node manualWebHook.js master

####Triggering deployments locally
Webhooks might seem like a great idea at first, but even with small sized teams you can get into situations where the server is constantly pulling and being restarted. In a lot of cases
it makes a lot more sense to coordinate the deployments. The postPullToAllInstances.js script allows you to trigger the pull manually from a local development machine. You can also trigger
a restart or a rebuild. 'pull' and 'restart' are self explanatory but the rebuild command clears all the package.copy files in the master project and its dependencies so that all the npm
resources are pulled and re-installed from scratch.

'postPullToAllInstances.js' needs a instance data JSON string passed in so it knows what types of servers to look for and what repository they are listening for. Here is an example:

    cd node-aws-deploy
    node postPullToAllInstances.js "/pull" '{"type":"production","listensTo":"master","deploy":true}'

It is worth mentioning that a third parameter can be specified on the postPullToAllInstances. It is a JSON that contains command lime values you would like to specify on the next server start.
It is ver useful for specifying versions and app-cache dates. Here is an example of the shell script we use to trigger staging deployments:

     cd your_application_directory/node-aws-deploy
     echo Enter type:
     read type
     echo Enter the version:
     read version
     dateTime=$(date +"%m-%d-%y%-T")
     route="/pull"
     args="{\"version\":\"$version\",\"appCacheDate\":\"$dateTime\"}"
     params="{\"type\":\"$type\",\"listensTo\":\"master\",\"secure\":true}"
     echo -e "\nSignaling Servers to Pull. Waiting for server response...\n"
     node postToAllInstances.js $route $params $args

###Misc

node-aws-deploy puts the following into environment variables which you application is free to inspect and use:

     process.env['CLOUD'] = <bool> is this running on an AWS server
     process.env['INSTANCE_ID'] = <string> EC2 instance id of this server.
     process.env['INSTANCE_DATA'] = <JSON> the user data associated with this ec2 instance

###Running Locally

node-aws-deploy when used locally on your development machine has the following functionality / benefits:

1. It will not start a server to listen for webhooks or pull requests
2. When it starts, it will automatically check for NPM dependency changes and the correct node version. It will update
    these as needed before starting the application. This will allow developers to add npm modules our update the
    current node version and have it automatically distributed across the team the next each team member pulls.
3. When used with nodemon it is a great combination for development.

    nodemon _start.js

To use node-aws-deploy for multiple projects on a single development machine, it works best to have a copy of node-aws-deploy inside each project with its own configuration specific
to each project.

To install and setup locally:

1. Clone the repository in your application folder

        git clone https://github.com/schlotg/node-aws-deploy.git
        cd node-aws-deploy
        npm install -d

2. Run the install.js script from within the node-aws-deploy folder

        cd node-aws-deploy
        node install.js

3. Answer the questions to configure node-aws-deploy
4. If you want to use nodemon install it globally.

        npm install -g nodemon

5. launch the application from the terminal with:

        cd node-aws-deploy
        nodemon _start.js

            or

        cd node-aws-deploy
        node _start.js

###Using a pre-launch File

You can specify a pre-launch file that gets executed prior to the application launching. This allows you to start services, create files, etc... The file must be a node Javascript
file that works with require. It must export a 'start' function. The start function takes a callback that will be called when the pre-launch is done executing. Calling the
callback will signal node-aws-deploy to continue execution by executing the file that is the entry point for your application. Specify the pre-launch file by setting it manually
in .app-config.json or using install.js. The file name must be relative to the application path.

In its simplest form the pre-launch file would look like something like this:

    exports.start = function (cb){
        // do pre-launch stuff here
        console.log ("hello world");
        // call callback when done
        cb ();
    };

###Security
It is my opinion that it is important to take reasonable steps to keep your assets secure. You should minimize the exposure to API access keys etc... The first step is to create a set
of development keys and when possible that limit the scope and functionality to just the bare minimum for normal day to day development and testing. Then create a set of production accounts
and keys that access the production assets. The development keys will usually travel with the code base and are accessible by developers while the production keys have limited access. To
facilitate this practice I recommend creating a private directory within node-aws-deploy and copy production only keys into it. You can then use the prelaunch.js file to determine the type
of deployment and read the appropriate data out of the private directory. The data stays stored on the AMI so you need to be careful to limit access to.

Other approaches include having a limited access repository on Git that only the production builds access. Or use encryption keys to encode the data in the public repository and then
decode it on the production build with the key stored on the server only. The point is there are many approaches that can work within the node-aw-deploy framework.

####Putting it all together
In AWS you can specify per instance or per launch configuration user data for the ec-2 instances. This is the mechanism that is used to distinguish the functionality differences across
instances and allows the use of a single AMI created in a staging server to also be deployed in production and have the restart pulling and command server turned off in production only.
Any other differences such as different keys sets across deployments can be accomplished by using the user defined prelaunch.js to steer the application to the production assets.

Using the 'type' variable specified in the user data of the instance can be a very easy way to change functionality of your application based on its deployment type. The 'commandArguments' field of the
.app-config.json file can be a single string or an object of command strings that go with different types of types. Additionally you can manually override the type by using the 'override=' command line parameter.

As an example, with the following commandArguments entry:

    "commandArguments": {
        "development": "--production --httpPort=80 --httpsPort=443",
        "production": "--production",
        "debug": "--remoteDB --httpPort=80 --httpsPort=443"
    },

Instances with user data set to "type": "production", would have the command argument string "--production". And you could override it during manual launch by typing:

    "sudo node _start.js override=debug"

repository: schlotg/node-aws-deploy

repo_name: schlotg/node-aws-deploy


text:
# ![KabileOnline-Backend](logo.png)

> ### A massive multiplayer browser-based online strategy game project.

Project demo is available at (https://kabileonline.com/)

# Used Technologies

* [Node](https://nodejs.org/)
* [Mysql](https://mysql.com/)
* [Sequelize](https://sequelize.com/)
* [Express](https://github.com/expressjs/express) - The server for handling and routing HTTP requests
* [Express-jwt](https://github.com/auth0/express-jwt) - Middleware for validating JWTs for authentication
* [Jsonwebtoken](https://github.com/auth0/node-jsonwebtoken) - For generating JWTs used by authentication
* [Passport](https://github.com/jaredhanson/passport) - For handling user authentication

# Getting started

To get the Node server running locally:
``` bash
# to install all required dependencies
> npm install
# to start the local server
> npm run dev
```

## Application Structure

- `app.js` - The entry point to our application. This file defines our express server. It also requires the routes and models we'll be using in the application.
- `config/` - This folder is central location for configuration/environment variables.
- `routes/` - This folder contains the route definitions for our API.
- `helpers/` - This folder contains the misc helper/utility methods and classes.
- `models/` - This folder contains the schema definitions for our sequelize models. Returns db connection.

## Authentication

Requests are authenticated using the `Authorization` header with a valid JWT. We define two express middlewares in `helpers/auth.js` that can be used to authenticate requests. The `required` middleware configures the `express-jwt` middleware using our application's secret and will return a 401 status code if the request cannot be authenticated. The payload of the JWT can then be accessed from `req.payload` in the endpoint. The `optional` middleware configures the `express-jwt` in the same way as `required`, but will *not* return a 401 status code if the request cannot be authenticated.

# Authors

* [akjmgalp](https://github.com/thebilge)
* [metalsimyaci](https://github.com/metalsimyaci)

# License

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

See also the list of [contributors](https://github.com/KaOnStudio/kabileonline/contributors) who participated in this project.

# Acknowledgments

The KaOnStudio would like to thank to all the contributors to the project, and loves the players.

license: MIT

repository: KaOnStudio/kabileonline-backend

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: KaOnStudio/kabileonline-backend


text:
# Cross-build container for ARM platforms

## Synopsis

This container allows building of ARM (arm32v7, arm64v8) images on a x64 machine.

It uses a Go-based script that intercepts Docker shell commands and executes them with a user-mode QEMU emulator (a.k.a qemu-arm-static).

The image is based on a core variant of Ubuntu LTS 18.04.02 (Bionic Beaver), but it can easily be replaced by and other Linux distribution.

## Usage

For arm32v7 architecture (32-bit ARM CPU, a.k.a arm7l, armhf), use:

```
FROM redisfab/arm64v8-xbuild:bionic
RUN [ "cross-build-start" ]
...
# your code here
...
RUN [ "cross-build-end" ]
```

For arm64v8 architecture (64-bit ARM CPU, a.k.a ARMv8-A, aarch64), use:

```
FROM redisfab/arm32v7-xbuild:bionic
RUN [ "cross-build-start" ]
...
# your code here
...
RUN [ "cross-build-end" ]
```

For Dockerfiles with multiple FROM sections, duplicate the "cross-build" commands:

```
FROM redisfab/arm32v7-xbuild:bionic as builder
RUN [ "cross-build-start" ]
...
# your code here
...
RUN [ "cross-build-end" ]

FROM redisfab/arm32v7-xbuild:bionic
RUN [ "cross-build-start" ]
...
# your code here
...
RUN [ "cross-build-end" ]
```

Cross-build images can be cascaded, thus it is possible to create an image that will in turn be used to cross-build other images.

## Building cross-build images

Cross-build images should be built on a native ARM system. It is possible to build both arm32v7 and arm64v8 on the latter system. For that purpose, one can use an emulated VM on QEMU/KVM, a physical RPi device, on an AWS EC2 machine.

The standard way to build for the docker.io/redisfab repo is (Docker experimental features are required):

```
docker build --squash --rm -t redisfab/arm32v7-xbuild:stretch -f Dockerfile.arm32v7-stretch .
docker build --squash --rm -t redisfab/arm64v8-xbuild:stretch -f Dockerfile.arm64v8-stretch .
```

## Building QEMU binaries

This binary emulates a arm64v8 architecture while running on x64. To build it, we added a build script in the qemu/ directory. This script is meant to be executed inside a Debian container, so use:

```
docker run -it debian bash
```

and then run the build script. If you want to build a static QEMU image for arm32v7, you should change the `--target-list=aarch64-linux-user` configuration option to `--target-list=arm-linux-user`. Finally copy the QEMU binary into the bin directory of this project.

## Building the cross-build scripts

The cross-build scripts are meant to be executed on x64, thus should be compiled with GOARCH=amd64. A compiled version is already supplied in the bin/ directory.

## Reference

[1] [Building ARM containers on any x86 machine, even DockerHub](https://www.balena.io/blog/building-arm-containers-on-any-x86-machine-even-dockerhub/)

[2] https://hub.docker.com/r/project31/aarch64-centos-qemu/

[3]  https://hub.docker.com/r/project31/aarch64-docker-openvpn/~/dockerfile/

[4] https://hub.docker.com/r/multiarch/ubuntu-core/

[5] https://github.com/multiarch/ubuntu-core

[6] https://github.com/docker-library/official-images#architectures-other-than-amd64

[7] https://github.com/balena-io/qemu

repository: RedisLabsModules/arm-xbuild

gha_language: Shell

repo_name: RedisLabsModules/arm-xbuild


text:
# stm_blinker2

Blinker using `gpio_interface` of `hwboard` module.

There is no addition connection. This example blinks on board LED.

## blicker.cpp

This project is cpp source project.

Compile options are set to minimize binary size and remove redundant codes.

repository: seanshpark/hwhobby

gha_language: C

repo_name: seanshpark/hwhobby


text:
I know of at least 3 cases where they pulled
> plugs on their users because they didn't like the contents of their speech.

> (Many people here probably remember Fred Cherry - Panix pulled his plug for
> "homophobia".)
> chris.com pulled the plug on TRRJC3 (Igor's pal) because of content.
I wish you could be a little more specific.
Harrashing email and excessive cross-posting in violation of each UseNet
group charter is not
censorship.
 Look out for the
next gay pride parade" that's is legitimate ground for action.

> I also wouldn't trust Lance Cottrell.  He's selling privacy for the $$, not
> for the ideology; he'll bend over the moment he thinks there's more $$ in
> bending over, which is usually the case.
What is wrong selling privacy for money?

I suppose you can back up your claim with documentation.

gha_license_id: MIT


text:
# go-version
Small package to provide version-like metadata to any application burnt into the binary

## Usage

To use this package, clone it into a subfolder of your go workspace, e.g.:

    cd $GOPATH
    go get github.com/fvhovell/go-version
    src/github.com/fvhovell/go-version/make.sh

Demo application will be available under $GOPATH/bin/version-test
Sample output:

    2016/01/03 18:49:19 Hello World:
    Appication:
    	Name    : version-test
    	Version : local-test-build
    Build data:
    	Type       : integration-build
    	Timestamp  : 2016-01-03 18:49:17 +0100 CET
    	Hostname   : localhost.local
    	Username   : builduser
    	Go version : go1.5.1-darwin/amd64
    Git:
    	Branch : master
    	Commit : 9818ee7f8ac3d57da9fe25d5d5c8848a46475f86
    {"app_name":"version-test","app_version":"local-test-build","build_type":"integration-build","build_time":"2016-01-03T18:49:17+01:00","build_hostname":"localhost.local","build_username":"builduser","build_go_version":"go1.5.1-darwin/amd64","git_branch":"master","git_commit":"9818ee7f8ac3d57da9fe25d5d5c8848a46475f86"}

repository: fvhovell/go-version

repo_name: fvhovell/go-version


text:
# Aporia jaapii Rehm SPECIES

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
Fung. Sel. Exs. 82 (1905)

#### Original name
Aporia jaapii Rehm

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
#Gameplays

## BoomerMan

## Running is not enough

###mode
- single player game

###what you can see:

- region of the game
- colored spots (could be the same color)

###players main task:
- run fast and visit all the spots
- make the longest chain with the spots of the same color to multiply your score
- beat the friends on the leaderboard

###game mechanics
- the spot is checked if the user is close (boomerman.spot.check.proximity=50m)

## BoomerTeam

## Boom with your friends

- multiplayer game

### what you can see:
- region of the game
- spots
- enemies
- active bombs
- bombs explosion
- (experimental) bombs recharge spot
- (experimental) immunity spot

### players main task:
- color maximum spots with the team's color
- kill enemies using bombs
- the game is ended when all the spots are colored or all the team's players are dead

### game mechanics
- to play the game user should be part of the team or create new one and invite the friends
- any team player can start new game and select game zone
- any team player can see the countdown boomerteam.game.countdown.time (1m) before the game starts (like flashcode)
- user should join the game to play
- when joining the game user selects a side (white side of angels or dark side of demons)
- any user visiting a spot color the spot with the team's color
- every user possesses a boomerteam.bombs.initial.count bombs
- user can put a bomb at any place
- bombs exploses after boomerteam.bomb.explosition.time (10s)
- if any user is in the boomerteam.bomb.explosition.distance radius (100 m) he is dead
- (experimental) boomerteam.bombs.recharge.count times during a game new recharge spot appears on the game
- (experimental) boomerteam.bombs.immunity.count times during a game new immunity spot appears on the game

## Boomer KillerHood

## When Neighbours become Killers

TODO

## Boomer Treasure

## Solve enigmas and find the hidden Treasure

TODO

repository: basilboli/boomer

repo_name: basilboli/boomer


text:
[![Build Status](https://travis-ci.org/drugilsberg/chimaera.svg?branch=master)](https://travis-ci.org/drugilsberg/chimaera)
[![DOI](https://zenodo.org/badge/176124980.svg)](https://zenodo.org/badge/latestdoi/176124980)

# chimaera

![Chimaera](docs/chimaera.png)

## References

Python implementation of Chimaera algorithm based on [Inferring clonal composition from multiple tumor biopsies](https://doi.org/10.1038/s41540-020-00147-5).

The supplementary tables for the publication can be found [here](https://bcm.box.com/v/chimaera-supplementary).

If you use Chimaera please cite it using the following:

```bibtex
@article{manica2020inferring,
  title={Inferring clonal composition from multiple tumor biopsies},
  author={Manica, Matteo and Kim, Hyunjae Ryan and Mathis, Roland and Chouvarine, Philippe and Rutishauser, Dorothea and Roditi, Laura De Vargas and Szalai, Bence and Wagner, Ulrich and Oehl, Kathrin and Saba, Karim and others},
  journal={NPJ systems biology and applications},
  volume={6},
  number={1},
  pages={1--13},
  year={2020},
  publisher={Nature Publishing Group}
}
```

## Requirements

- Python >=3.5
- pip >= 10.0

**NOTE:** For Python >=3.7 make sure `Cython` is installed before the installation of `chimaera`: `pip install Cython`.

## Installation

In case `pip` is installed just type:

```sh
pip install .
```

or directly from the repository.
Using ssh authentication:

```sh
pip install<EMAIL_ADDRESS>```

Using https:

```sh
pip install git+https://github.com/drugilsberg/chimaera.git
```

## Usage

Chimaera come with an excutable called `chimaera` that can be used as follows:

```sh
chimaera /path/to/data.txt
```

It accepts different arguments, read the help for a full description:

```console
usage: chimaera [-h] [--output-path OUTPUT_PATH]
                [--min-clone-size MIN_CLONE_SIZE]
                [--clone-analyzer CLONE_ANALYZER] [--input-sep SEP]
                [--allele-cn-lb DELTA_LB] [--allele-cn-ub DELTA_UB]
                [--log-file LOG_FILE] [--version]
                input_file

Run chimaera to estimate clonal composition of a tumor using multiple biosies
from a single patient.

positional arguments:
  input_file            File containing mutations data in tabular format. It
                        needs an header including VAF and CN fields(case-
                        insensitive) together with a sample-id, e.g.: id1-VAF
                        id1-CN ... idn-VAF idn-CN. An index containing the
                        mutations id is also required.

optional arguments:
  -h, --help            show this help message and exit
  --output-path OUTPUT_PATH
                        Path to directory where chimaera results should be
                        saved. If not passed it will print the output to
                        stdout (it can be used for piping commands).
  --min-clone-size MIN_CLONE_SIZE
                        Minimum number of mutations needed to consider a
                        clone. Default to 5.
  --clone-analyzer CLONE_ANALYZER
                        Clone analyzer used for optimizing clone frequencies.
                        Default to random. If robust is used it gives stable
                        estimates accross multiple run. Method random does not
                        underestimate frequencies but results are less
                        repeatable (~0.05-0.1 variability accross runs in
                        frequency estimates).
  --input-sep SEP       Field separator for input_file. Default to tab.
  --allele-cn-lb DELTA_LB
                        Allele copy number lower bound. Default to 0.0.
  --allele-cn-ub DELTA_UB
                        Allele copy number upper bound. Default to 4.0.
  --log-file LOG_FILE   File for logging chimaera output. Unless specified no
                        logging of chimaera execution is produced.
  --version, -v         chimaera version
```

## Example

See the file `data/exome_sample_data.txt` for an example of the input format.
Run the example:

```sh
chimaera data/exome_sample_data.txt
```

## web service deprecation

The Chimaera web-service has been deprecated in favour of the python package hosted in this repository.
Please check the examples to use Chimaera in your research.

repository: drugilsberg/chimaera

gha_language: Python

repo_name: drugilsberg/chimaera


text:
# About $DALLAF (deleteAllAnswersFor) _(New Project 3 Command)_

This command lets instructors remove all answers for a question in the #q-and-a channel.
Deletes all answers for a question. Instructor only.

## Changes

This command was introduced by [CSC510-Group-25](https://github.com/CSC510-Group-25/ClassMateBot/).

# Location of Code
The code that implements the above mentioned functionality is located in [cogs/qanda.py](https://github.com/CSC510-Group-25/ClassMateBot/blob/main/cogs/qanda.py).

# Code Description
## Functions
deleteAllAnsFor(self, ctx, num):

This function takes as arguments the values provided by the constructor through self, context in which the command was called, and the number of the question to delete answers for.

# How to run it? (Small Example)
You are in the server that has the Classmate Bot active and online. You go to
the #q-and-a channel and enter the command `$DALLAF <q_num>`.

Before deletion, archive the question and its answers with
`$getAnswersFor QUESTION_NUMBER`

Or, if it's a ghost or zombie:
`$channelGhost QUESTION_NUMBER`

```
$DALLAF <q_num>
$DALLAF 7
```

Successful execution of this command will delete all answers for the question on the channel and in the database,

and DM the user the number of answers that were deleted.

branch_name: refs/heads/main


text:
# shatterednippon
A complete overhaul to Europa Universalis IV in which feudal Japan replaces the original map by Curious and StabShot.

## Checklist
### [/map/](https://github.com/CuriouslyCurious/shatterednippon/blob/master/MAP.md)

![alt tag](https://raw.githubusercontent.com/CuriouslyCurious/shatterednippon/master/shatterednippon/map/provinces.bmp)

This mod is modeled after the excellent (but somewhat laggy) ShatteredEuropa, as such it does not strive to be historically accurate. All it is is a fun and interesting map for everyone to play BlobSimulator [CURRENT_YEAR] on. ;)

Primarly designed for SwedditUniversalis' multiplayer sessions.

This repo holds some useful scripts for mod making as well.

Idea by: StabShot

repository: CuriouslyCurious/shatterednippon

repo_name: CuriouslyCurious/shatterednippon


text:
# How to aggregate an array of objects based on object property?

Source: [StackOverflow.com](http://stackoverflow.com/questions/15441272/in-an-array-of-objects-how-can-i-aggregate-based-on-object-property/27657206#27657206)

### Question
There is the following array of objects:
```js
    dataArray = [
      { id: "a", score: 1 },
      { id: "b", score: 2 },
      { id: "c", score: 5 },
      ...
      { id: "a", score: 3 },
      ...
      { id: "c", score: 2},
      ...
     ]
```
How can I obtain a resultArray like the following:
```js
    resultArray = [
      { id: "a", score: sum of all the scores when id is a },
      { id: "b", score: sum of all the scores when id is b },
      ...
      ...
    ]
```

### Answer

You can do it in one line with AlaSQL library. See the example [in jsFiddle](http://jsfiddle.net/agershun/k4hkbm53/1/).
```js
        var dataArray = [ { id: "a", score: 1 }, { id: "b", score: 2 }, { id: "c", score: 5 },
                          { id: "a", score: 3 }, { id: "c", score: 2}, ];

        var res = alasql('SELECT id, SUM(score) AS score FROM ? GROUP BY id',[dataArray ]);
```

license: MS-PL,MIT

detected_licenses: MS-PL MIT


text:
# GodotSand
A basic falling sand game implementation for Godot in C#

This could be used as a template for anyone who wants to implement something similar in their own Godot game.

Current version is very simple, supports only sand, water and wall pixel types, and no special optimizations.
I am not planning to develop this further, as this was just a tiny test project to understand how this type of games is implemented.

The implementation is using a single `Sprite`, for which a reference to its `Image` is stored.
The painting is done using `set_pixel` method on the `Image`. I've tried using GDScript (Godot 3.2), but the performance was very poor
for some reason, even in an extremely simple example. For this reason I am using C# here, which results in a much better performance. That being said,
I don't have much experience with C#, so the code may have some obvious common C# practices/style violations.

Some obvious next steps in further development could be:

* optimize the code by working with a `ByteArray` directly instead (I haven't tested if it boosts performance though)
* add dirty boxing (see the Noita talk in the [References](References))
* use a 2D grid of `Sprite`s, and process them in multiple threads, again, as in the Noita talk

# References

* [Noita](https://noitagame.com/) game and [Noita talk](https://www.youtube.com/watch?v=prXuyMCgbTc)
* [Sandspiel](https://sandspiel.club/), [Making Sandspiel](https://maxbittker.com/making-sandspiel/), and its [source code](https://github.com/MaxBittker/sandspiel)
* A more advanced Godot C# [implementation](https://www.reddit.com/r/godot/comments/f6s141/made_a_falling_sand_engine_for_my_alchemy_game/),
  unfortunately without the source code (although the author might share if you ask nicely?). The thread has a few pieces of advice though,
  and even a helpful comment on how to use GDNative.
* [Recreating Noita's Sand Simulation in C and OpenGL](https://www.youtube.com/watch?v=VLZjd_Y1gJ8)
* [WebGL Fluid simulation](https://github.com/PavelDoGreat/WebGL-Fluid-Simulation). Not directly connected, but could be used for nice visual effects (and is indeed used in Sandspiel to simulate the wind).
* [2D Liquid simulator with cellular automaton in Godot Engine](https://www.youtube.com/watch?v=nF7cdUVgvNc). A very interesting approach
  that also shows the amount of water in each "pixel", allowing for a smoother look.
* [How To Make a “Falling Sand” Style Water Simulation](https://w-shadow.com/blog/2009/09/29/falling-sand-style-water-simulation/)

repository: Boyquotes/GodotSand

repo_name: Boyquotes/GodotSand


text:
---
layout: reference
title: xmos_linux_tools
category: package
tags:
- XMOS
- audio
- flash firmware
---

## Overview
This package contains the tool used for flashing and verification of the
firmware on the XMOS (audio) device.

## Usage
```sh
sudo /opt/gizmo/env.sh $(catkin_find xmos_linux_tools xmos_updater) [--skip-check] [path]
```

#### `--skip-check`
Instructs the firmware flasher to force update the firmware and disregard the
version specified as the latest version

#### `path`
Path to the XMOS firmware binary to install. This defaults to
`/opt/gizmo/share/xmos_linux_tools/mayfield.bin`, the latest official release
of the XMOS firmware by Mayfield.

> NOTE: On upstart, Kuri checks that the XMOS firmware is the latest available,
and installs the latest version if it is not currently installed. If you flash
a new version of firmware to the XMOS device, it may be overwritten on the
next boot. To prevent this, update the version string in `update_check` of
`/opt/gizmo/lib/xmos_linux_tools/xmos_updater`, or disable the `xmos_updater`
script in the `xmos-fw` upstart job

repository: cjwilliams/Kuri-Documentation

repo_name: cjwilliams/Kuri-Documentation


text:
# CMDAwesomeButton

This is my button subclass. It is awesome.

It is powered by one method:

```objc
- (void)setValue:(id)value forKeyPath:(NSString *)keyPath state:(UIControlState)state;
```

This lets you set any value for any keypath for the given control state.

It also has convenience setters for a few common tasks:

```objc
- (void)setBackgroundColor:(UIColor *)color forState:(UIControlState)state;
- (void)setBorderColor:(UIColor *)color forState:(UIControlState)state;
- (void)setBorderWidth:(CGFloat)width forState:(UIControlState)state;
- (void)setCornerRadius:(CGFloat)radius forState:(UIControlState)state;
```

Awesome right?

There's also a handy `backgroundView` property. You can put whatever you want there. Let's say you have a gradient view. Do something like this:

```objc
CMDAwesomeButton *gradientButton = [CMDAwesomeButton new];

SAMgradientView *gradientView = [SAMGradientView new];
gradientView.backgroundColor = [UIColor clearColor];
gradientButton.backgroundView = gradientView;

[gradientButton setValue:@[
    [UIColor colorWithRed:0.145 green:0.769 blue:0.757 alpha:1.000],
    [UIColor colorWithRed:0.196 green:0.678 blue:0.800 alpha:1.000]
]<EMAIL_ADDRESS>state:UIControlStateNormal];
[gradientButton setValue:@[
    [UIColor colorWithRed:0.145 green:0.769 blue:0.757 alpha:0.5],
    [UIColor colorWithRed:0.196 green:0.678 blue:0.800 alpha:0.5]
]<EMAIL_ADDRESS>state:UIControlStateHighlighted];
```

Boom. ([SAMGradientView](https://github.com/soffes/SAMGradientView) is great. I use it in all my apps.)

If you would like more convenience setters feel free to send me a pull request!

repository: calebd/CMDAwesomeButton

extension: markdown

gha_language: Objective-C

repo_name: calebd/CMDAwesomeButton


text:
# README file for WEEK 3: ENABLING THE TRANSACTIONAL BEHAVIOR OF AN APP
In week 3, you are going to enable the transactional handling in the UI service of the SAP Fiori elements-based Travel List Report app
built in [week 2](/week2/README.md).

# HANDS-ON EXERCISES
The information on the hands-on exercises for week 3 will be made available in a timely manner.

## License
Copyright (c) 2020 SAP SE or an SAP affiliate company. All rights reserved. This file is licensed under the Apache Software License, version 2.0 except as noted otherwise in the [LICENSE](LICENSES/Apache-2.0.txt) file.

repository: AlexAnth/abap-platform-rap-opensap

repo_name: AlexAnth/abap-platform-rap-opensap


text:
---
layout: default
---

# 1998-11-04 - 100S OF FREE PICS'N'LINKS EVERY DAY!

## Header Data

From: STUFFED WED NOV 4<EMAIL_ADDRESS>To: (OVER 100 FREE PICS DAILY!)

Message Hash: b8b39812e9834f42ccdb593767418c177fda35c62cb7b7a43269e1f4ad154ad3

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1998-11-04 09:15:59 UTC

Raw Date: Wed, 4 Nov 1998 01:15:59 -0800 (PST)

## Raw message

```
{% raw  %}From: STUFFED WED NOV 4<EMAIL_ADDRESS>Date: Wed, 4 Nov 1998 01:15:59 -0800 (PST)
To: (OVER 100 FREE PICS DAILY!)
Subject: 100S OF FREE PICS'N'LINKS EVERY DAY!
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

+ 30 SUPERB, HI-RES, HOT PHOTOS
+ 5 SUPER SEXY STORIES
+ BIG BEAR AMAZING PICS
+ SWEBABES
+ YVONNE'S ASIAN GIRLS
+ HOTT SHOTTS
+ MISGUIDED
+ CHEERLEADER SQUAD
+ THE BRASS ASS
+ CUM CATCHERS
+ XXX VAGINAS
+ PORNCLIPS
+ BONUS PIC 1 -> http://www.stuffed.net/home/14164.htm
+ BONUS PIC 2 -> http://www.stuffed.net/home/12417.htm
+ BONUS PIC 3 -> http://www.stuffed.net/home/10249.htm
+ BONUS PIC 4 -> http://www.stuffed.net/home/9906.htm
+ BONUS PIC 5 -> http://www.stuffed.net/home/10016.htm
+ MUCH, MUCH MORE!

       ---->   http://stuffed.net/home/   <----

If you haven't visited STUFFED in the last few days,  you're
in for a real treat.  It's faster than  ever before and now,
as a subscriber,  you get 35 FREE new pics  every day,  plus
over 100 more at carefully selected FREE sites we link to.

This  email  is  never  sent  unsolicited.  Stuffed  is  the
supplement for the Eureka newsletter you subscribed to. Full
instructions on unsubscribing  are in every issue of Eureka!

       ---->   http://stuffed.net/home/   <----

{% endraw %}
```

## Thread

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

+ Return to "[STUFFED WED NOV 4 <stuffed@stuffed.net>](/authors/stuffed_wed_nov_4_stuffed_at_stuffed_net_)"

+ 1998-11-04 (Wed, 4 Nov 1998 01:15:59 -0800 (PST)) - 100S OF FREE PICS'N'LINKS EVERY DAY! - _STUFFED WED NOV 4<EMAIL_ADDRESS>


text:
# Sofya: a Theme for Hugo

A minimalist theme for Hugo (static site generator).

See a [working example here](https://jonathondilworth.github.io/sofya-example/).

## Motivation

I was unable to find a theme that incompassed all of the design elements that I wanted for my blog, so I created my own. I was, however, inspired by the following designs:

* http://hbpasti.github.io/heather-hugo/
* http://motherfuckingwebsite.com/
* http://bettermotherfuckingwebsite.com/
* http://lessmade.com/themes/less/
* http://www.goldsborough.me/

Some of the base styles have been lifted from: http://hbpasti.github.io/heather-hugo/

## Installation

To get started with this theme, create a new hugo site:

```
hugo new site helloworld
```

Navigate to the themes directory:

```
cd helloworld/themes
```

Clone in (or download & extract) the theme:

```
git clone https://github.com/jonathondilworth/sofya.git
```

Update the theme parameter within the site's config.toml:

```
theme = "sofya"
```

Here is an example config.toml file:

```
title = "My Blog"
languageCode = "en-us"
theme = "sofya"
baseURL = "https://jonathondilworth.github.io/sofya-example/"

[author]
  name = "Jonathon Dilworth"
  homepage = "http://jonathondilworth.github.io/sofya-example/"

[params]
  desc = "Example Desc"
  displaymenu = true
  twitter = "https://twitter.com/"
  github = "https://github.com/"
  quora = "https://www.quora.com/"
  linkedin = "https://linkedin.com/"
  stackoverflow = "http://stackoverflow.com/"

[[menu.main]]
    name = "home"
    pre = ""
    weight = -110
    identifier = "home"
    url = "/"

[[menu.main]]
    name = "about"
    pre = ""
    weight = -100
    identifier = "about"
    url = "/about/"
```

## Notes

You can achieve syntax highlighting through using [pygments](http://pygments.org/), as explained [here](https://gohugo.io/extras/highlighting/).

## Feature Roadmap:
* ~~Social Media Links.~~
* ~~Responsive site / media queries.~~
* ~~Dynamic pages to populate nav bar.~~
* Taxonomies / tags.
* MathJax.
* Comments for posts (disqus).
* Gravatar integration on about page.

## License

MIT License http://opensource.org/licenses/MIT

repository: SpHit/Static-WebSite

gha_language: CSS

repo_name: SpHit/Static-WebSite


text:
music-nga
=========

Experiments in re-building the FxOS Music app using NGA

To set up development environment, clone this repo then run:
- `npm install`
- `bower install`

You may also occassionally need to run `bower update` to fetch the latest dependencies.

To run on Firefox OS device:
- Ensure "USB Debugging" is set to "ADB+DevTools" in "Settings" > "Developer"
- Open "WebIDE" in Firefox desktop
- Select your device from the right-hand "Runtime" menu
- Select "Open App" from the left-hand menu and choose "Open Packaged App..."
- Browse to the root folder of this repo
- Press "Run" to push to the device

Note: Be sure to "Request Higher Permissions" under "Runtime Info" for your device and set `dom.serviceWorkers.enabled` to `true` under "Device Preferences" before running the app.

Running a local web server for development:
- Install [nws](https://www.npmjs.com/package/nws)
  + `npm install -g nws`
- From this repo's root directory, run `nws` (automatically serves up this app from HTTP port 3030)

To run on Firefox desktop (Developer Edition *RECOMMENDED*):
- Check "Enable multi-process Firefox" in `about:preferences` > "General"
- Set `dom.webcomponents.enabled` to `true` in `about:config`
- Copy some music files into `./media` and update the DeviceStorage shim to reflect the names of the files you copied
  + https://github.com/justindarc/music-nga/blob/master/js/shims/device-storage.js#L9
- Browse to `http://localhost:3030`

If you encounter any problems (e.g. HTTP 404 errors, crashes, etc.), try running Firefox with a fresh profile:
- [Use the Profile Manager to create and remove Firefox profiles](https://support.mozilla.org/en-US/kb/profile-manager-create-and-remove-firefox-profiles)
- Try Firefox Developer Edition instead of Nightly for improved stability between builds

Note: You may occassionally need to clear your history to flush out the cache or go to `about:serviceworkers` to "Unregister" the Service Worker.

repository: justindarc/music-nga

gha_language: JavaScript

repo_name: justindarc/music-nga


text:
Tyme [![Build Status](https://travis-ci.org/doc75/tyme.svg?branch=master)](https://travis-ci.org/doc75/tyme)
=======

# Tyme

This gem allows to extract information from the `last` command in GNU/Linux system and store the result in a yaml file. For each users it stores the logged-in duration per day.
By default is stores the result in `/var/lib/tyme/db.yml` (so you have to run it as root).
The file is updated with new date and existing dates are overwritten.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'tyme'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install tyme

## Usage

Either you can launch as root:

```ruby
bin/tyme
```

Or you can use it in your own script:

```ruby
require 'tyme'

manager = Tyme::Manager.new('path/to/db.yml')
manager.run
```

## Development

After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/doc75/tyme.

## License

The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).


text:
# Getting Started

**This is the legacy guide that uses Clover and requires the user to manually set up the settings. It is recommended that everyone use the new guide with the automated installer. These pages are retained here for historical and educational purposes.**

### Prerequisites

* A Mac or another Hackintosh to prepare the installer
* USB flash drive with at least 16GB of storage
* [BIOS settings](../installation-guide/bios-settings.md)

{% hint style="info" %}
Please note that OSX software license prohibits running it on non-Apple hardware.
{% endhint %}

### Drivers

We will use a variety of drivers \(KEXTs\) to get all devices to work. Do not add any other KEXT such as WhateverGreen \(it does nothing for us as IGPU is disabled\) or UsbInjectAll \(we use a custom SSDT\).

* [FakeSMC](https://github.com/RehabMan/OS-X-FakeSMC-kozlek): required for all PCs to masquerade as a Macintosh
* [IntelMausiEthernet](https://github.com/Mieze/IntelMausiEthernet): driver for the first ethernet port \(I219-LM\)
* [SmallTreeIntel](https://www.small-tree.com/support/download_category?cat_id=5): driver for the second ethernet port \(I210-at\), must be patched
* [AppleALC](https://github.com/osy86/AppleALC): audio driver patches
* [Polaris22Fixup](https://github.com/osy86/Polaris22Fixup): fix graphics issues for Vega M
* [Lilu](https://github.com/acidanthera/Lilu): kernel patching framework used by AppleALC
* OldX4000HWLibs: macOS 10.14.5 broke Vega M support, so we load a patched version from 10.14.5 beta 1 instead

All of the above are pre-built as part of the [HaC Mini release](https://github.com/osy86/HaC-Mini/releases) \(use version v1.x for legacy Clover\).

{% hint style="warning" %}
We will be doing a clean installation. That means the SSD will be wiped and **any existing data will be lost**. If you plan to boot Windows and/or Linux, it is advised that you install those systems after OSX.
{% endhint %}

repository: osy/HaC-Mini

gha_language: ASL

repo_name: osy/HaC-Mini


text:
---
layout: page
title: Privacy Policy
include_in_header: false
---

# Look Busy Privacy Policy

Last Updated May 27, 2019

This Privacy Policy ("Policy") describes how AGB Consulting Group (“Look Busy” or "this application" or “we” or “our” or “us”) collects, stores, shares, and uses information, and your choices about privacy when you use our website, products, and services (collectively, “Services”). By accessing or using our Services in any way, you agree that your information may be collected, stored, shared, and used as described in this Policy and our Terms of Use.

## When This Policy Applies

This Policy applies to all of our Services, regardless of how you use them. This Policy does not apply to any entity that we do not own or control, or to any person that we do not employ or manage. If, at any time during the course of using our Services, you are directed to a third-party site, you understand and agree that the policies of the third-party site govern.

> For example, if you use this app to create a calendar event on your iCloud calendar, Apple's iCloud privacy policy will apply to that data.

## Information We Process

We collect information you provide via iOS, such as:

- which language your device is set to
- which calendars are currently configured
- which calendars can be written to
- preexisting events on these calendars (to avoid conflicts)

We might also collect your contact information, for example if you contact us directly.

## How we use this information

- to provide our Services to you, including new Services we develop later (reason: legitimate business purpose and performance of a contract);
- to provide you with customer support (reason: legitimate business purpose);
- to comply with our legal obligations, resolve disputes, or enforce our Terms of Use or any other policies or agreements with Users (reason: compliance with a legal obligation);

## Who do we share personal info with?

Unless you contact us, we don't have access to your personal contact information.

Calendar information is shared through iOS, potentially to third parties like iCloud, Google Calendar, and Outlook, depending on which calendars you have set up on your device.

We may access, preserve, and disclose your Personal Information and/or other information if we believe that such access, preservation or disclosure is reasonably necessary to: (i) comply with any law, regulation, legal process or governmental request (such as search warrants, subpoenas or court orders), which may include responding to legal requests from jurisdictions outside the United States; (ii) enforce our Terms of Use or our other policies or agreements with Users, or investigate potential violations; (iii) detect, prevent or otherwise address fraud, security or technical issues; (iv) protect or enforce the rights or property of Artsy, you, or any other person or entity; or (v) prevent physical harm to any person, including situations involving possible violence or self-harm.

We never sell or otherwise share your personal information, even in aggregate.

## What about children?

Children don't usually maintain complex calendars, and our Services are not directed to children under the age of 13, and we do not knowingly collect Personal Information from people in this age group. If you believe we may have collected Personal Information from anyone under the age of 13, please contact us.

## Accessing or correcting your Personal Information

We will honor any statutory right you may have to access or correct your Personal Information that we have in our records, and you can email such requests to<EMAIL_ADDRESS>Once we receive your request, we will let you know if an administrative fee will apply to fulfill your request, as permitted by applicable law. However, please note that even if you have a legal right to request access to information or to correct information, as permitted by applicable law, we may reject requests that are unreasonably repetitive, would require disproportionate technical effort (for example, developing a new system or materially changing an existing practice), would jeopardize the privacy of others, or would be extremely impractical to fulfill (for example, requests to access information located on backup systems).

## Contact Info

Contact<EMAIL_ADDRESS>if you have questions.

repository: getaaron/lookbusy

repo_name: getaaron/lookbusy


text:
# mongo-data-seeder

A command line application that automatically seeds a MongoDB database with random data.
- [mongo-data-seeder](#mongo-data-seeder)
  - [Structure of Random Data](#structure-of-random-data)
  - [Installation](#installation)
  - [Testing](#testing)
  - [Using `mongo-data-seeder` as a Command Line Utility](#using-mongo-data-seeder-as-a-command-line-utility)
  - [Running as a Docker Container](#running-as-a-docker-container)

## Structure of Random Data

The structure of the document that will be stored in the MongoDB database is:

* firstName: `string`
* lastName: `string`
* email: `string`
* phone: `string`
* dob: `Date`
* created: `Date`

## Installation

To install the dependency packages for `mongo-data-seeder` and the [Typescript compiler](https://www.typescriptlang.org/docs/handbook/compiler-options.html) (`tsc`) execute the following command:

`sudo npm run build`

## Testing

To run the test you need either an instance of MongoDB running on your local computer or an access to an instance of MongoDB running in the cloud, for example on [MongoDB Atlas](https://cloud.mongodb.com/).

**IMPORTANT!!!**  If you're testing by running against an external instance of MongoDB, you need to tell `seeder` the location of the remote instance as well as the credentials required to access it. You do this by adding the required information as a URL attached to the environment variable, `MONGODB_URL`.

You can put the environment variable information in a `.env` file. That `.env` file needs to be at the root of the project file system.

The following is an example of using the `echo` command to inject the environment variable and value into the file, `.env`.

```
 echo<EMAIL_ADDRESS>> .env
```

To verify that `MONGODB_URL` has been injected into the file, `.env`, execute the following command:

`cat .env`

Once database access is implemented, either locally or on the cloud, run the following command:

`npm test`

You'll get output similar to the following:

```
><EMAIL_ADDRESS>test /home/reselbob/mongo-data-seeder
> mocha -r ts-node/register src/tests/test.ts --exit

  WriteDataManager Tests
<EMAIL_ADDRESS>{
  mongoDbUrl<EMAIL_ADDRESS>}
Starting seeding for 10 orders at Sun Aug 08 2021 16:36:57 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100829c10c171862d48663","created":"2021-08-08T16:36:57.296Z","firstName":"Lincoln","lastName":"Swift","email":"Lincoln.Swift@ciara.net","phone":"(468) 591-3864 x338","dob":"1951-06-29T17:34:47.122Z","__v":0}  at Sun Aug 08 2021 16:36:57 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100829c10c171862d48666","created":"2021-08-08T16:36:57.444Z","firstName":"Kristoffer","lastName":"Kertzmann","email":"Kristoffer.Kertzmann@ebba.com","phone":"1-750-772-3476","dob":"1970-05-16T16:13:56.655Z","__v":0}  at Sun Aug 08 2021 16:36:57 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100829c10c171862d48668","created":"2021-08-08T16:36:57.511Z","firstName":"Bart","lastName":"Friesen","email":"Bart.Friesen@gus.net","phone":"343.716.0861 x085","dob":"1989-10-05T12:47:47.040Z","__v":0}  at Sun Aug 08 2021 16:36:57 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100829c10c171862d4866a","created":"2021-08-08T16:36:57.583Z","firstName":"Nestor","lastName":"Gottlieb","email":"Nestor.Gottlieb@rozella.net","phone":"791-478-2099 x25440","dob":"1970-06-29T04:46:19.344Z","__v":0}  at Sun Aug 08 2021 16:36:57 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100829c10c171862d4866c","created":"2021-08-08T16:36:57.658Z","firstName":"Tiana","lastName":"Murphy","email":"Tiana.Murphy@karianne.org","phone":"709-595-2210 x83899","dob":"1974-10-06T14:25:39.144Z","__v":0}  at Sun Aug 08 2021 16:36:57 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100829c10c171862d4866e","created":"2021-08-08T16:36:57.729Z","firstName":"Kamille","lastName":"Harris","email":"Kamille.Harris@lavon.org","phone":"1-879-693-2518","dob":"1951-12-28T23:27:17.305Z","__v":0}  at Sun Aug 08 2021 16:36:57 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100829c10c171862d48670","created":"2021-08-08T16:36:57.805Z","firstName":"Willy","lastName":"Labadie","email":"Willy.Labadie@marina.biz","phone":"(297) 268-9280","dob":"1961-05-18T20:49:50.702Z","__v":0}  at Sun Aug 08 2021 16:36:57 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100829c10c171862d48672","created":"2021-08-08T16:36:57.876Z","firstName":"Betsy","lastName":"Schroeder","email":"Betsy.Schroeder@felipa.com","phone":"946-786-1146 x691","dob":"1970-11-12T14:55:05.712Z","__v":0}  at Sun Aug 08 2021 16:36:57 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100829c10c171862d48674","created":"2021-08-08T16:36:57.943Z","firstName":"Nicolas","lastName":"Parker","email":"Nicolas.Parker@tanya.com","phone":"1-530-690-2408","dob":"1999-07-31T21:56:04.374Z","__v":0}  at Sun Aug 08 2021 16:36:58 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"6110082ac10c171862d48676","created":"2021-08-08T16:36:58.012Z","firstName":"Ivory","lastName":"Mertz","email":"Ivory.Mertz@aniyah.info","phone":"(513) 800-2332 x87494","dob":"1961-04-07T13:07:59.853Z","__v":0}  at Sun Aug 08 2021 16:36:58 GMT+0000 (Coordinated Universal Time)

Finished seeding at Sun Aug 08 2021 16:36:58 GMT+0000 (Coordinated Universal Time)
    ✔ Can seed (1534ms)

  1 passing (2s)

```

## Using `mongo-data-seeder` as a Command Line Utility

To get the `mongo-data-seeder` running as a command line utility, run the following command as `sudo`:

`sudo npm run deploy`

It will take a minute or two for the utility to install. The utility's name is `seeder`. When the installation process is finished you'll see the `--help` output as follows:

```
Usage: index.ts - m <MongoDB_CONNECTION_URL> (optional) -r <ROWS_OF_RANDOM_DATA> (optional) -c <MONGODB_DATABASE_NAME> (optional)

Options:
  -u, --url-mongodb    The URL representing a connection string to a remote instance of MongoDB. Defaults to mongodb://localhost:27017/.  [string]
  -r, --rows           The  number of rows of random data to inject into the MongoDB database. Defaults to 10.  [string]
  -d, --database-name  The name of the database in which to store the random data. Defaults to seeder.  [string]
  -h, --help           Show help  [boolean]
  -v, --version        Show version number  [boolean]

copyright 2021

```

Now you can use `seeder` as a command line utility.

The following is an example of using `seeder` to randomly generate data to a fictitious remote MongoDB database at<EMAIL_ADDRESS>
```
seeder -u<EMAIL_ADDRESS>```

You'll get results similar to the following:

----

```
Hi from MongoDB Data Seeder at Sun Aug 08 2021 16:16:16 GMT+0000 (Coordinated Universal Time)

Looks like you want to connect to MongoDB using: mongodb+srv://cooluser:9EI0O0xxxxxxRR11<EMAIL_ADDRESS>

Strike your <enter> key to continue. Type 'n' to abort.

Connecting to MongoDB at mongodb+srv://cooluser:9EI0O0xxxxxxRR11<EMAIL_ADDRESS>and creating 10 rows of random data at Sun Aug 08 2021 16:16:21 GMT+0000 (Coordinated Universal Time)
{
  mongoDbUrl: 'mongodb+srv://cooluser:9EI0O0xxxxxxRR11<EMAIL_ADDRESS>}
Starting seeding for 10 orders at Sun Aug 08 2021 16:16:22 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100356f4876017e91e0ed3","created":"2021-08-08T16:16:22.234Z","firstName":"Shanon","lastName":"Hessel","email":"Shanon.Hessel@brock.com","phone":"531.928.3642 x717","dob":"1965-05-12T16:00:56.240Z","__v":0}  at Sun Aug 08 2021 16:16:22 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100356f4876017e91e0ed6","created":"2021-08-08T16:16:22.339Z","firstName":"Mike","lastName":"Gerlach","email":"Mike.Gerlach@melissa.name","phone":"1-466-619-4417 x50381","dob":"1980-12-06T07:26:37.081Z","__v":0}  at Sun Aug 08 2021 16:16:22 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100356f4876017e91e0ed8","created":"2021-08-08T16:16:22.386Z","firstName":"Royce","lastName":"Beier","email":"Royce.Beier@stan.com","phone":"(972) 294-1666","dob":"1966-06-08T22:43:23.220Z","__v":0}  at Sun Aug 08 2021 16:16:22 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100356f4876017e91e0eda","created":"2021-08-08T16:16:22.430Z","firstName":"Jorge","lastName":"Stamm","email":"Jorge.Stamm@shane.name","phone":"(769) 901-7518 x46408","dob":"1985-11-16T12:30:01.523Z","__v":0}  at Sun Aug 08 2021 16:16:22 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100356f4876017e91e0edc","created":"2021-08-08T16:16:22.473Z","firstName":"Angeline","lastName":"Gislason","email":"Angeline.Gislason@zane.biz","phone":"1-947-201-8081","dob":"1953-08-15T07:18:01.263Z","__v":0}  at Sun Aug 08 2021 16:16:22 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100356f4876017e91e0ede","created":"2021-08-08T16:16:22.517Z","firstName":"Evangeline","lastName":"Bogisich","email":"Evangeline.Bogisich@wilburn.net","phone":"(479) 226-9127","dob":"1956-08-13T16:39:33.890Z","__v":0}  at Sun Aug 08 2021 16:16:22 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100356f4876017e91e0ee0","created":"2021-08-08T16:16:22.570Z","firstName":"Jennyfer","lastName":"Dach","email":"Jennyfer.Dach@ally.name","phone":"1-317-936-9035 x3683","dob":"1964-12-30T07:44:47.926Z","__v":0}  at Sun Aug 08 2021 16:16:22 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100356f4876017e91e0ee2","created":"2021-08-08T16:16:22.617Z","firstName":"Dorcas","lastName":"Marks","email":"Dorcas.Marks@karolann.com","phone":"1-319-465-6028 x80831","dob":"1967-11-12T16:23:36.482Z","__v":0}  at Sun Aug 08 2021 16:16:22 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100356f4876017e91e0ee4","created":"2021-08-08T16:16:22.693Z","firstName":"Fred","lastName":"Treutel","email":"Fred.Treutel@ludie.net","phone":"821.412.9112 x6532","dob":"1993-04-08T07:49:09.898Z","__v":0}  at Sun Aug 08 2021 16:16:22 GMT+0000 (Coordinated Universal Time)
Seeded {"_id":"61100356f4876017e91e0ee6","created":"2021-08-08T16:16:22.742Z","firstName":"Brannon","lastName":"Jacobs","email":"Brannon.Jacobs@prudence.info","phone":"(366) 342-7919 x048","dob":"1992-06-19T00:03:11.883Z","__v":0}  at Sun Aug 08 2021 16:16:22 GMT+0000 (Coordinated Universal Time)

Finished seeding at Sun Aug 08 2021 16:16:22 GMT+0000 (Coordinated Universal Time)
Seeder created 10 rows of random data Sun Aug 08 2021 16:16:22 GMT+0000 (Coordinated Universal Time)

```

----

## Running as a Docker Container

To run `mongo-data-seeder` from within a Docker container, take the following steps:

**Step 1:** Clone the source code for this project into your development environment:

`git clone https://github.com/reselbob/mongo-data-seeder.git`

**Step 2:** Go to the source code directory.

`cd mongo-data-seeder`

**Step 3:** Build the Docker image, which will be named, `seeder`:

`docker build -t seeder .`

**Step 4:** Create a container using the Docker image named, `seeder`. Run the container so that you can access the source code working directory from a command line within the container. The name of the container will be `myseeder`.

Execute the following command to execute the tasks described above:

`docker run --name myseeder --rm -ti  seeder /bin/bash`

You'll get output similar to the following:

`root@c898ded1dad7:/app#`

**Step 5:** Deploy `seeder` at the container's command line by executing the following command:

`npm run deploy`

You'll get output similar to the following:

```
.
.
.
Options:
  -u, --url-mongodb    The URL representing a connection string to a remote instance of MongoDB. Defaults to mongodb://localhost:27017/.  [string]
  -r, --rows           The  number of rows of random data to inject into the MongoDB database. Defaults to 10.  [string]
  -d, --database-name  The name of the database in which to store the random data. Defaults to seeder.  [string]
  -h, --help           Show help  [boolean]
  -v, --version        Show version number  [boolean]

copyright 2021
```

You can now enter a `seeder` command similar to the following to inject random data into the fictitious MongoDB database found at<EMAIL_ADDRESS>:

`seeder -u<EMAIL_ADDRESS>
**Step 6:** To exit the container and delete it from your development environment, type ...

`exit`

... at the container's command line.

**Step 7:** To removed Docker image, `seeder` from your development environment, type:

`docker image rm -f seeder`

repository: reselbob/mongo-data-seeder

repo_name: reselbob/mongo-data-seeder


text:
---
date: 2017-10-22T11:58:02-04:00
title: "Hello World"
seo_title: "Hello World | Python | GOUP"
subheader:
     greeting: Python - Programming Language
     description: This course covers the basics of programming in Python. Work your way through the videos/articles and I'll teach you everything you need to know to start your programming journey!
description: This tutorial covers hello world in Python.
author: GOUP
image: hello-world.png
video: yuc3RQ5a6Jg
url: /programming-languages/python/hello-world/
weight: 3
---

## Code

{{< code lang="py" >}}
print("Hello")
print("World")
print("!")
{{< /code >}}

gha_language: HTML


text:
---
layout: post
title: A little bit of cleaning
categories:
- Dev Diary
tags:
- clean
- cleaning
- gibson
- github
- libgibsonclient
- order
- phpgibson
- repositories
- repository
status: publish
type: post
published: true
---

Yesterday i've performed a little bit of cleaning in the repository, it was a mess with everyhing mixed up.
Now [gibson](http://github.com/evilsocket/gibson) ( the main server ), [libgibsonclient](http://github.com/evilsocket/libgibsonclient) ( the native client library ) and [phpgibson](http://github.com/evilsocket/phpgibson) ( the PHP5 extension ) have their own repositories.
The folder structure of the main repository has been cleaned up a little too.


text:
# Wide World Travel Guides

**You need to complete steps 1-4 before this one**

## Include Routing

* Selecting a guide will display it in a new view (page).

```jsx
<Link to={`${match.url}/${id}`}>{title}</Link>
```

* Incorporate `react-router-dom` to view the individual guides.
* Include a "Show Guides" button

```jsx
<Route exact path="/" component={Guides} />
<Route path="/guides/:id" component={OneGuide} />
```

**Pro-tip**
* Remember to add "keys" to your looped items. React needs a unique value when rendering dynamic data.

```
import {
  BrowserRouter as Router,
  Route,
  Link,
  Switch,
  Redirect
} from 'react-router-dom'
```

## Great Walk-through
* Reference: https://tylermcginnis.com/react-router-nested-routes/

repository: sjkimball/ux-developer-milestones

repo_name: sjkimball/ux-developer-milestones


text:
---
title: "Installing a HP Officejet 4500 Network Printer in Ubuntu"
date: "2010-10-12"
tags:
  - "4500"
  - "hp"
  - "hplip"
  - "officejet"
  - "ubuntu"
---

Download the latest version of HPLIP from [http://sourceforge.net/projects/hplip/files/](http://sourceforge.net/projects/hplip/files/) (forget the ubuntu standard repository)

Preferably set the printer to a static IP (using the small display and some tiresome typing)

Install the following packages:

> python-qt4 python-qt4-dbus libsnmp-dev libsane-dev libcups2-dev libusb-dev python-dev

Run the _hplip-x.xx.xx.run_ from the commandline. Choose the automatic install option.

When the installation is complete and the automatic configuration window pops up, set it to pick up the ip address of the printer (I think you have to click the "_advanced_" button for that). Click "_next_" till you are done.

The system administration "Printing" option is junk for installing a HP printer, even if you give it the IP address or whatever. I think it is due to the difference in "Device URI" which in my case ought to be "_**hp:/net/Officejet\_4500\_G510g-m?ip=<IP_ADDRESS>**_"

repository: SyedMuhammedBilal/Gatsby-Blog-WebApp

repo_name: SyedMuhammedBilal/Gatsby-Blog-WebApp


text:
Visual Studio Setup PowerShell Module
=====================================

![build status: master](https://devdiv.visualstudio.com/DevDiv/_apis/build/status/Setup/Setup-VSSetup.PowerShell-CI?branchName=master&label=master)
![build status: develop](https://devdiv.visualstudio.com/DevDiv/_apis/build/status/Setup/Setup-VSSetup.PowerShell-CI?branchName=develop&label=develop)
[![github release](https://img.shields.io/github/release/Microsoft/VSSetup.PowerShell.svg?logo=github&logoColor=white)](https://github.com/Microsoft/VSSetup.PowerShell/releases/latest)
[![github releases: all](https://img.shields.io/github/downloads/Microsoft/VSSetup.PowerShell/total.svg?logo=github&logoColor=white&label=github)](https://github.com/Microsoft/VSSetup.PowerShell/releases)
[![PowerShell Gallery](https://img.shields.io/powershellgallery/dt/VSSetup.svg?logo=powershell&logoColor=white&label=gallery)](https://powershellgallery.com/packages/VSSetup)

This PowerShell module contains cmdlets to query instances of Visual Studio 2017 and newer. It also serves as a more useful sample of using the Setup Configuration APIs than the previously [published samples][samples] though those also have samples using VB and VC++.

## Installing

With Windows Management Framework 5.0 or newer (which installs PowerShell and comes with Windows 10), or [PowerShellGet][psget] for PowerShell 3.0 or 4.0, you can download and install this module easily.

```powershell
Install-Module VSSetup -Scope CurrentUser
```

To install for all users, pass `AllUsers` instead of `CurrentUser`, or just leave the `-Scope` parameter out of the command entirely.

You can also download the ZIP package from the [Releases][releases] page on this project site and extract to a directory named _VSSetup_ under a directory in your `$env:PSMODULEPATH`.

```powershell
Expand-Archive VSSetup.zip "$([Environment]::GetFolderPath("MyDocuments"))\WindowsPowerShell\Modules\VSSetup"
```

## Using

You can query all usable instances of Visual Studio and other products installed by the Visual Studio installer.

```powershell
Get-VSSetupInstance
```

To get the instance for a specific installation directory, you can run the following.

```powershell
Get-VSSetupInstance 'C:\Program Files (x86)\Microsoft Visual Studio\2017\Community'
```

If you want to select the latest instance that contains the .NET desktop development workload, you can pipe all instances - usable or not - to `Select-VSSetupInstance` that provides more fine grain control over which instances you enumerate.

```powershell
Get-VSSetupInstance -All | Select-VSSetupInstance -Require 'Microsoft.VisualStudio.Workload.ManagedDesktop' -Latest
```

## Feedback

To file issues or suggestions, please use the [Issues][issues] page for this project on GitHub.

## License

This project is licensed under the [MIT license](LICENSE.txt).

## Code of Conduct

This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode<EMAIL_ADDRESS>with any additional questions or comments.

  [issues]: https://github.com/Microsoft/vssetup.powershell/issues
  [psget]: http://go.microsoft.com/fwlink/?LinkID=746217
  [releases]: https://github.com/Microsoft/vssetup.powershell/releases
  [samples]: https://aka.ms/setup/configuration/samples

branch_name: refs/heads/develop

gha_language: C#


text:
# StereoHttp
Non Blocking Http Client implementation based on Apache NIO

Be sure to check out the docs
https://decoded4620.github.io/StereoHttp/docs/javadoc/

# Usage
The easest way is to create a `StereoHttpRequest` using a `StereoHttpRequest.Builder`, and then create a new `StereoHttpTask`, passing the request, and `StereoHttpClient` instance in for execution. This assumes that the url you hit returns JSON serialized data that can be Deserialized into the provided type, e.g. User in the example below.

e.g.
```java
 // timeout value
 private int timeout = 2000;
 // inject the client
 @Inject
 private StereoHttpClient httpClient;

 // Start the client (once)
 httpClient.start();

 // make requests with the same client (over and over)
 StereoHttpRequest.Builder<User> requestBuilder = new StereoHttpRequest.Builder<>(User.class)
        .setRequestMethod(RequestMethod.GET)
        .setHost("mywebsite-api.com")
        .setPort(80)
        .setRequestUri("/api/users/get?id=123");

// the task that will execute the request, and map the response.
StereoHttpTask<User> task = new StereoHttpTask<>(User.class, stereoHttpClient, timeout);
task.execute(requestBuilder.build());
```

gha_language: Java


text:
+++
draft = false
author = "theobutler"
description = "Sean T. Allen's recent PWL on Deny Capabilities for Safe, Fast Actors Talk is available. Microsoft's Project Verona is now open source."
categories = [
    "Last Week in Pony",
]
title = "Last Week in Pony - January 19, 2020"
date = "2020-01-19T10:50:42-05:00"
+++

Sean T. Allen's recent PWL on Deny Capabilities for Safe, Fast Actors Talk is available. Microsoft's Project Verona is now open source.
<!--more-->

## News and Blog Posts

- Sean T. Allen's recent Papers We Love talk on [Deny Capabilities for Safe, Fast Actors](https://www.ponylang.io/media/papers/fast-cheap.pdf) is now [available](https://www.seantallen.com/talks/deny-capabilities/).

- Microsoft's Project Verona is now open source and [on GitHub](https://github.com/microsoft/verona)! See the brief overview below, and take a look at [their documentation](https://github.com/microsoft/verona/blob/master/README.md).

## Project Verona

Verona is a research language for exploring a new programming model for concurrent ownership. The language and runtime are designed around data-race freedom, concurrent owners, and linear regions. In this model, concurrent mutation is given up in order to provide scalable memory management. This is achieved through immutable regions that may be shared or isolated regions that may have their ownership transferred. This transfer of isolated regions between concurrent owners is similar to sending objects with the `iso` capability in Pony. There is no restriction on topology within a region and an entire isolated region is collected when the owning reference is no longer reachable. Systematic testing is also embedded into the runtime, allowing developers to thoroughly test and debug concurrent algorithms.

Pony core team members are very excited to integrate some of the ideas from Verona into the Pony language and runtime. Verona, as a language, is in a very early stage of development and we encourage everyone to learn from it and keep an eye on how it develops.

---

_Last Week In Pony_ is a weekly blog post to catch you up on the latest news for the Pony programming language. To learn more about Pony check out [our website](https://ponylang.io), our Twitter account [@ponylang](https://twitter.com/ponylang), or our [Zulip community](https://ponylang.zulipchat.com).

Got something you think should be featured? There's a GitHub issue for that! Add a comment to the [open "Last Week in Pony" issue](https://github.com/ponylang/ponylang.github.io/issues?q=is%3Aissue+is%3Aopen+label%3Alast-week-in-pony).

Interested in making a change, or keeping up with changes to Pony? Check out the [RFC repo](https://github.com/ponylang/rfcs). Contributors welcome!

repository: kapilash/ponylang-website

repo_name: kapilash/ponylang-website


text:
# Simple Tetris

Simple Tetris clone

## Info

Implements wall kicks based on definitions at [Tetris Wiki](https://tetris.wiki/SRS)

Scoring, game speed and randomness of tetrominos is arbitary; ie: does not match any official implementation

## License

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

repository: LeeBurrows/SimpleTetris

repo_name: LeeBurrows/SimpleTetris


text:
---
layout: default
---

# 1997-11-04 - Pet Bog Crypto Ban

## Header Data

From: John Young<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 405c9695af2854443791ee9b299fba51bf9e39c089272b1aaa5724db8b7eae20

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1997-11-04 11:52:21 UTC

Raw Date: Tue, 4 Nov 1997 19:52:21 +0800

## Raw message

```
{% raw  %}From: John Young<EMAIL_ADDRESS>Date: Tue, 4 Nov 1997 19:52:21 +0800
To<EMAIL_ADDRESS>Subject: Pet Bog Crypto Ban
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

As a strategic bank shot for banning domestic use of encryption the
US FBI and Fish and Wildlife Service have declared the pet Bog
Snatch Algorithm a terrorist threat:

   http://jya.com/fws110497.txt  (134K)

B. Overutilization for Commercial, Recreational, Scientific, or
Educational Purposes

    The bog turtle is a target for pet collectors due to its rarity in
the wild, distinctive coloration, and small size. Take (primarily
illegal) both for the national and international commercial pet trade
industry has occurred for many years. Collecting is a significant
factor in the species decline and is an ongoing threat to its continued
existence in the wild (Anon. 1991; Earley 1993; David Flemming, U.S.
Fish and Wildlife Service, in litt. 1991; Herman 1990; Klemens in
press; Stearns et al. 1990; Tryon 1990; Tryon and Herman 1990). During
the last 5 to 10 years, an increasing number of bog turtles have been
advertised for sale, and prices have increased substantially. The
increase in price most likely reflects the increase in demand for the
turtles; the increase in demand increases the threats to the wild
populations (Tryon and Herman 1990).
    Atlanta Zoo personnel reported that from 1989 to early 1991, over
1000 bog turtles were exported to Japan. These figures differ
significantly from CITES data and represent a significant amount of
unreported illegal trade (Anon. 1991). The World Wildlife Fund recently
listed bog turtles as among the world's top 10 ``most wanted''
endangered species (Earley 1993). According to Alan Salzburg, President
of the American Turtle and Tortoise Society, the bog turtle is
considered the most prized turtle in the United States, and when bog
turtle locations become publicly known, they are exploited by
collectors within 1 year (Laura Hood, Defenders of Wildlife, in litt.
1997).
    Due to the threats facing bog turtle populations, the Society for
the Study of Amphibians and Reptiles adopted a resolution calling for
the prohibition of collection from wild populations (Stearns et al.
1990). Due to the small size of existing populations, and the low
reproductive and recruitment potential of this species, the removal of
even a few breeding adults can do irrevocable damage to a population
(Tryon 1990). Collecting has been a factor in the reduction or
extirpation of several bog turtle populations in Delaware (Anon. 1991),
Maryland (Anon. 1991; Smith, in litt. 1994), Massachusetts (Anon.
1991), New Jersey (Farrell and Zappalorti 1989; Zappalorti, pers. comm.
1994; Zappalorti, in litt. 1997), New York (Breisch, in litt. 1993;
Breisch et al., in litt. 1994; Collins 1990; Behler, in litt. 1997),
and Pennsylvania (Ralph Pisapia, U.S. Fish and Wildlife Service, in
litt. 1992; Zappalorti, in litt. 1997). Many sites in these States have
suitable habitat, but have much-reduced bog turtle populations,
probably due to collecting.
    Throughout the bog turtle's entire range, States regulate take
through classification of the species as endangered (in Connecticut,
Delaware, Massachusetts, New Jersey, New York, Pennsylvania, and
Virginia) or threatened (in Georgia, Maryland, North Carolina, South
Carolina and Tennessee), yet trade continues.
    Illegal trade is difficult to detect due to the questionable origin
of turtles being offered for sale. Bog turtles are often ``laundered''
through States which either do not have native populations (e.g., West
Virginia, Florida, California), or through States which have inadequate
protection of their own bog turtle populations (Charles Bepler, U.S.
Fish and Wildlife Service, in litt. 1993; Breisch, in litt. 1993;
Michael Klemens, in litt. 1990). For example, in recent years dealers
have claimed West Virginia as the State of origin for bog turtles;
however, there is no evidence to support the contention that the bog
turtle occurs in that State (Dennis Herman, Project Bog Turtle
Coordinator, in litt. 1997; Tom Thorp, North Carolina Herpetological
Society, in litt. 1997). Hatchling and juvenile turtles marketed as
``captive-born'' are usually offspring from gravid adult females
illegally brought into captivity and held until they deposit eggs. The
eggs are then hatched in captivity, and the captive-born (but not
captive-bred) offspring are then marketed or retained (Bepler, in litt.
1993).
    A few specific instances of illegal bog turtle collecting and trade
are reported below:
    (1) An undercover officer purchased eight bog turtles from a person
who had collected them near Lancaster, Pennsylvania. Also, two
additional bog turtles were recovered from persons who had gotten them
from friends allegedly in the New York area (Bepler, in litt. 1993);
    (2) An individual from New Jersey was arrested for bringing bog
turtles from New Jersey to Florida and selling them as captive-born. It
is suspected that he collected about six turtles per year over a period
of several years (Bepler, in litt. 1993);
    (3) A reliable source in New York reported that over 2000 wild-
caught bog turtles were shipped to Japan in a 2-year period (Murdock,
in litt. 1990);
    (4) Researchers found several turtle traps and a much-diminished
bog turtle population at an important bog turtle site in Pennsylvania
(Pisapia, in litt. 1992);
    (5) In 1993, a New Jersey resident purchased 47 bog turtles in
Florida, and since 1984 had also bought 20 additional bog turtles. This
individual supposedly has an active breeding program for bog turtles
(Terry Tarr, U.S. Fish and Wildlife Service, in litt. 1993);
    (6) When confronted in a New York wetland, an individual claiming
to be a birdwatcher revealed the contents of the cloth bag he was
carrying--a bog turtle and spotted turtle (Paul Novak, New York Natural
Heritage Program, in litt. 1990);
    (7) A reliable source reported seeing approximately 60 bog turtles
at the Ohio residence of a person who frequents reptile shows. Based on
the physical appearance of the bog turtles, they were not captive-bred
(Scott Smith, Maryland Department of Natural Resources, in litt. 1996);
    (8) Bog turtles have been available at the major Herpetological
Expo in Orlando, Florida for the last 2 years (Herman, in litt. 1997;
Thorp, in litt. 1997); and
    (9) Bog turtles were observed in several Florida dealerships in
1996, although they have not been openly advertised for sale (Herman,
in litt. 1997).
    The general consensus among bog turtle researchers, nongame
biologists, and law enforcement officials is that illegal collecting is
occurring at a much greater rate than detected or reported (Anon. 1991;
Breisch, in litt. 1993; Flemming, in litt. 1991). Bog turtles are
already extremely low in numbers throughout much of their range, and
any additional take could eliminate marginal populations and hamper
survival and recovery efforts.
    Protecting existing sites for bog turtles can pose a threat when
these specific sites are revealed and publicized. In addition to the
threat of collection for the pet trade industry, collection of bog
turtles for exhibition at nature centers is also a threat (Anon. 1991).

{% endraw %}
```

## Thread

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

+ Return to "[John Young <jya@pipeline.com>](/authors/john_young_jya_at_pipeline_com_)"

+ 1997-11-04 (Tue, 4 Nov 1997 19:52:21 +0800) - Pet Bog Crypto Ban - _John Young<EMAIL_ADDRESS>


text:
# tagmkv

**Tag MKV movies with metadata from The Movie Database via a CLI.**

Requires: `node`, `npm`, `mkvtoolnix`

## Installation

### Mac OSX
- Install [Homebrew](http://brew.sh/).
- `brew install node`
- `brew install mkvtoolnix`
- `npm install tagmkv -g`
- Add your API key from [The Movie Database](https://www.themoviedb.org/documentation/api) to `api-key.txt` in the `tagmkv` folder.

### Windows and Linux

I haven't had a chance to test these platforms, but it should work if you have the required tool dependencies installed.

## Usage

```
tagmkv mkv-file

Options:

  -h, --help     output usage information
  -V, --version  output the version number
  -r, --rename   rename target file with canonical title and release year
```

## Tags

Generated tags are a subset of the [Matroska tagging spec](http://www.matroska.org/technical/specs/tagging/index.html) that apply specifically to movies.

The following tags will be auto-populated from [The Movie Database](https://www.themoviedb.org/) if they are available.

- `TITLE`
- `DIRECTOR`
- `DATE_RELEASED`
- `SUMMARY`
- `DESCRIPTION`

repository: gvn/tagmkv

repo_name: gvn/tagmkv


text:
---
layout: post
date:	2010-10-27 09:45:00
title:  Euphemisms....
tags: [archived-posts]
categories: archives
permalink: /:categories/:year/:month/:day/:title/
---
<LJ user="prashanthchengi"> and I were having a discussion on euphemisms...and I feel euphemisms have their uses. Very often, the bald truth is too raw to state, so the fact is indicated by a euphemism.

As long as the parties in the conversation understand what unpleasant fact is being talked about, and are thinking about it, an euphemism is quite acceptable.

But often...euphemisms are used to brush things under the carpet. When people don't want to face a problem, it's so easy to use a glib and more cosmetic term for it and forget about it. It's a quick fix to avoid thinking deeply about a problem...and that makes me uncomfortable. If I find a child without proper brain growth, I don't want to hide behind the term, "mentally challenged"....I want to see if something can be done to help the child, not docket it neatly and move on.

Another problem about euphemisms is that they often take on the very negative meaning that the original word or phrase used to convey. Gandhiji coined the term "Harijan" for the "lower castes" of our country...and today, the word itself has the same negative connotation.

However..if it's just to be able to refer to something not-nice in a socially acceptable way...euphemisms are not only good, they are often a source of humour as the listener works out what is actually meant, and smiles!

Sometimes euphemisms can also become unnecessary as the original word loses all its sting!  I stepped in some doggie poo-poo!" To her, the word "shit" had lost all its bad aura, and it was only when she wanted to refer to specific dog-shit that she used the euphemism, "poo-poo".

Note my use of "ordure" above :) That, to me, is an acceptable euphemism!


text:
# Taking rostered attendance via a Flow in SFDO's Program Management Module (PMM)

## Overview

This repository contains an unmanaged declarative screen Flow that assists with taking roster-based attendance as part of Salesforce's Program Management Module (PMM).

SFDO's PMM version 1.17 (11/05/2020) included new functionality for Service Schedules, Service Participants, and Service Sessions. Expanding on this new functionality, this screen Flow allows users to take roster-based attendance for an entire Service Session at once for all Service Participants, rather than one-by-one through Service Deliveries or Bulk Service Deliveries as currently configured through PMM.

The Flow finds all Service Participants for a particular Service Session and asks the user which participants attended that session. A secondary Flow screen is displayed for each individual that was not selected as "attended." This screen allows the user to select whether the absence was a "no show" or "excused." The Flow then mass creates Service Delivery records with the attendance status added to the Service Delivery with a default quantity of 1 for attendees and 0 for absentees.

Note: PMM is required to be installed in order for this add-on to work in your org. Download/install PMM on Salesforce.org's Product Page.

## Included Custom Fields

The following custom fields are included as part of this deployment:

Service Delivery object -- Status (Picklist)

Provides the ability to denote the attendance status via "Attended," "Absent - No Show," and "Absent - Excused" options

Service Participant object -- Contact Name (Formula Text)

Concatenated version of First Name and Last Name. This allows the Flow to display the full name of the client using a single field for attendance purposes

Service Session object -- Start Date (Formula Date)

Used to convert Date/Time of Session Start Date to a Date field in order to filter out Participants who signed up after the date of this session

Note: all three of the above custom fields are deployed with access ONLY granted to System Administrators. Please update your user permissions for any other users that need access to those fields and/or run this Flow.

## Flow Details

This screen Flow is launched using an Action (included in this package) from the Service Session record and finds all Service Participants for the parent Service Schedule. This package also includes a Lightning Page with for the Service Session with the Action included.

The Flow finds the parent Service Schedule for this Session and gathers all Service Participants for that Schedule (Note: by default, the Flow finds only Service Participants with a sign-up date of prior to this Service Session---though this can be edited in the Flow.).

The user is displayed a list of those participants and asked to mark who attended this session. The Flow then loops through the list of participants and sets output variables of 1 for quantity and "Attended" for those selected. Any individuals that were not selected are displayed on subsequent screens, where the user is asked to select their absence type: "Excused" or "No show." Those answers (along with those from the attendees) are written to an output variable.

The Flow ends with Service Delivery records created en masse (outside the loop for bulkification purposes) with the appropriate client and attendance status, as well as a quantity of 1 for attendees and 0 for absentees.

## Post-Install Manual Steps

After installing this package, you'll need to complete a couple manual steps:

Active the "Take Attendance" Flow

Add the "Take Attendance" lightning quick action to your active Service Sessions page layout

Clone and rename the "DEMO Service Session Record Page" lighting record page and active the new version.

By default, the three custom fields listed above are imported with access granted to only the System Administrator profile. You will need to update permissions for other users to see those fields and use the Flow.

By default, the Flow is deployed without any associated permissions. This assumes users that will need to run this Flow will either have Run Flows enabled via their user settings or via their Profile. Be sure to extend access to the three custom fields for any users that need to run this Flow or you will encounter errors.

## Step by step installation instructions

To install in a production or sandbox environment, click on this button (step by step instructions below):

1. Click the "Deploy to Salesforce" button above

2. Choose the environment (Production/Developer or Sandbox) you want to install the reports into. We recommend installing in a sandbox first. Leave the other fields as they are. Click "Login to Salesforce"

![Choose environment](https://biggerboatconsulting.com/wp-content/uploads/2020/06/Choose_the_environment.png)

3. Login in to Salesforce

![Login](https://biggerboatconsulting.com/wp-content/uploads/2020/06/Salesforce-login.png)

4. Confirm it's targeting the correct environment and then hit "Deploy"

![Deploy](https://biggerboatconsulting.com/wp-content/uploads/2020/06/Ready_to_deploy.png)

5. Deployment will begin. When it's complete the screen will update with the status

![Deploy Complete](https://biggerboatconsulting.com/wp-content/uploads/2020/06/Deploy_complete.png)

6. Close the window and go to your Salesforce environment to confirm the installation of the reports in the Program Managment Reports folder

Please report any issues to **info [at] biggerboatconsulting [dot] com**