text:
# NOTE: THIS REPO IS OBSOLETE.

## What is this?

Uh… It’s core engine of something like Windows 93 (which is not related to this). It has windows, icons, and status bar. Works fully on client side, you can add in your own work with only front-end supported page like github.io.

## What I need to develop/use this?

Editor, webpack, node.js and some packages. Typescript and SCSS.
JS and CSS for fake software development. All others are Typescript and SCSS.

## So… What’s the point of this?

Nothing. Maybe April joke?

# Common Rules

* File names must be case-insensitive. All file names are low characters.
*	__lib__ is library, __src__ is source folder.
  * At Webpack require, \_\_lib\_\_ is alias of lib folder and \_\_src\_\_ is alias of src folder.

## Structure
FakeOS is component-based program. As a developer, you can add any component or modules.
* __lib__
  * components
  * modules
  * common.scss : global stylesheet. SCSS.
  * index.scss : stylesheet entry
  * index.ts : component/module entry
* __src__
  * see "For users" guide.

# For users
## src structure:
* index.ts : add default values when the program is loaded.
* (and each components directory)
* resource : resource directory
  * background.jpg
  * default_icon.png : If Icon files are broken, this is used as default. (mandatory)
  * icons : for custom icons, which can be implemented in future.
### About each components…
* desktop
  * menu.ts : right-click menu file, which exported by “export default”. See below to how to make menu. (mandatory)
* statusbar
  * menu.ts: way of writing is same as desktop menu, but it isn’t right-click but a start menu. (mandatory)
* window
  * They are (program group folder)/program. For example, you can make system/explorer or system/cmd.
  * In a program, it contains:
    * favicon.png (Not mandatory)
    * index.html (mandatory)
      *	You can make more custom html page to load.
    * *program_name*.css (mandatory)
    * *program_name*.js (Not mandatory)
    * *program_name*.ts (mandatory)
    ```typescript
    import { WindowData } from "__lib__/index";

     const app={
     title: “title name”,
     resizable: true|false,
     menu?: [menuObject], //optional, see menu structure section
     }
     export default app;
     ```
    * *program_name*.system.ts (only in "system" folder, not mandatory)

### libraries:
* new window for _new WindowObject(winName:string)_
 * This calls from "program info" file from src/window. (See above!)
* new dialog for _new DialogObject(winName: string, message: string, buttons: [string, () => void][], parent: WindowObject | null = WindowObject.Now())_
* new icon for _new IconObject(iconName: string, Action?: (() => void) | null, iconLabel?: string, iconPicName?: string, controller=IconController.Get())_
* new Right-click menu for _new RightMenu(target: HTMLElement, menu: Menu, direction: MenuDirection = MenuDirection.down)_
* closing window for WIN.Close()
  * use WIN.CloseAll() instead for closing the dialog and its parent

### Menu structure
   ```typescript
    {
       name: “string”, //menu text to be shown
       action: ()=>void(), //don’t use only function name(like WIN.Close).
       menu: [ … ] //submenu, which contains “menu structure”
   }
   ```
* menu is "Menu" type array. (Menu[])
* Since menu contains function, it cannot be a JSON. But if you want to make JSON, remember to change the action to string.
* If you’re not sure, see the example in the file.

# For developers
## Guide
* Remember to call every stylesheets to lib/index.scss after adding. And removing too.
 * You can call to lib/index.ts if you want. This can make code clean, if you call it often and the path is complicated.
What’s Component and what’s module
* Class and most method names are PascalCase. Fields and properties are either PascalCase or camelCase.
* Components are directly used by library user and contains main HTML or CSS Element template.
* Modules used by components. Even it contains CSS,
  * Module make and attach HTML Elements through the TS code.
* If not sure (rightclick.ts), if it doesn’t contain HTML/CSS element, go to module.
## Component Rules
* Main instantiable name and its skeleton ends with ”Object”
* Instantiable objects’ controller name is “NameController” and they’re singleton. (Exception: IconController is "protected" for Explorer)
* right click menu is menu_name.ts in src directory.
* If the component is a library (can called by library user), add to lib/index.js
* Component structures are:
  * (component).html (not always )
  * (component).css
  * src
    *	(component).ts
    * (can add more ts files here)

## TODO
* Please make more programs!
* Icon multiselect
* Recycle bin
* Sound feature
* If you found some bugs, please report/fix it!
* Make documentation web page <3

## Still not sure?
In the src directory, you can read some test codes and learn how to use.

__Issues tab is always open.__

If you want to commit something, just do it. If the code doesn't follow the rules, I can change it.

repository: rnielikki/fakeos

repo_name: rnielikki/fakeos


text:
---
title: Proof-of-work (PoW)
description: An explanation of the proof-of-work consensus protocol and its role in Ethereum.
lang: en
sidebar: true
incomplete: true
---

