text:
Setting up Example Voting App in Codefresh
=========
[![Codefresh build status]( https://g.codefresh.io/api/badges/build?repoOwner=codefresh-io&repoName=example-voting-app&branch=master&pipelineName=example-voting-app-matrix&accountName=perfect_pipeline&type=cf-1)]( https://g.codefresh.io/repositories/codefresh-io/example-voting-app/builds?filter=trigger:build;branch:master;service:5a84d1002b8eaa0001568329~example-voting-app-matrix)

What are we doing?

We are deploying the Docker example voting app as a Helm Release using Codefresh.

(3) - result, vote and worker micro-services

We will show you how to:
* Add a repository to Codefresh.
* Create a matrix pipeline to build (3) micro-services in parallel.
* Deploy the Docker example voting app to your Kubernetes cluster using Codefresh + Helm.
* The Helm chart uses a combination of local-charts for (3) and community charts for Redis and Postgres.

Now onto the How-to!

Creating Codefresh pipelines
--------------

PreReqs:

* [Codefresh Account](https://g.codefresh.io/signup)
* [Kubernetes cluster](https://kubernetes.io/)

Some popular Kubernetes options

* [Amazon KOPs](https://github.com/kubernetes/kops) [Tutorial](https://codefresh.io/kubernetes-tutorial/tutorial-deploying-kubernetes-to-aws-using-kops/)
* [Amazon EKS (Preview)](https://aws.amazon.com/eks/)
* [Azure Container Service (Moving to AKS)](https://docs.microsoft.com/en-us/azure/container-service/kubernetes/container-service-kubernetes-walkthrough)
* [Azure Kubernetes Service (Preview)](https://docs.microsoft.com/en-us/azure/aks/) [Webinar](https://codefresh.io/webinars/devops_kubernetes_helm/)
* [Google Kubernetes Engine](https://cloud.google.com/kubernetes-engine/) [Tutorial](https://codefresh.io/kubernetes-tutorial/get-first-app-running-kubernetes-codefresh-google-container-engine/)
* [IBM Cloud Container Service](https://www.ibm.com/cloud/container-service)
* [Stackpoint Cloud](https://stackpoint.io/)

Fork this [Github Repository](https://github.com/codefresh-io/example-voting-app)
----
Either [Fork](https://help.github.com/articles/fork-a-repo/) or copy this repositories content to your Github Account or a GIT repository in another Version Control System.

[Attach Kubernetes Cluster to Codefresh](https://codefresh.io/docs/docs/deploy-to-kubernetes/adding-non-gke-kubernetes-cluster/)
----

You'll need to configure your Kubernetes cluster in Codefresh.  See link above.

Setup Docker Registry Pull Secret in Kubernetes
----

If you'd like to add your own Docker Registry

[Add Docker Registry to Codefresh](https://codefresh.io/docs/docs/docker-registries/external-docker-registries/)

If you want to us Codefresh Integrated Docker Registry

[Generate CFCR Login Token](https://codefresh.io/docs/docs/docker-registries/codefresh-registry/#generate-cfcr-login-token)

Example commands below use cfcr (Codefresh Integrated Registry).  Update if you decide to use your own Docker Registry

[Configure Kubernetes namespace with Pull Secret](https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/)

Command to create Pull Secret

``` sh
kubectl create secret docker-registry -n <kubenetes_namespace> cfcr  --docker-server=r.cfcr.io --docker-username=<codefresh_username>  --docker-password=<cfcr_token> --docker-email=<codefresh_email>
```

Command to patch Service Account with Pull Secret

``` sh
kubectl patch <service_account_name> <kubernetes_namespace> -p "{\"imagePullSecrets\": [{\"name\": \"cfcr\"}]}" -n <kubernetes_namespace>
```

Create [Codefresh CLI](https://codefresh-io.github.io/cli/getting-started/) Key
----

1. Create [API key in Codefresh](https://g.codefresh.io/account/tokens)
1. Click GENERATE button.
1. Copy key to safe location for later use in `CODEFRESH_CLI_KEY` variable.

Update YAML files
----

If you decided not use `cfcr` as your Docker Registry then you can skip this step.

Edit the Codefresh YAML in `./result`, `./vote` and `./worker` directories with your friendly Docker registry name for registry in YAML.

Create Codefresh pipelines
----

In Codefresh add a new Repository and select `example-voting-app`

1. Click Add New Repository button from Repositories screen.
1. Select the example-voting-app repository you forked or clone to your VCS/Organization. (master branch if fine) Then click NEXT button.
1. Click SELECT for CODEFRESH.YML option.
1. Update PATH TO CODEFRESH.YML with `./codefresh-matrix-pipeline.yml`. Then click NEXT button.
1. Review Codefresh YAML. Then click CREATE button.
1. Click CREATE_PIPELINE button.

You'll arrive at the `example-voting-app` pipeline.

Now we need to configure some Environment Variables for the Repository.

1. Click on General tab in the `example-voting-app` Repository page.
1. Add the following variables below. (Encrypt the sensitive variables). Click ADD VARIABLE link after every variable to add.
1. `CODEFRESH_ACCOUNT` Your Codefresh Account Name (shown in lower left of Codefresh UI). If you chose to use CFCR
1. `CODEFRESH_CLI_KEY` Your [Codefresh CLI](https://codefresh-io.github.io/cli/getting-started/) [Key](https://g.codefresh.io/account/tokens) ENCRYPT.
1. `KUBE_CONTEXT` Your friendly [Kubernetes Cluster Name](https://g.codefresh.io/account/integration/kubernetes) to use for release.
1. `KUBE_NAMESPACE` Kubernetes namespace to use for release.
1. `KUBE_PULL_SECRET` Kubernetes Pull Secret name.

The matrix pipeline is already configured and named after your GIT repository `example-voting-app`.

We need to setup the following (3) pipelines.
From Pipelines page of `example-voting-app` repository.
1. Click ADD PIPELINE (do this 3 times)
1. Name `example-voting-app1` to `example-voting-app-result`; Set WORKFLOW to YAML, Set Use YAML from Repository; Edit PATH_TO_YAML `./result/codefresh-result-pipeline.yml`; Click SAVE button at bottom of page.
1. Name `example-voting-app2` to `example-voting-app-vote`; Set WORKFLOW to YAML, Set Use YAML from Repository; Edit PATH_TO_YAML `./vote/codefresh-vote-pipeline.yml`; Click SAVE button at bottom of page.
1. Name `example-voting-app3` to `example-voting-app-worker`; Set WORKFLOW to YAML, Set Use YAML from Repository; Edit PATH_TO_YAML `./worker/codefresh-worker-pipeline.yml`; Click SAVE button at bottom of page.

Now we need to get your Codefresh Pipeline IDs to setup parallel builds.

Two options:
* CLI
1. `codefresh get pipelines`

* UI
1. Open Repository.
1. Click on each pipeline.
1. Expand General Settings.
1. Tempoary toggle on Webhook.
1. Capture ID from the curl command shown.

Record your Pipeline IDs

1. Open your `example-voting-app` Codefresh pipeline.
1. Add the following environment variable.
`PARALLEL_PIPELINES_IDS` with space delimited Codefresh Pipeline IDs.
1. Click ADD VARIABLE link below variable listing.
1. Click SAVE button at bottom of page.

Now you can run your example-voting-app pipeline to produce a Helm Release.

When the build is finished you will see a new Helm Release for [example-voting-app](https://g.codefresh.io/helm/releases/releases/?filter=search:example-voting-app)

[![Codefresh Helm Release Status]( https://g.codefresh.io/api/badges/release?type=cf-1&key=eyJhbGciOiJIUzI1NiJ9.NWE4NGNiNzQ1ODhjZjQwMDAxNDA0YzU2.ThdF7iizUJnusHWxZpbwLApHZDvr5uD_eZvem_fB3ho&selector=perfect-pipeline@FirstKubernetes&name=example-voting-app&tillerNamespace=kube-system)]( https://g.codefresh.io/helm/releases/perfect-pipeline@FirstKubernetes/default/example-voting-app/services)

Hopefully this has given you a somewhat overall picture of setting up Codefresh to run a Kubernetes deployment utilizing Helm.

Now you can play with the release or do something similar with your own application.

Notes
----

We'll be adding a Blog Post and additional followups to this example. Ex. Unit Tests, Integration Tests, Security Tests and Functional Testing.

If you'd like to schedule a demo of Codefresh to get help adding your own CI/CD steps to your Codefresh Pipelines [Click Here](https://codefresh.io/request-a-demo/)

ORIGINAL CONTENT BELOW, PLEASE NOTE DOCKER SWARM DOES NOT WORK AT THIS TIME.

Example Voting App
=========

Getting started
---------------

Download [Docker](https://www.docker.com/products/overview). If you are on Mac or Windows, [Docker Compose](https://docs.docker.com/compose) will be automatically installed. On Linux, make sure you have the latest version of [Compose](https://docs.docker.com/compose/install/). If you're using [Docker for Windows](https://docs.docker.com/docker-for-windows/) on Windows 10 pro or later, you must also [switch to Linux containers](https://docs.docker.com/docker-for-windows/#switch-between-windows-and-linux-containers).

Run in this directory:
```
docker-compose up
```
The app will be running at [http://localhost:5000](http://localhost:5000), and the results will be at [http://localhost:5001](http://localhost:5001).

Alternately, if you want to run it on a [Docker Swarm](https://docs.docker.com/engine/swarm/), first make sure you have a swarm. If you don't, run:
```
docker swarm init
```
Once you have your swarm, in this directory run:
```
docker stack deploy --compose-file docker-stack.yml vote
```

Architecture
-----

![Architecture diagram](architecture.png)

* A Python webapp which lets you vote between two options
* A Redis queue which collects new votes
* A .NET worker which consumes votes and stores them in…
* A Postgres database backed by a Docker volume
* A Node.js webapp which shows the results of the voting in real time

Note
----

The voting application only accepts one vote per client. It does not register votes if a vote has already been submitted from a client.

repository: todaywasawesome/example-voting-app

repo_name: todaywasawesome/example-voting-app


text:
---
title: NetworkManager Support
category: feature
authors: fabiand, mburns
wiki_category: Feature
wiki_title: Features/NetworkManager Support
wiki_revision_count: 5
wiki_last_updated: 2012-05-29
---

# NetworkManager Support

## Summary

This feature covers the migration of all the network related functionality to use NetworkManager.

## Owner

*   Feature owner: Mike Burns<EMAIL_ADDRESS>(?)

## Current status

*   Status: Design Stage
*   Last updated date: Tue May 08 2012

## Detailed Description

This means moving from the existing network service, not editing files directly anymore, determining what files NetworkManager changes and ensure they're persisted correctly.

## Benefit to oVirt

This migration ensures that Node can still be based on Fedora and doesn't need major workarounds.

## Dependencies / Related Features

(Probably) affected parts:

*   Node
    -   TUI
    -   o-c-\* scripts
    -   installer
*   VDSM (?)

## Documentation / External references

*   Corresponding bug: <https://bugzilla.redhat.com/show_bug.cgi?id=807039>
    -   Bug for bridge support: <https://bugzilla.redhat.com/show_bug.cgi?id=199246>
    -   Upstream GNOME bug to handle brigdes within NM: <https://bugzilla.gnome.org/show_bug.cgi?id=546197>
    -   <https://bugzilla.gnome.org/show_bug.cgi?id=546197>
*   Fedora
    -   F8 Feature: <http://fedoraproject.org/wiki/Releases/FeatureNetworkManager>
    -   F9 Feature: <http://fedoraproject.org/wiki/Releases/FeatureMoreNetworkManager>
    -   <http://fedoraproject.org/wiki/Tools/NetworkManager>
*   GNOME
    -   <https://live.gnome.org/NetworkManagerConfiguration>

## Comments and Discussion

*   Mailinglist<EMAIL_ADDRESS>

license: MIT

repository: igoihman/ovirt-site

branch_name: refs/heads/master

extension: md

gha_language: HTML

gha_license_id: NOASSERTION

license_type: permissive

repo_name: igoihman/ovirt-site


text:
# Naas (Notebooks As Automated Services)

Schedule notebooks, to automate all your tasks.

Use the power of scripting in the cloud.
Whenever you need it (even when you sleep).

* Schedule your scripts
* Use Notebooks as API
* Share assets securely

## Install

`pip3 install naas`

# DEVELOPMENT

## Install

`pip3 install -r requirements.txt`

## Run test

`pytest -x`

## test local server

`./test_runner.sh`

open manager :

`localhost:5000/`

## check lint

`python3 -m black naas` format better
`python3 -m flake8 naas` check if any left error

## publish

bump version
`cz bump --changelog`
create release
`python3 setup.py sdist`
upload release
`python3 -m twine upload dist/* -u YOUR_USERNAME`

repository: imasdekar/naas

repo_name: imasdekar/naas


text:
# To Do Backend

This project is born to **give a backend** to my other **front-end project** called [to-do](https://github.com/impe93/to-do). It is an easy express application for make **CRUD** (Create, Read, Update, Delete) operations, gives the possibility to **register** and serve the front-end app. Try the app on https://to--do.herokuapp.com/ .

## Getting Started

### Prerequisites

It's possible to run this in a local environment only if there's already installed [NodeJS](https://nodejs.org) (I’m using version 7.7.3), [NPM](https://nodejs.org/en/download/) and [MongoDB](https://www.mongodb.com/).

### Installing

After having installed those 3 things you have to run the command `npm install` to **install the project dependency** in the project directory. It’s important to **change the mongoDB URL** in the app.js code or pass this as env parameter `(MONGODB_URI=<db url>)` to establish the connection with the DB. It’s possible to **launch the app** just by run the command `npm run dev`, and this will start the project. The app tries to start on **port 80** but you can change that by passing `PORT=<port number>` as env parameter. The **port 80 can be an issue** for people that use Windows as OS because on that port is possible to find ISS running, for the other that use Linux or MacOS will need to use `sudo` command when running it.

## Deployment

Before deploying the app is necessary to build it with babel, for do that just run `npm run build` and you’ll be able to find it in the dist folder, the last thing to do in order to prepare the deploy is to copy the `src/dist` folder inside the `dist` folder, this because the dist folder will compile in a wrong way, so this is the fastest way is to make the things work properly. I deploy this web application on Heroku because it offers a free plan that is perfect for test the app in a real environment and learns how to do it properly.

## Built With

* NodeJS
* MongoDB
* ExpressJS
* Angular 5 (this app use the compiled code)

## Author

* Lorenzo Imperatrice

## License

This project is licensed under the **MIT** License

gha_language: JavaScript


text:
# neg lru cache

A simple cache object that deletes the least-recently-used items.

Fork from: [node-lru-cache](https://github.com/isaacs/node-lru-cache)

## Installation:

```javascript
npm install neg-lru-cache --save
```

## Usage:

```javascript
var LRU = require("lru-cache")
  , options = { max: 500
              , ttl: 1000 * 60 * 60 }
  , cache = LRU(options)
  , otherCache = LRU(50) // sets just the max size

cache.set("key", "value")
cache.get("key") // "value"

cache.set("key2", "value2", 1000 × 10) //individual ttl

// non-string keys ARE fully supported
var someObject = {}
cache.set(someObject, 'a value')
cache.set('[object Object]', 'a different value')
assert.equal(cache.get(someObject), 'a value')

cache.reset()    // empty the cache
```

If you put more stuff in it, then items will fall out.

If you try to put an oversized thing in it, then it'll fall out right
away.

## Options

* `max` The maximum size of the cache, checked by applying the length
  function to all values in the cache.  Not setting this is kind of
  silly, since that's the whole purpose of this lib, but it defaults
  to `Infinity`.
* `ttl` time to alive in ms. If you try to get an item that is too old, it'll
  drop it and return undefined instead of giving it to you.

## API

* `set(key, value, ttl)`
* `get(key) => value`

    Both of these will update the "recently used"-ness of the key.
    They do what you think. `ttl` is optional and overrides the
    cache `ttl` option if provided.

    If the key is not found, `get()` will return `undefined`.

    The key and val can be any value.

* `del(key)`

    Deletes a key out of the cache.

* `reset()`

    Clear the cache entirely, throwing away all values.

* `has(key)`

    Check if a key is in the cache, without updating the recent-ness
    or deleting it for being stale.

* `forEach(function(value,key,cache), [thisp])`

    Just like `Array.prototype.forEach`.  Iterates over all the keys
    in the cache, in order of recent-ness.  (Ie, more recently used
    items are iterated over first.)

* `rforEach(function(value,key,cache), [thisp])`

    The same as `cache.forEach(...)` but items are iterated over in
    reverse order.  (ie, less recently used items are iterated over
    first.)

* `keys()`

    Return an array of the keys in the cache.

* `values()`

    Return an array of the values in the cache.

* `count()`

    Return total quantity of objects currently in cache. Note, that
    `stale` (see options) items are returned as part of this item
    count.

license: ISC

repository: JamesYYang/node-lru-cache

repo_name: JamesYYang/node-lru-cache


text:
---
meta_title: Setup - Litebook
sidebar_title: Setup
sidebar_order: 1
---

# Setup

Next, we need to configure Litebook and provide Presta an entrypoint to render our pages.

### Entrypoint

Create an file called `site.js`. Presta will use this file to build all your pages.

Then, set up a `litebook` instance like `litebook(docsBase, fileGlobs[, options])(__filename)`:

- `docsBase` is the root directory that contains your markdown files — URLs will
  be resolved relative to this directory
- `fileGlobs` is a `string` or `string[]` that points to markdown files — if you
  want to support nested pages, include a directory glob as well i.e.
  `**/*.md`

```javascript
import { litebook } from 'litebook'

const docs = litebook('./pages', '**/*.md')(__filename)
```

> The `__filename` is important. It tells `litebook` and `presta` which file is
> declaring the docs theme.

### Exports

Presta requires two exports, which `litebook` provides you. Export those
and you're good to go!

```javascript
import { litebook } from 'litebook'

const docs = litebook('./pages', '**/*.md')(__filename)

export const getStaticPaths = docs.getStaticPaths
export const handler = docs.handler
```

Then, just run `npx presta watch site.js` in your terminal and you're ready to
start adding [pages](/getting-started/pages).

repository: front-of-house/litebook

repo_name: front-of-house/litebook


text:
# MapsIndoorsAndroid
MapsIndoors Standard App for Android

## Usage

Clone the project and open it in Android Studio.

## Requirements

First you need to generate a google maps key for android from this [link](https://developers.google.com/maps/documentation/android-sdk/signup) and create a file named : "google_maps_api" under  "Values" containing :
```xml
<resources>
<string name="google_maps_key" templateMergeStrategy="preserve" translatable="false">YOUR_KEY_HERE</string>
</resources>
```
Then replace the "YOUR_KEY_HERE" with your key.

## Author

MapsPeople A/S, Mohammed Amine Naimi<EMAIL_ADDRESS>Jose J Varó<EMAIL_ADDRESS>Martin Hansen<EMAIL_ADDRESS>
## License

MapsIndoors SDK is released under a commercial license. The MapsIndoors standard app is released under MIT license.

repository: TomTasche/MapsIndoorsAndroid

repo_name: TomTasche/MapsIndoorsAndroid


text:
[//000000001]: # (doctools2toc\_introduction \- Documentation tools)
[//000000002]: # (Generated from file 'toc\_introduction\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Copyright © 2009 Andreas Kupries<EMAIL_ADDRESS>[//000000004]: # (doctools2toc\_introduction\(n\) 2\.0 tcllib "Documentation tools")

 [ Main Table Of Contents | Table Of Contents | Keyword Index | Categories | Modules | Applications ]

# NAME

doctools2toc\_introduction \- DocTools \- Tables of Contents

# Table Of Contents

  - [Table Of Contents](#toc)

  - [Description](#section1)

  - [Related formats](#section2)

  - [Package Overview](#section3)

  - [Bugs, Ideas, Feedback](#section4)

  - [See Also](#seealso)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# DESCRIPTION

*[doctoc](\.\./\.\./\.\./\.\./index\.md\#doctoc)* \(short for *documentation tables
of contents*\) stands for a set of related, yet different, entities which are
working together for the easy creation and transformation of tables and contents
for documentation\.

These are

  1. A tcl based language for the semantic markup of a table of contents\. Markup
     is represented by Tcl commands\. Beginners should start with the *[doctoc
     language introduction](\.\./doctools/doctoc\_lang\_intro\.md)*\. The formal
     specification is split over two documents, one dealing with the *[doctoc
     language syntax](\.\./doctools/doctoc\_lang\_syntax\.md)*, the other a
     *[doctoc language command
     reference](\.\./doctools/doctoc\_lang\_cmdref\.md)*\.

  1. A set of packages for the programmatic manipulation of tables of contents
     in memory, and their conversion between various formats, reading and
     writing\. The aforementioned markup language is one of the formats which can
     be both read from and written to\.

  1. The system for the conversion of tables of contents is based on a plugin
     mechanism, for this we have two APIs describing the interface between the
     packages above and the import/export plugins\.

Which of the more detailed documents are relevant to the reader of this
introduction depends on their role in the documentation process\.

  1. A *writer* of documentation has to understand the markup language itself\.
     A beginner to doctoc should read the more informally written *[doctoc
     language introduction](\.\./doctools/doctoc\_lang\_intro\.md)* first\. Having
     digested this the formal *[doctoc language
     syntax](\.\./doctools/doctoc\_lang\_syntax\.md)* specification should become
     understandable\. A writer experienced with doctoc may only need the
     *[doctoc language command
     reference](\.\./doctools/doctoc\_lang\_cmdref\.md)* from time to time to
     refresh her memory\.

     While a document is written the __dtp__ application can be used to
     validate it, and after completion it also performs the conversion into the
     chosen system of visual markup, be it \*roff, HTML, plain text, wiki, etc\.
     The simpler __[dtplite](\.\./\.\./apps/dtplite\.md)__ application makes
     internal use of doctoc when handling directories of documentation,
     automatically generating a proper table of contents for them\.

  1. A *processor* of documentation written in the
     *[doctoc](\.\./\.\./\.\./\.\./index\.md\#doctoc)* markup language has to know
     which tools are available for use\.

     The main tool is the aforementioned __dtp__ application provided by
     Tcllib\. The simpler __[dtplite](\.\./\.\./apps/dtplite\.md)__ does not
     expose doctoc to the user\. At the bottom level, common to both
     applications, however we find the three packages providing the basic
     facilities to handle tables of contents, i\.e\. import from textual formats,
     programmatic manipulation in memory, and export to textual formats\. These
     are

       - __doctoools::toc__

         Programmatic manipulation of tables of contents in memory\.

       - __doctoools::toc::import__

         Import of tables of contents from various textual formats\. The set of
         supported formats is extensible through plugin packages\.

       - __doctoools::toc::export__

         Export of tables of contents to various textual formats\. The set of
         supported formats is extensible through plugin packages\.

     See also section [Package Overview](#section3) for an overview of the
     dependencies between these and other, supporting packages\.

  1. At last, but not least, *plugin writers* have to understand the
     interaction between the import and export packages and their plugins\. These
     APIs are described in the documentation for the two relevant packages, i\.e\.

       - __doctoools::toc::import__

       - __doctoools::toc::export__

# Related formats

The doctoc format does not stand alone, it has two companion formats\. These are
called *[docidx](\.\./\.\./\.\./\.\./index\.md\#docidx)* and
*[doctools](\.\./\.\./\.\./\.\./index\.md\#doctools)*, and they are intended for the
markup of *keyword indices*, and of general documentation, respectively\. They
are described in their own sets of documents, starting at the *DocTools \-
Keyword Indices* and the *DocTools \- General*, respectively\.

# Package Overview

                                        ~~~~~~~~~~~ doctools::toc ~~~~~~~~~~~
                                       ~~                   |               ~~
                    doctools::toc::export ~~~~~~~~~~~~~~~~~ | ~~~~~~~~~~~~~ doctools::toc::import
                            |                               |                       |
            +---------------+-------------------------+     |    +------------------+---------------+-----------------------+---------------+
            |               |                         |     |    |                  |               |                       |               |
    struct:map              =                         |     |    |                  =       doctools::include       struct::map      fileutil::paths
                            |                         |     |    |                  |
                    doctools::toc::export::<*>        |     |    |          doctools::toc::import::<*>
                            doctoc                    |     |    |                  doctoc, json
                            json                      |     |    |                  |           \
                            html                      |     |    |          doctools::toc::parse \
                            nroff                     |     |    |                  |             \
                            wiki                      |     |    |  +---------------+              json
                            text                      |     |    |  |               |
                                                    doctools::toc::structure        |
                                                                                |
                                                                            +-------+---------------+
                                                                            |                       |
              doctools::html  doctools::html::cssdefaults           doctools::tcl::parse    doctools::msgcat
                    |                                                                               |
              doctools::text  doctools::nroff::man_macros                                           =
                                                                                |
                                                                                doctools::msgcat::toc::<*>
                                                                                c, en, de, fr
                                                                                (fr == en for now)
            ~~      Interoperable objects, without actual package dependencies
            --      Package dependency, higher requires lower package
            =       Dynamic dependency through plugin system
            <*>     Multiple packages following the given form of naming.

# Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *doctools* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# SEE ALSO

[doctoc\_intro](\.\./doctools/doctoc\_intro\.md),
[doctools](\.\./doctools/doctools\.md), doctools2doc\_introduction,
[doctools2idx\_introduction](\.\./doctools2idx/idx\_introduction\.md),
[doctools\_lang\_cmdref](\.\./doctools/doctools\_lang\_cmdref\.md),
[doctools\_lang\_faq](\.\./doctools/doctools\_lang\_faq\.md),
[doctools\_lang\_intro](\.\./doctools/doctools\_lang\_intro\.md),
[doctools\_lang\_syntax](\.\./doctools/doctools\_lang\_syntax\.md),
[doctools\_plugin\_apiref](\.\./doctools/doctools\_plugin\_apiref\.md)

# KEYWORDS

[contents](\.\./\.\./\.\./\.\./index\.md\#contents),
[conversion](\.\./\.\./\.\./\.\./index\.md\#conversion),
[formatting](\.\./\.\./\.\./\.\./index\.md\#formatting),
[markup](\.\./\.\./\.\./\.\./index\.md\#markup),
[parsing](\.\./\.\./\.\./\.\./index\.md\#parsing),
[plugin](\.\./\.\./\.\./\.\./index\.md\#plugin), [semantic
markup](\.\./\.\./\.\./\.\./index\.md\#semantic\_markup), [table of
contents](\.\./\.\./\.\./\.\./index\.md\#table\_of\_contents)

# CATEGORY

Documentation tools

# COPYRIGHT

Copyright © 2009 Andreas Kupries<EMAIL_ADDRESS>

repository: markemer/macports-base

gha_language: Tcl

repo_name: markemer/macports-base


text:
---
code: true
type: page
title: core:overload
---

# core:overload

| Arguments | Type              | Description                    |
| --------- | ----------------- | ------------------------------ |
| `fill`    |
number
 | Request buffer fill percentage |

Triggered when the requests buffer fills up more quickly than requests can be processed.

The requests buffer is configurable through the `limits` parameters in the [Kuzzle configuration](/core/2/guides/essentials/configuration).

Requests submitted while the request buffer is completely filled (i.e. the payload is equal to `100`) are rejected with a [ServiceUnavailableError](/core/2/api/essentials/error-handling#common-errors) (code `503`)

:::info
Pipes cannot listen to that event, only hooks can.
:::


text:
# Chinese Relation Extraction by biGRU with Character and Sentence Attentions

[Attention-Based Bidirectional Long Short-Term Memory Networks for Relation Classification](http://anthology.aclweb.org/P16-2034)
[Neural Relation Extraction with Selective Attention over Instances](http://aclweb.org/anthology/P16-1200)

repository: Alexzsh/FDDC

repo_name: Alexzsh/FDDC


text:
Fitness Tracker

![Fitness Tracker App](fitness.png)

Click [here](https://fitness-tracker-ibarrasb.herokuapp.com/?id=60283576d8272b0015782fb4) to launch App.

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

## Description
🔍 Manage your daily workouts with one simple application! Where you can create some workouts of your own, or continue with previous workouts youve already done. This application also allows you to track your progress with charts and can be updated daily!
## Table of Contents
- [Description](#description)
- [License](#license)
- [Installation](#Installation)
- [Contributing](#contributing)

## Installation
```
npm install
```
## Usage

```
node server.js
```
```
npm start
```

## License
![badge](https://img.shields.io/badge/license-MIT-brightgreen)

This application is covered by the MIT license.
## Contributing
Eddie Ibarra

:octocat: Find me on GitHub: [ibarrasb](https://github.com/ibarrasb)

✉Email me with any questions<EMAIL_ADDRESS>/>

repository: ibarrasb/Fitness-Tracker

branch_name: refs/heads/main

repo_name: ibarrasb/Fitness-Tracker


text:
# Array Reversal
### Description
Given an array, of size , reverse it.

        Example: If array, arr=[1,2,3,4,5] , after reversing it, the array should be, arr=[5,4,3,2,1] .

### Link Hacker Rank
https://www.hackerrank.com/challenges/reverse-array-c/problem

gha_license_id: MIT


text:
# RISK SCORES GENERATION
Machine learning-based resource allocation allows us to identify clients or Front Line Workers (FLWs) who are at the highest risk for a particular (e.g., malnourishment in children) outcome and direct appropriate attention towards them to attempt to improve the outcome. For example, a predictive model that identifies high-risk pregnancies would allow an organization to intervene in due time, such as by focusing additional resources on the pregnant woman to ensure a safe pregnancy.

When applying machine learning algorthims to public health datasets that were collected in the field using a mobile health tool such as CommCare, DHIS2 we need to keep in mind that it is likely that the dataset is very noisy and highly imbalaced. Therefore when evaluating the performance of such algorthims we should carefully choose an appropriate metric.

For example, for the classification tasks, a simple metric, such as accuracy, is unsuitable for evaluating where the occurrence of one category is small. If only 7% of pregnancies have an adverse outcome, we can achieve 93% accuracy if we classify every pregnancy as having a positive outcome. The specific metric used is covered in more detail in each of the project-specific sections.

To avoid the previously mentioned issue with accuracy as a metric, data scientists often use the AUC (area under curve), which is the two-dimensional area underneath the receiver operating characteristic (ROC) curve, as an evaluation metric. The ROC curve plots true positive rate against false positive rate in order to visualize the performance of a model in different scenarios. Therefore, we use AUC score in the code in this repository.

The following scripts and snippets of code were designed specifically to work with CommCare HQ, however, they can easily be expanded to other softwares such as DHIS2 by replacing the CommCare specific export and submit data tools to corresponding tools for the software of interest.

## Dataset Loading and Saving Models
This repository is specifically designed to expand the greater CommCare platform to use Machine Learning to generate a model to produce risk scores. The starting input data is assumed to be transactional (form-level) data. This data then needs to be aggregated down to a single row per 'case' about which we are creating the risk scores. The row will consists of all the historical form submission data for that particular case. In *build_model.py*, the dataset is loaded from a parquet file (you can similarly load a csv or sql file or pull from a database as well).

The final trained model can be saved as pickle file at a desired location by setting the PATH variables in the *settings.py* file. You can then load your saved model, generate risk scores on your own dataset (formatted as one row per case) and save the risk scores as a csv file in *build_model.py* file.

## Submit Data to CommCare
Following the example script from this [repository](https://github.com/dimagi/submission_api_example), you can submit the risk scores to update the case properties in CommCare using the *submit_data.py* file.

(If you would like to update existing cases, you can set the server_modified_on attribute for existing cases.)

## Generating Risk Scores for a Case
1. After training your random forest model, you can save your final model on your device or working environment.
```python
filename = settings.MODEL_PATH
pickle.dump(rf, open(filename, 'wb'))
print('Model saved at {}'.format(filename))
```
2. You can then fetch the cases you want to generate risk scores for from the Commcare HQ using the [Data Export Tool](https://confluence.dimagi.com/display/commcarepublic/CommCare+Data+Export+Tool). You can save the case data in a csv format or directly into sql tables.
```bash
commcare-export \
    --verbose \
    --commcare-hq https://www.commcarehq.org \
    --username "username"\
    --project 'project_name'\
    --auth-mode apikey \
    --password  "apikey"\
    --query "det_config file"\
    --batch-size=1000 \
    --output-format csv \
```

3. Once you have exported the case and form data from CommCare HQ. You can transform the data to collate all form properties and historical data to create a clean and easy-to-use data. Sample Python code for data transformations has been provided in the preprocess_data.py script.
4. Once, the data has been tranformed, you can load your saved model and generate risk scores for the cases. These risk scores can be output to the terminal or saved into a csv for ease of use.
```python
# load the model from disk, run on cases and save the risk scores to a csv file
loaded_model = pickle.load(open(filename, 'rb'))
result = loaded_model.predict_proba(features)
pd.DataFrame(result).to_csv("path/to/file.csv")
```
6. Once, the risk scores for each case have been generated and saved into a file, you can submit the scores via the submit_data.py script to update the case properties on CommCare HQ.
```bash
$ export CCHQ_PROJECT_SPACE=my-project-space
$ export CCHQ_CASE_TYPE=person
$ export<EMAIL_ADDRESS>$ export CCHQ_PASSWORD=MijByG_se3EcKr.t
$ export CCHQ_USER_ID=c0ffeeeeeb574eb8b5d5036c9a61a483
$ export CCHQ_OWNER_ID=c0ffeeeee1e34b12bb5da0dc838e8406
```

```bash
$ python3 submit_data.py sample_result.csv
```

## Usage
1. (Recommended) Create a virtual enviroment and activate it
```bash
$ python3 -m venv venv
$ source venv/bin/activate
```
3. Use the *requirements.txt* file to download all of the required libraries to run the script. cd to to the directory where the *requirements.txt* is located
```bash
$ pip install -r requirements.txt
```
4. Fill the variables in the *settings.py* file with the appropiate values, based on the previous step.
5. You can train a binary Random Forest Classifier by running:
```bash
$ python3 build_model.py
```
5. You can generate risk scores for a case and update the case properties on CommCare HQ via the [Submission API](https://confluence.dimagi.com/display/commcarepublic/Submission+API)

repository: dimagi/risk-scores

repo_name: dimagi/risk-scores


text:
# examples

- examples/blog is simple crud project.
- examples/config is kratos config example.
- examples/errors is kratos errors example, it is generated through proto-gen-go-errors.
- examples/helloworld is helloworld example.
- examples/http is transport/http some examples of usage.
- examples/log is log example, including、logger、helper、filter、valuer, etc.
- examples/metadata is metadata example.
- examples/metrics is metrics example, in the example, prom is used to collect data.
- examples/registry is registration and discovery examples,including Etcd, Consul, Nacos.
- examples/traces is middleware/tracing example，middleware/tracing is implemented by opentelemetry.
- examples/validate is middleware/validate example, the verification code is generated by proto-gen-validate.
- examples/ws is implementation of transport interface with websocket example.
- examples/swagger is implementation of server with embed swagger api.

repository: miyabyte/kratos

repo_name: miyabyte/kratos


text:
#`Phalconry`
The root namespace contains some useful utility classes.

##`VarType`
Provides consistent and performant methods for casting variables to various PHP types.
####Methods
  * __`toArray($arg)`__ Casts a variable to an array. If `$arg` is an array, it is returned. If `$arg` is not an object, it is cast to an array using `(array)$arg`. If `$arg` is an object, the function proceeds as follows:
    * Calls `toArray()` method, if it exists;
    * Calls `iterator_to_array()` if object implements `Traversable`
    * Calls `get_object_vars()`
  * __`toObject($arg)`__ Casts a variable to an object. If `$arg` is an object and not an instance of `stdClass`, it is first cast to an array using `VarType::toArray()` and subsequently cast to an object using `(object)$arg`. All other argument types are simply cast.
  * __`toArrays($arg)`__ Casts a variable to an array recursively. First, `$arg` is cast to an array using `VarType::toArray()`. It is then iterated over, and any array or object members are cast to an array (recursively) using `VarType::toArrays()`.

##`Text`
__Extends `Phalcon\Text`__
####Methods
  * __`hasChars($str, $charlist)`__ Checks whether `$str` contains any (one or more) of the characters in `$charlist` and returns `boolean`.
  * __`pearCase($str)`__ Converts a string to a PEAR-style name (e.g. "Http_Request2_Response").
  * __`snakeCase($str)`__ Converts a string to snakecase. This is the same as `pearCase()` except lowercase.
  * __`studlyCase($str)`__ Converts a string to "studly caps" (e.g. "SomethingLikeThis").
  * __`camelCase($str)`__ Converts a string to camelcase. This is the same as `studlyCase()` except the first character is lowercase.
  * __`isJson($str)`__ Checks whether a string is valid JSON and returns `boolean`.
  * __`isXml($str)`__ Checks whether a string is valid XML and returns `boolean`.
  * __`isSerialized($str)`__ Checks whether a string is PHP serialized and returns `boolean`.
  * __`format($str, $template)`__ Replaces non-alphanumeric characters in `$template` with characters from `$str` in sequence.
  * __`between($str, $substr_start, $substr_end)`__ Returns the string found between two substrings within `$str`.
  * __`sentences($str, $num = 1, $strip_abbr = false)`__ Extracts a given number of sentences from a string. Accounts for some basic abbreviations (e.g. "Mr.", "Mrs.", "Co.", "Inc.") and allows the user to provide others so that the function does not interpret abbreviations containing `.` as the end of a sentence.

repository: phalconry/cphalconry

repo_name: phalconry/cphalconry


text:
---
permalink: 'linting/linting-types.html'
title: Linting Types
section: guides
tags:
  - guides
---

# Linting Types

Use [TypeScript](https://www.typescriptlang.org/) to type lint your es6 JSDoc annotated code.

## Setup

```bash
npm init @open-wc linting-types-js
```

TIP

This is an OPTIONAL recommendation. You will need to opt-in by running the generator or following the manual steps.

## Manual

- `yarn add --dev typescript`
- Copy [tsconfig.json](https://github.com/open-wc/open-wc/blob/master/packages/create/src/generators/linting-types-js/templates/static/tsconfig.json) to `tsconfig.json`
- Add these scripts to your package.json
  ```js
  "scripts": {
    "lint:types": "tsc",
  },
  ```

## What you get

For general information about types please see [developing/types](../developing/types.html).

- Awesome intellisense for @open-wc tools/helpers
- Ability to jump directly to the source of @open-wc code via F12 (in vs code)
- Type safety (To read more about why type safety can help you, go to: [developing/types](../developing/types.html)).

## Usage

Run:

- `npm run lint:types` to check if you have type errors

## Type linting error example

```bash
$ npm run lint:types

> foo-bar@ lint:types /path/to/foo-bar
> tsc

test/foo-bar.test.js:7:22 - error TS2554: Expected 1 arguments, but got 2.
7     const el = await fixture('<foo-bar></foo-bar>', { hasMoreOptions: false });
                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Found 1 error.
```

repository: busterc/open-wc

repo_name: busterc/open-wc


text:
---
uid: buildingsourcecode
---
# Building the project

Make a clone of the repository, navigate to the `build` folder in the repository and run `Build-Debug.ps1`.

This will restore all references and copy the required files to the correct location on your computer.

Notice that we refer to the nuget package of the PnP.Framework project. As this is rebuilt every night you will receive a new version of the PnP.Framework package every day.

If you run on Windows both the .NET Framework and the .NET Core version will be build and installed.

If you run on MacOS or Linux only the .NET Core version will be build and installed.

> [!NOTE]
> Unlike the older repository for the legacy version of PowerShell for Windows you do not need to have local clone of the PnP Framework repository anymore (we changed the PnP Sites Core library used under the hood to the PnP Framework repository, see for more info about that library here: https://github.com/pnp/pnpframework).

## Folder Structure

In the repository you'll find the following folder structure

```
- build
- documentation
- pages
- resources
- samples
- src/ALC
     /Commands
     /Resources
     /Tests
```

### Build folder
The build folder contains scripts used to build the project, build the Helpfile, etc. While debugging locally the `Build-Debug.ps1` script is the script to use to build the project and copy the correct files to the correct location on your machine. The other build scripts are used in GitHub actions to automate the nightly builds etc.

### Documentation folder
The documentation folder contains the markdown files all describing every single cmdlet available. If you create a new cmdlet we *require* you to also provide a documentation file. Notice that the documentation files *require* a front-matters yaml header as specified in the other files. Updated accordingly.

### Pages folder
The pages folder contains the structure which is published to https://pnp.github.io/powershell. We automatically copy the cmdlet documentation in there at build time, but you can create PRs on the 'articles' folder if you want.

### Resources
The resources folder contains an XML file which is copied into the output folder of the build. This file defines how PowerShell should parse and render the objects shown as output from the PnP PowerShell cmdlets

### src/ALC
Due to possible conflicts with already loaded assemblies in PowerShell we create an Assembly Load Context for a specific assembly. See https://docs.microsoft.com/en-us/dotnet/core/dependency-loading/understanding-assemblyloadcontext for more information about ALCs.

### src/Commands
This is the main location of all the cmdlet code.

### src/Resources
Any resources used by cmdlets go into this folder

### src/Tests
This is where the the unit/integration tests reside. See [Running test](runningtests.md) for more information.

# Running against a local copy of the PnP Framework
If your code changes require changes to the PnP Framework you might want to use a local version of the PnP Framework which you modified. In order to do this you will need to have both the PnP.PowerShell repository (https://github.com/pnp/powershell) and the PnP.Framework repository (https://github.com/pnp/pnpframework) locally on your computer. Make sure that both repositories are located at the same folder level. E.g.:

```console
c:\repos\powershell
c:\repos\pnpframework
```

Now, build the PnP Framework by navigating to the `build` folder in the `pnpframework` folder and run `Build-Debug.ps1`. This will compile the PnP Framework.

Next, navigate to the `build` folder of the `powershell` folder and run `Build-Debug.ps1 -LocalPnPFramework`. This will compile PnP PowerShell and refer to the -locally- compiled version of the PnP Framework. If you do not specify the `-LocalPnPFramework` switch it will refer to the latest nightly build available on NuGet.org instead.

# Running against a local copy of the PnP Core SDK
If your code changes require changes to the PnP Core SDK (meaning any of the PnP Core SDK libraries like: PnP.Core, PnP.Core.Auth, PnP.Core.Admin, PnP.Core.Transformation, or PnP.Core.Transformation.SharePoint) you might want to use a local version of the PnP Core SDK which you modified. In order to do this you will need to have both the PnP.PowerShell repository (https://github.com/pnp/powershell) and the PnP.Core repository (https://github.com/pnp/pnpcore) locally on your computer. Make sure that both repositories are located at the same folder level. E.g.:

```console
c:\repos\powershell
c:\repos\pnpcore
```

Now, build the PnP Core SDK by navigating to the `build` folder in the `pnpcore` folder and run `Build-Debug.ps1`. This will compile the whole PnP Core SDK solution, including PnP.Core.Auth, PnP.Core.Admin, PnP.Core.Transformation, and PnP.Core.Transformation.SharePoint.

Next, navigate to the `build` folder of the `powershell` folder and run `Build-Debug.ps1 -LocalPnPCore`. This will compile PnP PowerShell and refer to the -locally- compiled version of the PnP Core SDK. If you do not specify the `-LocalPnPCore` switch it will refer to the latest nightly build available on NuGet.org instead.

repository: MattGestic/powershell

repo_name: MattGestic/powershell


text:
# Command Line Git

Git is a version control system often used by teams to manage project files. Github is a website built around Git on which hundreds of thousands of users manage projects and project files. Incorporating Git and Github into your workflow can save lots of time, can help you show the individuals responsible for different features of your projects, and can give you one of the fundamental skills required for a variety of technical enterprises.

This guide is intended for researchers with some exposure to GitHub. If you're totally new to GitHub, we recommend you try out GitHub's [visual introduction to Git](https://guides.github.com/activities/hello-world/) before continuing with the guide below.

# Installing Dependencies

To get started with Git on the command line, we need to install some system-level dependencies.

#### Installing Dependencies on OSX

To install the required dependencies on OSX, you should first open a terminal. The easiest way to do so is to hold COMMAND and press SPACE BAR, type "terminal" and hit enter.

Inside the terminal, type `git`. If Git is installed you'll get a response like this:

![git response on osx](./assets/git-osx.png)

Otherwise, you should be prompted to install xcode. If you're not prompted, you can run `xcode-select --install` to manually install xcode, which will install git for you.

Once that finishes downloading and installing, you should see the commands displayed in the screenshot above when you run `git`.

#### Installing Dependencies on Windows

If you use Windows, the easiest way to install the required dependencies is to download and install [Git Bash](https://git-scm.com/download/win), a Unix-like terminal for Windows. After clicking the link above, click on the installer and accept all defaults.

Once that installs, you should be able to click on the Windows icon in the lower-left-hand corner of your taskbar, search for "Git Bash", and click on the Git Bash icon:

![git bash in programs](./assets/git-bash.png)

That should bring up a terminal that's fully equipped with Git.

## Introduction to Git

Now that Git's installed, let's cover what Git does. Essentially, Git is a simple tool that keeps track of changes made to files. Git users can tell Git when to add, edit, or delete files in a folder, and how to handle cases where multiple people have edited the same file in different ways.

The core ideas of Git are simple. We start with some files in a workspace (a folder under Git control). We then add those files to a staging area (a representation of the changes we want to keep). Next we commit those changes to our local repository (the copy of our project's content on your machine). Finally, we push those changes from our local repository to our remote repository (the copy of our project's content on a remote server, e.g. on GitHub). Here's a visual representation of this workflow:

![simple git workflow](./assets/git-operations.png)

To contribute to a project using Git, we only need to `add` files to our staging area, `commit` the changes in our staging area, then `push` those changes up to our remote server. That's all it takes!

## Getting Set Up: Creating a Remote Repository

In order to practice this workflow, we'll need a remote repository to which we can push our changes. Let's go ahead and make that repository on GitHub. To do so, log into GitHub then navigate to `https://github.com/new`. This will display an interface that looks like this:

![new repository](./assets/new-repository.png)

Let's name our new repository 'learning-git', and let's type a short description that outlines the goal of our repository. Once we've filled out those fields, let's click the big green button that says "Create Repository". That will display a screen that looks like this:

![new repository created](./assets/new-repository-created.png)

The important line here is the one that says:

```
git remote add origin https://github.com/GITHUB_USERNAME/learning-git.git
```

We'll come back to that url in a moment, so keep this page open.

## Getting Set Up: Creating a Local Repository

In addition to a remote repository, we'll also need a local repository, or a copy of our project's code on our local machine. Our imaginary project doesn't have any content yet, so let's go ahead and make a directory on our machine in which we can store sample project files. To do so, you should be able to open a fresh terminal (on OSX) or Git Bash terminal (on Windows), and type:

```
cd Desktop
```

From there, you can create a new directory by typing:

```
mkdir learning-git
```

Then to move your terminal into that folder let's run:

```
cd learning-git
```

## Initializing a Git Repository

To tell Git that you want to carefully manage the files in a given directory (and its subdirectories), the first command to run is `git init`. That will return a line like the following, which confirms the current directory is ready for git commands:

![git init](./assets/git-init.png)

After initializing our current directory, let's run the most important Git command, `git status`. That command will return output that looks like this:

![git status](./assets/git-status.png)

This output tells us some important things:
 * We're on the `master` branch (we'll discuss branches more below)
 * We're preparing for our first commit (i.e. we haven't committed anything yet)
 * There's nothing to "commit" in our directory--because it's empty!

## Adding Files to Your Staging Area

Let's add a file to our working directory so we have something for Git to manage:

```
touch data.txt
```

That command will generate an empty text file named "data.txt" in your current working directory. After creating that file, let's re-run the `git status` command:

![git status after touch](./assets/git-status-after-touch.png)

Like above, this status informs us we're still on the master branch and are preparing to make our first commit. However, this git status output differs from the git status output above in one important way--we now have "untracked files"!

Untracked files are files that are present in a Git-enabled directory that have not been "added" to the directory's version control system yet To add a file to your directory's version control system, we can use the following command: `git add FILENAME`. For example, to add our data.txt file to our version control system, let's run:

```
git add data.txt
```

That command doesn't return anything on the terminal. To investigate the change we just made, let's run another `git status`. That returns:

![git status after add](./assets/git-status-after-add.png)

Here we see we have some "changes to be committed"--that is to say, we have some files in our Staging Area.

## Committing Changes to Your Local Repository

Once we have files in our staging area, we can "commit" to those changes and push those changes to our project repository. To commit our changes, we can run:

```
git commit -m 'add data file'
```

This command indicates that we wish to commit all changes in our staging area, and we wish to assign a commit message that says 'add data file'. The commit message is a brief note to yourself and your teammates that indicates what you changed in your commit. Once issued, that command returns the following output:

![git commit](./assets/git-commit.png)

## Pushing Your Local Repository to Your Remote Repository

After commiting your changes, you can push those changes to your remote repository to share the changes with your teammates.

To do so, we first need to tell Git the address of our remote repository (i.e. the address of our GitHub repository). To do so, we can run the line that we copied above:

```
git remote add origin https://github.com/YOUR_GITHUB_USERNAME/learning-git.git
```

This line creates an alias named "origin" that points to the http address you specified (i.e. your github repository address). If you're curious, you can see where that alias is stored if you run `cat .git/config`, which will [display](./assets/git-config.png) your Git repository's internal configuration information in your terminal.

After creating an alias for your GitHub repository, you can push your changes to that repository by running:

```
git push origin master
```

This command indicates that you wish to push the `master` branch in your local repository to `origin`, an alias for your remote repository on GitHub.

 Feel free to consult the notes above as you do so!

***

## Understanding the Staging Area

In the example above, we added some files to our staging area by running `git add data.txt`. Let's further explore the staging area by changing our sample data file:

```
echo "hello git" > data.txt
```

If you now open data.txt in a text editor, you'll see that it now contains some content. If you run a `git status` command, you'll see that Git is aware your file changed:

![git status after modification](./assets/git-status-after-modification.png)

Let's add a new file as well:

```
touch secret.json
```

And run another `git status`:

![git status after add and modify](./assets/git-status-add-modify.png)

Here we see that we have made changes to our data.txt file, and have a new "untracked" file, secret.json. Let's add secret.json to our staging area:

```
git add secret.json
```

And run another `git status`:

![git status after add and modify](./assets/git-status-add-json.png)

Now let's suppose we want to remove secret.json from our staging area. To do so, we can use the `git reset` command:

```
git reset secret.json
```

And run another `git status`:

![git status after reset](./assets/git-status-after-reset.png)

As we can see, this removed secret.json from our staging area, which is now empty (hence the "no changes added to commit" in the git status response above).

This is just to say, we can add files to our staging area with `git add`, and can remove those files from our staging area with `git reset`.

***
#### CHALLENGE

Given what we covered above, see if you can add data.txt to your staging area, then see if you can remove it from your staging area. Once you're done, add all of your local files to your staging area and push them to GitHub.

***

## Pulling from a Remote Repository

So far we've made changes in our local respository and have then pushed those changes up to our remote repository on GitHub. Sometimes, however, your remote repository will have changes that are not present in your local repository. (For example, teammates could push changes to the remote repository, or you yourself might push changes to the remote repository from another machine.) In those situations, you'll want to "pull" those changes down to your local repository so that your local repository matches the remote repository.

Let's create some changes on your remote repository that aren't present in your local repository. To do so, let's navigate to `https://github.com/YOUR_USER_NAME/learning-git` and click the button that says "Create new file". Add a name and some content to your file then click the big green button at the bottom of the page that says "Commit new file". After doing so, you should see your new file in your repository.

If you run `ls` in your terminal, you'll note that that new file is not present in your local repository. Let's pull that file into your local repository. To do so, we can run:

```
git pull origin master
```

If you now run an `ls` in your directory, you'll see that it contains the file you added on GitHub:

![ls after pull](./assets/ls-after-pull.png)

Congratulations--you've just pulled content from your remote repository to your local repository!

***
#### CHALLENGE

Given what we covered above, see if you can add a file named README.md to your repository on GitHub, then see if you can pull that file into your local repository using Git.

***

## Getting Started With Branches

Each time we've run `git status` so far, the returned output has indicated that we're on the "master" branch. It's now time for us to discuss what this means.

Each "branch" in a Git repository is a separate representation of the data in the given repository. Different branches can have radically different ideas about what the given repository contains, and by switching between those branches, you can change the content that's displayed on the filesystem within the given repository.

To explore branches, let's create our first custom branch. We can do so by running:

```
git checkout -b my-new-branch
```

If you now run `git status`, you'll see that you're on a branch named "my-new-branch". Let's add some files to this branch:

```
touch a.txt b.txt c.txt
```

If you now run another `git status`, you'll see your new untracked files:

![new branch content](./assets/new-branch-content.png)

Let's add all those files to our staging area with a nice Git shorthand, then commit them all:

```
git add .
git commit -m 'add additional sample files'
```

After commiting those files, let's change back to the master branch and check the files present on the master branch:

```
git checkout master
ls
```

After running that `ls` command, you'll see that your new files (a.txt, b.txt, and c.txt) are missing! That's because you added them inside the branch named `my-new-branch`, not the `master` branch. Let's checkout to the branch with the files and show that they're still there:

```
git checkout my-new-branch
ls
```

That should show the files are indeed still present. Try toggling back and forth a few times between the "master" branch and the branch named "my-new-branch". Run some `ls` commands as you do so in order to investigate the content in each branch:

![changing branches](./assets/changing-branches.gif)

As we can see, each branch contains a distinct representation of the project content. That's important, because it allows you to keep one polished version of your codebase in your master branch, and allows you to experiment with new features in other branches without fear of ruining your master branch code.

## Merging Branches in Your Local Repository

There are two ways to combine content from branches. The first is to use the `merge` command:

```
git checkout master
git merge my-feature-branch
```

This will return output similar to the following:

![merge results](./assets/merge-results.png)

This response indicates that three new files were created in our master branch. Those files come from "my-new-branch" of course. By "merging" that branch into master, we ask Git to automatically combine the files in the two branches. Often times Git can do so without any trouble, as it is the case above. If Git can't automatically merge your branches, you will need to manually resolve any "merge conflicts" (see [here](https://help.github.com/articles/resolving-a-merge-conflict-using-the-command-line/) for a brief guide).

## Merging Branches on GitHub

Another way to merge branches is to push your new branch up to GitHub, then use GitHub to merge your new branch. Let's practice this technique.

First, let's make a new branch, make some changes in that branch, and commit those changes:

```
git checkout -b awesome-feature
touch server.js
git add server.js
git commit -m 'initial commit of server'
```

Now let's push that branch up to GitHub:

```
git push origin awesome-feature
```

The structure of this command is as follows:

```
git push DESTINATION BRANCH_TO_PUSH
```

After running that command, let's go back to your repository on GitHub. On your user page you should see a little yellow box with your new branch:

![new branch on github](./assets/new-branch-on-github.png)

Let's click the big green button that says "Compare & pull request". On the next page, click the big green button that says "Create pull request", and on the subsequent page, click the green button that says "Merge pull request". Congrats--you've just merged some branches!

***
#### CHALLENGE

Given what we covered above, see if you can add a file named README.md to your repository on GitHub, then see if you can pull that file into your local repository using Git.

***

# Group Activity: Building a Collaborative Madlib on GitHub

Finally, we come to our last task: contributing to open source projects on GitHub. The Open Source community is built around voluntary contributions individuals make to code repositories. In your futures as developers, you may want to contribute to these projects. Let's discuss how you can do so.

Earlier we practiced merging changes in a repository that you created. In what follows we'll discuss merging changes into repositories that you didn't create. To get started, you'll first want to "fork" a repository to which you wish to contribute. For the sake of this exercise, let's fork the repository that hosts this README.md file by navigating to https://github.com/YaleDHLab/lab-workshops:

![preparing to fork](./assets/preparing-to-fork.png)

Once there, click the icon in the upper right-hand-corner that says "Fork". Forking a repository makes a copy of that repository in your username's account. To see the repository you forked, click on your user's icon in the upper-right-hand corner of the navigation bar. If you then click the "Repositories" tab, you should see the forked repo.

After forking the repository, let's "clone" the forked repository down to your local machine. To "clone" a repository is simply to copy that repository from one server to another. In this case we'll clone the repository from a GitHub server to your local machine:

```
cd ..
git clone https://github.com/YOUR_USERNAME/lab-workshops
cd lab-workshops
```

If you run an `ls` inside lab-workshops, you'll see all the content of the repository you cloned. Our task from here is to make some changes to a particular set of files in the repository. There's a catch, though! Those files are located in a branch named `gh-pages` of the lab-workshops repository. Let's checkout into that branch:

```
git checkout gh-pages
```

Once we're on the "gh-pages" branch, let's change into the directory of interest:

```
cd command-line-git/parts-of-speech/
```

If you run an `ls` command in that branch, you'll see three JSON files: `adjectives.json`, `nouns.json`, and `verbs.json`, each of which contains a list of examples of the given part of speech. For example, here are the contents of the `nouns.json` file:

```
[
  "banker",
  "Irishman",
  "princess",
  "taxi driver"
]
```

Your mission is to modify the contents of one of those files. Make sure the list of items you write match the given filename's part of speech. Once you're done, validate that your final file is indeed valid JSON by pasting your updated file [here](https://jsonlint.com/).  If you click the "branches" icon on that page, you should see the "gh-pages" branch you just updated.

In our case, the pull requests we're making will update the data fed into a [simple madlibs website](http://yaledhlab.github.io/lab-workshops/command-line-git/):

![ls after pull](./assets/madlibs.png)

As we merge your changes, we'll see the terms you added on the webpage :tada: :monkey: :thumbsup:

Congratulations--you're now a contributor on an Open Source project!

# Going Further with Git

The following notes are meant to help resolve problems you might encounter in your future with Git.

#### Storing Your GitHub User Information

Rather than type out your GitHub username and password when pushing code to GitHub, it's helpful to save this information on your system. To do so, you can run:

```
git config --global user.name "YOUR_GITHUB_USERNAME"
git config --global user.email "YOUR_GITHUB_PASSWORD"
```

#### Multiple Git Users on One Machine

If there are multiple Git users on one machine, you can use the following syntax to explicitly state the username and password of the user who will perform a push or pull action:

```
git push<EMAIL_ADDRESS>gh-pages
```

#### Reviewing Your Git History

To review all commits made in your repository and their associated commit messages, we can run `git log`:

![git log](./assets/git-log.png)

To exit that view, just hit `q`.

#### Cleaning Up Old Branches

To list all branches in your repository, you can run:

```
git branch -a
```

To delete a given branch, you can run:

```
git branch -D BRANCH_NAME
```

To delete all merged branches, you can run the following (make sure you undstand the command before you run it!):

```
git branch --merged | egrep -v "(^\*|master|gh-pages)" | xargs git branch -d
```

# Questions? Difficulties?

If you have questions about Git or programming more generally, or would like help with your programming tasks, please feel free to stop by Yale's Digital Humanities Lab in Sterling Memorial Library, 316 during office hours--Tuesdays and Wednesdays 2-4.

repository: YaleDHLab/lab-workshops

gha_language: Jupyter Notebook

repo_name: YaleDHLab/lab-workshops


text:
# OpenTracing Common

> Common utilities for OpenTracing Instrumentation Plugins

[![Build Status](https://travis-ci.org/opentracing-contrib/java-common.svg?branch=master)](https://travis-ci.org/opentracing-contrib/java-common)
[![Coverage Status](https://coveralls.io/repos/github/opentracing-contrib/java-common/badge.svg?branch=master)](https://coveralls.io/github/opentracing-contrib/java-common?branch=master)
[![Javadocs](https://www.javadoc.io/badge/io.opentracing.contrib/common.svg)](https://www.javadoc.io/doc/io.opentracing.contrib/common)
[![Released Version](https://img.shields.io/maven-central/v/io.opentracing.contrib/common.svg)](https://mvnrepository.com/artifact/io.opentracing.contrib/common)

The <ins>OpenTracing Common</ins> library is a collection of utilities used in common by OpenTracing Instrumentation Plugins.

## Usage

Add the following dependency to your project's POM:

```xml
<dependency>
  <groupId>io.opentracing.contrib</groupId>
  <artifactId>common</artifactId>
  <version>0.1.4</version>
</dependency>
```

## License

This project is licensed under the Apache 2 License - see the [LICENSE.txt](LICENSE.txt) file for details.

repository: opentracing-contrib/java-common

gha_language: Java

repo_name: opentracing-contrib/java-common


text:
Related Work
============

Similar testing processes are load testing and stress testing. Load testing is .... Stres testing is .... This however different from measering elasticity. __Give reasons with sources also for load and stress testing__
“Load testing is the process of putting demand on a system or device and measuring its response. Stress testing refers to tests that determine the robustness of software by testing beyond the limits of normal operation”.

TODO

Related works (Gatling, Chaos Monkeys) -> stress testing -> not elasticity in particular

Papers on dynamic scaling, fault tolerant programming etc.

repository: ItsMeijers/elasticity-test

repo_name: ItsMeijers/elasticity-test


text:
Bundlizer [![Stillmaintained](http://stillmaintained.com/Tomohiro/bundlizer.png)](http://stillmaintained.com/Tomohiro/bundlizer)
================================================================================

The Bundlizer is RubyGems and Bundler apps management tool from the command line. _NO MORE sudo_

[![Dependency Status](https://gemnasium.com/Tomohiro/bundlizer.png)](https://gemnasium.com/Tomohiro/bundlizer)
[![Build Status](https://travis-ci.org/Tomohiro/bundlizer.png?branch=master)](https://travis-ci.org/Tomohiro/bundlizer)

Table of Contents
--------------------------------------------------------------------------------

- [Requirements](#requirements)
- [Getting Started](#getting-started)
    - [Installation](#installation)
    - [Upgrade the Bundlizer](#upgrade-the-bundlizer)
    - [Uninstall the Bundlizer](#uninstall-the-bundlizer)
- [Basic Usage](#basic-usage)
    - [Install Gem apps from RubyGems.org](#install-gem-apps-from-rubygemsorg)
    - [Install Bundler apps from GitHub Repository](#install-bundler-apps-from-github-repository)
    - [Set the local application-specific Ruby version](#set-the-local-application-specific-ruby-version)
    - [Show the installed apps](#show-the-installed-apps)
    - [Show the dependencies of an installed app](#show-the-dependencies-of-an-installed-app)
    - [Add dependent gem to the app](#add-dependent-gem-to-the-app)
    - [Update apps](#update-apps)
    - [Uninstall](#uninstall)
- [Tips](#tips)
    - [Install autocompletion](#install-autocompletion)
    - [Backup and Restore app list](#backup-and-restore-app-list)
- [LICENSE](#license)

---

Requirements
--------------------------------------------------------------------------------

- OSX or Ubuntu
- Git
- Bundler 1.1 or later

Getting Started
--------------------------------------------------------------------------------

### Installation

To install the Bundlizer, open a terminal and run this command:

    $ curl -L git.io/bundlizer-install | sh

Source `~/.bundlizer/etc/bashrc` in your `~/.bash_profile` or `~/.zshenv`:

    $ echo 'source $HOME/.bundlizer/etc/bashrc' >> ~/.bash_profile

Restart your shell or `exec $SHELL`

### Upgrade the Bundlizer

    $ bundlizer upgrade

### Uninstall the Bundlizer

    $ rm -rf ~/.bundlizer

Basic Usage
--------------------------------------------------------------------------------

### Install Gem apps from RubyGems.org

Install (e.g. Ruby on Rails: https://rubygems.org/gems/rails):

    $ bundlizer install rails
    Searching in RubyGems...
    Fetching: i18n-0.6.0.gem (100%)
    Fetching: multi_json-1.3.6.gem (100%)
    Fetching: activesupport-3.2.6.gem (100%)
    Fetching: builder-3.0.0.gem (100%)
    Fetching: activemodel-3.2.6.gem (100%)
    Fetching: rack-1.4.1.gem (100%)
    Fetching: rails-3.2.6.gem (100%)
    ..snip..
    Successfully installed builder-3.0.0
    Successfully installed activemodel-3.2.6
    Successfully installed rack-1.4.1
    Successfully installed rails-3.2.6
    26 gems installed
    It was installed 'erubis' into /home/tomohiro/.bundlizer/apps/erubis
    It was installed 'rackup' into /home/tomohiro/.bundlizer/apps/rackup
    It was installed 'rails' into /home/tomohiro/.bundlizer/apps/rails
    It was installed 'rake2thor' into /home/tomohiro/.bundlizer/apps/rake2thor
    It was installed 'thor' into /home/tomohiro/.bundlizer/apps/thor
    It was installed 'tilt' into /home/tomohiro/.bundlizer/apps/tilt
    It was installed 'tt' into /home/tomohiro/.bundlizer/apps/tt

You can start a rails project as usual:

    $ rails -v
    Rails 3.2.6
    $ rails new awesome-project
    $ cd awesome-project
    $ bundle install --path gems
    $ rails s
    => Booting WEBrick
    => Rails 3.2.6 application starting in development on http://<IP_ADDRESS>:3000
    => Call with -d to detach
    => Ctrl-C to shutdown server
    [2012-07-12 19:54:49] INFO  WEBrick 1.3.1
    [2012-07-12 19:54:49] INFO  ruby 1.9.3 (2012-04-20) [i686-linux]
    [2012-07-12 19:54:49] INFO  WEBrick::HTTPServer#start: pid=1479 port=3000

### Install Bundler apps from GitHub repository

Install (e.g. heroku: `git://github.com/heroku/heroku.git`):

    $ bundlizer install heroku/heroku
    Cloning into heroku...
    remote: Counting objects: 9595, done.
    remote: Compressing objects: 100% (3304/3304), done.
    remote: Total 9595 (delta 6435), reused 9094 (delta 5994)
    Receiving objects: 100% (9595/9595), 1.18 MiB | 316 KiB/s, done.
    Resolving deltas: 100% (6435/6435), done.

    Start bundle installing to /home/tomohiro/.bundlizer/bundles/heroku
    Fetching gem metadata from http://rubygems.org/.........
    Installing rake (0.9.2)
    ..snip..
    Using heroku (2.18.1) from source at .
    ..snip..
    Installing webmock (1.7.7)
    Using bundler (1.1.rc.7)
    Your bundle is complete! It was installed into ./vendor/bundle
    It was installed `heroku` into /home/tomohiro/.bundlizer/apps/heroku

You don't need `bundle` command. You can use `<cmd>` instead of `bundle exec <cmd>`:

    $ type heroku
    heroku is /home/tomohiro/.bundlizer/apps/heroku
    $ heroku version
    heroku-gem/2.19.0

Or, You can run the following command if you want use `https://github.com/...` or `https://bitbucket.org/...`:

    $ bundlizer install https://bitbucket.org/foo/bar.git

### Set the local application-specific Ruby version

Use the `rbenv local` command by [rbenv](https://github.com/sstephenson/rbenv).

Set 2.0.0-p0:

    $ bundlizer use 2.0.0-p0 heroku
    Use 2.0.0-p0 at heroku

Set 1.9.3-p392:

    $ bundlizer use 1.9.3-p392 rails
    Use 1.9.3-p392 at rails

Unset:

    $ bundlizer use --unset rails
    Unset local Ruby version at rails

### Show the installed apps

    $ bundlizer list --verbose
    Gem/Bundler apps installed by the Bundlizer:

     * foreman (rubygems.org: http://rubygems.org/gems/foreman)
         apps: foreman,rake2thor,thor
     * guard (git://github.com/guard/guard.git)
         apps: guard
     * heroku (git://github.com/heroku/heroku.git)
         apps: heroku
         ruby: 2.0.0-preview1
     * pry (git://github.com/pry/pry.git)
         apps: pry
         ruby: 1.9.3-p362
     * rails (rubygems.org: http://rubygems.org/gems/rails)
         apps: erubis,rackup,rails,rake2thor,thor,tilt,tt
     * yard (git://github.com/lsegal/yard.git)
         apps: yard,yardoc,yri

### Show the dependencies of an installed app

    $ bundlizer depends rails

### Add dependent gem to an app

Example: add `veewee` gem to the `vagrant` app:

    $ bundlizer install vagrant
    $ bundlizer depends vagrant --add-gem veewee

Example: add `net-ssh`, `net-scp` gem to the `backup` app:

    $ bundlizer install backup
    $ bundlizer depends backup --add-gem net-ssh -v '~> 2.3.0'
    $ bundlizer depends backup --add-gem net-scp -v '~> 1.0.4'

### Update apps

Update the app:

    $ bundlizer update heroku

Update all apps:

    $ bundlizer update

### Uninstall

    $ bundlizer uninstall heroku
    uninstall: remove app 'heroku'? (yes/no) yes
    rm -f /home/tomohiro/.bundlizer/apps/heroku
    rm -rf /home/tomohiro/.bundlizer/bundles/heroku
    It was Uninstalled 'heroku'

Tips
--------------------------------------------------------------------------------

### Install autocompletion

Sourcing `~/.bundlizer/completions/bundlizer.zsh` will set up that, for Zsh users:

    $ echo 'source "$HOME/.bundlizer/completions/bundlizer.zsh"' >> ~/.zshenv

### Backup and Restore app list

Backup installed app list:

    $ bundlizer list | tail -n +3 > ~/bundlizer_installed_apps

Reinstall app from backup installed app list:

    $ cat ~/bundlizer_installed_apps | xargs bundlizer install

---

LICENSE
--------------------------------------------------------------------------------

© 2012 - 2013 Tomohiro TAIRA.
This project is licensed under the MIT license.
See LICENSE for details.

repository: naoto/bundlizer

repo_name: naoto/bundlizer


text:
:mortar_board: Stanford - CS224n : Natural Language processing with deep learning

+ Author : [C. Manning](https://nlp.stanford.edu/manning/){:.mdLink}, [R. Socher](http://www.socher.org/){:.mdLink}
+ Review : Excellent class for understanding state of the art NLP methods. As the name of the class suggests, it talks very little in "older" NLP methods, it focuses on deep learning and the use of the "newer" word embeddings (~2013). You should probably have some machine learning knowledge to take ful advantage of the class.
+ Recommend as :
    * Course to effectively apply and understand state-of-the art NLP methods.
+ Notes : Probably the most famous state-of-the art NLP class (in 2017). The NLP version of the other famous Stanford class : CS231n. I watched the older version but I think that the review still holds (even though 2 courses merged in this one).
+ Level : Intermediate-Advanced.
+ [Link](https://www.youtube.com/playlist?list=PLU40WL8Ol94IJzQtileLTqGZuXtGlLMP_){:.mdLink}

:movie_camera: Coursera - Natural Language Processing

+ Author : [M. Collins](http://www.cs.columbia.edu/~mcollins/){:.mdLink}.
+ Review : Excellent MOOC which gives you a in depth view of the major algorithms which were done in NLP before the "deep-learning era". I've rarely seen a professor keeping such a level of clarity during the whole course.
+ Recommend as :
    * Course if you are starting in NLP but are serious about continuing.
    * Course if you have applied deep learning to NLP, but would like to really understand this very interesting field.
+ Notes : Unfortunately not given on Coursera anymore. I understand that giving such a class must take a huge amount of time, but I'm a bit disappointed that they didn't put the old videos on youtube. Thankfully, you can still find someone who put the videos up.
+ Level : Beginner-Intermediate.
+ [Link](https://www.youtube.com/watch?v=mieV29RVpuQ&index=1&list=PL0ap34RKaADMjqjdSkWolD-W2VSCyRUQC){:.mdLink}

:computer: Ruder.io

+ Author : [S. Ruder](http://ruder.io/about/){:.mdLink}.
* Review : Top quality NLP and Deep Learning posts, that are very easy to read.
+ Level : Advanced.
+ [Link](http://ruder.io/){:.mdLink}

:computer: Other Great Blogs

* [Explosion](https://explosion.ai/blog/){:.mdLink} applied NLP

:headphones: NLP Highlights

+ Author : [M. Gardner](http://allenai.org/team/mattg/){:.mdLink}, [W. Ammar](http://allenai.org/team/waleeda/){:.mdLink}.
+ Review : Very good NLP podcast where the 2 research scientists discuss about a new paper in the field or interview other scientists about their recent work. Great way to keep up with the research in the field of NLP! The only downside with this podcast compared to the more general ones is that I find it hard to multi-task while listening to it.
+ Recommend as :
    * PoPodcast to keep up with the recent papers and research in the field of NLP.
+ Level : Advanced-Expert.
+ [Link](https://itunes.apple.com/us/podcast/nlp-highlights/id1235937471){:.mdLink}


text:
[![Build Status](https://travis-ci.org/pabzdzdzwiagief/initialization.svg?branch=master)](https://travis-ci.org/pabzdzdzwiagief/initialization)
[![Coverage Status](https://coveralls.io/repos/pabzdzdzwiagief/initialization/badge.svg?branch=master)](https://coveralls.io/r/pabzdzdzwiagief/initialization?branch=master)

initialization
==============

A Scala compiler plugin. Detects code that may run into any of several Scala's
initialization order
[pitfalls](http://docs.scala-lang.org/tutorials/FAQ/initialization-order.html).
It does not attempt to prevent every possible reference-before-initialization.
Still, at least some classes of such errors are covered.

The difference between this and `-Xcheckinit` compiler switch is that checks
are done purely during compilation time. There are no costs incurred
at runtime, only a library dependency is brought for necessary metadata.

usage
-----

Add this to your `build.sbt`:

     autoCompilerPlugins := true

     libraryDependencies += compilerPlugin("com.github.pabzdzdzwiagief" %% "initialization" % "0.11.0-rc.2")

     libraryDependencies += "com.github.pabzdzdzwiagief.initialization" %% "annotation" % "0.11.0-rc.2"

example
-------

    // simple.scala

    pacakge localhost

    class simple {
      m1()
      val v1 = 4

      def m1() {
        println(v1)
      }
    }

The code above will generate following warning:

    simple.scala:10: warning: value v1 is referenced before assignment
            at localhost.simple.m1(simple.scala:6)
            at localhost.simple.<init>(simple.scala:5)

        println(v1)
                ^

For more examples see `src/test/resources/examples/positives/`.

limitations
-----------

#### code compiled without the plugin

Initialization problems can be spotted only in the code compiled with
the plugin. When e.g. extending a class that comes from some external
library, the analysis will loose its track every time a call graph descends
to methods defined in that class.

#### false positives

The plugin may happen to be overreactive. In such cases use standard
`@unchecked` annotation.

    pacakge localhost

    import util.Random.{nextBoolean => iFeelLucky}

    class uncheck {
      (m1() : @unchecked) // no warnings
      val v1 = 4

      def m1() {
        println(if (iFeelLucky) v1 else 4)
      }
    }

#### functions

All functions are always treated as if they were called immediately after
being created. The primary reason is handling a quite typical case:

    class usageOfForLoop {
      for (i <- 1 to 10) {
        println(notInitialized)
      }

      val notInitialized = 4
    }

which uses a compiler-generated function underneath. Tracking down where do
functions passed as parameters eventually end up being called requires
far broader and more detailed analysis than one the plugin performs.

In some cases changing a function definition to a local method may help:

    // change this:
    val inc = {(x: Int) => x + 1}

    // to this:
    def inc(x: Int) = x + 1

and while any later partial application/currying will trigger reference check
anyway, it will at least happen in a closer proximity to the actual function
call.

test cases
----------

To add a test case, put a file in `src/test/resources/positives/` directory
(or in `negatives/` for tests with no compilation warnings expected) with
the following format:

    // [one-line title of the test case]

    package localhost

    [scala code to compile]

    // [expected compilation messages, with one-space margin]
    //
    //

to have it automatically picked up when tests are executed.

license
-------

[BSD 2-Clause](http://opensource.org/licenses/BSD-2-Clause)

repository: pabzdzdzwiagief/initialization

gha_language: Scala

repo_name: pabzdzdzwiagief/initialization


text:
[![CircleCI](https://circleci.com/gh/giantswarm/gatekeeper-rules-app.svg?style=shield)](https://circleci.com/gh/giantswarm/gatekeeper-rules-app)

# gatekeeper-rules-app chart

Giant Swarm offers a gatekeeper-rules-app Managed App which can be installed in tenant clusters.
Here we define the gatekeeper-rules-app chart with its templates and default configuration.

## Credit

* https://github.com/open-policy-agent/gatekeeper

repository: giantswarm/gatekeeper-rules-app

repo_name: giantswarm/gatekeeper-rules-app


text:
## 5.5 Characters Pointers and Functions

### Key points:

1. String copy - is standard library function <stdlib.h>

    Array version:

    ```
    void strcpy(char *s, char *t) {
        int i;

        i = 0;

        while ((s[i] = t[i]) != '\0') {
            i++;
        }
    }
    ```

    Pointers version:

    ```
    void strcpy(char *s, char *t) {
        while (*s++ = *t++) ;
    }
    ```

2. String compare

    Array:

    ```
    int strcmp(char *s, char *t) {
        int i;

        for (i = 0; s[i] == t[i]; i++) {
            if (s[i] == '\0')
                return 0;
        }

        return s[i] - t[i];
    }
    ```

    ```
    int strcmp(char *s, char *t) {
        while (*s++ == *t++) {
            if (!*s) {
            return 0;
            }
        }

        return *s - *t;
    }
    ```

3. *--p - Decrements pointer, before fetching it.

    In fact pair of expressions:

    ```
    // push val onto stack
    *p++ = val;
    // pop top of stack into val
    val = *--p;
    ```

### Exercises:

#### Exercise 5-3
  Write a pointer version of strcat(s, t) copies the string t to the end of s.

  Refer to the code in **strcat.c**.

##### Compile and run the code:

```
$ gcc -o strcat strcat.c

$ ./strcat
```

#### Exercise 5-4
  Write a function strend(s, t), which returns 1 if the string t occurs at the end of the string s, and zero otherwise.

  Refer to the code in **strend.c**.

##### Compile and run the code:

```
$ gcc -o strend strend.c

$ ./strend
```

#### Exercise 5-5
  Write versions of of the lib functions **strncpy**, **strncat**, and **strncmp**, which operate on at most the first n characters of their argument strings.
  For example, strncpy(s, t, n) copies at most n characters of t to s.

  Refer to the code in **strend.c**.

##### Compile and run the code:

```
$ gcc -o strncpy strncpy.c

$ ./strncpy
```

```
$ gcc -o strncat strncat.c

$ ./strncat
```

```
$ gcc -o strncmp strncmp.c

$ ./strncmp
```

#### Exercise 5-6
  Rewrite appropriate programs from earlier chapters and exercises with pointers instead of arrays.
  As an example getline, atoi, itoa, reverse, strindex, getop.

##### Compile and run the code:

```
$ gcc -o TODO TODO.c

$ ./TODO
```


text:
Buffs are limited scope modifications of characters. They can be applied through weapons, enemies and world objects(traps, random objects)

These are some examples of what the buff system should be able to do minimally (procedurally):

* A buff that deals damage every second for 10 seconds
* A buff that increases the movespeed of the character while in a certain radius

These are some examples of what a buff system **ideally** should be able to do (procedurally):

* A buff that heals the player 3 times upon taking lethal damage
* A buff that increases damage every time the player hits an enemy but is lost after some time
* A buff that kills the owner after taking any kind of damage
* A buff that binds two characters together, making them share a health pool
* A buff that reserves a resource for a character in exchange for a bonus in attack damage

Use modules to build behavior:
	One module to tick every x dealing damage
	One module to kill the buff after x seconds

Designer is responsible for creating modules that do not interfere with eachother(somehow)

Buffs have 2 parts. One blueprint part, and one instanced part:
* The blueprint part contains the information for the buff type
* The instanced part contains the information stored per buff instance

For example, a weapon might apply a buff on hit. The weapon then has the buff blueprint create an instance on the character when hitting them.

BuffBlueprint		| LifetimeBuffProperty
BuffInstance		| TimeLeft

repository: nicolasgustafsson/WonderMake

repo_name: nicolasgustafsson/WonderMake


text:
# Large Scale Machine Learning Suite for Julia

[![Build Status](https://github.com/AStupidBear/MLSuite.jl/workflows/CI/badge.svg)](https://github.com/AStupidBear/MLSuite.jl/actions)
[![Coverage](https://codecov.io/gh/AStupidBear/MLSuite.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/AStupidBear/MLSuite.jl)

## Installation

```julia
using Pkg
pkg"add MLSuite"
```

## Install Driverless AI

```bash
url=https://gist.githubusercontent.com/AStupidBear/f8a7e66bb9313483cffae923e775510e/raw/dai.Dockerfile.py
python -c "$(wget -qO- $url)"
```

gha_language: Julia