text:
# Lexus
[![Build Status](https://jenkins.appcelerator.org/buildStatus/icon?job=pem/lexus/master)](https://jenkins.appcelerator.org/job/pem/job/lexus/job/master/)

*Please note the open source Lexus project is a work in progress. There are some aspect of the current version that are likely to change soon. And other portions of the Lexus project will be open sourced in other repositories.*

Lexus is a small [JSON](http://www.json.org/) language used for querying data storage systems.
It is intended to be portable across systems and therefore does not try to cover the features of any one system comprehensively.
With Lexus you can query for a set of specific documents using filters that match them, or for counts of the documents that match.
You can also ask for basic histograms or group by field values in the documents.
Other aggregations such as sums and averages are also possible.

[This document](https://github.com/appcelerator/lexus-opensource/blob/master/docs/getting-started.md) will present a small set of examples to get you started.

There are various projects that translate other query languages to Lexus, and that translate Lexus to other query languages. For this reason Lexus can be used to bridge the translation between languages that normally have no direct translation.

The Lexus language is named after Dr. Lexus, a fictional character from the 2006 film [Idiocracy](https://en.wikipedia.org/wiki/Idiocracy).

## Project Organization

This repository contains the Lexus spec, docs, test suite and a list of ports that we are aware of and that pass the test suite.

The json-schema specification of the Lexus DSL syntax is located in [schema/](https://github.com/appcelerator/lexus-opensource/tree/master/schema). The documentation describing Lexus is in [docs/](https://github.com/appcelerator/lexus-opensource/tree/master/docs) and the Lexus test suite in [testsuite/](https://github.com/appcelerator/lexus-opensource/tree/master/testsuite).

To visualize the spec, use the small CLI included:

```bash
$ bin/lexus-spec bundle <vsn>
```

To validate the syntax of a Lexus query against the spec:
```bash
$ bin/lexus-spec validate query.json
```
where `query.json` is an example file containing a Lexus query to check for validation of.

The test suite ensures any ports of Lexus to a new data storage system will yield the same results for the same query on the same data as any other port for another system.

## Lexus Ports

TBD

## Contributing

If you would like to report a bug, feel something can be improved, or have any questions about Lexus please feel free to file a Github issue.

If you have implemented a new Lexus frontend or backend implementation, please try to implement tests that cover all the cases in the Lexus test suite in [testsuite/](https://github.com/appcelerator/lexus-opensource/tree/master/testsuite). The tool described [here](https://github.com/appcelerator/lexus/blob/master/testsuite/README.md) might make things easier to start out. You may then file a PR to add your project's repository to the table above in this README.md file.

## Licence

Lexus is open source software from [Axway](https://www.axway.com/) licensed under the Apache License 2.0.

repository: appcelerator/lexus

repo_name: appcelerator/lexus


text:
# List of Property Keys

| Key           | Value                                                         | Scope                 |
|---------------|---------------------------------------------------------------|-----------------------|
| address       | Street and number (eg 'Westernstraße 4')                      | Store                 |
| city          | City and zip code (eg '33098 Paderborn)                       | Store                 |
| image         | Promotional image in base64 encoding                          | Vendor, Store         |
| image_uid     | Promotional image uid under assets/                           | Vendor, Store         |
| logo          | Logo image in base64 encoding                                 | Vendor                |
| logo_uid      | Logo image uid under assets/                                  | Vendor                |
| description   | Short text describing the object                              | Vendor, Store, Coupon |
| telephone     | Telephone number in text format                               | Vendor, Store         |
| latlng        | Comma-seperated latitude longitude values (eg. '51.706,8.745')| Vendor, Store         |
| code          | Optional permanent code string                                | Coupon                |
| product       | product image for display on vendor page                      | Vendor                |
| product_uid   | product uid under assets/ for display on vendor page          | Vendor                |
| website       | URL of vendor's website                                       | Vendor                |
| disabled      | boolean flag to hide vendor in client list                    | Vendor                |
| email         | email adress for vendor or specific store                     | Vendor, Store         |
| hours         | opening hours of a store                                      | Store                 |

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# ODIN

To create a better understand of ODIN, the follow documentation describes:

- [Behaviors and life-cicles](./Behaviors-and-lifecycles.md)
- [Kinds of dependencies](./Types-of-dependencies.md)
- [How to define a dependency](./How-to-define-a-dependency.md)
- [Bundles & Inject](./Bundle-and-inject.md)
- [Custom Provider](./Container-and-customprovider.md)
- [Configuration](./Configuration.md)

license: MIT

repository: philips-software/odin

branch_name: refs/heads/main

gha_language: TypeScript

gha_license_id: MIT

repo_name: philips-software/odin


text:
# Legacy Bundle Snowpack Plugin
This is a Snowpack plugin that provides a dead simple way to add a legacy bundle and implement differential serving for browsers that don't support modules.

It transpiles code and adds basic Pollyfills with Babel and uses Rollup to build a legacy bundle. By loading the bundle with `<script nomodule ...`, the bundle is only used in older browsers and the everybody else gets all the benefits and speed of ES modules and bundler-free experience Snowpack offers.  Works with CJS modules, too.

---

## Setup
Setup is super simple. First install:
`npm install --dev legacy-bundle-snowpack-plugin`
or
`yarn add --dev legacy-bundle-snowpack-plugin`

---

Add a script file for your legacy code and add `imports` for your entry point and any non-Babel pollyfills you want to add:

`src/scripts/legacy.js`
```
// Legacy

@import index.js
@import { somePoly } from 'polyfill'

...
```
---

Add the plugin to your Snowpack config:
`snowpack.config.js`
```
...
  plugins: [
    'legacy-bundle-snowpack-plugin',
...
```
Or with one of the options.  `filePath` is relative to the build directory and defaults to 'scripts/legacy.js' which is build/scripts/legacy.js and built from src/scripts/legacy.js in my setup.
```
...
  plugins: [
    [ 'legacy-bundle-snowpack-plugin',
      {
        filePath: 'scripts/legacy.js',
        babelConfig: { ... }
      }
    ]
  ]
...
```
---
Finally, just add it to your `index.html` under your main script.  Make sure to load the normal/modern version with `type=module` and this one as `nomodule` (just the attribute)
```
...
    <script type="module" src="/scripts/main.js"></script>
    <script nomodule src="/scripts/legacy.js"></script>
  </body>
</html>
```

Now run build and the output of legacy.js should be an old-school bundle.  That's it.

---

gha_language: JavaScript


text:
# Sider organization-wide files and settings

See the [document](https://help.github.com/en/github/building-a-strong-community/creating-a-default-community-health-file) about the `.github` repository.

## Syncing labels

You can add or edit labels in [`labels.json`](labels.json) (in alphabetical order).

Use [github-label-sync](https://github.com/Financial-Times/github-label-sync) and follow the steps:

1. [Get a new access token](https://github.com/settings/tokens/new?description=Sider+labels+sync&scopes=repo) in GitHub
2. Set the new token above in your terminal, e.g. `export GITHUB_ACCESS_TOKEN=xxxxxx`
3. Try to sync with dry-run mode: `npx github-label-sync sider/.github --allow-added-labels --dry-run`
4. Sync actually: `npx github-label-sync sider/.github --allow-added-labels`
5. Check the synced labels on the [labels](https://github.com/sider/.github/labels) page
6. Try to sync for other repositories: `npx github-label-sync sider/<repo> --allow-added-labels [--dry-run]`
7. [Delete the generated token](https://github.com/settings/tokens) on GitHub

Note that we should **always set `--allow-added-labels`** because existing labels would be deleted without it.


text:
# Iceberg Theme for VSCode

## Iceberg is a dark blue Visual Studio Code Theme.<br>It brings a cool-headed perspective for your happy coding!

**based on [Iceberg for Vim](http://cocopon.github.io/iceberg.vim/) by [cocopon](https://github.com/cocopon)**

## General preview
![Iceberg Screenshot](https://raw.githubusercontent.com/harg/iceberg-visual-studio-code/master/assets/iceberg-screenshot.png)

## Features
- coherent colorscheme
- Fully supported Workbench styles
- Terminal support

## Installation

1. Open **Extensions** sidebar panel in VS Code. `View → Extensions`
2. Search for `iceberg`
3. Click **Install** to install it.
4. Click **Reload** to reload  your editor
5. Code > Preferences > Color Theme > **Iceberg**

## Restore gutter background

Add the following line to you `settings.json` :

`"workbench.colorCustomizations": {
    "editorGutter.background": "#1e2132"
}`

## Language preview

### Python

![Python example](https://raw.githubusercontent.com/harg/iceberg-visual-studio-code/master/assets/iceberg-py-screenshot.png)

### PHP

![PHP example](https://raw.githubusercontent.com/harg/iceberg-visual-studio-code/master/assets/iceberg-php-screenshot.png)

### Go

![Go example](https://raw.githubusercontent.com/harg/iceberg-visual-studio-code/master/assets/iceberg-go-screenshot.png)

### Ruby

![Ruby example](https://raw.githubusercontent.com/harg/iceberg-visual-studio-code/master/assets/iceberg-rb-screenshot.png)

### XML

![XML example](https://raw.githubusercontent.com/harg/iceberg-visual-studio-code/master/assets/iceberg-xml-screenshot.png)

## For other environments

- [Vim](http://cocopon.github.io/iceberg.vim/) by [cocopon](https://github.com/cocopon) (The original!)
- [Terminal.app profile](http://cocopon.github.io/iceberg.vim/) by [cocopon](https://github.com/cocopon)
- [iTerm2](https://github.com/aseom/dotfiles/blob/master/osx/iterm2/iceberg.itermcolors) by [aseom](https://github.com/aseom)
- [Atom](https://github.com/cocopon/atom-iceberg-syntax/) by [cocopon](https://github.com/cocopon)
- [Xcode](https://github.com/cocopon/xcode-iceberg) by [cocopon](https://github.com/cocopon)
- [AppCode](https://github.com/Kuniwak/iceberg.icls) by [Kuniwak](https://github.com/Kuniwak)
- [Hyper](https://github.com/cocopon/hyper-iceberg) by [cocopon](https://github.com/cocopon)

**enjoy!**

repository: harg/iceberg-visual-studio-code

repo_name: harg/iceberg-visual-studio-code


text:
#      Crystal:A very fast distributed subgraph matching algorithm
This project contains the implemetation of the method described in **Subgraph matching: on compression and computation** published in VLDB2018.

##      Patterns
![Pattern](./pattern.jpg?raw=true "Pattern")

##      Environment Requirement

[Hadoop 2.7.3](https://hadoop.apache.org).

##      How to use?

#### 1) preprocess datasets (in edge list form) by
run "Preprocess.sh"

#### 2) perform counting
run "CountingTest.sh", which will count subgraph matching for all pattern listed.

#### 3) generate compression form
run "WritingTest.sh", which will dump the the result of subgraph matching for all pattern listed to HDFS

##	Detail Specification
Source Code is in **Subgraph** folder, which can be open by **Intellij Idea**.

In it you can find three packages:

- sAlg
    - Square
    - Chordal Square
    - House
        - HouseS: for small data graph
        - House:for large data graph
    - Chordal Roof
    - Three Triangle
    - Solar Square
    - Near5Clique
    - QuadTriangle
    - SolarSquarePlus
- sData: data structure used in sAlg
- sPreprocess: Preprocessing Related
    - sCliqueGeneration
        - classes used to generate the crystal
    - sTool
        - preprocessing the graph

Each of the patterns comes with two java class, one for counting, one for outputting(class with name ended with O). More detail please read the code.

###	Test File
Files related to testing is at Top level.

- **Data**: small datasets for testing the algorithm, in which each dataset is attached with a *-pattern-size.txt recording the pattern's size in each graph for each pattern.
- Preprocess.sh: Preprocessing the Data for CountingTest.sh and WritingTest.sh.
- CountingTest.sh: Testing the code related to counting in **Crystal**
- WritingTest.sh: Testing the code related to writing in **Crystal**
- pattern.eps: give a visulization about what pattern looks like

Please run Preprocess.sh first, before running the other two shell script. More detail please read the .sh file, and change some of the variables accordingly in the script file.

###	Parameter
- mapreduce.job.reduces: better using the same number as vCore in yarn
- mapreduce.reduce.memory.mb: the default is 4000MB, if graph bigger than UK2002 need to be processed, this might need to increase.
- mapreduce.map.memory.mb: the default is 4000MB, if graph bigger than UK2002 need to be processed, this might need to increase.
- test.memory: same as mapreduce.map.memory.mb. But only available in sAlg.
- bloomHash: controlling hash function used in Bloom filter
- bloomBit: controlling numbers of bit for representing a record in Bloom filter
- test.p
    - test.p (for classes in sIntersection): controlling the number of the round for the algorithm, the lower the better (if memory permit)
    - test.p (for classes in sPartition)L controlling the number of partitions for the algorithm, the lower the better (if memory permit)
- test.isOutput: specify whether the result should be outputted in *O.class.
- test.isEnumerating: whether just counting or enumerating.

###	Format
- InputFormat: Edge List
- OutputFormat: file format specified in the paper.

```
    //Below three configuration is commented for maximum compatibility for the different version of Hadoop, if possible, they should be uncommented to improve the performance and compression ratio.

    //These configurations can be found in the source code.

    SequenceFileOutputFormat.setOutputCompressionType(job, CompressionType.BLOCK);

    FileOutputFormat.setCompressOutput(job, true);

    FileOutputFormat.setOutputCompressorClass(job, SnappyCodec.class);
```

###	Core-Crystal Decomposition

The pattern decomposition aims at optimzing Objective 3 in the paper.

This package provides decomposition.cpp which decomposes the pattern graph with/without the statistics of the cliques.

input specification
Input the pattern graph to pattern.txt.
	first line :
		n m b
			n: # of nodes, m: # of edges. Note that nodes are labeled with [1,n].
			b: a boolean value of 0 or 1, specifying that statistics are used (1) or not (0)
	followed by m lines, each line
		x y
			describes an undirected edge (x,y)

followed by a line, if b=1,
		k M
			k: the largest clique with statistics, k should be at least = the largest clique size in the pattern graph
			M: memory size
	followed by k lines, the i-th line specifies
		the total number of Clique_i in the target graph. Specifically, the first line is the # of nodes in the target graph and the second line is the # of edges in the target

```
Example input 1

4 4 0
1 2
1 3
2 4
3
```
```
Example input 2
4 4 1
1 2
1 3
2 4
3 4

2 20
100
200
```
Please refer to patternpool.txt for further example

For citatation
```
@article{qiao2017subgraph,
  title={Subgraph matching: on compression and computation},
  author={Qiao, Miao and Zhang, Hao and Cheng, Hong},
  journal={Proceedings of the VLDB Endowment},
  volume={11},
  number={2},
  pages={176--188},
  year={2017},
  publisher={VLDB Endowment}
}
```

### contact me at [hzhang<EMAIL_ADDRESS>

repository: Shengsj/Crystal

repo_name: Shengsj/Crystal


text:
How to contribute
=================

If you feel like contributing to whereas, here’s how.

First of all, fork this repo and clone the fork to your local machine:

```console
$ git clone git@github.com:your-username/whereami.git
```

Make sure you can build the project. There’s no tests (yet). Either build from the command line or from Xcode

```console
$ xctool build
```

Make your changes, and commit them. Push to your fork, and from there submit a pull request.

TODO
====

* Set a timeout for CoreLocation to fail. Sometimes it gets stuck for lack of permission (without requesting it) and then it never returns.
* Write a proper man page.
* Add more options for output of additional data, like altitude, precision or course, and also for input of minimum precision

repository: victor/whereami

branch_name: refs/heads/swift

gha_language: Swift

repo_name: victor/whereami


text:
# Call SLB APIs {#concept_xvm_tff_cz .concept}

When you call Server Load Balancer \(SLB\) APIs, HTTP GET requests are sent to the API service address of SLB, and the system responds according to the parameters set in the request. Both the requests and responses are UTF-8 encoded.

## Request syntax {#section_mqj_q3f_mdb .section}

SLB APIs use RPC style. To call SLB APIs, send HTTP GET requests.

The structure of an SLB API request is as follows:

```
http://Endpoint/?Action=xx&Parameters
```

where,

-   Endpoint: The service address of SLB APIs is slb.aliyuncs.com.
-   Action: the name of the action. For example, if you need to query created SLB instances, the action is DescribeLoadBalancers.
-   Version: the version of the API. The version of SLB APIs is 2014-05-15.
-   Parameters: the request parameters. Separate multiple parameters by using ampersands \(&\).

    Request paramters include common parameters and API-specific parameters. Common parameters include API version and identity authentication information among other parameters. For more information, see [Common parameters](intl.en-US/Developer Guide/Common parameters.md).

The following is an example of calling DescribeLoadBalancers to query created SLB instances.

**Note:** The following code has been edited to ease readability.

``` {#public}
https://slb.aliyuncs.com/?Action=DescribeLoadBalancers
&Format=xml
&Version=2014-05-15
&Signature=xxxx%xxxx%3D
&SignatureMethod=HMAC-SHA1
&SignatureNonce=15215528852396
&SignatureVersion=1.0
&AccessKeyId=key-test
&TimeStamp=2012-06-01T12:00:00Z
…
```

## RAM user authorization {#section_mlp_qmf_mdb .section}

To maintain account security, we recommend that you use the Access Keys \(AKs\) of RAM users to call APIs. Before you call APIs by using the AKs of RAM users, you need to grant permissions to the RAM users by attaching corresponding policies to them.

For more information, see [RAM authentication](intl.en-US/Developer Guide/RAM authentication.md).

## Request signature {#section_jtc_ymf_mdb .section}

Authentication is required by the SLB service for each API call, which is provided by the inclusion of signature information in the request.

For more information about the calculation of signatures, see [RPC API signature](https://www.alibabacloud.com/help/doc-detail/66384.htm).

SLB uses an AccessKeyID and AccessKeySecret pair \(that is, an AK\) and symmetric encryption to authenticate the identity of the request sender. AKs are certificates that Alibaba Cloud issues to Alibaba Cloud accounts and RAM users for authentication. It is similar to a logon password. The AccessKeyID is used to identify the visitor's identity. The AccessKeySecret is the key used to encrypt the signature string. The server uses the AccessKeySecret to decrypt the signature string. The AccessKeySecret must be kept confidential.

A request in an API call is signed in the following format:

```
https://endpoint/?SignatureVersion=1.0&SignatureMethod=HMAC-SHA1&Signature=CT9X0VtwR86fNWSnsc6v8YGOjuE%3D&SignatureNonce=3ee8c1b8-83d3-44af-a94f-4e0ad82fd6cf
```

Take the API call of DescribeLoadBalancers as an example. If your AccessKeyID is `testid`, and your AccessKeySecret is `testsecret`, then, the URL in the signature is as follows:

``` {#public1}
http://slb.aliyuncs.com/?Action=DescribeLoadBalancers
&TimeStamp=2016-02-23T12:46:24Z
&Format=XML
&AccessKeyId=testid
&SignatureMethod=HMAC-SHA1
&SignatureNonce=3ee8c1b8-83d3-44af-a94f-4e0ad82fd6cf
&Version=2014-05-26
&SignatureVersion=1.0
```

To generate the signature, follow these steps:

1.  Create the string to be signed by using the request parameter.

    ```
    GET&%2F&AccessKeyId%3Dtestid%26Action%3DDescribeRegions%26Format%3DXML%26SignatureMethod%3DHMAC-SHA1%26SignatureNonce%3D3ee8c1b8-83d3-44af-a94f-4e0ad82fd6cf%26SignatureVersion%3D1.0%26TimeStamp%3D2016-02-23T12%253A46%253A24Z%26Version%3D2014-05-26
    ```

2.  Calculate the HMAC value of the string.

    Add an ampersand \(&\) after the AccessKeySecret to add the key of the HMAC value. In this example, the key is `testsecret&`.

    ```
    CT9X0VtwR86fNWSnsc6v8YGOjuE=
    ```

3.  Add the signature to the request parameter.

    ``` {#public3}
    http://slb.aliyuncs.com/?Action=DescribeLoadBalancers
    &TimeStamp=2016-02-23T12:46:24Z
    &Format=XML
    &AccessKeyId=testid
    &SignatureMethod=HMAC-SHA1
    &SignatureNonce=3ee8c1b8-83d3-44af-a94f-4e0ad82fd6cf
    &Version=2014-05-26
    &SignatureVersion=1.0
    &Signature=CT9X0VtwR86fNWSnsc6v8YGOjuE%3D
    ```

path: /intl.en-US/Developer Guide/Call SLB APIs.md

filename: Call SLB APIs.md


text:
Techniques are duplicated from [edX - How to Write an Essay](https://learning.edx.org/course/course-v1:BerkeleyX+ColWri2.1x+1T2021/home), thanks to *Maggie Sokolik, Ph.D., Instructor*.

# Six Steps to More Concise Writing

## Step 1. Avoid redundancy

They say the same thing as the main phrase.

* ten p.m. (at night)
* tall (in height)
* our (final) conclusion
* (the month of) June
* square (in shape)
* to combine (together)
* to ask (a question)
* a consensus (of opinion)

## Step 2. Avoid wordy phrases

You use more words than you need to say something.

| Wordy                     | Concise     |
| ------------------------- | ----------- |
| based on the fact that    | because     |
| despite the fact that     | although    |
| in the event that         | if          |
| at the present time       | now         |
| until such a time as      | until       |
| on a weekly basis         | weekly      |
| it is often the case that | often       |
| have the ability to       | can         |
| during the course of      | during      |
| take under consideration  | consider    |
| to be of the opinion      | to think    |
| to make reference to      | to refer to |
| in the final analysis     | finally     |

## Step 3. Clear subject and no empty subject

* Unclear: **The practice of revision** would improve our writing.
* Clear: **Revision** would improve our writing.

---

* Empty: **There is** no way to become a better writer than to practice.
* Defined: **We** can become better writers if we practice.

## Step 4. Using strong verbs

* to be + nouns: **What we found was a solution** to the problem.
* Strong verb: We **solved** the problem.

## Step 5. Avoid vague words

Words like "thing," "stuff," "material," "people," "get," or "did" should be replaced with precise nouns or verbs.

* Vague: I needed to get **some stuff** at **the store**.
* Clear: I needed to buy **some groceries** at the **farmer's market**.

## Step 6. Remove unnecessary modifiers.

* Unnecessary: **In my opinion,** that movie was **really quite good**. I'm **very** glad we saw it.
* Concise: That movie was **fantastic**! I'm **glad** we saw it.

## Bonus. Strengthen your sentences

If the revision of that sentence sounds too simple, think of other ways to modify it that add information.

| Level              | Sentence                                                    |
| ------------------ | ----------------------------------------------------------- |
| Unnecessary        | In my opinion, that movie was really quite good.            |
| Concise            | That movie was fantastic!                                   |
| Adding Information | That movie was an interesting retelling of a familiar story |

repository: windsuzu/Essay-Writing

repo_name: windsuzu/Essay-Writing


text:
simplestruct
============

Struct-like classes with attribute type checking.

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

### Installation

You can install it from pip.

```
$ pip install simplestruct
```

### Basic Usage

Here's a simple an example.

```python
import simplestruct

class Person(simplestruct.Struct):
    name = str

p = Person(name="Jesse")

# Assigning a value of a different type to an attribute
# will raise a `TypeError` exception.
p.name = 1  # Raises a `TypeError` Exception

# And durning instantiation.
Person(name=1)  # Raises a `TypeError` Exception
```

Type Support
------------

Simplestruct supports all python standard types and user-defined
types.

```python
from datetime import datetime

class Person(simplestruct.Struct):
    name = str            # This would require `str`.
    age = int             # This would require `int`.
    birthday = datetime   # This would require `datetime`.
```

Composable
----------

You can compound structs after structs.

```python
class Address(simplestruct.Struct):
    country = str

class Telephone(simplestruct.Struct):
    number = str

class Person(simplestruct.Struct):
    address = Address
    telephone = Telephone

Person(
    address=Address(country="PH"),
    telephone=Telephone(number="+6302111111")
)
```

Typed List
----------

You can define typed lists where the value of items in a list
must be of the defined type.

```python
class Address(simplestruct.Struct):
    ...

class Person(simplestruct.Struct):
    addresses = [Address]

Person(addresses=[Address(), Address(), Address()])

# This however would raise a `TypeError` exception.
Person(addresses=[Address(), "wat"])
```

Typed Tuple
-----------

You can define tuples as attributes and each of the tuples item's
attribute.

```python
class Person(simplestruct.Struct):
    age_and_gender = (int, str)

Person(age_and_gender=(10, "M"))
```

repository: jpanganiban/simplestruct

repo_name: jpanganiban/simplestruct


text:
ifaxity/wait-on-action
======================

A GitHub Actions wrapper for the [wait-on](https://npmjs.com/package/wait-on)

Inputs
------

### `resource`

**Required**  Resources types are defined by their prefix, if no prefix is
present, the resource is assumed to be of type 'file'

resource prefixes are:

* `file`      - regular file (also default type). ex: file:/path/to/file

* `http`      - HTTP HEAD returns 2XX * response. ex: http://m.com:90/foo

* `https`     - HTTPS HEAD returns 2XX response. ex: https://my/bar

* `http-get`  - HTTP GET returns 2XX response. ex: http://m.com:90/foo

* `https-get` - HTTPS GET returns 2XX response. ex: https://my/bar

* `tcp`       - TCP port is listening. ex: <IP_ADDRESS>:9000 or foo.com:700

* `socket`    - Domain Socket is listening. ex: socket:/path/to/sock
                   For http over socket, use http://unix:SOCK_PATH:URL_PATH
                   like http://unix:/path/to/sock:/foo/bar or
                        http-get://unix:/path/to/sock:/foo/bar
### `config`

js or json config file, useful for http(s) options

### `delay`

Initial delay before checking for resources in ms, default 0

### `httpTimeout`

Maximum time in ms to wait for an HTTP HEAD/GET request, default 0
    which results in using the OS default

### `interval`

Interval to poll resources in ms, default 250ms

### `log`

Log resources begin waited on and when complete or errored

### `reverse`

Reverse operation, wait for resources to NOT be available

### `simultaneous`

Simultaneous / Concurrent connections to a resource, default Infinity
Setting this to 1 would delay new requests until previous one has completed.
Used to limit the number of connections attempted to a resource at a time

### `timeout`

Maximum time in ms to wait before exiting with failure (1) code, default Infinity

### `tcpTimeout`

Maximum time in ms for tcp connect, default 300ms

### `verbose`

Enable debug output to stdout

### `window`

Stability window, the time in ms defining the window of time that
resource needs to have not changed (file size or availability) before
signalling success, default 750ms. If less than interval, it will be
reset to the value of interval. This is only used for files, other
resources are considered available on first detection.

Example usage
-------------
```yaml
uses: ifaxity/wait-on-action
with:
  resource: http://localhost:8080
```

repository: einnjo/wait-on-action

repo_name: einnjo/wait-on-action


text:
# Bookshelf

## Description

Our goal is to provide a platform where users are able to enhance
their reading habits while getting cheaper options to get books.

Users will be able to keep track of their progress on the user page
and will be able to get book options when they search for any books,
authors, ISBNs, or authors.

There will also be suggestions of books from the New York Times
Bestsellers Lists as well as suggestions based on other users'
reading habits.

## Developer Info

Name: Lily Sam              | Email address<EMAIL_ADDRESS>
Name: Dayana Alejandro         | Email address<EMAIL_ADDRESS>
Name: Anthony Meza             | Email address<EMAIL_ADDRESS>
Name: Chris Berniel Cobashatse | Email address<EMAIL_ADDRESS>
Name: Axel Irikungoma          | Email address<EMAIL_ADDRESS>
## License
[Click here for the license](license)

repository: oforiwaasam/bookshelf

gha_language: HTML

repo_name: oforiwaasam/bookshelf


text:
---
# Documentation: https://sourcethemes.com/academic/docs/managing-content/

title: "Normalization_in_DL"
subtitle: ""
summary: "Some brief summary to understand normalizaion in DL"
authors: [admin]
tags: [Academic, Normalization--Neual Network Optimization]
categories: [Computer Vision, DL]
date: 2019-12-23T11:26:06Z
lastmod: 2019-12-23T11:26:06Z
featured: false
draft: false

# Featured image
# To use, add an image named `featured.jpg/png` to your page's folder.
# Focal points: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight.
image:
  caption: ""
  focal_point: ""
  preview_only: false

# Projects (optional).
#   Associate this post with one or more of your projects.
#   Simply enter your project's folder or file name without extension.
#   E.g. `projects = ["internal-project"]` references `content/project/deep-learning/index.md`.
#   Otherwise, set `projects = []`.
projects: []
---

## Batch Normalization (BN)

### Short Description

[Batch Normalization](https://arxiv.org/pdf/1502.03167.pdf) is a basic method to initialize inputs to neural networks. In the early years, the neural network is sensitive to the hyperparameters, which makes it difficult to train and stabilize. To address this problem, Loffe et al. proposed a novel normalization method to accelerate the neural network trianing process.

### Training Problems

**1. Slow learning speed.**
The $W$ weights and $b$ bias (parameters) in each layer are updated along with each SGD iterative optimization (back propagation), which makes the distribution of inputs to the next layer changes all the time. Thus the learning speed becomes slow as each layer has to adapt to input changes.

**2. Slow convergence speed.**
For saturating nonlinearities like Sigmoid and Tanh, more and more inputs to activation functions may lay in the saturation regions along with the $W$ and $b$ increase. This further causes the gradient becomes close to 0 and weights update in a slow rate.

These problems are described as **Internal Covariate Shift** in Loffe et al. 2015.
### Solutions to Internal Covariate Shift

**1. Whitening (machine learning).**
Whitening aims to linearly transform the inputs to zero mean and unit variances, which decorrelates the inputs. There are normally two whitening methods: PCA and ZCA, where PCA whitening transforms inputs to zero mean and unit variance, and ZCA whitening transforms inputs to zero mean and same variance as original inputs.

**2. Batch Normalization.**
Motivation: 1. whitening costs too much computation if it is put before each layer; 2. the distribution of transformed inputs does not have expressive power as original inputs.

Solutions:
1. simplify the linearly transformation by following equations:
$$ \mu_j = \frac{1}{m}\Sigma_{i=1}^{m}{x_j^i}$$
$$\sigma^2_j = \frac{1}{m}\Sigma_{i=1}^{m}{(x_j^i - \mu_j)^2}$$
$$x_j^{i\'} = \frac{x_j^i - \mu_j}{\sqrt{\sigma_j^2 + \varepsilon}}$$
where $j$ denotes the $j$th layer, $\mu_j$ and $\sigma_j^2$ denote the mean and variance of inputs $x_j$. $x_j^{i\'}$ denotes the transformation output which has zero mean and unit variance, $m$ denotes the sample number in $x_i$ and $\varepsilon$ ($\varepsilon=10^{-8}$) prevents the zero in variance.

2. learn a linear transformation with parameter $\gamma$ and $\beta$ to restore original input distribution by following equation:
$$x_j^{i\"} = \gamma_j x_j^{i\'} + \beta_j$$
where the transformed output will have the same distribution of original inputs when $\gamma_j^2$ and $\beta_i$ equal to $\sigma_j^2$ and $\mu_j$.

**Normalization in testing stage.** Generally, there may be just one or a few examples to be predicted in testing stage, the mean and variance computed from such examples could be baised. To address this problem, the $\mu_{batch}$ and $\sigma^2_{batch}$ of each layer are stored to compute the mean and variance for testing stage. For example, $\mu_{test} = \frac{1}{n} \Sigma \mu_{batch}$ and $\sigma^2_{batch}=\frac{m}{m-1} \frac{1}{n} \Sigma \sigma^2_{batch}$, then $BN(x_{test})=\gamma \frac{x_{test} - \mu_{test}}{\sqrt{\sigma^2_{test} + \varepsilon}} + \beta$.

### Advantages of BN
1. Faster learning speed due to stable input distribution.
2. Saturating nonlinearities like Sigmoid and Tanh can still be used since gradients are prevented from disappearing.
3. Neural network is not sensitive to parameters, simplfy tuning process and stabilize the learning process.
4. BN partially works as regularization, increases generalization ability. The mean and variance of each mini
-batch is different from each other, which may work as some noise input for the nerual network to learn. This has same function as Dropout shutdowns some neurons to produce some noise input to the neural networks.

### Disadvantages of BN
1. NOT well for small mini-batch as the mean ans variance of small mini-batch differ great from other mini-batches which may introduce too much noise into the NN training.
2. NOT well for recurrent neural network as one hidden state may deal with a series of inputs, and each input has different mean and variance. To remember these mean and variance, it may need more BN to store them for each input.
3. NOT well for noise-sensitive applications such as generative models and deep reinforcement learning.

### Rethink the resaon behind the effectiveness of BN
**Why does the BN works so well in CNNs?** [This paper](https://arxiv.org/pdf/1805.11604.pdf) revisits the BN and proposes that the success of BN has little to do with reducing Internal Covariate Shift. Well, the ICS does exist in the deeper neural layers, but adding artifiical ICS after BN into a deep neural network, the added ICS does not affect the good performance of BN, which indicates that the performance of BN has little to do with ICS. Then what does the BN do to improve the training performance? The work mentioned above points out that BN smoothes the optimization landscape and makes the optimizer more easier to find the global minimic solution (c.f. Figure 4 in the paper). For more details, please refer to the paper.

## Weight Normalization (WN)

### Short description
[Weight normalization](https://arxiv.org/pdf/1602.07868.pdf) is designed to address the disadvantages of BN which are that BN usually introduces too much noise when the mini-batch is small and the mean and variance of each mini-batch is correlated to inputs. It eliminates the correlations by normalizing weight parameters directly instead of mini-batch inputs.

### Motivation and methodology
The core limitaion of BN is that the mean and variance is correlated to each mini-batch inputs, thus a better way to deal with that is design a normalization without the correlation. To achieve this, Salimans et al. proposed a Weight Normalization which is denoted as:
$$w = \frac{g}{||v||} v$$
where $v$ denotes the parameter vector, $||v||$ is the Euclidean norm of $v$, and $g$ is scalar. **This reparameterization has the effect of fixing the Euclidean norm of weight vector $w$, and we now have $||w||=g$ which is totally independent from parameter vector $v$**. This operation is similar to divide inputs by standard deviation in batch normalization.

The mean of neurons still depends on $v$, thus the authors proposed a **'mean-only batch normalization'** which only allows the inputs to subtract their mean but not divided by variance. Compared to variance divide, the mean subtraction seems to introduce less noise.

## Layer Normalization

### Short description
[Layer normalization]((https://arxiv.org/pdf/1607.06450.pdf)) is inspired by batch normalization but designed to small mini-batch cases and extend such technique to recurrent neural networks.

### Motivation and methodology
As mentioned in short description. To achieve the goal, [Hinton et al. 2016](https://arxiv.org/pdf/1607.06450.pdf) **alter the sum statistic of inputs from batch dimension to feature dimension (multiple channels)**. For example, in a mini-batch (containing multiple input features), the computation can be described as following picture:

{{< figure library="true" src="layer_normalization.png" title="Fig 1. Layer Normalization Visualization" lightbox="true" >}}

As can be seen, batch normalization computes the sum statistic of inputs across the batch dimension while layer normalization does across the feature dimension. The computation is almost the same in both normalization cases, but the mean and variance of layer normalization is independent of other examples in the same mini-batch. Experiments show that **layer normalization works well in RNNs**.

## Instance Normalization (IN)

### Short description
[Instance normalization](https://arxiv.org/pdf/1607.08022.pdf) is like layer normalization mentioned above but it goes one step further that **it computes mean and variance of each channel in each input feature**. In this way, the statistic like mean and variance is independent to each channel. The IN is originally designed for neural style transfer which discovers that stylization network should be agnostic to the contrast of the style image. Thus it is usually specific to image.

## Group Normalization (GN)

### Short description
[Group normalization](https://arxiv.org/pdf/1803.08494.pdf) computes the mean and variance across a group of channels in each training example, which makes it sound like a combination of layer normalization and instance normalization. For example, group normalization becomes layer normalization when all the channels are put into one single group, and becomes instance normalization when each channel is put into one single group.
The picture below shows the visual comparisons of batch normalization, layer normalization, instance normalization and group normalization.

{{< figure library="true" src="normalization_visualization.png" title="Fig 2. Normalization Visualization" lightbox="true" >}}

### Motivation
Training small batch size with BN introduces noise into network which decreases the accuary. However, for larger models like object detection, segmentation and video, they have to require small batches considering the memory consumption. In addition, dependence bewteen channels widely exists but it is not extremely like all channels have dependences (layer normalization) or totally no dependence between channels (instance normalization). Based on this oberservation, [He et al. 2018](https://arxiv.org/pdf/1803.08494.pdf) proposed a group-wise normalization which divides the channels into groups and makes it flexiable for different applications.

## Batch-Instance Normalization (BIN)

### Short description
[Batch-instance normalization](https://arxiv.org/pdf/1805.07925.pdf) is actually a interpolation of BN and IN, and lets the gradient descent to learn a parameter to interploates the weight of BN and IN. The equation below shows the defination of BIN:

$$BIN(x) = \gamma (\rho BN(x) + (1-\rho) IN(x)) + \beta$$
To some extend, this BIN inspires readers that models can learn to adaptively use different normalization methods using gradient descent. Would the network be capable of learning to use even wider range of normalization methods in one single model?

### Motivation
Rethinking the instance normalization, [Nam et al. 2019](https://arxiv.org/pdf/1805.07925.pdf) regard instance normalization as an effective method to earse unnecessary style information from image and perserve useful styles for tasks like object classification, multi-domain learning and domain adaptation.

## Switchable Normalization (SN)

[Luo et al. 2018](https://arxiv.org/pdf/1811.07727v1.pdf) investigated into whether different layers in a CNN needs different normalization methods. Thus they proposed a Switchable Normalization which learns parameters to switch normalizers between BN, LN and IN. As for results, their experiments suggest that (1) using distinct normalizations in different layer indeed improves both learning and generation of a CNN;(2) the normalization choices are more related to depth and batch size but less relevant to parameter initialization, learning rate decay and solver;(3) different tasks and datasets influence tha normalization choices. Additionally, the experiments in general also suggest that IN works well in early layers, LN works better in later layers while BN is preferred in middle layers.

## Spectral Normalization
[Spectral normalization](https://arxiv.org/pdf/1802.05957.pdf) (another form of weight normalization) is designed to improve the training of GANs by tuning the Lipschitz constant of the discriminator. The Lipschitz constant is a constant $L$ used in the following equation:
$$||f(x) - f(y)|| \leqslant L ||x-y||$$

The Lipschitz constant is tuned by normalizing the weight matrices where is by their largest eigenvalue. And experiments show that spectral normalization stabilize the training by minimal tuning.

## Conclusion
BN is a millstone research on training deep neural network which makes it much easier and more robust. However, the limitations like small batch size, noise-sensitie applications and distributed training still need to be fixed in further researches. And different applications/tasks may prefer different normalizations respect to accurancy. New dimensions of normalization still need to be discovered.

### Reference:
1. BN, https://arxiv.org/pdf/1502.03167.pdf
2. WN, https://arxiv.org/pdf/1602.07868.pdf
3. LN, https://arxiv.org/pdf/1607.06450.pdf
4. IN, https://arxiv.org/pdf/1607.08022.pdf
5. GN, https://arxiv.org/pdf/1803.08494.pdf
6. BIN, https://arxiv.org/pdf/1805.07925.pdf
7. SN, https://arxiv.org/pdf/1811.07727v1.pdf
8. https://arxiv.org/pdf/1805.11604.pdf
9. Spectral Normalization, https://arxiv.org/pdf/1802.05957.pdf
10. https://zhuanlan.zhihu.com/p/34879333
11. https://mlexplained.com/2018/11/30/an-overview-of-normalization-methods-in-deep-learning/

repository: Alibabade/academic-kickstart

repo_name: Alibabade/academic-kickstart


text:
### Cellular-Network-Info
This plugin is a mix of the two [cordova-plugin-networkinterface](https://github.com/salbahra/cordova-plugin-networkinterface) and the [cordova-plugin-sim](https://github.com/pbakondy/cordova-plugin-sim) plugins.
The usage is similar to that of [cordova-plugin-sim](https://github.com/pbakondy/cordova-plugin-sim), except the exposed object is `CellularInfo` instead of `sim`, and `getCellularInfo` is used instead of `getSimInfo`.

Additionally, the `getIPAddress` method from [cordova-plugin-networkinterface](https://github.com/salbahra/cordova-plugin-networkinterface) is exposed here as another method of the `CellularInfo` object. Its usage is the exact same thing.

    document.addEventListener("deviceready", onDeviceReady, false);

    function onDeviceReady() {
      window.plugins.CellularInfo.getCellularInfo(successCallback, errorCallback); // from cordova-plugin-sim
      window.plugins.CellularInfo.getIPAddress(function (ip) { // from cordova-plugin-networkinterface
          addInfo('ip Address', ip);
      });
    }

    function successCallback(result) {
      console.log(result);
    }

    function errorCallback(error) {
      console.log(error);
    }

### Difference with cordova-plugin-networkinterface

The `getIPAddress()` method from this plugin has a small difference with the one from [cordova-plugin-networkinterface](https://github.com/salbahra/cordova-plugin-networkinterface):

On ios devices only, I've expanded this plugin to return the ip address of the cellular network if the device is using a cellular network. Whereas on cordova-plugin-networkinterface, this method only returns the wifi ip address. If the phone is connected to a wifi network, this plugin will work just like cordova-plugin-networkinterface and will return the wifi ip address. On non-ios devices, this plugin will be no different than cordova-plugin-networkinterface.

So the returned string from the method will be: "connected via wifi : x.x.x.x" or "connected via cell : x.x.x.x" depending on the phone's network connection status.


text:
# TestSel_MOPSO
Code for "A Multi-Objective Test Selection Tool using Test Suite Diagnosability"

## Dependencies + Assumptions
### General
- Python 3.7.2
- Minified OpenCover (fork)
  - Code Comparison: https://github.com/OpenCover/opencover/compare/4.6.519...danielcorreia96:oc_2016_merged
  - Appveyor Artifact: https://ci.appveyor.com/project/danielcorreia96/opencover/builds/23686399
- Target source code is stored in SVN repository

### Python Libraries
- numpy: data manipulation and metrics calculations (https://github.com/numpy/numpy)
- jMetalPy: BMOPSO implementation (https://github.com/jMetal/jMetalPy)
- pyodbc: database integration (https://github.com/mkleehammer/pyodbc)
- PySvn: svn integration (https://github.com/dsoprea/PySvn)
- joblib: database results caching (https://github.com/joblib/joblib)
- faker: results anonymization for demonstration (https://github.com/joke2k/faker)

## Tool Usage Overview (3 main components)
### 1. Coverage Data Profiling (Offline/Ad-Hoc)
- Execute tests using OpenCover instrumentation and collect coverage data to build the required activity matrix.
- CLI: cov_profiler.py
- Input Dependencies:
   - Target source code and test suite is available in the system
   - A directory with lists of tests to be ran with coverage profiling
   - Configuration file: paths to minified OpenCover executable, NUnit test runner, input/output directories; OpenCover filters and cover_by_test to be used (following the docs at https://github.com/OpenCover/opencover/wiki/Usage); threshold value for methods visit counter.
   - A sample configuration file (with instructions) is provided at data/opencover/oc_config.json.sample
- Output: a set of xml reports at the chosen output directory
- Example Command: `python cov_profiler.py run data/opencover/oc_config.json`

### 2. Build Activity Matrix (Offline/Ad-Hoc)
- Process the obtained xml coverage reports into an activity matrix and some additional information to be used by the test selection pipeline
- CLI: parse_xml.py
- Input Dependencies:
  - Directory with xml coverage reports obtained in the previous component
  - Name/Id for the output json files
  - Name of the folder where the svn repository is stored in the local filesystem
- Output: 3 json files: an activity matrix, a map of row indices <-> test names and a map of column indices <-> method names
- Example Command: `python parse_xml data\reports\demo1\ demo1 trunk_demo1`

### 3. Test Selection Pipeline (Online)
- Run test selection pipeline for a given commit/revision id
- CLI: testsel_pipeline.py
- Input Dependencies:
  - JSON files from previous component -> only the path to activity matrix is passed as an argument, the other 2 are inferred
  - Database configuration file and SQL queries for metrics (samples provided in data/database)
  - Configuration file to setup branch path, dates range and ignored tests/changes details
  - CLI -o option: provide order of objectives to be used
  - Available metrics:
    - ddu: DDU
    - coverage: method coverage (raw sum)
    - norm_coverage: method coverage (normalized to 0/1)
    - n_tests: total number of tests selected
    - fails: total number of test failures from build history
    - exec_times: total "expected" execution time for the selected tests using build history info
  - CLI --masked option: anonymize output results by replacing the file/test names with fake ones
- Output:
  - Interactive Mode: for the revision id, returns a list of selected tests
  - Batch Mode: for each revision id in the dates range, tries to run the tool (printing tests results at the end or logging error cases) and terminates with a summary of the batch run with some statistics
- Example command (interactive): `python testsel_pipeline.py single -o ddu -o fails data\jsons\actmatrix_demo1.json data\demo1.config`
- Example command (batch mode): `python testsel_pipeline.py demo -o ddu -o fails data\jsons\actmatrix_demo1.json data\demo1.config`


text:
### [Removing Stars From a String](https://leetcode.com/problems/removing-stars-from-a-string)

You are given a string s, which contains stars *.

In one operation, you can:

Choose a star in s.

Remove the closest non-star character to its left, as well as remove the star itself.

Return the string after all stars have been removed.

Note:

The input will be generated such that the operation is always possible.

It can be shown that the resulting string will always be unique.

Example 1:

Input: s = "leet**cod*e"
Output: "lecoe"
Explanation: Performing the removals from left to right:
- The closest character to the 1st star is 't' in "leet**cod*e". s becomes "lee*cod*e".
- The closest character to the 2nd star is 'e' in "lee*cod*e". s becomes "lecod*e".
- The closest character to the 3rd star is 'd' in "lecod*e". s becomes "lecoe".
There are no more stars, so we return "lecoe".

Example 2:

Input: s = "erase*****"
Output: ""
Explanation: The entire string is removed, so we return an empty string.

Constraints:

1 <= s.length <= 105

s consists of lowercase English letters and stars *.

The operation above can be performed on s.

url: https://raw.githubusercontent.com/6leetcode/6leetcode/0c0973c634c881bd874bad5a0526b91a2d83f1a0/questions/Algorithms/2390. Removing Stars From a String/README.md

gha_language: C


text:
# Connect-Four
Two player Connect Four coded in MATLAB. I created this initially in 2016 to practice and experiment with GUI elements.

Click anywhere in the column you want to place your piece. Features a scoreboard, Undo button that can undo the entire game, colored turn indicator, and an option to decide who starts each game.

The function has two optional input arguments. The first 'scale' is the height of the initial window, in pixels, though you can drag to resize the window at any time. The second is the figure number the game will use if you want to specify for some reason.

![](https://i.imgur.com/4ZgoVJz.png)


text:
Pattern: Consecutive literal appends

Issue: -

## Description

Violations occur when method calls to `append(Object)` are chained together with literals as parameters. The chained calls can be joined into one invocation.

Example of violations:

``` groovy
writer.append('foo').append('bar')      // strings can be joined
writer.append('foo').append(5)          // string and number can be joined
writer.append('Hello').append("$World") // GString can be joined
```

Example of passing code:

``` groovy
// usage not chained invocation
writer.append('Hello')
writer.append('World')

writer.append(null).append(5)           // nulls cannot be joined

writer.append().append('Hello')             // no arg append is unknown
writer.append('a', 'b').append('Hello')     // two arg append is unknown
```

## Further Reading

* [CodeNarc - ConsecutiveLiteralAppends](https://codenarc.github.io/CodeNarc/codenarc-rules-unnecessary.html#consecutiveliteralappends-rule)

repository: Adroiti/docs-for-code-review-tools

repo_name: Adroiti/docs-for-code-review-tools


text:
# A Python raycasting engine made in openGL
This ia a simple python raycasting engine made in python.
To run it, you must have Python3 and PyOpenGL.

Python can be installed from the [website](python.org)

To install PyOpenGL, you can go to the [documentaion](http://pyopengl.sourceforge.net/documentation/index.html)

Once both are ready and configured, download or clone `ray.py` and use `python ray.py` to run it.

## Running the code
Once the program starts, you'll  see 2 views : A 2D map with the player and all the rays, and a 3d, raycasted projection. Use WASD to move, and Q to teleport.

## Playing with the code

The algorithm, though it may appear complex, is actually really simple and fast, and hence was used on many classic games like Wolfenstien 3D, to great effect on the limited hardware of the time. If you want to learn more about the algorithm, [this guide is a excellant starting point](https://permadi.com/1996/05/ray-casting-tutorial-1/#INTRODUCTION).

In order to change the map, simploy edit the 64 element long `world` list. it is formatted so thet a `0` is a space and a `1` is a block.

## Screenshots
[img](https://github.com/ARYANTECH123/pythonRaycaster/blob/main/image.png)


text:
# FINN

Fast, Scalable Quantized Neural Network Inference on FPGAs

[![Gitter](https://badges.gitter.im/xilinx-finn/community.svg)](https://gitter.im/xilinx-finn/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)

## Description

FINN is an experimental framework from Xilinx Research Labs to explore deep neural network inference on FPGAs. It specifically targets quantized neural networks, with emphasis on generating dataflow-style architectures customized for each network.
For more information, please visit the [project page](https://xilinx.github.io/finn/).

A new, more modular version of FINN is currently under development on GitHub, and we welcome contributions from the community!
Stay tuned for more updates.

## Old version

We previously released an early-stage prototype of a toolflow that took in Caffe-HWGQ binarized network descriptions and produced dataflow architectures. You can find it in the [v0.1](https://github.com/Xilinx/finn/tree/v0.1) branch in this repository.
Please be aware that this version is deprecated and unsupported, and the master branch does not share history with that branch so it should be treated as a separate repository for all purposes.

repository: robertdigital/finn

repo_name: robertdigital/finn


text:
# LWC Service Modules

Rewrite of [Service Components Framework (Aura)](https://github.com/tsalb/sfdc-lightning-service-components) but with Lightning Web Components (LWC). This repository includes all my previous Service Components for easy side-by-side comparison.

![side-by-side](/readme-images/side-by-side.png?raw=true)

## Install with SFDX

SFDX CLI and VSCode has matured enough for general usage so I will be moving my repo to SFDX format only.

For VSCode and SFDX setup see steps (1 and 2) from the [official lwc-recipes repo](https://github.com/trailheadapps/lwc-recipes#installing-recipes-using-salesforce-dx). Once you have the SFDX CLI set up and Authed into a Dev Hub you can then:

1) Open VSCode, then open terminal with `` ctrl+` `` then clone lwc-utils.

```
git clone https://github.com/tsalb/lwc-utils
```

2) Use [Command Palette](https://code.visualstudio.com/docs/getstarted/userinterface#_command-palette) to `SFDX: Create a Default Scratch Org` .

3) Use Command Palette to `SFDX: Push Source to Default Scratch Org`.

4) Use Command Pellete to `SFDX: Open Default Org`.

## Install with unlocked package

Coming later (maybe)...

## Service Components Framework (Aura)

See [Readme](https://github.com/tsalb/sfdc-lightning-service-components#dataservice-usage-example) for any Aura component usage.

## Datatable Service (LWC @wire and imperative)

Two samples:

1) An `@wire` child template component fed by a reactive attribute that emits events on success/error.
2) An imperative callout using `async await` that uses promises in the returning tableResults.

Parent relationships (1 level up) are working okay. It's safer to use formulas still, for now.

![side-by-side](/readme-images/datatable.gif?raw=true)


text:
# LatentDirichletAlloc
A python implementation to apply Latent Dirichlet allocation model on paper abstract and citation data.
This was implemented for COS 561 project in Princeton University.
The code base was used to learn a LDA model on abstract data from the INFOCOM conference and analyse it.

## Requirements
numpy
matplotlib
pyplot
gensim
bibtexreader

## Instructions

They need to be stored in a folder named abstracts which contains a directory for each year of the conference.
Within a year directory a txt file containing the abstract and title data is kept in the form of Bibtex citations.

To train the model run the following command:
```
python src/lda.py
 ```
it will train a topic model with 30 topics and store model params in model_all_500_30 and store the list of top words
related to a topic in result_all_500_30. Now we can run various tests on it. If we want to generate the topic distributions
for the dataset run the command:
```
python src/lda_test.py
 ```
it will store the data as a numpy array in the director doc_results_all_500_30. At this point we can use the model to input
abstracts from arbitrary papers (even from other sources) and try to find similar papers. For that run the command:
```
python src/find_similar_docs.py FILE_NAME
 ```
 FILE_NAME should be a text file containing the abstract and title data. This command will print out the topic distribution
 for the data in file and the title of the 3 closest papers on which the model was trained.

To make a stacked bargraph to show trends over the years run the command,
```
python src/stacked_barchart.py
 ```
which will output the image in a file named "topic_weights_by_year.svg". To make the trend line graphs and the frequency histogram run.
```
python src/plot_graphs.py
 ```


text:
Several quality-of-life fixes applied to the last official LME LaTeX Beamer Template done by T. Geimer

**Macros**

*Partner Logo*

Space for an additional partner logo in the header positioned next to the LME Logo:

```
\setPartnerLogo{"PartnerLogoPath"}
```

*Conference / Group Seal*

Additional Seal (e.g. for conference logo) on the title page at a mirrored position to the FAU Seal.

```
\setLeftSeal{"SealPath"}
```

repository: akmaier/pr-slides

repo_name: akmaier/pr-slides


text:
# Intro to SQL Homework #

----------
1. SQL = Structured Query Language. DML = Data Manipulation Language -> SELECT, INSERT, UPDATE, DELETE. DDM = Data Definition Language -> CREATE, DROP, ALTER, GRANT, INVOKE
2. T-SQL(Transact SQL) is an extension to the standard SQL language. T-SQL is the standard language used in MS SQL Server. Supports if statements, loops, exceptions. T-SQL is used for writing stored procedures, functions, triggers, etc.

repository: vassildinev/Databases

repo_name: vassildinev/Databases


text:
# Speed Tracks

We've organized our focus into tracks to address the following concerns:

 * Utilize domain expertise to manage incoming bugs and regression reports
 * Have a clear escalation paths
 * Organize optimization efforts as needed
 * Identify opportunities for improvement and to manage projects

## Tracks Organization

### Memory

This track deals with memory use by Chrome on all platforms. Primary focus is:

 * Gracefully deal with situations where user is out of memory (OOM)
 * Manage memory for idle and backgrounded tabs

#### Links

 * [Mailing List](https://groups.google.com/a/chromium.org/forum/#!forum/memory-dev)
 * Performance-Memory [Bug
   Queue](https://bugs.chromium.org/p/chromium/issues/list?can=2&q=Performance%3DMemory)
 * [Docs](https://chromium.googlesource.com/chromium/src/+/master/docs/memory)

### Power

The Power track is concerned with improving power usage for our users.
Collectively, our product has an impact on global greenhouse gas imitions and we
want to do our best to make that efficient. If we can give users a good
experience of not burning laps/hands or making fan noises, we feel like we did a
good job.

#### Links

 * Power
   [Rotation](https://rotation.googleplex.com/#rotation?id=5428142711767040)
 * Rotation
   [Documentation](https://docs.google.com/document/d/1YgsRvJOi7eJWCTh2p7dy2Wf4EJtjk_3XU30yp_7mhaM/preview)
 * Power
   [Backlog](https://docs.google.com/spreadsheets/d/1VhU1aM6APdUN74NVPW98X3aqpQyJkxg1UJcvBidXaK8/edit)
 * Performance-Power [Bug
   Queue](https://bugs.chromium.org/p/chromium/issues/list?can=2&q=Performance%3DPower)

### Loading

The Loading track focuses on the time between click to the time when you can
interact with a website.

#### Links

 * [Mailing
   List](https://groups.google.com/a/chromium.org/forum/#!forum/loading-dev)
 * Performance-Loading [Bug
   Queue](https://bugs.chromium.org/p/chromium/issues/list?can=2&q=Performance%3DLoading)

### Responsiveness

Responsiveness track focuses on making sure all websites have smooth transitions
by serving 60fps, and that the click to action time is not noticible.

#### Links

 * Performance-Responsiveness [Bug
   Queue](https://bugs.chromium.org/p/chromium/issues/list?can=2&q=Performance%3DResponsiveness)

### Binary Size

Chrome has an update for you at least every six weeks. Since we do that for all
of our users, we want to be nice to our users where downloading updates costs
real money. We also don't want to hog all of the disk space on low end phones.
So we focus attention on making sure we don't include bits in our update that
are not necessary for users.

#### Links

 * [Mailing List](://groups.google.com/a/chromium.org/forum/#!forum/binary-size)
 * Performance-Size [Bug
   Queue](https://bugs.chromium.org/p/chromium/issues/list?can=2&q=Performance%3DSize)
 * Description of [metrics](binary_size/metrics.md)

### Data Usage

Data Usage is a focus on the question: Do the user see or need every byte
downloaded? By looking at this, we can save user's cost of data, time to load,
memory and power.

#### Links

 * Performance-Data [Bug
   Queue](https://bugs.chromium.org/p/chromium/issues/list?can=2&q=Performance%3DData)

### Startup, Omnibox, Browser UI, etc.

There are a handful of performance angles that don't fit into the tracks already
mentioned. Historically, we've put these into a "Browser" bucket as that's
descriptive of what's left over. These are things like making sure the Omnibox
experience on Chrome is fast, making sure all of the Chrome UI, e.g. Settings,
is fast and that the browser startup and session restore doesn't allow users to
make coffee before they use the browser.

#### Links

 * Performance-Browser [Bug
   Queue](https://bugs.chromium.org/p/chromium/issues/list?can=2&q=Performance%3DBrowser)

repository: Samsung/Castanets

repo_name: Samsung/Castanets


text:
# Mutable and Immutable Objects

* Immutable object - no state change after creation.
* Any instance can become immutable by calling `freeze` method.

## Freezing Objects

* `Object.freeze` method - makes the object state a constant.
* Changing state of freezed results in **`FrozenError`**

~~~ruby
# Ruby strings are mutable by default
message = "Hello world"
puts message.frozen?

# freezes instance point to by the variable message
message.freeze
puts message.frozen?

# raises FrozenError
puts message.downcase!

# freeze freezes the instance.
# as long as any variable points to the same instance
# trying to modify the state of the underlying object results in exception being raised.
new_message = message
puts new_message.downcase!

puts new_message.frozen?

# changing variable to point to some other object
message = "Hello"
puts message.frozen?
puts message.downcase!

# chaining assignment points to same object
a = b = 'hello'
puts a.object_id
puts b.object_id

# freezes the underlying object pointed by a
puts a.freeze

puts a.frozen?
puts b.frozen?

~~~

## Usecases

> **Copy and Freeze Pattern**
>
> Ruby sometimes copies objects and freezes the copies. When you use a string as a hash key, Ruby actually copies the string, freezes the copy, and uses the copy as the hash key: that way, if the original string changes later on, the hash key isn't affected.

~~~ruby
key = "foo"
value = "bar"
hash = { key: value }

puts key.object_id
puts key.frozen?

hash_key = hash[key]
puts hash_key.object_id
puts hash_key.frozen?
~~~

* Class can be frozen to prevent future modifications.

---

## References

* [Mutable and Immutable Objects](http://rubylearning.com/satishtalim/mutable_and_immutable_objects.html)

gha_language: Ruby


text:
### Minimal example

Add here an online minimal example and share the link here, if the case.

### Expected behaviour

I thought that by going to the page '...' and do the action '...' then '...' would happen.

### Actual behaviour

Instead of '...', what I saw was that '...' happened instead.

### How to simulate the behaviour (if applicable)

This is the example of the current behaviour https://stackblitz.com/edit/hex-to-css-filter-playground

### Browsers/OS/Platforms affected

Please specify the affected browsers/OS/platforms.

repository: willmendesneto/hex-to-css-filter

repo_name: willmendesneto/hex-to-css-filter


text:
# react-native-branch 4.0

## Updating from 3.x

### React Native 0.60 required

The peer dependency on the react-native package for version 4.x is ^0.60.0.
It is not possible to build using older versions of react-native. Your app
must be updated to use react-native 0.60 or later.

### AndroidX required

Android support requires converting your app to AndroidX.

### CocoaPods required

CocoaPods is the mainstream integration path for iOS as of react-native 0.60.
Version 4.0.0 of this SDK may not work with any other option. This may be
revisited in the future, but it's not yet clear how feasible it would be to
support any other option. At any rate, if an RN 0.60 app is set up to use
CocoaPods with `use_native_modules!`, the CocoaPods integration of
react-native-branch will be automatic. It might be necessary to disable
CocoaPods throughout a RN app in order to support any other solution for this
SDK.

### Autolinking

The `react-native link` command is no longer required. Once you have updated
your app to RN 0.60, run `react-native unlink` once for every native dependency,
including this one:

```bash
react-native unlink react-native-branch
```

This will remove entries for this SDK from your Podfile, settings.gradle and
app/build.gradle. It will also remove some code from your MainApplication.java
if you are still using `RNBranchPackage`. The entire `getPackages()` method in
your MainApplication.java with RN 0.60 should look like this:

```Java
@Override
protected List<ReactPackage> getPackages() {
  return new PackageList(this).getPackages();
}
```

No mention of RNBranch is necessary in that method. **Note:** The call to
`RNBranchModule.getAutoInstance(this);` is still required in `onCreate()` as
well as the integration steps in MainActivity.java.

After running `react-native unlink react-native-branch` (and any other native
modules), it is necessary also to run:

```bash
cd ios
pod install
```

It may be necessary to run `pod update` instead of `pod install` if the version
number of anything under `node_modules` has increased.

### Update iOS imports

If you are using Objective-C, you can use:

```Obj-C
#import <RNBranch/RNBranch.h>
```

This form is independent of other build options. Clang will automatically
convert it to `@import RNBranch;` whenever possible. As of version 0.60.3,
react-native does not support `use_frameworks!` in a Podfile. See
https://github.com/facebook/react-native/issues/25349. Once that is
supported, the same `#import <RNBranch/RNBranch.h>` will still work. However,
with `use_frameworks!` you will also have the option to explicitly use
`@import RNBranch;`.

Swift apps usually require `use_frameworks!`. It is possible to use this SDK
with Swift and RN 0.60.3 by adding `#import <RNBranch/RNBranch.h>` to a
bridging header. A Swift import statement will not work without
`use_frameworks!`. Once that is supported, you can use `import RNBranch` in
your Swift source code.

See [webview_example_native_ios](../examples/webview_example_native_ios) for
an example of a Swfit app using a Swift pod with `use_frameworks!` while
disabling that option for all native modules. It uses a bridging header to
import React and RNBranch.

The previous include path, `react-native-branch` caused problems with Clang,
CocoaPods and React Native because of the hyphens.

### branch.json

The postlink hook that added `branch.json` to a project automatically when
running `react-native link` has been removed. It is currently necessary to
integrate `branch.json` manually as described
[here](branch.json.md#manual-integration-without-react-native-link). Note
that if you run `react-native unlink react-native-branch` after updating to
version 4.0.0, there is no postunlink hook, and branch.json will not be removed
from your project if found. Manual integration is only
necessary for new projects.

## New installations

In an app using RN 0.60, simply run:

```bash
yarn add react-native-branch
cd ios
pod install
```

Add branch.json to your project manually as described above if you wish.
Note you should not run `react-native link` for this SDK.

Then follow the common Branch [setup instructions](../README.md#setup).

Finally:

```bash
react-native run-ios
```

or

```bash
react-native run-android
```

Or use Xcode/AndroidStudio to open, build and run your app.


text:
# ekx

## Key Features

- *Edit Mode*
    - Resources *hot reloading*
    - Resources *loading on the fly*
    - Resources *deferred export*
    - Sprites resolution hot reloading on Window Resize
    - Export Platforms (iOS, Android, Web)

- Export for Production
    - Build statically against the whole Codebase
    - Run/Debug in XCode and Android Studio
    - Debug runtime-code
    - Stripped libraries code

- Capabilities
    - ECS framework
    - Multi-resolution export: @x1, @x2, @x3, @x4
    - Export from Animate CC (`.fla` / `.xfl` files)
    - Import TTF fonts with Effects
    - GLSL shaders
    - Marketing assets export from Flash template
    - Simple Binary serialization

## Prerequisites for tooling

- `python3` and `pip`
- NodeJS, NPM
- CMake >= 3.13
- XCode for iOS
- Android Studio for Android

## Dependencies

#### System packages

```
brew install pkg-config
brew install cairo
```

- pkg-config
- Cairo
- Freetype2

# Development

It's very hard to fix platform-side code inside generated projects (XCode, Android Studio), so
we able to switch platform inside your cmake-compatible IDE (like CLion).

1. Create Debug-Emscripten
2. Set the path to CMake Emscripten Toolchain

```shell script
# Emscripten
-DCMAKE_TOOLCHAIN_FILE=/Users/PATH_TO_emsdk/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake

# iOS
-DCMAKE_TOOLCHAIN_FILE=$EKX_ROOT/external/cmake/ios.toolchain.cmake

# Android
-DCMAKE_TOOLCHAIN_FILE=/Users/ilyak/Library/Android/sdk/ndk/20.0.5594570/build/cmake/android.toolchain.cmake -DANDROID_ABI=x86_64

# Windows from MacOS
brew install mingw-w64
-DCMAKE_TOOLCHAIN_FILE=$EKX_ROOT/external/cmake/x86_64-w64-mingw32.cmake
```

3. Set Env from:
    For example you have output of running `emsdk_env.sh`:
```sh
PATH += /Users/ilyak/dev/emsdk
PATH += /Users/ilyak/dev/emsdk/upstream/emscripten
PATH += /Users/ilyak/dev/emsdk/node/12.9.1_64bit/bin

EMSDK = /Users/ilyak/dev/emsdk
EM_CONFIG = /Users/ilyak/.emscripten
EMSDK_NODE = /Users/ilyak/dev/emsdk/node/12.9.1_64bit/bin/node
```
So add the PATH and EM variables:

```
PATH = /Users/ilyak/dev/emsdk;/Users/ilyak/dev/emsdk/upstream/emscripten;/Users/ilyak/dev/emsdk/node/12.9.1_64bit/bin;$PATH
EMSDK = /Users/ilyak/dev/emsdk
EM_CONFIG = /Users/ilyak/.emscripten
EMSDK_NODE = /Users/ilyak/dev/emsdk/node/12.9.1_64bit/bin/node
```

license: ISC


text:
# Release v1.3.1 (2021-04-08)

### Smithy Go module
* `transport/http`: Loosen endpoint hostname validation to allow specifying port numbers. ([#279](https://github.com/aws/smithy-go/pull/279))
* `io`: Fix RingBuffer panics due to out of bounds index. ([#282](https://github.com/aws/smithy-go/pull/282))

# Release v1.3.0 (2021-04-01)

### Smithy Go module
* `transport/http`: Add utility to safely join string to url path, and url raw query.

### Codegen
* Update HttpBindingProtocolGenerator to use http/transport JoinPath and JoinQuery utility.

# Release v1.2.0 (2021-03-12)

### Smithy Go module
* Fix support for parsing shortened year format in HTTP Date header.
* Fix GitHub APIDiff action workflow to get gorelease tool correctly.
* Fix codegen artifact unit test for Go 1.16

### Codegen
* Fix generating paginator nil parameter handling before usage.
* Fix Serialize unboxed members decorated as required.
* Add ability to define resolvers at both client construction and operation invocation.
* Support for extending paginators with custom runtime trait

gha_language: Go


text:
---
title: Week 1
layout: post
author: ben.rooke
permalink: /week-1/
source-id: 1RDrbZFaRDXV-Vv7Yap1jtZEaB23F-vnyyGxKSOL8xVo
published: true
---

    Title:
    Week 1
     Date:
    7/6/17

    Starting point:
    A fair amount of knowledge on creating websites and writing blogs.

    Target for this lesson?
    I wasn't in the lesson.

    Did I reach my target?
(add details to "Lesson Review")
    N/A

    Lesson Review

    How did I learn? What strategies were effective?

    I had a cricket match so i wasn't in the lesson so I learnt by catching up and asking friends what we did and if there was homework.

    What limited my learning? Which habits do I need to work on?

    I wasn't there.

    What will I change for next time? How will I improve my learning?

    There isn't anything to change because i wasn't there.


text:
Hangfire.Autofac [![Build status](https://ci.appveyor.com/api/projects/status/oncvxlqtnake9c86)](https://ci.appveyor.com/project/odinserj/hangfire-autofac)
================

[Autofac](http://autofac.org) integration for [Hangfire](http://hangfire.io). Provides an implementation of the `JobActivator` class and registration extensions, allowing you to use Autofac container to **resolve job type instances** as well as **control the lifetime** of the all related dependencies.

*Hangfire.Autofac* resolves service instances using a child, tagged [lifetime scope](http://docs.autofac.org/en/latest/lifetime/index.html). A child scope is created and disposed each time when background job processing takes place, so you have precise control of your service's lifetime, including **shared instances** and **deterministic disposal**.

Installation
--------------

*Hangfire.Autofac* is available as a NuGet Package. Type the following command into NuGet Package Manager Console window to install it:

```
Install-Package Hangfire.Autofac
```

Usage
------

The package provides an extension methods for the `IGlobalConfiguration` interface, so you can enable Autofac integration using the `GlobalConfiguration` class:

```csharp
var builder = new ContainerBuilder();
// builder.Register...

GlobalConfiguration.Configuration.UseAutofacActivator(builder.Build());
```

After invoking the `UseAutofacActivator` method, Autofac-based implementation of the `JobActivator` class will be used to resolve job type instances during the background job processing.

### Shared Components

Sometimes it is required to share the same service instance for different components, such as database connection, unit of work, etc. *Hangfire.Autofac* allows you to share them in a scope, limited to the **current** background job processing, just call the `InstancePerBackgroundJob` method in your component registration logic:

```csharp
builder.RegisterType<Database>().InstancePerBackgroundJob();
```

### Non-tagged scopes

Whenever the scopes in `AutofacActivator` are created, by default they are created using tag `BackgroundJobScope`. There might be a scenario when it is needed not to use tagged scopes though. This might be a case if it is required to have a new instance of every service for each lifetime scope (in Hangfire it would be for every job). To disable tagged scopes you can use a flag `useTaggedLifetimeScope` during initialization of `AutofacActivator` for Hangfire.

```csharp
var builder = new ContainerBuilder();
// builder.Register...

GlobalConfiguration.Configuration.UseAutofacActivator(builder.Build(), false);
```

Then you can register services by using `InstancePerLifetimeScope` and expect them to work like intended.

```csharp
builder.RegisterType<Database>().InstancePerLifetimeScope();
```

### Deterministic Disposal

The *child lifetime scope* is disposed as soon as current background job is performed, successfully or with an exception. Since *Autofac* automatically disposes all the components that implement the `IDisposable` interface (if this feature not disabled), all of the resolved components will be disposed *if appropriate*.

For example, the following components will be **disposed automatically**:

```csharp
builder.RegisterType<SmsService>();
builder.RegisterType<EmailService>().InstancePerDependency();
builder.RegisterType<Database>().InstancePerBackgroundJob();
```

And the following components **will not be disposed**:

```csharp
builder.RegisterType<BackgroundJobClient>().SingleInstance();
builder.RegisterType<MyService>().ExternallyOwned();
```

Please refer to the Autofac documentation to learn more about [Automatic Disposal](http://docs.autofac.org/en/latest/lifetime/disposal.html#automatic-disposal) feature.

HTTP Request Warnings
----------------------

Services registered with `InstancePerHttpRequest()` method **will be unavailable** during job activation, you should re-register these services without this hint. If you have components registered for the HTTP request scope, please add an additional scope for them:

```csharp
builder.RegisterType<Database>()
    .InstancePerBackgroundJob()
    .InstancePerHttpRequest();
```

**`HttpContext.Current` is also not available during the job performance. Don't use it!**


text:
# [Thanksgiving Facts](http://alexa.amazon.com/#skills/amzn1.ask.skill.b3007983-0262-49c0-a5fe-55a5cfba8993)
![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png) 0

To use the Thanksgiving Facts skill, try saying...

* *Alexa, open Thanksgiving Facts*

* *Alexa, ask Thanksgiving Facts to tell me a Thanksgiving fact*

* *Alexa, ask Thanksgiving Facts to give me a Thanksgiving trivia*

This skill gives facts about Thanksgiving celebrations in United States and Canada. Just enable this skill from Alexa website or app and ask "Alexa, open Thanksgiving Facts". Its a wonderful way to brush up your history on this important family tradition!

***

### Skill Details

* **Invocation Name:** thanksgiving facts
* **Category:** null
* **ID:** amzn1.ask.skill.b3007983-0262-49c0-a5fe-55a5cfba8993
* **ASIN:** B01MTRBN4R
* **Author:** Rajesh Agrawal
* **Release Date:** November 25, 2016 @ 09:05:18
* **In-App Purchasing:** No


text:
# Code 301 Lab 03 jQuery and Events

**Andrew Bloom and Robert Reed**
**Version 1.0.2**

## Overview
Our goal with this project was to build a mobile-first site, using jQuery to dynamically render blog posts sorted by most recent publication date. Additional functionality includes being able to sort the articles by author and category from drop down lists. Also, only a preview of each article is shown, and a read more button, when pressed, reveals the entire article.

## Getting Started
To build this app on your own machine, clone this repo and launch the html page in your browser.

## Architecture
We are using a SMACSS organization of our CSS. We are using jQuery to dynamically render and manipulate DOM elements.

## Change Log
**No changes currently**

## Credits and Collaborations
Created by Andrew Bloom and Rob Reed, based off of source code from the Code Fellows 301 lab repo. We used the clearfix CSS convention from CSS Tricks: https://css-tricks.com/snippets/css/clear-fix/, the normalize.css from github.com/necolas/normalize.css and the jQuery v3.2.1 library. CSS code originates from Nicholas Carignan and Rob Reed.


text:
---
title: "CorDebugEHClause Structure | Microsoft Docs"
ms.custom: ""
ms.date: "03/30/2017"
ms.prod: ".net-framework"
ms.reviewer: ""
ms.suite: ""
ms.technology:
  - "dotnet-clr"
ms.tgt_pltfrm: ""
ms.topic: "reference"
api_name:
  - "CorDebugEHClause"
api_location:
  - "mscordbi.dll"
api_type:
  - "COM"
dev_langs:
  - "C++"
ms.assetid: 0e350a1b-6997-46d0-bfc5-962a5011ef43
topic_type:
  - "apiref"
caps.latest.revision: 4
author: "rpetrusha"
ms.author: "ronpet"
manager: "wpickett"
---
# CorDebugEHClause Structure
[Supported in the .NET Framework 4.5.2 and later versions]

 Represents an exception handling (EH) clause for a given piece of intermediate language (IL) code.

## Syntax

```vb

typedef struct _CorDebugEHClause {
   ULONG32 Flags;
   ULONG32 TryOffset;
   ULONG32 TryLength;
   ULONG32 HandlerOffset;
   ULONG32 HandlerLength;
   ULONG32 ClassToken;
   ULONG32 FilterOffset;
} CorDebugEHClause;

```

## Members

|Member|Description|
|------------|-----------------|
|`Flags`|A bit field that describes the exception information in the EH clause. For more information, see the Remarks section.|
|`TryOffset`|The offset, in bytes, of the `try` block from the start of the method body.|
|`TryLength`|The length, in bytes, of the `try` block.|
|`HandlerOffset`|The location of the handler for this `try` block.|
|`HandlerLength`|The size of the handler code in bytes.|
|`ClassToken`|The metadata token for a type-based exception handler.|
|`FilterOffset`|The offset, in bytes, from the start of the method body for a filter-based exception handler.|

## Remarks
 An array of `CoreDebugEHClause` values is returned by the [GetEHClauses](../../../../docs/framework/unmanaged-api/debugging/icordebugilcode-getehclauses-method.md) method.

 The EH clause information is defined by the CLI specification. For more information, see [Standard ECMA-355: Common Language Infrastructure (CLI), 6th Edition](http://www.ecma-international.org/publications/standards/Ecma-335.htm).

 The `flags` field can contain the following flags. Note that they are not defined in CorDebug.idl or CorDebug.h.

|Flag|Value|Description|
|----------|-----------|-----------------|
|`COR_ILEXCEPTION_CLAUSE_EXCEPTION`|0x00000000|A typed exception clause.|
|`COR_ILEXCEPTION_CLAUSE_FILTER`|0x00000001|An exception filter and handler clause.|
|`COR_ILEXCEPTION_CLAUSE_FINALLY`|0x00000002|A `finally` clause.|
|`COR_ILEXCEPTION_CLAUSE_FAULT`|0x00000004|A fault clause (a `finally` clause that is called only when an exception is thrown).|

## Requirements
 **Platforms:** See [System Requirements](../../../../docs/framework/get-started/system-requirements.md).

 **Header:** CorDebug.idl, CorDebug.h

 **Library:** CorGuids.lib

 **.NET Framework Versions:** [!INCLUDE[net_current_v452plus](../../../../includes/net-current-v452plus-md.md)]

## See Also
 [GetEHClauses Method](../../../../docs/framework/unmanaged-api/debugging/icordebugilcode-getehclauses-method.md)
 [Debugging Structures](../../../../docs/framework/unmanaged-api/debugging/debugging-structures.md)


text:
# N1QL Benchmark

A CLI to benchmark different Couchbase N1QL queries/indexes

## Usage

Execute profiling session
```sh
./n1qlb -i config.json
```

All flags and options are available with the following command:
```sh
./n1qlb -help
```

### Options

* -c Number of logical CPUs used for the test, default 2
* -i Configuration input file, default ```config.json```
* -o Output csv file, default ```report-execution.csv```
* -p Output json file with the explain of the queries, default ```explain.json```
* -t Query timeout, default 30s (30 seconds)
* -pause Pause between tests, usefult to allow Couchbase to recover and have a clear separation between different queries. Default 2s (2 seconds)

## Configuration file format

Configuration example
```json
{
	"concurrency": [1,2,5,10],
	"createPrimary": true,
	"repetitions": 5,
	"bucket": "default",
	"cbhost": "localhost",
	"password": "",
	"user": "",
	"indexes": [
		{"name": "someIndex", "definition": ["afield", "bfield"], "dropOnFinish": true}
	],
	"queries":[
		{"name": "Indexed", "query": "select * from default where name='John' and lastName='Doe'", "indexes": [{"name": "byName", "definition": ["name", "lastName"], "dropOnFinish": true}]},
		{"name": "Covered", "query": "select name, lastName from default where name='John' and lastName='Doe'", "indexes": [{"name": "byName", "definition": ["name", "lastName"], "dropOnFinish": true}]},
		{"name": "Without index", "query": "select name, lastName from default where name='John' and lastName='Doe'"}
	]
}
```

- concurrency. Number of concurrent calls/users to test against.
- createPrimaryIndex. Self explanatory.
- repetitions. Number of times that each query will be tested against each concurrency.
- bucket. Couchbase bucket.
- cbhost. Couchbase server.
- user. Couchbase user.
- password. Couchbase password.
- indexes. Group of common indexes for all queries (optional), useful to test covered vs non-covered queries. The ```dropOnFinish``` option will make sure that these indexes are removed when set to true.
- queries. Collection of queries to be tested, each one of them can create its own index (that can be dropped after its own test).


text:
# Bootstrap Nav: Tabs and Pills
- **Objective :** learn how to create Bootstrap nav components.

### Preface
Bootstrap provides an easy and quick way to create basic nav components like tabs and pills which are very flexible and elegant.

All the Bootstrap's nav components—tabs and pills—share the same base markup and styles through the base **`.nav`** class

With these bunch of examples demonstrating the Navs concept and its features in real action.

---
**Understand and Practice these examples for better grip on the concept.**

### Happy Learning !! 👍🏻✌🏻

---

path: /Bootstrap Navs/description.md


text:
# Font-Awesome-For-Ionic-Tabs
Use Font Awesome icons with Ionic Framework tabs. Includes icons from Font Awesome 4.5.0 (thanks to [@ollycross](https://github.com/ollycross))

## Installation
Make sure you have Font Awesome installed correctly and is working with your Ionic app. You'll need to make sure the fonts are located locally on in your app and that your @font-face src is correctly pointing to files.

Then include the font-awesome-ionic-tabs.css file in your app. If it's working correctly, you should be able to use the classes just like the ionicons.

```html
<ion-tab title="Photos" icon-on="ion-tab-fa-anchor" icon-off="ion-tab-fa-anchor">
  <ion-nav-view name="tab-one"></ion-nav-view>
</ion-tab>
```

## Adding Font Awesome Icons
* Find the unicode characters here: http://fortawesome.github.io/Font-Awesome/cheatsheet/
* See if they are already included in this list
* Name your style identical to the font awesome style, but prefix with "ion-tab-"
* Add the class with the unicode content to the list

*Example...*

```css
.ion-tab-fa-anchor:before {
  content: "\f13d"; }
```

*Now you can use your new class...*

```html
<ion-tab title="Photos" icon-on="ion-tab-fa-anchor:before" icon-off="ion-tab-fa-anchor:before">
  <ion-nav-view name="tab-one"></ion-nav-view>
</ion-tab>
```

repository: hyunjuhw/Font-Awesome-For-Ionic-Tabs

repo_name: hyunjuhw/Font-Awesome-For-Ionic-Tabs


text:
---
templateKey: basic-page
title: Membership - TEST
---
### Who can join?

Membership of Tayside Airgun Club is open to all, providing that legal requirements are met.

### Legal Requirements

The law makes no distinction between airguns and more powerful guns and all are classed as Firearms. This means that any offence committed can carry a very heavy penalty. There are at least 38 different offences, but the main points are:.

#### Power

* Air rifles must not exceed 12 foot-lbs muzzle energy.
* Air pistols must not exceed 6 foot-lbs muzzle energy.

### Licensing

You must be 18 or over and have an  Air Weapons Licence (AWL) to buy, own or transport an airgun in Scotland, but most people can use an airgun without an AWL, under supervision, at a recognised club like Tayside.

See <https://www.mygov.scot/air-weapon/> or contact the club if in doubt.

### Age restrictions

There are restrictions on the possession and use of airguns for people under the age of 18 and further restrictions for those under the age of 14.  In particular, under-18's cannot buy, hire or own an airgun but they can use one under supervision.

See <https://www.mygov.scot/air-weapon/>or contact the club if in doubt.

repository: paulcockrell/tagc-website

repo_name: paulcockrell/tagc-website


text:
# Context Route Plugin

This is a Cloud Foundry CLI plugin for manage routes with context paths.

## To Install
```
cf install-plugin https://github.com/zrob/context-route-plugin/blob/master/bin/OSX_binary?raw=true
```

## Commands

### create-context-route
`cf create-context-route SPACE DOMAIN HOST PATH`
##### Example
`cf create-context-route myspace bosh-lite.com apphost /v2`

### map-context-route
`cf map-context-route APP DOMAIN HOST PATH`
##### Example
`cf map-context-route myapp bosh-lite.com apphost /v2`

### unmap-context-route
`cf unmap-context-route APP DOMAIN HOST PATH`
##### Example
`cf unmap-context-route myapp bosh-lite.com apphost /v2`

### delete-context-route
`cf delete-context-route DOMAIN HOST PATH`
##### Example
`cf delete-context-route bosh-lite.com apphost /v2`

repository: zrob/context-route-plugin

repo_name: zrob/context-route-plugin


text:
[![Contributors][contributors-shield]][contributors-url]
[![Forks][forks-shield]][forks-url]
[![Stargazers][stars-shield]][stars-url]
[![Issues][issues-shield]][issues-url]
[![MIT License][license-shield]][license-url]
[![LinkedIn][linkedin-shield]][linkedin-url]

Raspberry Pi Custom Metrics

    Collect additional system metric of a Raspberry Pi for Datadog

    Explore the docs »

    View Demo
    ·
    Report Bug
    ·
    Request Feature

Table of Contents

      About The Project

Built With

      Getting Started

Prerequisites

Installation

Usage

Roadmap

Contributing

License

Contact

Acknowledgements

## About The Project

Datadog is great for monitoring infrastructure among other things, and the IoT Agent is very light.
But on small devices like a Raspberry Pi, cpu and gpu temperature, as well number of process are important to monitor.

This project collects metrics every 15 seconds and send them to the Datadog agent via [DogStatsD](https://docs.datadoghq.com/developers/dogstatsd/?tab=hostagent#pagetitle).

Collected metrics are:

* GPU Temperature
* CPU Temperature
* Number of threads
* Number of processes

### Built With

* [DogStatsD](https://docs.datadoghq.com/developers/dogstatsd/?tab=hostagent#pagetitle)
* [GoReleaser](https://goreleaser.com/)
* [Logrus](https://github.com/sirupsen/logrus)
* [Viper](github.com/spf13/viper)

## Getting Started

To get a local copy up and running follow these simple steps.

### Installation

1. Clone the repo
   ```sh
   wget https://github.com/abruneau/pi_custom_metrics/releases/download/1.0.1/pi_custom_metrics_1.0.1_linux_armv7.deb
   ```
2. Install deb packages
   ```sh
   sudo apt install pi_custom_metrics_1.0.1_linux_armv7.deb
   ```

## Usage

To start/stop datadog-custom-metrics:

```sh
sudo systemctl start datadog-custom-metrics
sudo systemctl stop datadog-custom-metrics
```

To enable/disable datadog-custom-metrics starting automatically on boot:

```sh
sudo systemctl enable datadog-custom-metrics
sudo systemctl disable datadog-custom-metrics
```

To reload datadog-custom-metrics:

```sh
sudo systemctl restart datadog-custom-metrics
```

To view datadog-custom-metrics logs:

```sh
journalctl -f -u datadog-custom-metrics
```

## Roadmap

See the [open issues](https://github.com/abruneau/pi_custom_metrics/issues) for a list of proposed features (and known issues).

## Contributing

Contributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make are **greatly appreciated**.

1. Fork the Project
2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
3.  Push to the Branch (`git push origin feature/AmazingFeature`)
5. Open a Pull Request

## License

Distributed under the MIT License. See `LICENSE` for more information.

## Contact

Your Name - [@BruneauAntonin](https://twitter.com/BruneauAntonin) -<EMAIL_ADDRESS>
Project Link: [https://github.com/abruneau/pi_custom_metrics](https://github.com/abruneau/pi_custom_metrics)

## Acknowledgements

* [go-to-deb](https://github.com/alexhowarth/go-to-deb)

[contributors-shield]: https://img.shields.io/github/contributors/abruneau/pi_custom_metrics.svg?style=for-the-badge
[contributors-url]: https://github.com/abruneau/pi_custom_metrics/graphs/contributors
[forks-shield]: https://img.shields.io/github/forks/abruneau/pi_custom_metrics.svg?style=for-the-badge
[forks-url]: https://github.com/abruneau/pi_custom_metrics/network/members
[stars-shield]: https://img.shields.io/github/stars/abruneau/pi_custom_metrics.svg?style=for-the-badge
[stars-url]: https://github.com/abruneau/pi_custom_metrics/stargazers
[issues-shield]: https://img.shields.io/github/issues/abruneau/pi_custom_metrics.svg?style=for-the-badge
[issues-url]: https://github.com/abruneau/pi_custom_metrics/issues
[license-shield]: https://img.shields.io/github/license/abruneau/pi_custom_metrics.svg?style=for-the-badge
[license-url]: https://github.com/abruneau/pi_custom_metrics/blob/master/LICENSE.txt
[linkedin-shield]: https://img.shields.io/badge/-LinkedIn-black.svg?style=for-the-badge&logo=linkedin&colorB=555
[linkedin-url]: https://linkedin.com/in/antoninbruneau


text:
# Grasshopper-Loader

**Description**: This is the data loader for [Grasshopper](https://github.com/cfpb/grasshopper), cfpb's work-in-progress geocoder.
Data is assumed to conform to the relevant Input Data Standard for Grasshopper (*q.v.* the [Input Point Data Standard](https://github.com/cfpb/grasshopper/blob/master/docs/data_format.md).
Data is transformed from these standard formats and loaded into Elasticsearch (the schema of which may change).

## Usage
  - [Install node](https://nodejs.org/)
  - Run **npm install** from the project root
  - The loader is a command-line application, run by invoking **grasshopper-loader.js** with the following options:
    - **-d, --data** *Required* The data source to load. This can be a gdb, shp, GeoJSON, zip, or a directory of any of these.
    - **-t, --transformer** *Default: transformers/default.js* The transformer to use. This converts state-specific data formats to our [Point Data Schema](https://github.com/cfpb/grasshopper/blob/master/docs/point_data_spec.md)
    - **-h, --host** *Default: localhost* The elasticsearch host
    - **-p --port** *Default: 9200* The elasticsearch port
  - Test the loader by starting elasticsearch on localhost:9200, and, from the root of the project, run **./grasshopper-loader.js -d test/data/ny.json -t transformers/new_york.js**
    - This will load 100 addresses from New York into the address index and the point type
    - Check this with **curl -XGET "localhost:9200/address/point/_count?q=properties.address:NY"**

## Info
  - **Technology stack**: Due to a high volume of IO, the loader uses [node.js](http://nodejs.org/) for high throughput.
  - **Status**: Alpha
  - **Notes on change**: As both the Elasticsearch schema and data standards may (and likely will) change, expect to see active, breaking changes in this repo until tagged otherwise. Also, many new transformations will be added as more state-specific data is acquired.

----

## Open source licensing info
1. [TERMS](TERMS.md)
2. [LICENSE](LICENSE)
3. [CFPB Source Code Policy](https://github.com/cfpb/source-code-policy/)

repository: jmarin/grasshopper-loader

repo_name: jmarin/grasshopper-loader