Ethereum, like Bitcoin, currently uses a consensus protocol called **[Proof-of-work (PoW)](https://wikipedia.org/wiki/Proof_of_work)**. This allows the nodes of the Ethereum network to agree on the state of all information recorded on the Ethereum blockchain and prevents certain kinds of economic attacks.

Over the next year, proof-of-work will be phased out in favour of **[Proof-of-stake (PoS)](/developers/docs/consensus-mechanisms/pos)**. The transition to proof-of-stake will also phase out mining from Ethereum. [More on The Merge.](/upgrades/merge/)

## Prerequisites {#prerequisites}

To better understand this page, we recommend you first read up on [transactions](/developers/docs/transactions/), [blocks](/developers/docs/blocks/), and [consensus mechanisms](/developers/docs/consensus-mechanisms/).

## What is Proof-of-work (PoW)? {#what-is-pow}

Proof-of-work is the mechanism that allows the decentralized Ethereum network to come to consensus, or agree on things like account balances and the order of transactions. This prevents users from "double spending" their coins and ensures that the Ethereum chain is tremendously difficult to attack or manipulate.

## Proof-of-work and mining {#pow-and-mining}

Proof-of-work is the underlying algorithm that sets the difficulty and rules for the work miners do. Mining is the "work" itself. It's the act of adding valid blocks to the chain. This is important because the chain's length helps the network follow the correct Ethereum chain and understand Ethereum's current state. The more "work" done, the longer the chain, and the higher the block number, the more certain the network can be of the current state of things.

[More on mining](/developers/docs/consensus-mechanisms/pow/mining/)

## How does Ethereum's proof-of-work work? {#how-it-works}

Ethereum transactions are processed into blocks. Each block has a:

- block difficulty – for example: 3,324,092,183,262,715
- mixHash – for example: `0x44bca881b07a6a09f83b130798072441705d9a665c5ac8bdf2f39a3cdf3bee29`
- nonce – for example: `0xd3ee432b4fb3d26b`

This block data is directly related to proof-of-work.

### The work in proof-of-work {#the-work}

The proof-of-work protocol, Ethash, requires miners to go through an intense race of trial and error to find the nonce for a block. Only blocks with a valid nonce can be added to the chain.

When racing to create a block, a miner will repeatedly put a dataset, that you can only get from downloading and running the full chain (as a miner does), through a mathematical function. The dataset gets used to generate a mixHash below a target nonce, as dictated by the block difficulty. The best way to do this is through trial and error.

The difficulty determines the target for the hash. The lower the target, the smaller the set of valid hashes. Once generated, this is incredibly easy for other miners and clients to verify. Even if one transaction were to change, the hash would be completely different, signalling fraud.

Hashing makes fraud easy to spot. But proof-of-work as a process is also a big deterrent to attacking the chain.

### Proof-of-work and security {#security}

Miners are incentivised to do this work on the main Ethereum chain. There is little incentive for a subset of miners to start their own chain – it undermines the system. Blockchains rely on having a single state as a source of truth. And users will always choose the longest or "heaviest" chain.

The objective of proof-of-work is to extend the chain. The longest chain is most believable as the valid one because it's had the most computational work done.  That's because a malicious miner would need to always solve the block nonce faster than everyone else.

To consistently create malicious yet valid blocks, you'd need over 51% of the network mining power to beat everyone else. You'd need a lot of computing power to be able to do this amount of "work". And the energy spent might even outweigh the gains you'd make in an attack.

### Proof-of-work economics {#economics}

Proof-of-work is also responsible for issuing new currency into the system and incentivizing miners to do the work.

Miners who successfully create a block get rewarded with two freshly minted ETH but no longer receive all the transaction fees, as the base fee gets burned, while the tip and block reward goes to the miner. A miner may also get 1.75 ETH for an uncle block.  Uncle blocks usually happen due to network latency.

## Finality {#finality}

A transaction has "finality" on Ethereum when it's part of a block that can't change.

Because miners work in a decentralized way, two valid blocks can get mined at the same time. This creates a temporary fork. Eventually, one of these chains will become the accepted chain after a subsequent block has been mined and added, making it longer.

But to complicate things further, transactions rejected on the temporary fork may have been included in the accepted chain. This means it could get reversed. So finality refers to the time you should wait before considering a transaction irreversible. For Ethereum, the recommended time is six blocks or just over 1 minute. After six blocks, you can say with relative confidence that the transaction was successful. You can wait longer for even greater assurances.

Finality is something to bear in mind when designing dapps. It would be a poor user experience to misrepresent transaction information to your users, especially if the transaction is of high value.

Remember, this timing doesn't include the wait times for having a transaction picked up by a miner.

## Proof-of-work energy-usage {#energy}

A major criticism of proof-of-work is the amount of energy output required to keep the network safe. To maintain security and decentralization, Ethereum on proof-of-work consumes 73.2 TWh annually, the energy equivalent of a medium-sized country like Austria.

## Pros and cons {#pros-and-cons}

| Pros                                                                                | Cons                                                                                |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| Proof-of-work is neutral. You don't need ETH to get started and block rewards allow you to go from 0ETH to a positive balance. With [proof-of-stake](/developers/docs/consensus-mechanisms/pos/) you need ETH to start with. | Proof-of-work uses up so much energy that it's bad for the environment.                                                                      |
| Proof-of-work is a tried and tested consensus mechanism that has kept Bitcoin and Ethereum secure and decentralized for many years.                                                                                | If you want to mine, you need such specialized equipment that it's a big investment to start.                                                |
| Compared to proof-of-stake it's relatively easy to implement.                                                                                | Due to increasing computation needed, mining pools could potentially dominate the mining game, leading to centralization and security risks. |

## Compared to proof-of-stake {#compared-to-pos}

At a high level, proof-of-stake has the same end goal as proof-of-work: to help the decentralized network reach consensus securely. But it has some differences in process and personnel:

- Proof-of-stake switches out the importance of computational power for staked ETH.
- Proof-of-stake replaces miners with validators. Validators stake their ETH to activate the ability to create new blocks.
- Validators don't compete to create blocks, instead they are chosen at random by an algorithm.
- Finality is clearer: at certain checkpoints, if 2/3 validators agree on the state of the block it is considered final. Validators must bet their entire stake on this, so if they try to collude down the line, they'll lose their entire stake.

[More on proof-of-stake](/developers/docs/consensus-mechanisms/pos/)

## More of a visual learner? {#visual-learner}

<YouTube id="3EUAcxhuoU4" />

## Further Reading {#further-reading}

- [Majority attack](https://en.bitcoin.it/wiki/Majority_attack)
- [On settlement finality](https://blog.ethereum.org/2016/05/09/on-settlement-finality/)

### Videos {#videos}

- [A technical explanation of proof-of-work protocols](https://youtu.be/9V1bipPkCTU)

## Related Topics {#related-topics}

- [Mining](/developers/docs/consensus-mechanisms/pow/mining/)
- [Proof-of-stake](/developers/docs/consensus-mechanisms/pos/)

license: MIT

branch_name: refs/heads/dev

extension: md

gha_language: Markdown

gha_license_id: MIT

license_type: permissive


text:
## Using presets

To simplify  might do something like:

```js
options: {
  permalinks: {
    preset: 'pretty',
    structure: ':archives/:categories',
  },
  files: {
    './blog/': ['./templates/blog/*.hbs']
  }
}
```

Which, following the `dest + structure + preset` pattern, would result in:

```js
./blog/archives/categories/foo/index.html
```

## Path separators

You don't have to use slashes (`/`) only in your permalinks, you can use `-` or `_` wherever you need them as well. For example, this is perfectly valid:

```
:YYYY_:MM-:DD/:slug:category:foo/:bar/index.html
```

**Warning**, this should be obvious, but make sure not to use a `.` in the middle of your paths, especially if you use Windows.

## Pretty links

Pretty links involve saving an "index.html" to each directory, with the tile, file name or slug as the basename of the directory:

```js
assemble: {
  blog: {
    options: {
      permalinks: {
        structure: ':category/:slug/:index.html'
      }
    },
    files: [
      {expand: true, cwd: 'templates/', src: ['*.hbs'], dest: 'blog/', ext: '.html'}
    ]
  }
}
```

This would result in a directory structure that looks something like this:

```
/programming/my-node-js-post/index.html
/programming/my-javascript-post/index.html
/programming/my-assemble-post/index.html
```

## Dynamically build slugs

You can even dynamically build up strings using Lo-Dash templates:

```yaml
---
date: 1-1-2014

# Dynamically build the slug for example
area: business
section: finance
slug: <%= area %>-<%= section %>
---
```
With this config:

```js
blog: {
  options: {
    permalinks: {
      structure: ':year/:month/:day/:slug/:title.html'
    }
  },
  files: {
    'blog/': ['posts/*.hbs']
  }
}
```

Would render to:

```
blog/2014/01/01/business-finance/index.html
```

## More examples

Keep in mind that the date is formatted the way you want it, you don't need to follow these examples. Also, some of these variables will only work if you add that property to your pages, and setup the replacement patterns.

```js
:YYYY/:MM/:DD/news/:id/index:ext
//=> dest + '/2014/01/01/news/001/index.html'

:YYYY/:MM/:DD/:mm/:ss/news/:id/index:ext
//=> dest + '/2014/01/01/40/16/news/001/index.html'

:year/:month/:day/:basename:ext
//=> dest + '/2014/01/01/my-post.html'

blog/:year-:month-:day/:basename:ext
//=> dest + 'blog/2014-01-01/my-post.html'

:date/:basename:ext
//=> dest + '2014-01-01/my-post.html'

:year/:month/:day/:category/index.html
//=> dest + '/2014/01/01/javascript/index.html'

:year/:month/:day/:slug/index.html
//=> dest + '/2014/01/01/business-finance/index.html'
```

repository: mostafah/permalinks

branch_name: refs/heads/master

repo_name: mostafah/permalinks


text:
---
title: Block of Emerald
layout: document
---
## Detail

|Kind|Content|
|---|---|
|Description|Block of Emerald|
|Type|[Blocks](Blocks)|
|Production Tool|[Crafting Table](Crafting_Table)|

## Recipe

|Result|Materials|
|---|---|
|[Block of Emerald](Block_of_Emerald)x1|[Emerald](Emerald)x9|

## Materials that can be crafted

[Emerald](Emerald)

branch_name: refs/heads/main


text:
## KnotXpert® of KnotDB®
A manually curated dedicated computational proteomics proteins knots database.

### About
KnotXpert®, is a data visualisation engine for proteins knots database.

It's driven by Topology - a branch of mathematics, mainly geometric topology — which is the study of manifolds and maps between them, particularly embeddings of one manifold into another; primarily it includes Knot theory and Graph Theory — is the study of graphs, which are mathematical structures used to model pairwise relations between objects.

repository: jorenberg/KnotDB

repo_name: jorenberg/KnotDB


text:
# Cyber Flower: Digital Valentine

    'Roses are red,
     Violets are blue,
     This flower changes color,
     To show its love for you.'

Load this on a Gemma M0 running CircuitPython and it will smoothly animate
the DotStar LED between different color hues.  Touch the D0 pad and it will
cause the pixel to pulse like a heart beat.  You might need to also attach a
wire to the ground pin to ensure capacitive touch sensing can work on battery
power.  For example strip the insulation from a wire and solder it to ground,
then solder a wire (with the insulation still attached) to D0, and wrap
both wires around the stem of a flower like a double-helix.  When you touch
the wires you'll ground yourself (touching the bare ground wire) and cause
enough capacitance in the D0 wire (even though it's still insulated) to
trigger the heartbeat.  Or just leave D0 unconnected to have a nicely
animated lit-up flower!

Note that on power-up the flower will wait about 5 seconds before turning on
the LED.  During this time the board's red LED will flash and this is an
indication that it's waiting to power on.  Place the flower down so nothing
is touching it and then pick it up again after the DotStar LED starts
animating.  This will ensure the capacitive touch sensing isn't accidentally
calibrated with your body touching it (making it less accurate).

The main.py version of the code depends on the following external modules to
also be loaded on the board:
-   Adafruit CircuitPython DotStar: https://github.com/adafruit/Adafruit_CircuitPython_DotStar
-   Adafruit CircuitPython FancyLED: https://github.com/adafruit/Adafruit_CircuitPython_FancyLED

You _must_ have both adafruit_dotstar.mpy and the adafruit_fancyled folder
and files within it on your board for this code to work!  If you run into
trouble or can't get the dependencies see the main_simple.py code as an
alternative that has no dependencies but slightly more complex code.

gha_language: C


text:
## [size_t](#size_t)
## [NULL](#NULL)
## [max_align_t](#max_align_t)

### size_t

	Defined in header <stddef.h>
	Defined in header <stdio.h>
	Defined in header <stdlib.h>
	Defined in header <string.h>
	Defined in header <time.h>
	Defined in header <uchar.h> (since C11)
	Defined in header <wchar.h>
> `size_t` is the unsigned integer type of the result of `sizeof` , `_Alignof` (since C11) and offsetof, depending on the data model. The bit width of `size_t` is not less than 16. (since C99)`size_t` can store the maximum size of a theoretically possible object of any type (including array). `size_t` is commonly used for array indexing and loop counting. Programs that use other types, such as unsigned int, for array indexing may fail on, e.g. 64-bit systems when the index exceeds `UINT_MAX` or if it relies on 32-bit modular arithmetic.

```c
#include <stdio.h>
#include <stddef.h>
#include <stdint.h>

int main(void)
{
    const size_t N = 100;
    int numbers[N];
    for (size_t ndx = 0; ndx < N; ++ndx)
        numbers[ndx] = ndx;
    printf("SIZE_MAX = %zu\n", SIZE_MAX);
    size_t size = sizeof numbers;
    printf("size = %zu\n", size);
}
```

Possible output:
```sh
SIZE_MAX =<PHONE_NUMBER>3709551615
size = 400
```

### NULL
	Defined in header <stddef.h>
	Defined in header <string.h>
	Defined in header <wchar.h>
	Defined in header <time.h>
	Defined in header <locale.h>
	Defined in header <stdio.h>
	Defined in header <stdlib.h>
> #define NULL /*implementation-defined*/

The macro NULL is an implementation-defined null pointer constant, which may be

    an integer constant expression with the value 0
    an integer constant expression with the value 0 cast to the type void*

A null pointer constant may be converted to any pointer type; such conversion results in the null pointer value of that type.

**Possible implementation**

C++ compatible:
```c
		#define NULL 0
```
C++ incompatible:
```c
	#define NULL (10*2 - 20)
	#define NULL ((void*)0)
```
```c
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
    // any kind of pointer can be set to NULL
    int* p = NULL;
    struct S *s = NULL;
    void(*f)(int, double) = NULL;

    // many pointer-returning functions use null pointers to indicate error
    char *ptr = malloc(10);
    if (ptr == NULL) printf("Out of memory");
    free(ptr);
}
```

### ptrdiff_t

	Defined in header <stddef.h>

typedef /*implementation-defined*/ ptrdiff_t;

`ptrdiff_t` is the signed integer type of the result of subtracting two pointers.

The bit width of `ptrdiff_t` is not less than 17.
	(since C99)
*Notes*

`ptrdiff_t` is used for pointer arithmetic and array indexing, if negative values are possible. Programs that use other types, such as int, may fail on, e.g. 64-bit systems when the index exceeds `INT_MAX` or if it relies on 32-bit modular arithmetic.

Only pointers to elements of the same array (including the pointer one past the end of the array) may be subtracted from each other.

If an array is so large (greater than `PTRDIFF_MAX` elements, but less than `SIZE_MAX` bytes), that the difference between two pointers may not be representable as `ptrdiff_t`, the result of subtracting two such pointers is undefined.

For char arrays shorter than `PTRDIFF_MAX`, `ptrdiff_t` acts as the signed counterpart of `size_t`: it can store the size of the array of any type and is, on most platforms, synonymous with `intptr_t`).
Example
Run this code
```c
#include <stdio.h>
#include <stddef.h>
#include <stdint.h>

int main(void)
{
    const size_t N = 100;
    int numbers[N];

    printf("PTRDIFF_MAX = %ld\n", PTRDIFF_MAX);
    int *p1=&numbers[18], *p2=&numbers[23];
    ptrdiff_t diff = p2-p1;
    printf("p2-p1 = %td\n", diff);

    return 0;
}
```

Possible output:
```sh
PTRDIFF_MAX =<PHONE_NUMBER>854775807
p2-p1 = 5
```

## `max_align_t`

	Defined in header <stddef.h>

typedef /*implementation-defined*/ `max_align_t`;
		(since C11)

`max_align_t` is a type whose alignment requirement is at least as strict (as large) as that of every scalar type.
Notes

Pointers returned by allocation functions such as malloc are suitably aligned for any object, which means they are aligned at least as strictly as `max_align_t`.

`max_align_t` is usually synonymous with the largest scalar type, which is long double on most platforms, and its alignment requirement is either 8 or 16.
Example
Run this code
```c
#include <stdio.h>
#include <stddef.h>
#include <stdalign.h>
#include <stdlib.h>
#include <stdint.h>
#include <inttypes.h>

int main(void)
{
    size_t a = alignof(max_align_t);
    printf("Alignment of max_align_t is %zu (%#zx)\n", a, a);

    void *p = malloc(123);
    printf("The address obtained from malloc(123) is %#" PRIxPTR"\n",
            (uintptr_t)p);
    free(p);
}
```
Possible output:
```sh
Alignment of max_align_t is 16 (0x10)
The address obtained from malloc(123) is 0x1fa67010
```


text:
# ascalongw-discord-bot

## Prerequisites

NodeJS 14 or higher
NPM 6 or higher
Vagrant & Virtualbox if deploying to a server or VM

`.env.rb` is not included in the repository; see below for use
`ssh/3vcloud_ssh_key.ppk` is used for production deployment, but the ssh folder is not included in the repository; used for production deployment.

## Local deployment

`npm install --include-dev`
`npm run build`
`npm run dev`

## Local deployment (VM)

Ensure `ENV["ASCALONGW-TOKEN"]` is a valid token for the bot, or define `ENV["ASCALONGW-TOKEN"] = "<your_token>"` in `env.rb`

`vagrant up local --provision` to bring the server up
`vagrant provision local` to rebuild/restart the bot
`vagrant halt local` to stop the VM

## Production deployment

`Jon [SNOW]#1816` has SHH keys for production server, but its basically the same as above with a different machine name.
`rene#0683` has the AscalonGW bot token, ask him for it before deploying

repository: scumguzzler/ascalongw-discord-bot

repo_name: scumguzzler/ascalongw-discord-bot


text:
# RELICS :sparkles:: Regulatory Element Location Identification  in CRISPR screens

RELICS uses a generalized linear mixed model (GLMM) to analyze CRISPR regulatory screens. Given a set of guides to train on, RELICS identifies regions with high similarity to the positive controls (enhancer-like) and regions which are more similar to negative controls (non-regulatory-like).

This work is continously being improved. Please ask questions or [post issues](https://github.com/patfiaux/RELICS/issues).

# Installation
RELICS runs on [R](https://cran.r-project.org/bin/windows/base/). Please make sure you have R version 3.5.1 or higher

## Obtain source code
Clone source code to your desired location with the following command:
```bash
git clone https://github.com/patfiaux/RELICS.git
```
Alternatively, download the repository.

## Install requirements
You will need the following packages to run RELICS. If you don't have them, install them using the following commands. Installations will take about 5 minutes on a standard laptop.
## R packages
dplyr
```r
install.packages('dplyr')
```
ggplot2
```r
install.packages('ggplot2')
```
pROC
```r
install.packages('pROC')
```
glmmTMB
```r
install.packages('glmmTMB')
```
## Bioconductor packages
```r
if (!requireNamespace("BiocManager", quietly = TRUE))

    install.packages("BiocManager")
```
IRanges
```r
BiocManager::install("IRanges", version = "3.8")
```

GenomicRanges
```r
BiocManager::install("GenomicRanges", version = "3.8")
```

## Input data format
RELICS reqires two different files as input:
1. A **guide information file**, containing information about all the simulated guides (chromosome, start, end, label).
2. A **counts file**, containing the counts for each guide in each pool.

The counts file contains only the counts for each guide for each experiment. Column names are necessary but the names do not matter as the user will index the columns by number, not by name.

Example count file: 2 replicates from a FACS experiment. Input pools was sorted into high, medium and low expression

| repl1_input | repl1_high | repl1_med | repl1_low | repl2_input | repl2_high | repl2_med | repl2_low |
|----------|----------|-------|------- |------|------|------|------|
| 11 | 9 | 12 | 11 | 152 | 119 | 189 | 102 |
| 68 | 81 | 39 | 67 | 360 | 339 | 280 | 821 |
| 96 | 89 | 109 | 17 | 3 | 4 | 5 | 0 |
| 104 | 97 | 116 | 38 | 190 | 198 | 194 | 23 |

The guide information file contains all remaining info about the guides such as targeting position and type of guide (positive control, negative control, exon targeting etc.). Non-targeting controls should be specified by setting `chrom`, `start`, and `end` to NA. The columns specifying chromosome, guide target start, guide target end and label are mandatory and must be labelled `chrom`, `start`, `end`, and `label` respectively.

| chrom | start | end | label |
|----------|----------|----------|----------|
| chr8 | 128704468 | 128704488 | chr |
| chr8 | 128704469 | 128704489 | chr |
| NA | NA | NA | neg |
| chr8 | 128704482 | 128704502 | exon |

Row 1 in the count file should correspond to the guide in row 1 in the info file.

## Quickstart with example data
In an interactive R session:

### 1. Source the script
```r
source('/path/to/script/RELICS.r')
```

### 2. Set up the analysis specification file
Several parameters must be specified by the user before running RELICS. These parameters are set within the specification file. This allows a user to refer back to the specification file for the parameters that were used for a particular analysis. The options below  describe the most important parameters required to get the analysis going.

#### Option 1: Modify the given template in the `Example_data` folder (`Type_3_analysis_specs.txt`)
There is a template specification file already set up for the example data. It contains the main flags required to run RELICS. The meaning of the different flags are discussed in the next section.

#### Option 2: Set the flags within `R` and save them to the specification file prior to analysis
It is also possible to create a specification file from scratch by setting parameters within R. The following steps demonstrate how to set up parameters for the example specification file. At the end of this section, you will be able to run RELICS on the example data.

1. Flags are set up in a list object

```r
analysis.specs <- list()
```

2. Set the output name of the analysis (`dataName`). Be sure to choose a different name from the existing file so that you don't overwrite the example, and you can compare and check that you got the same flags.

```r
analysis.specs$dataName <- 'Type_3_exampleSim'
```

3. Specify the path to the count and info files.

```r
analysis.specs$CountFileLoc <- './Type_3_simulated_counts.csv'
analysis.specs$sgRNAInfoFileLoc <- './Type_3_simulated_info.csv'
```

4. RELICS uses a GLMM and jointly analyzes all pools from each replicate. The replicates are separated by a semicolon (`;`) and each pool from the count file is referred to by number.

Example: `1,2,3,4;5,6,7,8` represents two replicates. The first four columns of the count file comprise replicate 1 and the next four columns comprise replicate 2.

Note 1: The input type is a string, such as the example shown above.

Note 2: Analysis across multiple replicates has not been implemented yet, so jointly analyzing all pools (`1,2,3,4,5,6,7,8`) is not advised!

```r
analysis.specs$repl_groups <- '1,2,3,4;5,6,7,8'
```

5. RELICS empirically estimates the GLMM parameters from the data. A set of positive and negative controls should be provided. Positive controls are usually promoter- or exon-targeting guides. Negative controls can be non-targeting guides or can be everything that is not a positive control. Although the latter option increases the runtime, we have observed that it typically reduces the noise in the results.

```r
analysis.specs$glmm_positiveTraining <- 'exon'
analysis.specs$glmm_negativeTraining <- 'neg'
# alternatively use: analysis.specs$glmm_negativeTraining <- c('chr', 'neg') to include everything except positives as negatives
```

6. Specify the method to use as RELICS
```r
analysis.specs$Method <- 'RELICS-search'
```

7. Specify the CRISPR system used and the range of perturbation effect. Depending on the CRISPR system used, the range of effect is different. We recommend setting the range to 20bp for `CRISPRcas9`, 1000bp for `CRISPRi` and `CRISPRa`. In the example provided, the effect range is added to the guide positions specified in the [guide information file](https://github.com/zrcjessica/RELICS#input-data-format). When this is the case, the effect range should be set to `0` in this step.

In case of a `dualCRISPR` system, an arbitrary `crisprEffectRange` can be specified, as RELICS will automatically use the deletion range between guide 1 and guide 2 as effect range.
```r
analysis.specs$crisprSystem <- 'CRISPRi' # other options: CRISPRcas9, CRISPRa, dualCRISPR
analysis.specs$crisprEffectRange <- 1000
```

8. Once you set your flags, create a specification file using the `write_specs_file()` function. It takes two arguments: the list of flags that you have just set (`analysis.specs`) and the name of the file to write to (`.txt` will be automatically appended as the file extension):
```r
write_specs_file(analysis.specs, 'Type_3_exampleSim_specs')
```

### 3. Run RELICS
Once your specification file has been set up, simply use the `analyze_data()` function and pass it the name of the specification file (sans the `.txt` file extension) to begin the RELICS analysis. The example provided should take about 5 minutes to run on a typical desktop computer.
```r
analyze_data('Type_3_exampleSim_specs.txt') # or whatever you named your spec. file
```

### 3. Output files
RELICS will return several output files. They all start with the `dataName` specified in step 2 above:

* `{dataName}_RELICS_genomeScores.bedgraph`: This file contains the RELICS scores in bedGraph format and allows you to visualize your results in your preferred genome browser.

* `{dataName}_RELICS_genomeScores.csv`: This file contains the genome scores in bedGraph format. This file has 7 columns:

> genomeScore: combined per-guide RELICS score for this region

> chrom, start, end: position of the region

> label: highest overlapping label according to the label hierarchy

> log2_FC: does not apply to RELICS but kept for backward compatibility

> nrSupportGuides: number of guide effect ranges which overlap this particular region

* `{dataName}_RELICS_guideScores.csv`: This file contains the per-guide RELICS scores, which are combined aross regions of overlapping effects. Minimum number of columns: 8

> raw_scores, guide_scores: contain identical values. `raw_scores` was kept for backward compatibility. Use `guide_scores` when working with this file

> chrom, start, end: position of the region

> label: same as specified in the information file

> log2_FC: does not apply to RELICS but kept for backward compatibility

> replX_bf: RELICS score (Bayes Factor) for replicate `X`. Scores are reported for each replicate.

* `{dataName}_RELICS_parSummary.csv`: This file contains RELICS parameter estimates for all replicates, for each pool, for regulatory and background model.

* `{dataName}_RELICS_replX_parEst.csv`: This file contains RELICS parameter estimates from the positve and negative controls for replicate `X`. For each replicate, the first pool is used as intercept, and all subsequent ones defined as deviance from intercept.

# Advanced flags

RELICS combines information of guides which overlap with their guide effect. This can lead to scenarios where guides with different labels overlap. By default the label with fewer occurances in the data set is chosen. However, it is also possible for the user to specify the tie breaking by explicitly setting the `labelHierarchy` flag.

The rightmost label has highest priority. For example: if a region has overlapping guides labeled as both exon overlapping (`exon`) as well as targeting guides with unknown effect (`chr`), then the region will be assigned the label with higher priority in the hierarchy - in this case being `exon`.

This example dataset was part of the simulations used to assess method performance. In addition to the usual `exon` and `neg` labels, it also contains a `pos` label for guides overlapping simulated enhancer regions. Below, we will train on exon overlapping guides and negative controls to identify the simulated positive regions (`pos`).

```r
analysis.specs$labelHierarchy <- c('chr', 'neg', 'exon', 'pos')
```

repository: zrcjessica/RELICS

repo_name: zrcjessica/RELICS


text:
Sample code for Chapter 4 - "Text and bytes"

From the book "Fluent Python" by Luciano Ramalho (O'Reilly, 2015)
http://shop.oreilly.com/product/0636920032519.do

repository: niyunsheng/fluent-python

repo_name: niyunsheng/fluent-python


text:
---
title: "pre- and post-tsunami aceh through satellite imagery"
layout: post
date: 2016-01-23 22:10
tag: [geology, landsat]
image: ../assets/images/projects/thumbnail/aceh.jpg
headerImage: true
projects: true
hidden: true # don't count this post in blog pagination
description: "This is a simple and minimalist template for Jekyll for those who likes to eat noodles."
jemoji: ''
category: geo
author: tiffanycitra
externalLink: false
---

This is my final project for one of the best classes I have taken at Brown so far — *Global Environmental Remote Sensing (Spring 2015)*.

---

![Preprocessed Images](../assets/images/projects/aceh/preprocessed.png)
*Preprocessed images displayed in natural color (321)*

Using Landsat 5 TM imagery, I attempted to explore the relationship between land cover changes and socioeconomic growth in pre- and post-tsunami Aceh, Indonesia. To do so, I compared land cover in December 2004 (pre-tsunami), January 2005 (right after tsunami), and February 2010 (post-tsunami).

I used ENVI to do the necessary preprocessing (dark pixel subtraction and reflectance calibration), select the region of interest (Banda Aceh and Aceh Besar), and finally perform spectral mixture analysis  — with four end members: urban, sediment, vegetation, and shades — to quantify land cover changes.

![Processed Images](../assets/images/projects/aceh/processed.jpg)
 *Stacked end member map in (red) 2004, (cyan) 2010: (top-left) sediment, (top-right) shades, (bottom-left) urban, (bottom-right) vegetation*

---

Land cover changes

We can see from the table above that the percentage of urban and sediment areas increase quite significantly, whereas vegetation and shade areas decrease.

My findings suggest that remote sensing can be used to correlate land cover changes with socioeconomic growth in Aceh, Indonesia. The results obtained in this project display relatively similar trends as the growing economic sectors and population growth in the region, as well as a previous study that maps the land use changes within the same time period (Achmad, 2013).

**Reference:**

Achmad, A. (2013). Land use changes in the urban growth process after a tsunami using RS and GIS: A case of Banda Aceh, Indonesia. CSIS (Center for Strategic and International Studies) Days 2014, Tokyo, Japan.

extension: markdown


text:
# AWS-related scripts

## `iam_get_user_from_access_key`

This script either list all keys on an account
or list the user corresponding to the given key

## `ec2_security_group_reports`

This script list the security groups with ports opened to the world for IPv4.

## `cloudwatch_metrics_density`

This script reports the number of metrics in cloudwatch for each namespace /
metric / metric dimension that can be pulled over the last 2 hours. It helps
tracking the density of the metrics and this way find who stores at least 1
metric per second. This is needed when you try to track down the spend in the
monthly report for the PutMetrics operation.

## `elb_log_analyzer`

The script in `elb_log_analyzer` is a tool to parse AWS Elastic LoadBalancer
access logs and push them to a MySQL database.

## `s3_reporter`

This script generates reports about files age, extensions, size and other attributes for one or all of your s3 buckets.

repository: vevo-matt-lam/joeyzTools

repo_name: vevo-matt-lam/joeyzTools


text:
4.0.2 - Aug 06 2023
===================

  * update dependencies
  * update information related to supported versions

4.0.1 - Apr 26 2020
===================
  * update performance numbers
  * drop support for node.js 8 and 13, add support for node.js 15 & 16

4.0.0 - Apr 23 2020
===================
  * drop support for node.js 6, add support for node.js 14
  * update dependencies (nan v2.14.1, jshint v2.11.0)
  * use g++-6 on travis

3.0.0 - Sep 21 2019
===================
  * drop support for node.js 4

2.0.10 - Sep 07 2019
====================
  * more linting
  * update dependencies (nan v2.14.0)

2.0.9 - Mar 14 2019
===================
  * update dependencies (nan v2.13.0, jshint v2.10.2)

2.0.8 - Mar 02 2019
===================
  * add simple stub for non-linux installs
  * don't compile epoll.cc on non-linux systems
  * lint with jshint
  * add travis build

2.0.7 - Dec 19 2018
===================
  * fix deprecation warnings on node.js v12 nightly
  * update dependencies (nan v2.12.1, bindings v1.3.1)

2.0.6 - Oct 14 2018
===================
  * suppress warnings complaining about casting between incompatible function types (see https://github.com/nodejs/nan/issues/807)

2.0.5 - Oct 13 2018
===================
  * fix deprecation warnings on node.js v10.12 (see https://github.com/nodejs/nan/pull/811)

2.0.4 - Sep 29 2018
===================
  * update dependencies (nan v2.11.1)
  * adapt to V8 7.0: replace v8Value->Int32Value() with Nan::To<int32_t>(v8Value).FromJust()

2.0.3 - Jul 28 2018
===================
  * code style

2.0.2 - Jul 22 2018
===================
  * add coin acceptor stress test
  * replace new Buffer with Buffer.from or Buffer.alloc
  * sleep for one second after exporting gpios to avoid permission issues
  * construct AsyncResource for callback when callback is stored

2.0.1 - Apr 02 2018
===================
  * update dependencies (nan v2.10.0)

2.0.0 - Feb 25 2018
===================
  * update dependencies (nan v2.9.2)
  * fix deprecations
  * drop support for node.js v0.10, v0.12, v5 and v7

1.0.2 - Dec 24 2017
===================
  * don't suppress deprecated-declaration warnings
  * nan 2.8.0

1.0.1 - Nov 04 2017
===================
  * suppress deprecated-declaration warnings
  * document node 9 support

1.0.0 - Oct 15 2017
===================
  * update dependencies (bindings v1.3.0, nan v2.7.0)
  * document supported node versions

0.1.22 - Jun 18 2017
====================
  * nan 2.6.2

0.1.21 - Feb 12 2017
====================
  * require node v0.10 or higher
  * nan 2.5.1

0.1.20 - Jul 22 2016
====================
  * document dependency on Linux
  * nan 2.4.0

0.1.19 - May 03 2016
====================
  * add accessor for closed property to instance template

0.1.18 - Apr 27 2016
====================
  * upgrade to NAN v2.3.2 for Node.js v6.0.0 compatability

0.1.17 - Jan 29 2016
====================
  * nan 2.2.0
  * documentation

0.1.16 - Oct 10 2015
====================
  * documentation
  * nan 2.1.0

0.1.15 - Aug 24 2015
====================
  * fix null passed to callback

0.1.14 - Aug 24 2015
====================
  * nan2 migration

0.1.13 - May 07 2015
====================
  * io.js v2.0.0+ compatibility [#13](https://github.com/fivdi/epoll/issues/13)

0.1.12 - Feb 10 2015
====================
  * nan 1.6.2
  * refactored interrupts-per-second example [#11](https://github.com/fivdi/epoll/issues/11)

0.1.11 - Jan 17 2015
====================
  * support io.js [#10](https://github.com/fivdi/epoll/issues/10)

0.1.10 - Nov 02 2014
====================
  * nan 1.4.0

0.1.9 - Aug 09 2014
===================
  * nan 1.3.0

0.1.8 - Jul 12 2014
===================
  * nan 1.2.0
  * bindings 1.2.1

0.1.7 - May 29 2014
===================
  * Fixed date in History.md

0.1.6 - May 29 2014
===================
  * Replace NanSymbol with NanNew<v8:String> [#9](https://github.com/fivdi/epoll/issues/9)

0.1.5 - May 04 2014
===================
  * nan 1.0.0 alignment [#8](https://github.com/fivdi/epoll/issues/8)

0.1.4 - Apr 18 2014
===================
  * Documented BeagleBone Ångström prerequisites
  * Use bindings for laoding

0.1.3 - Mar 23 2014
===================
  * 0.11.5+ compatibility [#7](https://github.com/fivdi/epoll/issues/7)
  * Updated dependencies: nan 0.6.2 -> 0.8.0

0.1.2 - Nov 21 2013
===================
  * 0.11.9+ compatibility [#6](https://github.com/fivdi/epoll/issues/6)
  * Updated dependencies: nan 0.5.2 -> 0.6.0

0.1.1 - Nov 19 2013
===================
  * A hopefully successfull attempt to fix an npm install issue

0.1.0 - Nov 18 2013
===================
  * Updated dependencies: nan 0.4.1 -> 0.5.2
  * removed using namespace v8 (bad practice)

0.0.8 - Oct 14 2013
===================
  * Epoll thread code improved (#4)
  * EINTR handling (#3)

0.0.7 - Oct 05 2013
===================
  * closed property added (#1)
  * Segfault issue fixed (#5)
  * add and modify now accept Epoll.EPOLLET as an event (#2)

0.0.6 - Oct 01 2013
===================
  * Example for watching outputs added
  * Tests improved

0.0.5 - Sep 25 2013
===================
  * Link removed from readme

0.0.4 - Sep 25 2013
===================
  * Url in readme fixed so that it displays correctly at npmjs.org, hopefully

0.0.3 - Sep 25 2013
===================
  * Content added to readme
  * Examples for the BeagleBone and RaspberryPi
  * Minor bug fixes
  * Tests improved

0.0.2 - Sep 22 2013
===================
  * Tests extended and improved
  * Allow installation on non-Linux systems but provide no functionality (needed for firmata-pi tests)

0.0.1 - Sep 22 2013
===================
  * Initial release

repository: fivdi/epoll

gha_language: JavaScript

repo_name: fivdi/epoll


text:
# Office Hours Queue

## Overview

Provides a web-based interface for requesting help during office hours.

Students request help on an assignment and question number from a location.

This app uses [Ok](https://okpy.org) to manage access. Even if you aren't using Ok for assignments, you should create a course on Ok and enroll all of your staff, academic interns, and students with the appropriate roles.

## For other courses

This is a hosted app provided by 61A. To set it up for your own course, visit [Auth](https://auth.apps.cs61a.org) and add the desired domain under `Domains`. Make sure that the OKPy endpoint and course name are what you expect. Then contact 61A staff for your queue to be activated. If you want to move the queue to a new OKPy course, update the endpoint on Auth - the change should be reflected in the queue within an hour.

## Installation

1. Clone this repo:

   ```
   git clone https://github.com/Cal-CS-61A-Staff/oh-queue.git
   ```

   Then cd into it:

   ```
   cd oh-queue
   ```

2. Create and activate a virtualenv:

   ```
   python3 -m virtualenv env  (If this does not work, try: `virtualenv -p python3 env`)
   source env/bin/activate
   ```

3. Use pip to install all the dependencies:

   ```
   pip install -r requirements.txt
   npm install
   ```

4. Run the database migrations to setup the initial database.

   ```
   ./manage.py resetdb
   ./manage.py seed_data
   ./manage.py db upgrade
   ```

5. Run the server:

   ```
   ./manage.py server
   ```

6. Point your browser to http://localhost:5000. (This might take a while the first time.)

7. You can log in as any email while testing by going to http://localhost:5000/testing-login/.

### Dokku: Initial Deployment

    dokku apps:create app-name
    dokku clone app-name https://github.com/Cal-CS-61A-Staff/oh-queue
    dokku mysql:create db-name
    dokku mysql:link db-name app-name
    dokku domains:set app-name <domain>

    dokku config:set app-name OH_QUEUE_ENV=prod OK_KEY=<OK CLIENT> OK_SECRET=<OK SECRET> SECRET_KEY=<DB SECRET> AUTH_KEY=<AUTH_KEY> AUTH_SECRET=<AUTH_SECRET>
    dokku run app-name ./manage.py db upgrade
    dokku letsencrypt app-name
    # Change OK OAuth to support the domain

For `OK_KEY` and `OK_SECRET`, you'll need to create an Ok OAuth client [here](https://okpy.org/admin/clients) and have it approved by an Ok admin.

### Dokku: Upgrading

    dokku clone app-name https://github.com/Cal-CS-61A-Staff/oh-queue
    dokku run app-name ./manage.py db upgrade


text:
# DDEVManager

A fancy Desktop Application to manage your DDEV Projects.

![Screenshot](https://raw.githubusercontent.com/CubE135/DDEVManager/master/src/assets/img/screenshot.png)

## Installation

Just download the windows installer and run it. This will install the App and all it's dependencies.

Currently, i only offer a windows installer. If you want to install this App on a device using a different operating system, please contact me or make an issue in this repository.

## Features

- A List of all DDEV projects on your system
- Start/Stop a project by simply clicking a button
- Connect to the DDEV project via SSH
- Open the Folder, the project is located in
- Power Off all projects

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


text:
# Welcome to Microservices Demo!

In this repository you can find 3 microservices, and some techs that you probably will enjoy.
:)

In order **to run** all the services, there is a folder with the **docker-compose.yaml**. After that you will find an Swagger UI in the http://localhost:8090/swagger.

![demo](docs/imgs/demo.jpg)

## 1-) Microservice **Product**:
The idea behind this Service is to be a **API REST**, to get products list from another API, and set price to them.

Let's assume that you have an external API with your products catalogue. I this case it was used the Star Wars API https://swapi.dev/.

The service will consume items from the Star Wars API and it possible to set price for them. The prices are stored in memory db using **Entity Framework Core**.

Also it integrates another service to get address details from a ZipCode (the implementation is based on Correios Brazilian Post Service). There are two integrations, one with cache and another without it. This way we have an API/Versioning system, with a deprecated operation.

The service is built on **.NET Core 3.1**. There is a **Circuit Breaker** in the consumption of the APIs, using **Polly** (3 calls, 2 seconds of interval). The **API is versionated** and documentated with **Swagger**.

The internal structure of the Solution and Projects is based on vast concepts of **DDD**.

## 2-) Microservice ZipCode V1:
Here we have a wrapper for Correios Postal Service **SOAP** webservice, using **WCF** to consume and exposing in a **JSON** format, with **API REST** calls. It is a very simple microservice and that is the ideia hre, a kind of wrapper.
Despite of the simplicity, the service also contains **Swagger** documentation. It is built on **.NET Core 3.1**.

## 3-) Microservice ZipCode V2:
Is the evolution of ZipCode V1. It already has some concepts of **DDD**, but mainly use a cache system with **Redis** (with 20 seconds of cache).

As usual, it is built on **.NET Core 3.1** and has **Swagger** as well.

## Docker
Each project has its own **Docker file** to build the images. Also there is a **docker-compose.yaml** to run all the microservices and the **Redis**. There is no necessity of database, because the data is persisted in memory.

## Tests
There is a project with the tests related to domain, model end service. This project is using **MS Test** e **Moq**.

## Wrap Up
This is a demo, not a final product. But is very interesting study the structure and technologies used in these implementations, to bring that to your real projects. So enjoy!

repository: spaki/microservices-demo

repo_name: spaki/microservices-demo


text:
# Intro to Engineering

*(Middle School Curriculum)*

**Project based learning about technology and engineering** *(and communication)*

Class website can be found at: [https://ed-gility.github.io/intro-engineering/]

repository: ed-gility/intro-engineering

repo_name: ed-gility/intro-engineering


text:
### 2017-12-10
diff between today and yesterday

#### python
* [yidao620c/python3-cookbook](https://github.com/yidao620c/python3-cookbook): Python Cookbook 3rd Edition Translation
* [faneshion/MatchZoo](https://github.com/faneshion/MatchZoo): MatchZoo is a toolkit for text matching. It was developed to facilitate the designing, comparing, and sharing of deep text matching models.
* [eridgd/WCT-TF](https://github.com/eridgd/WCT-TF): TensorFlow/Keras implementation of "Universal Style Transfer via Feature Transforms" from https://arxiv.org/abs/1705.08086
* [kharazi/snapp-cli](https://github.com/kharazi/snapp-cli): a command-line interface to ride with Snapp (Snapp API)
* [mitmproxy/mitmproxy](https://github.com/mitmproxy/mitmproxy): An interactive TLS-capable intercepting HTTP proxy for penetration testers and software developers
* [tuxxy/hazmat-math](https://github.com/tuxxy/hazmat-math): Hazmat ECC arithmetic for Cryptography.io

#### go
* [openfaas/faas](https://github.com/openfaas/faas): OpenFaaS - Serverless Functions Made Simple for Docker & Kubernetes
* [golang/dep](https://github.com/golang/dep): Go dependency management tool
* [prometheus/prometheus](https://github.com/prometheus/prometheus): The Prometheus monitoring system and time series database.
* [coreos/etcd](https://github.com/coreos/etcd): Distributed reliable key-value store for the most critical data of a distributed system
* [junegunn/fzf](https://github.com/junegunn/fzf):  A command-line fuzzy finder
* [tj/node-prune](https://github.com/tj/node-prune): Remove unnecessary files from node_modules (.md, .ts, etc)
* [kubeless/kubeless](https://github.com/kubeless/kubeless): Kubernetes Native Serverless Framework
* [Unknwon/the-way-to-go_ZH_CN](https://github.com/Unknwon/the-way-to-go_ZH_CN): The Way to GoGo

#### cpp
* [mfosse/JoyCon-Driver](https://github.com/mfosse/JoyCon-Driver): A vJoy feeder for the Nintendo Switch JoyCons
* [mikesart/gpuvis](https://github.com/mikesart/gpuvis): GPU Trace Visualizer
* [ctubio/Krypto-trading-bot](https://github.com/ctubio/Krypto-trading-bot): Self-hosted crypto trading bot (automated high frequency market making) in node.js, angular, typescript and c++
* [jianqingdu/kedis](https://github.com/jianqingdu/kedis): Kedis-Server is a Redis-Protocol compatible persistance NoSQL with RocksDB as its storage engine
* [clemahieu/raiblocks](https://github.com/clemahieu/raiblocks): RaiBlocks is a cryptocurrency
* [Microsoft/CNTK](https://github.com/Microsoft/CNTK): Microsoft Cognitive Toolkit (CNTK), an open source deep-learning toolkit
* [radareorg/cutter](https://github.com/radareorg/cutter): A Qt and C++ GUI for radare2 reverse engineering framework

#### javascript
* [learn-anything/learn-anything](https://github.com/learn-anything/learn-anything):  Search Interactive Maps to Learn Anything
* [jiayihu/react-tiny-dom](https://github.com/jiayihu/react-tiny-dom):  A minimal implementation of react-dom using react-reconciler
* [ccxt/ccxt](https://github.com/ccxt/ccxt): A JavaScript / Python / PHP cryptocurrency trading library with support for more than 90 bitcoin/altcoin exchanges
* [webpack/webpack](https://github.com/webpack/webpack): A bundler for javascript and friends. Packs many modules into a few bundled assets. Code Splitting allows to load parts for the application on demand. Through "loaders," modules can be CommonJs, AMD, ES6 modules, CSS, Images, JSON, Coffeescript, LESS, ... and your custom stuff.
* [facebook/react-native](https://github.com/facebook/react-native): A framework for building native apps with React.
* [date-fns/date-fns](https://github.com/date-fns/date-fns):  Modern JavaScript date utility library
* [atom/atom](https://github.com/atom/atom): The hackable text editor

#### coffeescript
* [atom/language-c](https://github.com/atom/language-c): C support in Atom
* [basecamp/pow](https://github.com/basecamp/pow): Zero-configuration Rack server for Mac OS X

gha_language: Python


text:
THIS FOLDER CONTAINS YOUR LIVE CONTROLLER

`namespace:` Path\App\Controllers\Live

You can generate a new file using `php __path create controller <ServiceName> --graph`

gha_language: PHP


text:
{{{
  "title": "Enabling the Distributed Firewall (Flex UI)",
  "date": "12-13-2018",
  "author": "Anthony Hakim",
  "keywords": ["cpc", "cloud", "vmware", "firewall", "support", "vcf"],
  "attachments": [],
  "related-products" : [],
  "contentIsHTML": false,
  "sticky": false
}}}

### Description
In this KB article, we walk through how to enable Distributed Firewall for Lumen Private Cloud on VMware Cloud Foundation.

### Prerequisites
* Your base URL, and user credentials for Lumen Private Cloud on VMware Cloud Foundation.

### Steps

1. Log In to your CPC on vCF environment.

2. Click on **Help** in the upper right corner, then click **Support**.

  ![DFW](../../images/dccf/dfw-enable1.png)

3. You will be taken to the **Managed Support Portal**. Click **Create** and select the following options:

  * What Product is this for? **Cloud**
  * Which Cloud Product? **Lumen Private Cloud on VMware Cloud Foundation (Formerly DCC Foundation)**
  * What is the status? **Requesting a Change**
  * When should this change be performed? **Prioritized (Any time in the next X hours)**
  * Change Subject: **Lumen Private Cloud on VMware Cloud Foundation Prioritized**
  * Change Details: **Please enable Distributed Firewall in my CPC on vCF environment - `<yourURL>`**.
  * Priority: Select the appropriate priority (**P2 Standard or P3 Standard**).
  * Click on the **submit** button.

4. You will be contacted by Lumen to coordinate the change request.

url: https://raw.githubusercontent.com/AnthonyHakim/PublicKB/86e64ab577c486c8aa7fffc6ff92d40cd274fe99/Lumen Private Cloud on VMware Cloud Foundation/Firewall/dfw-enabling-flex.md

repository: AnthonyHakim/PublicKB

gha_license_id: NOASSERTION

repo_name: AnthonyHakim/PublicKB


text:
localStorage-tools
==================

Some tools to extend the javascript localStorage feature: Cross-domain localStorage, limit the number of elements (avoid infinite growing...)

* **js/tools/cross_domain_storage.js**
  It allows to share values in localStorage between different domains (or subdomains).

* **js/tools/list_storage.js**
  To store a given maximum number of elements in localStorage (avoid infinite growing).

* **js/tools/cross_domain_list_storage.js**
  By using cross_domain_storaje.js, it stores a given maximum number of elements which can be shared between different domains.

**There are some use examples in the index.html file.**

*Notes:*

* *To see the stored values, in Chrome you can go to "Right click->Inspect element->Resources" and unfold the Local Storage tree.*

* *You have to include the [json3](http://bestiejs.github.io/json3/) library to get it working on IE8 and IE9*

cross_domain_storage.js
-----------------------

Cross domain storage based on: http://www.nczonline.net/blog/2010/09/07/learning-from-xauth-cross-domain-localstorage/

You need to put the **crossd_iframe.html** file in your server, and add your domain to the **whitelist** (allowed domains) var in the file.

Initialization function:
* cross_domain_storage({origin:'', path:''});
    * origin The URL where the iframe file is located. i.e: `"http://www.example.com"`
    * path Path to the iframe file in origin. i.e: `"/path/to/iframe.html"`

It returns an object with the following functions:
* getItem(key, callback)
  Request the value asociated to the `key`.
  The callback function will receive two parameters: `key` and `value`.
* setItem(key, value)
  Add or update the value asociated to the `key`.

### Usage example:

```javascript
//If you are testing in your local computer, you can leave the default values in
// the crossd_iframe.html file, then switch the url between "localhost" and "<IP_ADDRESS>",
// and see in the localStorage of your browser how it works (see previous Notes).

//Once you've added your domain to the `whitelist` in the crossd_iframe.html:
var options = {
    origin: "http://www.example.com",
    path: "/path/to/iframe.html"
};
Storage = cross_domain_storage(options);

//...
Storage.setItem('key', 'value');

//...
Storage.getItem('key', callback_function);

function callback_function(key, value){
    //if key was not present, value will be 'undefined'
	if (value !== 'undefined') {
        //...
    } else {
        //key not found...
    }
}
```

If you are using jQuery (>=1.5), also you can use 'promises':

```javascript
Storage = cross_domain_storage(options);
$.when(
    Storage.getItem('key1')
    , Storage.getItem('key2')
    [, etc...]
).done(function(response_key1, response_key2 [, etc...]){
    //response_key1 contains the value for the key1 ('undefined' if not found)
    //response_key2 contains the value for the key2 ('undefined' if not found)
    //etc...
});
```

list_storage.js
-----------

Stores a given maximum number of elements in localStorage.
It can be used as a dictionary with key-value pairs.

*It's a queue: if the limit is reached, then first in - first out.*
*If a previously present item is added (with `set(key, item)` method), it will be put last in the queue again.*

Initialization function:
* list_storage({max_items: 100, var_name: ''})
  max_items: Max number of items to store (default value is 100)
  var_name: Variable name in the localStorage space

It returns an object with the following functions:
  * set(key, value)
    `value` must be serializable by JSON.stringify method.
  * get(key)
    If `key` does not exists, returns null
  * del(key)
    Delete the item associated with the `key`
  * get_all()
    Returns a copy of the stored dictionary

### Usage example:

```javascript
lstorage = list_storage({max_items: 20, var_name: 'local_1'}); //max: 20 items

//Note that the specified number of max items (20) are smaller
//than the number of keys to store in the following loop (100):
for (var i = 0; i<=100; i++) {
    lstorage.set("key-"+i, {'a_tag': 'a value - '+i, 'other_tag': 'other value - '+i});
}

//There must be only the last 20 values
for (var i = 0; i<=100; i++) {
    value = lstorage.get("key-"+i);
    if (value !== null) {
        //you'll need a <div id="results"></div> in your test page...
        document.getElementById('results').innerHTML += "<br/>found: key-"+i+", value: "+JSON.stringify(value);
    }
}
```

cross_domain_list_storage.js
------------------------

Stores a given maximum number of elements which can be shared between different domains.

It uses **jQuery, cross_domain_storage.js and crossd_iframe.html files**.

Initialization function:
* cross_domain_list_storage(storage, {max_items: 100, name: ''})
  The first parameter is a cross_domain_storage object (using cross_domain_storage.js)
  The second parameter is a JSON object with the following attributes:
  * max_items Max items stored (default value is 100)
  * name Var name in the shared local storage space (default: '_items')

It returns an object with the following functions:
  * ready(callback)
    Callback function will be executed when the object is ready to use.
  * set(key, value)
    `value` must be serializable by JSON.stringify method.
  * get(key, callback)
    The callback function will be called with two parameters: `key` and `value`.
    If `key` does not exists, value will be null
  * del(key)
    Delete the item associated with the `key`
  * get_all()
    Returns a copy of the stored dictionary

### Usage example:

```javascript
//Cross Domain Storage Configuration (required cross_domain_storage.js and crossd_iframe.html files).
//Also you have to include your "origin domain" in the whitelist in crossd_iframe.html (in this case would be
// "localhost" or perhaps your computer name or IP if you are doing local testing...):

var options = {
    origin: "http://localhost",
    path: "/localStorage/crossd_iframe.html"
};
Storage = cross_domain_storage(options);

cdls = cross_domain_list_storage(Storage, {max_items: 20, var_name: 'crossD_storage'});

cdls.ready(function(){
    //The value can be a string or JSON object:
    cdls.set("cross_key", {'a_key':'Cross Domain data', 'another_key':'another Cross Domain data...'});

    //...
    var cdvalue = cdls.get("cross_key");
    if (cdvalue !== null) {
        document.getElementById('results').innerHTML += "<br/><br/>Cross Domain list value: " + JSON.stringify(cdvalue) + "<br/><br/>";
    }
});
```

repository: anodynos/localStorage-tools

repo_name: anodynos/localStorage-tools


text:
# PInet
This repo is under major reconstruction, new version is coming soon!
<!---## Simple Preprocess
run

> cd utils

Modify the path to pdb2pqr and apbs binary files in PreProcessLifeSavor.py
Just for testing

> python PreProcessLifeSavor.py 2I25-l.pdb 2I25-r.pdb

Generate label for trainning

> python PreProcessLifeSavor.py 2I25-l.pdb 2I25-r.pdb train

Replace 2I25-l.pdb and 2I25-r.pdb by your input pair of pdbs. File name format should be XXXX*.pdb where XXXX is the id.

## Simple Prediction
run

> python SimplePredictor.py 2I25-l.pts 2I25-r.pts

## Simple Residue Prediction Aggregation
run

> python PredictionPoint2Residue.py 2I25
--->
## Setup
run
> pip install -e .

## Train
run

> python utils/train_richdbd2_fixed6mmgk.py -dataset [your dataset] \

for example here \
> python utils/train_richdbd2_fixed6mmgk.py -dataset dbd

## Load pretrained model
In python with torch imported
> classifier.load_state_dict(torch.load('model/seg_model_protein_15.pth'))

## Sample dataset folder
Dbd 5
dataset folder should follow dbd folder structure
input data should be a n-by-5 matrix, with columns' order [x,y,z,electrostatic,hydrophobicity]
dbd data are now avalable at https://www.dropbox.com/sh/qqi9op061mfxbmo/AADibYuDdMF4n2bDS3uqiEVha?dl=0

EpiPred
dataset folder should follow dbd folder structure
input data should be a n-by-5 matrix, with columns' order [x,y,z,electrostatic,hydrophobicity]
EpiPred data are now avalable at https://www.dropbox.com/sh/wnrn65y4vfs2m84/AABSFL8IeWh_U7gQO2__ZFEHa?dl=0

## Preprocess Helper
utils/pdb2wrlpymol2_pub.py
change pdb files folder in the script and for a given complex ABCD.pdb, split the ligand and receptor as ABCD_l.pdb and ABCD_r.pdb.

utils/pdb2pqrall_pub.py
compute apbs for all pdb files. Need to change path in script for your pdb2pqr and apbs binary exe file.

utils/transdata2.m
set your path to data folder which will be your train script --dataset input. It will create coordinate data and interface label file.

utils/RichFeatureApbsCon_pub.py
modify matlab output 3 dims coordinate feature data file to 5 dims coordinate+electrostatic+hydrophobicity feature.


text:
# Calico

## Needs to be updated soon / TODO

* Right now these scripts pull calico binaries for calico and calico-ipam, this seems to be [going away](https://github.com/projectcalico/calico-containers/issues/1037) in favor of a container appraoch
* Move from downloading calicoctl to a container native approach

## Caveats

* Calico is going to create a manifest file on the master node to run as a static pod, this means that kubelet needs to read in /etc/kubernetes/manifests when it starts)
* Calico assumes that writing things to /opt/cni/bin is sufficient for CNI plugins, again this may be problematic for hyperkube containers (but OK if properly mapped)

## Assumptions in examples

* Assumes K8S API is SSL-enabled called api-endpoint.testcluster.io
* etcd is running on <IP_ADDRESS> at port 2379

## Native

### Shared Snippets

#### Environment Files

##### non-SSL etcd

In a non SSL setup, the requirements are easier:

```yaml
  - path: /etc/calico-setup.env
    owner: root
    permissions: 0755
    content: |
      ETCD_AUTHORITY=<IP_ADDRESS>:2379
```

##### SSL etcd

In an SSL setup we need to provide the certificates as well

```yaml
  - path: /etc/calico-setup.env
    owner: root
    permissions: 0755
    content: |
      ETCD_AUTHORITY=<IP_ADDRESS>:2379
      ETCD_SCHEME=https
      ETCD_CA_CERT_FILE=/etc/ssl/etcd/ca.pem
      ETCD_CERT_FILE=/etc/ssl/etcd/client.pem
      ETCD_KEY_FILE=/etc/ssl/etcd/client-key.pem
```

#### Units

```yaml
    - name: calico-node.service
      runtime: true
      command: start
      content: |
        [Unit]
        Description=calicoctl node
        After=docker.service
        Requires=docker.service

        [Service]
        User=root
        EnvironmentFile=/etc/calico-setup.env
        EnvironmentFile=/etc/networking.env
        PermissionsStartOnly=true
        ExecStartPre=/usr/bin/wget -N -P /opt/bin http://www.projectcalico.org/builds/calicoctl
        ExecStartPre=/usr/bin/chmod +x /opt/bin/calicoctl
        ExecStartPre=/usr/bin/wget -N -P /opt/cni/bin https://github.com/projectcalico/calico-cni/releases/download/v1.3.1/calico
        ExecStartPre=/usr/bin/chmod +x /opt/cni/bin/calico
        ExecStartPre=/usr/bin/wget -N -P /opt/cni/bin https://github.com/projectcalico/calico-cni/releases/download/v1.3.1/calico-ipam
        ExecStartPre=/usr/bin/chmod +x /opt/cni/bin/calico-ipam
        ExecStart=/opt/bin/calicoctl node --ip=${DEFAULT_IPV4} --detach=false
        Restart=always
        RestartSec=10
        [Install]
        WantedBy=multi-user.target
```

### Nodes

#### Within write_files:

In addition to the calico-setup.env (appropriate for SSL/non-SSL etcd) we need the following

```yaml
  - path: /etc/cni/net.d/10-calico.conf
    owner: root
    permissions: 0755
    content: |
      {
          "name": "calico-k8s-network",
          "type": "calico",
          "etcd_authority": "<IP_ADDRESS>:2379",
          "log_level": "info",
          "ipam": {
              "type": "calico-ipam"
          },
          "policy": {
              "type": "k8s",
              "k8s_api_root": "https://api-endpoint.testcluster.io:8080/api/v1/"
          }
      }
```

### API Master

#### Within write_files:

##### Within write_files:

In addition to the calico-setup.env (appropriate for SSL/non-SSL etcd) we need the following

```yaml
  - path: /etc/kubernetes/manifests/policy-controller.manifest
    owner: root
    permissions: 0755
    content: |
      apiVersion: v1
      kind: Pod
      metadata:
        name: policy-controller
        namespace: kube-system
        labels:
          version: current
          projectcalico.org/app: "policy-controller"
      spec:
        hostNetwork: true
        containers:
          # The Calico policy controller.
          - name: policy-controller
            image: calico/kube-policy-controller:v0.2.0
            env:
              - name: ETCD_ENDPOINTS
                value: "http://<IP_ADDRESS>:2379"
              - name: K8S_API
                value: "http://<IP_ADDRESS>:8080"
              - name: LEADER_ELECTION
                value: "false"
```


text:
---
title: "New d3.js visualization: Understanding Significance Testing and Statistical Power"
date: 2014-02-02 14:06
author: Kristoffer Magnusson
category: D3.js
tags:
    - D3.js
    - Significance testing
    - Power analysis
    - Statistics
    - Visualization
slug: new-d3-js-visualization-understanding-significance-testing-and-statistical-power
summary: This new visualization is an interactive display of classical null hypothesis significance testing and statistical power.
---

![Understanding Significance Testing and Statistical Power. Visualization. By Kristoffer Magnusson](./img/feature_significance_testing_and_power_d3.jpg)

Here is a new visualization created in the same manner as my [Cohen’s d vizualisation](http://rpsychologist.com/d3/cohend). This new visualization is an interactive display of classical null hypothesis significance testing and statistical power.

The visualization should work on mobile phones and tablets, but it requires a modern browser that supports SVG. [Check it out here.](http://rpsychologist.com/d3/NHST)

repository: rpsychologist/rpsychologist-com

repo_name: rpsychologist/rpsychologist-com


text:
## THE GENERATOR
These are all ideas on how the final system could look like. Everything is still very much a work in progress.

### wacc / wa++
`wacc` and `wa++` commands are supposed to serve as a drop-in replacement for `clang` and `clang++` respectively. They contain code needed for handling `wasabi`-specific arguments as well as passing proper flags to `clang` for wasm compilation.

One of `wasabi`-specific arguments is the `--gen` flag. It generates the necessary bindgen for running in respective runtime.

- Generating js wrapper code.

    ```bash
    wacc test.c -o test.wasm --gen=web
    ```

- Generating wasmer wrapper code. It also determines the host data needed and creates a cargo project that can run the wasm file.

    ```bash
    wa++ test.cpp -o test.wasm --gen=wasmer
    ```

- Generating nodejs wrapper code.

    ```bash
    wacc test.c -o test.wasm --gen=node
    ```

### refs
1. Compilation Flags
    - https://emscripten.org/docs/tools_reference/emcc.html

repository: appcypher/wasabi

repo_name: appcypher/wasabi


text:
# Braitenberg-Vehicles

Simulated the Braitenberg Vehicles with configurable directions on GUI using differential driving techniques.

## Installation

Install numpy through numpy

```bash
pip install numpy
```

## Compilation & Run

```python
python Main.py
```

## Demonstration

Taking the lights position, vehicle position, and K matrix as input, where K matrix affects how sensitive is the vehicle to the received light intensity from the sensor. \
The Instantaneous Center of Curvature is plotted in green, and Vehicle path is plotted in black.\
![demo](demo.png)

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

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

## Reference
CSCE 452 from Texas A&M University

## Contributor
Avinash Chaurasia\
Michaela Matocha\
Kyle Lamb\
Osric Nagle

repository: ArthurChenCoding/Braitenberg-Vehicles

repo_name: ArthurChenCoding/Braitenberg-Vehicles


text:
# Jackle Example

An example todo-list application using Jackle.

## Getting Started

Install dependencies with yarn or npm

```bash
yarn
```

Run `webpack-serve` script

```bash
yarn serve
```

Open browser to `(localhost:3000)[http://localhost:3000]`

license: ISC


text:
MMA7361 Library for Arduino
============================

This library helps you to easily *play* with the almost universal 3 axis accelerometer available in most **Hobby** markets that is based on [Freescale's MMA7361](http://www.freescale.com/files/sensors/doc/data_sheet/MMA7361L.pdf).

In order to get in working you have to pull-up the sleep pin using a `10K` resistor to the 3.3V pin.
All other connections are labelled.

Just for *curious* ones:

* **X,Y,Z** give Analog Voltage outputs based on the orientation
* **SL** - Sleep (Pulled up)
* **0g** - It gives a signal when 0g is detected.
* **5v,3v,GND** - Usual Power Connections 3V is produced internally if 5v is applied
* **GS** - Sensitivity select- the IC allows 1.5g and 6g settings ( see gselect in *.cpp* file, Default is 1.5g)
* **ST** - Self Test

Enjoy!


text:
# vscode-dynamodb

A DynamoDB Viewer in VS Code, inspired by ~~vscode-mongodb~~ [vscode-cosmosdb](https://github.com/microsoft/vscode-cosmosdb). Currently in alpha.

* Connect to local or AWS-hosted instances of DynamoDB
* Create and view DynamoDB tables with the DynamoDB Explorer
* Create and view information on DynamoDB Streams
* Execute scripts and see results directly in VS Code

## Prerequisites

Must have [AWS CLI](http://docs.aws.amazon.com/cli/latest/userguide/installing.html) and [DynamoDB](http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.html) installed.

Additionally you need to have an AWS access key and secret key stored as environment variables to authenticate to DynamoDB (Even for local instances! I know, ugh).

## WARNING: please read

This extension can connect to and manipulate AWS-hosted DynamoDB tables, which means you should be ***VERY CAREFUL*** not to accidentally delete something or create a table/global secondary index with some extra zeros on the provisioned throughput...you could find those zeros mirrored on your bill. I therefore **highly reccommend** that you only use this for developing on local instances, and maybe deploying some test tables to AWS to get your throughput numbers right. Please don't use this extension to destroy an expensive production environment, because I won't be able to help you (beyond offering you my condolences, #HugOps).

## Current Features

* Connect to local or AWS-hosted instances of DynamoDB
* Create/Update/Delete tables with guided input through VS Code
* Create/Update tables through JSON files
* Use provided JSON Schemas to validate your AWS JSON requests!
* Use snippets to quickly build standard table schemas and create/update requests!

## Planned Features

### DynamoDB Viewer
* View tables, their primary key(s), indexes, and streams in an explorer tab

### DynamoDB Development Tools
* Quickly generate boilerplate DynamoDB Queries based on table structures
* See query results directly in VS Code.
* Quickly switch between multiple AWS named profiles

### DynamoDB Stream Manager
* Generate boilerplate code for reading shards from streams

## Extension Settings

* `dynamo.showExplorer`: Show or hide the DynamoDB Explorer. **[False by default, explorer not yet implemented]**
* `dynamo.sslEnabled`: Enable or Disable SSL on requests.
* `dynamo.region`: If running on EC2, specify the region.

repository: hariscodes/vscode-dynamodb

gha_language: TypeScript

repo_name: hariscodes/vscode-dynamodb


text:
---
layout: post
title: Path of Exile Analysis
---

# Path of Exile Leagues Analysis

[Path of Exile](http://www.pathofexile.com/) is an action role playing game made
by Grinding Gear Games (GGG) in a similar vein as Diablo. From its intricate,
unified skill tree to its purely barter economy, PoE has a number of unique
gameplay mechanics that cater to hard-core gamers. What really sets it apart,
though, are the races. In these events, which last anywhere from 12 minutes to
multiple months, players roll fresh characters, compete under a variety of
gameplay conditions, and generally try to run through the game faster than
everyone else.

If you have ever watched or played Path of Exile, you've probably had a number
of questions: Is there a preferred class? How consistent are the top racers? Are
certain races quantifiably more difficult than others (how _much_ worse is BLAMT
than Exiles Everywhere)? Puzzles solved, debates settled! I scraped the entire
Path of Exile database for the race results of 5,140,057 characters over 5,222
leagues to answer these very conundrums. You can read about how I did the
scraping [here]({{ site.baseurl }}{% post_url 2017-03-12-PoE-scraping%}).

## Basic info

First let's take a general look at the data.

![League size distribution](/public/league_size_hist.png)

If we plot a histogram of the number of characters in each league, we see most
events have fewer than 2,000 characters. Path of Exile has a complete game outside
of races and there are a _lot_ of events in PoE so perhaps this isn't too
surprising.
A
[2015 press release](http://www.gamasutra.com/view/pressreleases/243342/Path_of_Exile_The_Awakening_Supporter_Packs_Achieve_RecordSales.php) put
the worldwide player base north of 10 million players, which means on the order
of 0.01% of players compete in any given event.

The bump in the histogram at 15,000 corresponds to the depth of the ladder
retrievable by the API (if a ladder had more than 15,000, I could only retrieve
the first 15,000 and it appeared to me to only have 15,000 characters). These
large events are mostly season-long leagues and the main game's perennial
Standard and Hardcore leagues. There is an outlier race that was only 3 days
long. The '3 Day Exiles Event HC (IC010)' was an in between season event
that
[awarded closed beta access](http://www.pathofexile.com/forum/view-thread/1293370) to
the next expansion for the top 200 players. Additionally Exiles Everywhere races
are especially unique, entertaining, and deadly (racers likely ended up having
multiple characters). In exiles everywhere, 20 rogue exiles (mini-bosses) spawn
per zone. You can check
out [ZiggyD](https://www.youtube.com/watch?v=t3TBU_Kwbes) in this event to
see just how brutal these races are.

Looking at how events have been distributed over time, we can see there are
generally 1000+ events a year. There is a noticeable up tick in events after
both the start of the open beta and the game's official release.

![Events over time](/public/poe_events_over_time.png)

## Classes over time

In any competitive game, the metagame is constantly in flux. Classes fade in and
out of popularity. After its release, the Scion quickly became the most played
class. Over time interest in the Scion has waned and in the past 12 months
players have started to favor racing Rangers.

![Class popularity over time](/public/poe_class_popularity_vs_time.png)

## Player consistency

A common debate in games that have randomly generated maps, monsters, and loot
drops is whether players win based on skill or luck. Can you actually win
consistently given the random number generator (RNG)? Yes, yes you can. Let's
look at one of PoE's most famous racers, Kripparrian. (The whiskers in the plot
correspond to 1.5x the range between the 25% and 75% quartiles)

![Kripp race consistency](/public/poe_kripp_consistency.png)

When he was active in the racing scene, Kripp dominated. He finished first 23%
(!) of the time, in the top ten in 69% of his races, and in the top 100 in 88%
of his races! To see just how amazing this is, let's look at the most recent
winner of the Medallion season: Steelmage.

![Steelmage race consistency](/public/poe_steelmage_consistency.png)

Over all their races, Steelmage placed first 3%, top ten 31%, and top 100 67% of
the time. While quite a ways from Kripp-level consistency, this is still pretty
impressive especially considering how long Steelmage has managed to keep up this
level of gameplay. Over roughly 3 years Steelmage has competed in 629 events
compared to Kripp's 259 in about 1 year. Since events aren't evenly distributed
but grouped into seasons, this means top racers are competing multiple times a
day, every day, during the month-long race leagues.

And for fun let's look at professional Youtuber and streamer ZiggyD who races
regularly, but not quite at the level of the previous two players.

![ZiggyD race consistency](/public/poe_ziggyd_consistency.png)

Over 133 events ZiggyD has placed first overall 0%, top ten 1.5%, and top 100
31% of the time. So yes there is some RNG in Path of Exile, but the very best
racers can consistently break the top 100 in the majority of their races, and
top ten more than a quarter of the time.

## Race difficulty

It seems clear that some races are more difficult than others: a Lethal mod race
where enemies do 50% extra normal damage and 50% normal damage as each element
should be more _lethal_ than a vanilla Burst race. But quantifying race
difficulty is not immediately straightforward. If we look at the experience
histogram for characters in an event, it always has roughly an exponential
decay.

![Race experience histogram](/public/poe_experience_example.png)

There's a pile up of characters at low levels who die early on and then a long
tail of high performers. I would claim that in the more difficult races there's
a larger disparity between the less-skilled majority who only manage to get a
small amount of experience points and the elite who accumulate many more
experience points. We can roughly quantify this using the skew of the
distribution [^Skew_statistic]. Skew measures how long and fat the experience
tail is.

[^Skew_statistic]:
    Specifically I used the adjusted Fisher-Pearson standardized moment
    coefficient G1 built into most statistical packages including pandas.

![Race difficulty](/public/poe_race_difficulty.png)

Let's digest this. The highest skew, most difficult leagues include Exiles
Everywhere, BLAMT, and Cutthroat. The "easier" leagues with less separation
between skill levels include vanilla Burst races and, generally, Endless Ledge.

The Exiles Everywhere race was mentioned earlier. In this race 20 mini-bosses
are spawned per area.

BLAMT is a masochistic race with a combination of modifiers: **B**lood magic,
**L**ethal, **A**ncestral, **M**ulti-projectile, **T**urbo. This means
characters use health instead of mana for skills, monsters do 50% extra normal
damage and 50% normal damage as each element, there are many more enemey buff
totems, enemies fire four additional projectiles, _and_ monsters move, cast, and
attack 60% faster. Lethal and Turbo races have just their modifiers,
respectively.

Cutthroat centers around killing other players for loot and experience. Not
surprisingly most characters get killed at low levels while some snowball by
coming out on top early.

In Headhunter races players acquire bonuses after killing rare monsters which
are much more plentiful in this league, but still just as deadly.

Endless Ledge is a straight run in a fixed looping area (Ledge) with
increasingly difficult monsters after each loop.

In contrast Burst races have no modifiers and, like the other races, the
objective is to get as much experience as possible in the time limit. It makes
sense that there is a lot less skew in experience for a typical 12 minute Burst
race.

It looks like, on average, Exiles Everywhere races do just a little bit better
job than BLAMT races of separating the pros from the newbs. Surprised?

## Where to from here?

To see the code behind this post (and some more analysis that didn't make the
cut!) checkout
the [github repository](https://github.com/stevejbrown/PoE-analysis). I
encourage you to play with the data yourself. There are answers to so many
questions buried in this data set: how has the winning class changed over time?
What is the distribution of race lengths? Are some players better at certain
races than others? Which races are going in and out of style? How did the
Russian Garena Realm differ from the main GGG realm? Which races are most
popular? Happy digging!


text:
### [1770\. Maximum Score from Performing Multiplication Operations](https://leetcode.com/problems/maximum-score-from-performing-multiplication-operations/)

Difficulty: **Medium**

Related Topics: [Dynamic Programming](https://leetcode.com/tag/dynamic-programming/)

You are given two integer arrays `nums` and `multipliers`of size `n` and `m` respectively, where `n >= m`. The arrays are **1-indexed**.

You begin with a score of `0`. You want to perform **exactly** `m` operations. On the `i<sup>th</sup>` operation **(1-indexed)**, you will:

*   Choose one integer `x` from **either the start or the end** of the array `nums`.
*   Add `multipliers[i] * x` to your score.
*   Remove `x` from the array `nums`.

Return _the **maximum** score after performing_ `m` _operations._

**Example 1:**

```
Input: nums = [1,2,3], multipliers = [3,2,1]
Output: 14
Explanation: An optimal solution is as follows:
- Choose from the end, [1,2,3], adding 3 * 3 = 9 to the score.
- Choose from the end, [1,2], adding 2 * 2 = 4 to the score.
- Choose from the end, [1], adding 1 * 1 = 1 to the score.
The total score is 9 + 4 + 1 = 14.
```

**Example 2:**

```
Input: nums = [-5,-3,-3,-2,7,1], multipliers = [-10,-5,3,4,6]
Output: 102
Explanation: An optimal solution is as follows:
- Choose from the start, [-5,-3,-3,-2,7,1], adding -5 * -10 = 50 to the score.
- Choose from the start, [-3,-3,-2,7,1], adding -3 * -5 = 15 to the score.
- Choose from the start, [-3,-2,7,1], adding -3 * 3 = -9 to the score.
- Choose from the end, [-2,7,1], adding 1 * 4 = 4 to the score.
- Choose from the end, [-2,7], adding 7 * 6 = 42 to the score.
The total score is 50 + 15 - 9 + 4 + 42 = 102.
```

**Constraints:**

*   `n == nums.length`
*   `m == multipliers.length`
*   `1 <= m <= 10<sup>3</sup>`
*   `m <= n <= 10<sup>5</sup>`
*   `-1000 <= nums[i], multipliers[i] <= 1000`

#### Solution

Language: **JavaScript**

```javascript
/**
 * @param {number[]} nums
 * @param {number[]} multipliers
 * @return {number}
 */
var maximumScore = function(nums, multipliers) {
    const n = nums.length
    const m = multipliers.length
    const cache = Array(n).fill().map(() => () => Array(m).fill())

    function dfs(s, e, i) {
        if (i === m) return 0
        if (cache[s][i] === undefined) {
            cache[s][i] = Math.max(
                nums[s] * multipliers[i] + dfs(s + 1, e, i + 1),
                nums[e] * multipliers[i] + dfs(s, e - 1, i + 1)
            )
        }
        return cache[s][i]
    }

    return dfs(0, n - 1, 0)
};
```


text:
# booTravel

booTravel is a Python library for dealing with word pluralization.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install booTravel.

```bash
pip install booTravel
```

## Usage

```python
import booTravel

booTravel.pluralize('word') # returns 'words'
booTravel.pluralize('goose') # returns 'geese'
booTravel.singularize('phenomena') # returns 'phenomenon'
```

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

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

repository: mohdazlan/let-s-Travel

gha_language: HTML

repo_name: mohdazlan/let-s-Travel


text:
# GoCD Kickstarter

A repository which lets you get started with [GoCD](https://www.gocd.org) and its [Terraform provider](https://github.com/beamly/terraform-provider-gocd). You can use Terraform to fully express all of your pipelines as code.

# Setup

Prerequisites:

- Docker (>= 18.06.1-ce)
- docker-compose (>= 1.20.1)
- Terraform (>= 0.11.8)
- curl
- bash

# Run a GoCD server/agent

You can use the `docker-compose.yml` file that is shipped with this kickstarter to provision a new GoCD server and a single agent along with it:

```sh
$ ./run compose
```

This will run the `docker-compose` definitions in the foreground.

_Note: The GoCD server takes a lot of time to get started, sometimes up to 60 seconds. Keep that in mind when provisioning your instance._

# Deploy your pipelines

The `run` script will do the heavy lifting for you:

```sh
$ ./run terraform apply
```
This will use Terraform to provision two simple pipelines, mostly `echo` statements, with a `git` material, some environment variables, and a pipeline dependency. It's not too complicated to grasp in the beginning but also complex enough to suit most initial GoCD deployments.

# TODO

- Windows support (technically, Windows is supported already, it just has never been tested)

repository: ssalvatori/gocd-kickstarter

repo_name: ssalvatori/gocd-kickstarter


text:
# Virtual Machine for PHP development

Virtual machine suitable for PHP development (Symfony, Laravel, Drupal 8, etc).
Build with Debian 7.x (Wheezy) including Nginx, MySQL, PHP-FPM and more packages.

## Requirements

- VirtualBox: https://www.virtualbox.org/wiki/Downloads
- Vagrant: http://downloads.vagrantup.com/

## Available Roles

- Java (openJDK)
- MailCatcher

Set your favourite app to deliver to smtp://<IP_ADDRESS>:1025 instead of your default SMTP server, then check out
http://<IP_ADDRESS>:1080 to see the mail that's arrived so far.
- Memcached
- MySQL

Uses the custom.ini from provisioning/roles/mysql/templates to override the default settings
- NodeJs
- Redis

Uses the config from provisioning/roles/redis/templates/redis.conf.j2
- PHP-FPM

Uses the config files from provisioning/roles/php-fpm/templates
- Nginx
- Zend-Server

Can't be used with the roles PHP-FPM and Nginx!

## Configuration
- Vagrantfile

This file contains a config options array which you can change, or create a Vagrantfile.local with the config options
you want to override.

- provisioning/group_vars/all

This file contains all configuration variables for the available roles.

- provisioning/playbook.yml

Enable the roles you need by removing the # in front of the line or place a # in front of a role to disable it

## Usage
Copy the Vagrantfile and provisioning directory to your project, update the configuration and type:

```
vagrant up
```

## Todo
- Make PHP Timezone configurable, currently hardcoded to Europe/Amsterdam
- Add vhost to Zend-Server

##  License

This code is open-sourced software licensed under the
[MIT license](http://opensource.org/licenses/MIT)

repository: ProcessManagement/DevOPSLAMP

repo_name: ProcessManagement/DevOPSLAMP


text:
#Example rules

- If ram usage > 80% for more than 5 minutes, ram +1gb
- If systemload > x for more than y minutes,  cpu +1core
- If systemload > x for more than 2*y minutes, cpu -1 core
- If systemload > x for more than 2*y minutes, trigger alert (removing the last cpu is blocked by the isac api)
- If ram usage < x for more than y minutes, ram -1gb
- If systemload < x for more than y minutes, cpu -1core

repository: tweichart/ScaleManager

repo_name: tweichart/ScaleManager


text:
# Todo Application Using React Hooks [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/akashishu777/debounce-input-react/blob/master/LICENSE) [![Build Status](https://github.com/akashishu777/Todo-Applicaton-Using-Hooks/workflows/Node%20CI/badge.svg)](https://github.com/akashishu777/Todo-Applicaton-Using-Hooks/actions)
A simple Todo Application, with React, Hooks.

App Link: https://akashishu777.github.io/Todo-Applicaton-Using-Hooks

Pipeline: https://github.com/akashishu777/Todo-Applicaton-Using-Hooks/actions

## Dependencies

- @testing-library/jest-dom
- @testing-library/react
- @testing-library/user-event
- @types/jest
- @types/node
- @types/react
- @types/react-dom
- react
- react-dom
- react-scripts
- typescript

## Running

```
git clone https://github.com/akashishu777/Todo-Applicaton-Using-Hooks.git
```
 go to directory and run, this will install all dependencies for the project.
```
npm install
```
Then run App with:
```
npm run start
```

For testing the App
```
npm run test
```

## Author

* **Akash Vishwakarma** - [GitHub](https://github.com/akashishu777) - Email<EMAIL_ADDRESS>


text:
---
num: "h12"
desc: "Dynamic Classes"
ready: true
assigned: 2018-05-08 08:00:00.00-7:00
due: 2018-05-15 12:30:00.00-7:00
reading: "PS 11.4, DS 4.4"
---

Reading: {{page.desc}}, {{page.reading}}

(10 pts) Fill in the information in the header. The following are required to get the 10 "participation" points.

Filling in your name and umail address.

Also: For paper submission PLEASE submit on ONE SHEET OF PAPER, double-sided if at all possible. If you must submit on two printed sheets write name on BOTH sheets and no staples, paperclips, or folded corners.

 Some classes have private data members with pointers to values allocated on the heap.  Your textbook calls the heap the "freestore", and it calls these values on the heap "dynamic variables".

When you have a class with dynamic variables, i.e. when you have attributes that are pointers to things on the heap, you likely need to think about the "big-three", i.e. three special kinds of things that you need to implement in your class.

What are the names of this so-called 'big three?' You may list them in any order:

(2 pts)

(2 pts)

(2 pts)

 (6 pts) What is the purpose of a destructor?

 (4 pts) Write the function prototype for the destructor for a class with the name Foobar.

 (4 pts) Write the function prototype for a copy constructor for a class with the name Foobar.

 (10 pts) The parameter to the copy constructor is a const reference.  Sometimes you use a const reference instead of pass-by-value for reasons of efficiency, but in the case of a copy constructor, there is an even more fundamental reason why pass-by-value CANNOT be used.  Why is that?

 (4 pts) Write the function prototype for an overloaded assignment operator for the class Foobar.

 (6 pts) Why does C++ provide users with both a <tt>delete</tt> operator and <tt>delete [ ]</tt> operator?


text:
# Contributing the Varnish

## Requirements

The only thing you need to install before getting started is [Docker 🐳](https://www.docker.com/).

## Getting Started

To get your development environment setup, follow these instructions:

1. Clone the repository:

     ```bash
    git clone git@github.com:allenai/varnish.git
    ```

1. Start an instance of the demo:

   ```bash
   docker-compose up --build
   ```

1. Visit [http://localhost:3000](http://localhost:3000) and use the demo to
   verify the changes you're making.

1. Once you're complete, open a pull-request with your changes.

1. Before merging into master, make sure that your changes are properly formatted:

   ```bash
   yarn run lint:fix
   ```

## Releasing a new Version

To release a new version, you'll need to install [NodeJs](https://nodejs.org/en/)
and [yarn](https://yarnpkg.com/lang/en/).

Then, follow these steps:

1. Make sure you're in a clean state, with the latest changes:

    ```bash
    git fetch origin
    git reset --hard origin/master
    ```

2. Review you'll be releasing:

    ```bash
    # Replace `v0.5.8` with the latest version
    git log v0.5.8...HEAD
    ```

   If there's something there that you're not positive is ready to be released,
   ask the person responsible for that commit. You'll also use this information
   to inform the version you choose to release in step #4.

3. Login to `npm`:

    ```bash
    npm login
    ```

   Note, if you haven't been added to the `@allenai` NPM organization you'll
   get a permissions error when you attempt the `publish` command below. If
   this occurs ask someone from<EMAIL_ADDRESS>to add you.

4. Create a new version, we intend to follow [semantic versioning](https://semver.org/),
   though at the moment we're pre-1.0, and accordingly increase the `minor` version
   for significant changes, and the `patch` version for small ones.

   ```bash
   # Replace `0.5.8` with the version you're releasing.
   npm version 0.5.8
   ```

5. Commit and push the change, and make sure to include tags:

   ```bash
   git push --tags origin master
   ```

6. Publish the version to `npm`:

   ```bash
   npm publish --access public
   ```

7. Draft and publish a new [Github Release](https://github.com/allenai/varnish/releases).
   To get a list of changes since the last tag, run this command:

   ```bash
   ~ git log vX.X.X...vY.Y.Y
   ```

   Where `vX.X.X` is the previous version, and `vY.Y.Y` is the new one. Try to
   base the description of the release off of previous ones. The idea is to
   give users a clear idea of what changed in the release.

8. Announce the new version by linking to the Github release in the
   `#varnish-releases` Slack channel.

repository: kant/varnish

repo_name: kant/varnish


text:
# Power Up Scoring Simulation

This is a simulation of scoring in the FIRST Robotics Power Up game.

[FIRST Inspires Season info](https://www.firstinspires.org/resource-library/frc/competition-manual-qa-system).

[The Blue Alliance](https://www.thebluealliance.com/).