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]

Learning Java

    A repo of my progress in learning Java

    View Demo
    ·
    Report Bug
    ·
    Request Feature

Table of Contents

      About The Project

Built With

      Getting Started

Prerequisites

Installation

License

Contact

Acknowledgements

## About The Project

This is my eclipse workspace from my time learning Java and OOP

### Built With

* [Java 15](https://www.oracle.com/uk/java/technologies/javase-downloads.html)
* [Eclipse](https://www.eclipse.org/downloads/)
* [Java Tutorial for Complete Beginners](https://www.udemy.com/course/java-tutorial)

## Getting Started

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

### Prerequisites

Java Instalation

* Windows
  ```sh
  choco install adoptopenjdk15
  ```
* Mac
  ```sh
  brew install oracle-jdk
  ```
* Linux (Debian Based)
  ```sh
  sudo apt install open-jdk
  ```
* Linux (Arch Based)
  ```sh
  sudo pacman -S jdk-openjdk
  ```

Eclipse Install
* Windows
  ```sh
  choco install eclipse-java-oxygen
  ```
* Mac
  ```sh
  brew install --cask eclipse-java
  ```
* Linux (Ubuntu Based)
  ```sh
  sudo snap install eclipse :(
  ```
* Linux (Arch Based)
  ```sh
  sudo pacman -S eclipse-java
  ```

### Installation

1. Clone the repo
   ```sh
   git clone https://github.com/71xn/learning-java.git
   ```
2. Open in Eclipse (Set the cloned repo as the project workspace)

## License

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

## Contact

Finn Lestrange - [@71xxn](https://twitter.com/71xxn) -<EMAIL_ADDRESS>
Learning Java: [https://github.com/71xn/learning-java](https://github.com/71xn/learning-java)

## Acknowledgements

* [Cave of Programming](https://www.caveofprogramming.com)

[contributors-shield]: https://img.shields.io/github/contributors/71xn/learning-java.svg?style=for-the-badge
[contributors-url]: https://github.com/71xn/learning-java/graphs/contributors
[forks-shield]: https://img.shields.io/github/forks/71xn/learning-java.svg?style=for-the-badge
[forks-url]: https://github.com/71xn/learning-java/network/members
[stars-shield]: https://img.shields.io/github/stars/71xn/learning-java.svg?style=for-the-badge
[stars-url]: https://github.com/71xn/learning-java/stargazers
[issues-shield]: https://img.shields.io/github/issues/71xn/learning-java.svg?style=for-the-badge
[issues-url]: https://github.com/71xn/learning-java/issues
[license-shield]: https://img.shields.io/github/license/71xn/learning-java.svg?style=for-the-badge
[license-url]: https://github.com/71xn/learning-java/blob/master/LICENSE.txt


text:
# Google APIs for Mobile: Quickstarts

Demonstrates use of the
[Nearby.Messages API](https://developers.google.com/nearby/)
for communicating between
devices within close proximity of each other.

Introduction
------------

This sample allows a user to publish a message to nearby devices, and subscribe
to messages published by those devices.

To run this sample, use two or more devices to publish and subscribe messages.

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

This sample uses the Gradle build system. To build this project, use the
"gradlew build" command. Or, use "Import Project" in Android Studio.

To use this sample, follow the following steps:

1. Create a project on
[Google Developer Console](https://console.developers.google.com/). Or, use an
existing project.

1. Click on `APIs & auth -> APIs`, and enable `Nearby Messages API`.

1. Click on `Credentials`, then click on `Create new key`, and pick
`Android key`. Then register your Android app's SHA1 certificate
fingerprint and package name for your app. Use
`com.google.android.gms.nearby.messages.samples.nearbydevices`
for the package name.

1. Copy the API key generated, and paste it in `AndroidManifest.xml`.

Support
-------

- Stack Overflow: http://stackoverflow.com/questions/tagged/google-play-services

If you've found an error in these samples, please file an issue in this repo.

Patches are encouraged, and may be submitted according to the instructions in
CONTRIBUTING.md.

## How to make contributions?
Please read and follow the steps in the [CONTRIBUTING.md](CONTRIBUTING.md)

repository: luiscarlosjunior/android-classes

branch_name: refs/heads/master

extension: md

gha_language: Java

gha_license_id: MIT

license_type: permissive

repo_name: luiscarlosjunior/android-classes


text:
# Stash Pull Requests lists

> Simple proxy, to get the API, and combine pull-requests with mergin info, and narrrowing down to a single user.

## Table of Contents

- [Install](#install)
- [Usage](#usage)
- [License](#license)

## Install

```console
    git clone git@github.com:DKunin/stash-prs-list.git
    cd stash-prs-list
    npm prepeare
```
npm prepeare will create .projects file for you, there you should put links PR projects you are interested in.

Before usage JIRA_PASS, STASH_HOST and STASH_PROJECTS env variables should be set in your .bashrc file, or any other place, you use to declare variables. JIRA_PASS is base64 encoded your 'username:password'.
STASH_PROJECTS - should be a list of project paths.

```bash
    export JIRA_PASS='ZnJlZDpmcmVk'
    export STASH_HOST='www.stash.com'
    export STASH_PROJECTS='JS/repos/utils JS/repos/middleware'
```

```console
    npm start
```

Or with Docker

```console
    docker pull dkunin/stash-prs-list
    docker run -d -p 4848:4848 -e "JIRA_PASS=$JIRA_PASS" -e "STASH_HOST=$STASH_HOST" -e "STASH_PROJECTS=$STASH_PROJECTS" dkunin/stash-prs-list
```

Or if you want to modify/build your own image

```console
    npm run docker-image-build
    npm run docker-image-start
```
which will run:
```console
    docker build ./ -t $(whoami)/$(basename $PWD)
    docker run -d -p 4848:4848 -e "JIRA_PASS=$JIRA_PASS" -e "STASH_HOST=$STASH_HOST" -e "STASH_PROJECTS=$STASH_PROJECTS" $(whoami)/$(basename $PWD)
```

## Usage

Go to address:
```
    http://localhost:4848/api/prs?username=dkunin
```

## License

MIT © Dmitri Kunin

license: MIT

repository: DKunin/stash-prs-list

repo_name: DKunin/stash-prs-list


text:
---
title: Advanced Types
module: Dynamic Types
type: course
cover: './cover.png'
order: 1200
youtubeVideoId: I8EnPH8qLCw
articleSlug: /tltr-typescript-advanced-types
---

Let's review 4 of the most advanced TypeScript features, that let you automatically generate types on the fly. Instead of creating manually your types, you can use these features to instruct TypeScript on what you want to reuse from your existing types. Did you know that the typeof keyword behaves differently on TypeScript? We will also learn about the keyof operator, lookup types and the keyword infer. Use these features in your generic types, to automate your workflow.

gha_language: JavaScript


text:
---
title: Definitions
---

Arend supports the following kinds of definitions: [functions](functions), [data](data), [records](records), [classes](classes), [instances](classes#instances), and [coercions](coercion).
Every definition has a name which must be a valid identifier as described in [Lexical structure](../lexical-structure#identifiers).

Definitions can be referred by _defcall_ expressions.
If {%ard%} def {%endard%} is a name of a definition, defcall is an expression of the form:
{%ard%} def e_1 ... e_n {%endard%}, where {%ard%} e_1, ..., e_n {%endard%} are expressions.
Expressions {%ard%} e_1, ..., e_n {%endard%} are called arguments of the defcall.

There are alternative notations in case a defcall has precisely one or two arguments.
In case of two arguments, it is possible to use the infix notation: {%ard%} def e_1 e_2 {%endard%} is equivalent
to {%ard%} e_1 \`def\` e_2 {%endard%}.
In case of one argument, it is possible to use the postfix notation: {%ard%} def e_1 {%endard%} is equivalent to {%ard%} e_1 \`def {%endard%}.

## Precedence

The parsing of complex defcall expressions, containing several infix and postfix notations, is regulated by precedence
of involved definitions: their priority and the type of associativity. Precedence of a definition can be specified
by writing {%ard%} FIX N {%endard%} just before the name of the definition, where {%ard%} FIX {%endard%} is one of keywords
{%ard%} \fixl {%endard%}, {%ard%} \fixr {%endard%} or {%ard%} \fix {%endard%},
which mark the definition as left, right associative or non-associative respectively, and {%ard%} N {%endard%} is the priority,
which is an integer between 1 and 9. For example, {%ard%} \func \fixl 3 op (a b : Nat) => 0 {%endard%} defines a binary function
named {%ard%} op {%endard%} which is left associative with priority 3. The default precedence is {%ard%} \fixr 10 {%endard%}.

If {%ard%} op1 {%endard%} and {%ard%} op2 {%endard%} are two definitions and {%ard%} e1, e2, e3 {%endard%} are expressions,
the expression {%ard%} e1 \`op1\` e2 \`op2\` e3 {%endard%} is parsed according to the following rules:

* If priorities of {%ard%} op1 {%endard%} and {%ard%} op2 {%endard%} are different and, say, the priority of {%ard%} op1 {%endard%} is higher, then the expression is parsed as {%ard%} (e1 \`op1\` e2) \`op2\` e3 {%endard%}.
* Assume priorities of {%ard%} op1 {%endard%} and {%ard%} op2 {%endard%} are the same. If they are both left or both right associative, the expression is
  parsed as {%ard%} (e1 \`op1\` e2) \`op2\` e3 {%endard%} or {%ard%} e1 \`op1\` (e2 \`op2\` e3) {%endard%} respectively. If {%ard%} op1 {%endard%} and {%ard%} op2 {%endard%} have
  different types of associativity or are non-associative, then the parsing error is generated.

## Infix operators

A definition can be labeled as an _infix operator_.
This means that its defcalls are parsed as infix notations even without `` ` ` ``.
An infix operator is defined by specifying one of keywords {%ard%} \infixl {%endard%}, {%ard%} \infixr {%endard%}, {%ard%} \infix {%endard%} before the name of operator.
These keywords have the same syntax and semantics as keywords {%ard%} \fixl {%endard%}, {%ard%} \fixr {%endard%}, and {%ard%} \fix {%endard%}, which are described above.

An infix operator can be used in the prefix form as an ordinary definition.
For example, if the function {%ard%} + {%endard%} is defined as {%ard%} \infixl 6 + {%endard%}, then it is allowed to write either {%ard%} + 1 2 {%endard%} or {%ard%} 1 + 2 {%endard%};
these expressions are equivalent.

Finally, if {%ard%} f {%endard%} is an infix operator or an operator surrounded with `` ` ` ``, then it is allowed to write {%ard%} e f {%endard%} and
this is equivalent to {%ard%} f e {%endard%}.
For example, the function that adds {%ard%} 1 {%endard%} to its argument can be written either as {%ard%} 1 + {%endard%} or as {%ard%} + 1 {%endard%}.
The result of application of the first function to {%ard%} 2 {%endard%} is {%ard%} 1 + 2 {%endard%}, the result of application of the second one to {%ard%} 2 {%endard%}
is {%ard%} + 1 2 {%endard%}, and as noted before these expressions are equivalent.

As noted above, it is possible to use a left section of an operator, that is {%ard%} x + {%endard%} is equivalent to {%ard%} \lam y => x + y {%endard%}.
It is also possible to use right sections:
if a postfix notation is applied to an argument from the right as in {%ard%} `+ y {%endard%}, then such an expression is equivalent to {%ard%} \lam x => x + y {%endard%}.

## Aliases

An alias is an alternative name for the definition.
It can be specified by putting {%ard%} \alias aliasName {%endard%} after the name of a definition.
The definition itself and its alias can be used interchangeably.
Aliases can have their own precedence which is specified before the alias name.
Aliases can also contain unicode symbols between `U+2200` and `U+22FF`.

repository: marat-rkh/site

repo_name: marat-rkh/site


text:
# Call the Web Api from the photo taking app

In the [previous step](./ReturnTheEmotionCount.md) you returned the count of each emotion from the Web Api. In this step you will connect the photo taking app to the Web Api to test it out.

## Calling a Web Api

Web Apis can be called from Python, passing data to and receiving data from the Api. There is a package called `requests` that provides a simple to use way to call Web Apis.

## Install the requests package

* Open the `requirements.txt` file in Visual Studio Code.

* Add the following to the bottom of the file:

  ```python
  requests
  ```

* Save the file

* Install the new package from the terminal using the following command:

  ```sh
  pip3 install -r requirements.txt
  ```

## Write the code

* Open the `picturetaker.py` file in Visual Studio Code.

* Add an import for the requests package, as well as a system library below the other imports

  ```python
  import requests
  import base64
  ```

* Add the following code just after the imports:

  ```python
  imageUrl = 'https://<Your Web App>.azurewebsites.net/image'

  def upload(frame):
    data = {}
    img = cv2.imencode('.jpg', frame)[1]
    data['image'] = base64.b64encode(img).decode()
    requests.post(url=imageUrl, json=data)
  ```

* Update the `imageUrl` to be the URL of your Web App. Keep the `/image` part on the end.

* Add a call to this function before the `break`:

  ```python
  ...
  if k%256 == 32:
    upload(frame)
    break
  ...
  ```

## Run the code

* Start running the code. There are two ways to run this code:

  * Start debugging by either:
    * Select *Debug -> Start Debugging*
    * Press **F5**
    * Select the Debug pane from the toolbar on the left. Make sure the configuration is set to *Pyyhon: Current file* and select the green *Start Debugging* button.

    If you use one of these methods you will be able to set breakpoints and debug your code.

  * Run this directly from the Visual Studio Code terminal using the command

    ```sh
    python picturetaker.py
    ```

    If you use this method you will not be able to set breakpoints and debug your code.

* When the code runs, a window will appear showing the view from your camera. Press *Space* to take a picture with one or more faces in it and end the app.

The picture will be uploaded to the Web Api, faces detected and the results inserted into Cosmos DB. To verify it all worked, you can use the Cosmos DB explorer.

* Open the *Azure* tab, and expand the *COSMOS DB* section.

* Expand your Cosmos DB account, expand the database and the collection.

* In the collection, expand the documents node. You will see one document for every photo you've uploaded.

* Click on a document to see its contents. You will see the id of the document and the emotion.

  ![The Cosmos DB explorer showing the document, and the document in a pane with a neutral emotion](../Images/CosmosDocument.png)

* Try with different people, more than one person in a picture and faces showing different emotions and check the results.

## What does this code do

The overall flow of this code is:

1. When the picture is taken, send it to the `upload` functions
2. Create a dictionary to store the data being sent as JSON
3. Convert the image to binary data, then Base64 encode it
4. Add the Base64 encoded data to the dictionary, then convert that to JSON
5. POST the JSON to the Web Api

Lets look in more detail at the actual code.

```python
import requests
import base64
```

This tells the Python compiler that we want to use code in the `requests` package. It also tells the python compiler that we want to use `base64` from the Python standard libraries - these come with Python so there is no need to install another package to use them.

```python
imageUrl = 'https://<Your Web App>.azurewebsites.net/image'
```

This defines a variable with the URL of the Web Api.

```python
def upload(frame):
```

This code declares the `upload` function to upload the image.

```python
data = {}
```

This code defines a new, empty dictionary. A dictionary contains key/value pairs, so is ideal to convert to JSON to send to a Web Api.

```python
img = cv2.imencode('.jpg', frame)[1]
```

The image needs to be encoded as Base64 to be sent as JSON. This code takes the frame and extracts the image from it as a JPEG. This format is specific by the `'.jpg'` file extension.

```python
data['image'] = base64.b64encode(img).decode()
```

Once the image is extracted, it is converted to a Base64 encoded string and set as the value of the `image` key in the dictionary.

```python
requests.post(url=imageUrl, json=data)
```

This code sends the json to the Web Api using a POST request.

```python
upload(frame)
```

The `upload` function is called once the frame is captured and the **space** key is pressed.

## Next step

In this step you connected the photo taking app to the Web Api and tested it out, uploading a picture and seeing the results of the analysis in Cosmos DB. In the [next step](./AlertTheUser.md) you will alert the user via the command line if sad faces are detected too often.

repository: baiwenjia/computerscience

path: /Events and Hacks/Student Hacks/mood-detector-workshop/Steps/CallTheWebApiFromDesktop.md

gha_license_id: NOASSERTION

repo_name: baiwenjia/computerscience


text:
# LockerGoga

## Description

### MITRE Description

> [LockerGoga](https://attack.mitre.org/software/S0372) is ransomware that has been tied to various attacks on European companies. It was first reported upon in January 2019.(Citation: Unit42 LockerGoga 2019)(Citation: CarbonBlack LockerGoga 2019)

## Aliases

```
LockerGoga
```

## Platforms

```
['Windows']
``

# Techniques

* [Lateral Tool Transfer](../techniques/Lateral-Tool-Transfer.md)

* [File Deletion](../techniques/File-Deletion.md)

* [Data Encrypted for Impact](../techniques/Data-Encrypted-for-Impact.md)

* [Disable or Modify Tools](../techniques/Disable-or-Modify-Tools.md)

* [Code Signing](../techniques/Code-Signing.md)

* [System Shutdown/Reboot](../techniques/System-Shutdown-Reboot.md)

* [Account Access Removal](../techniques/Account-Access-Removal.md)

# Actors

* [FIN6](../actors/FIN6.md)


text:
# Day 3

## Customizing ImageJ using ImageJ Macro
* [ImageJ Macro crash course (Slides)](customizing_imagej/ImageJ_macro.pptx)
  * [ImageJ Macro cheat sheets](https://github.com/BiAPoL/imagej-macro-cheat-sheet)
* [Customizing ImageJ](customizing_imagej/Customizing_ImageJ_GUI_and_IJ_markdown.pptx)
  * [Examples](customizing_imagej/]

## Interactive Design of GPU-accelerated Image Data Flow Graphs in Fiji
* [Installation instructions for Fiji](https://clij.github.io/clij2-docs/installationInFiji)
  * Note for linux users: You may have to [install OpenCL](https://clij.github.io/clij2-docs/installationInFiji#Linux)
* [Interactive Design of GPU-accelerated Image Data Flow Graphs (Slides)](image_data_flow_graphs/CLIJ_Mini_Course.pptx)
  * [CLIJ Macro cheat sheets](https://clij.github.io/clij2-docs/CLIJ2-cheatsheet_V3.pdf)

## Ilastik Hands On
Ilastik software can be downloaded from [here](https://www.ilastik.org/download.html), we will use version 1.3.3. Images for hands on are in **ilastik_data** folder. Documentation, tutorials and instalation instructions can be found [here](https://www.ilastik.org/documentation/basics/installation).

## Stardist Hands On
Stardist plugin for ImageJ can be found [here](https://imagej.net/plugins/stardist). Images for hands on are in **stardist_data** folder. Stardist plugin is installed through FIJI/ImageJ update sites, you can find instructions [here](https://imagej.net/plugins/stardist#installation).

branch_name: refs/heads/main


text:
# jsx-a11y/no-noninteractive-element-interactions

💼 This rule is enabled in the following configs: ☑ `recommended`, 🔒 `strict`.

<!-- end auto-generated rule header -->

Non-interactive HTML elements and non-interactive ARIA roles indicate _content_ and _containers_ in the user interface. A non-interactive element does not support event handlers (mouse and key handlers). Non-interactive elements include `<main>`, `<area>`, `<h1>` (,`<h2>`, etc), `<p>`, `<img>`, `<li>`, `<ul>` and `<ol>`. Non-interactive [WAI-ARIA roles](https://www.w3.org/TR/wai-aria-1.1/#usage_intro) include `article`, `banner`, `complementary`, `img`, `listitem`, `main`, `region` and `tooltip`.

## How do I resolve this error?

### Case: This element acts like a button, link, menuitem, etc

Move the event handler function to an inner element that is either a semantically interactive element (`<button>`, `<a href>`) or that has an interactive role. This leaves the _content_ or _container_ semantic value of this element intact.

Common interactive roles include:

  1. `button`
  1. `link`
  1. `checkbox`
  1. `menuitem`
  1. `menuitemcheckbox`
  1. `menuitemradio`
  1. `option`
  1. `radio`
  1. `searchbox`
  1. `switch`
  1. `textbox`

Note: Adding a role to your element does **not** add behavior. When a semantic HTML element like `<button>` is used, then it will also respond to Enter key presses when it has focus. The developer is responsible for providing the expected behavior of an element that the role suggests it would have: focusability and key press support.
see [WAI-ARIA Authoring Practices Guide - Design Patterns and Widgets](https://www.w3.org/TR/wai-aria-practices-1.1/#aria_ex).

### Case: This element is catching bubbled events from elements that it contains

Move the event handler function to an inner element like `<div>` and give that element a role of `presentation`. This leaves the _content_ or _container_ semantic value of this element intact.

```jsx
<div role="article">
  <div
    onClick="onClickHandler"
    onKeyPress={onKeyPressHandler}
    role="presentation">
    {this.props.children}
  </div>
</div>
```

Marking an element with the role `presentation` indicates to assistive technology that this element should be ignored; it exists to support the web application and is not meant for humans to interact with directly.

### Case: This is a heading that expands/collapses content on the package

Headers often double as expand/collapse controls for the content they headline. An accordion component is a common example of this pattern. Rather than assign the interaction handling code to the heading itself, put a button inside the heading instead. This pattern retains the role of the heading and the role of the button.

```jsx
<h3>
  <button onClick={this._expandSection}>News</button>
</h3>
<ul id="articles-list">
  <li>...</li>
</ul>
```

### Case: This element is a table cell

Table cells (and tables in general) are meant to contain data. ARIA provides us with a construct called a [Grid](https://w3c.github.io/aria-practices/#grid) that is essentially a 2 dimensional logical container for content and interactive elements.

You have two options in this case.

#### Option 1, move the interactive content inside the table cells

For instance, move the button inside the cell:

```jsx
<table>
  <tr>
    <td><button>Sort</button></td>
  </tr>
</table>
```

This preserves the table cell semantics and the button semantics; the two are not conflated on the cell.

#### Option 2, convert the table into an ARIA grid

If your user interface has a table-like layout, but is filled with interactive components in the cells, consider converting the table into a grid.

```jsx
<table role="grid">
  <tr>
    <td role="gridcell" onClick={this.sort}>Sort</td>
  </tr>
</table>
```

You can also put the interactive content inside the grid cell. This maintains the semantic distinction between the cell and the interaction content, although a grid cell can be interactive.

## Rule options

You may configure which handler props should be taken into account when applying this rule. The recommended configuration includes the following 6 handlers.

```javascript
'jsx-a11y/no-noninteractive-element-interactions': [
  'error',
  {
    handlers: [
      'onClick',
      'onMouseDown',
      'onMouseUp',
      'onKeyPress',
      'onKeyDown',
      'onKeyUp',
    ],
  },
],
```

Adjust the list of handler prop names in the handlers array to increase or decrease the coverage surface of this rule in your codebase.

### Succeed

```jsx
<div onClick={() => void 0} role="button" />
<div onClick={() => void 0} role="presentation" />
<input type="text" onClick={() => void 0} /> // Interactive element does not require role.
<button onClick={() => void 0} className="foo" /> // button is interactive.
<div onClick={() => void 0} role="button" aria-hidden /> // This is hidden from screenreader.
<Input onClick={() => void 0} type="hidden" /> // This is a higher-level DOM component
```

### Fail

```jsx
<li onClick={() => void 0} />
<div onClick={() => void 0} role="listitem" />
```

## Accessibility guidelines

- [WCAG 4.1.2](https://www.w3.org/WAI/WCAG21/Understanding/name-role-value)

### Resources

- [WAI-ARIA roles](https://www.w3.org/TR/wai-aria-1.1/#usage_intro)
- [WAI-ARIA Authoring Practices Guide - Design Patterns and Widgets](https://www.w3.org/TR/wai-aria-practices-1.1/#aria_ex)
- [Fundamental Keyboard Navigation Conventions](https://www.w3.org/TR/wai-aria-practices-1.1/#kbd_generalnav)
- [Mozilla Developer Network - ARIA Techniques](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Techniques/Using_the_button_role#Keyboard_and_focus)


text:
Ansible Role - Fedora NFS Client
=========

An ansible role that attaches an NFS file share at a designated filesystem location on Fedora (v33 or newer) using /etc/fstab (via ansible.posix.mount) and systemd. The NFS client package is installed if not present. The target client ecosystem is Fedora running on hardware or in VMs. This role is not designed for attaching NFS directly to a container-based application.

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

An existing NFS share on a remote NFS server with appropriate security configuration. The first implementation of this role implicitly assumes a v4.x NFS server. As noted above, Fedora machines (hardware or VM) comprised the target clientele.

Role Variables
--------------

The following three (3) variables are required parameters that need to be defined as `vars` when this role is instantiated in a play or task. They are also listed, but not defined, in `./defaults/main.yaml`:

| Variable       | Notes      |
| -------        | ----       |
| fnm_server | NFS server host name or IP |
| fnm_export | Export path on NFS server |
| fnm_mnt_path | Client filesystem location |

The following two (2) variables are optional parameters with default values that can alse be passed to the role (see `./defaults/main.yaml`):

| Variable       | Default Value | Notes      |
| -------        | ------------- | ----       |
| fnm_options |see ./defaults/main.yaml  | See https://www.freedesktop.org/software/systemd/man/systemd.mount.html for detailed explanations of all options. |
| fnm_state | `mounted`      | options are absent, mounted, present, unmounted, remounted. See https://docs.ansible.com/ansible/latest/collections/ansible/posix/mount_module.html for definitions of each state. |

The following variables are defined in `.\vars\main.yaml` and are not intended to be configurable at runtime:

| Variable       | Default Value | Notes      |
| -------        | ------------- | ----       |
| fnm_package  | `nfs_utils`      | NFS client rpm package in Fedora |

Dependencies
------------

None at this time.

Example Playbooks
----------------
The following playbook attaches the `/volume1/nfs-test` NFS share on the client at the `/mnt/test` location. Systemd unit files to persist the attachment across rebootsare automatically created and enabled. By default, the NFS share is only attached when in use. The three mandatory parameters are defined but not the two optional parameters.

```
- name: Attach NFS share
  hosts: pi02
  become: true
  tasks:
    - name: "Include fedora_nfs_mount"
      include_role:
        name: "fedora_nfs_mount"
      vars:
        fnm_server: quga.lan
        fnm_export: /volume1/nfs-test
        fnm_mnt_path: /mnt/test
```

The following playbook removes the NFS share from the client.

```
- name: Remove NFS share
  hosts: pi02
  become: true
  tasks:
    - name: "Include fedora_nfs_mount"
      include_role:
        name: "fedora_nfs_mount"
      vars:
        fnm_server: quga.lan
        fnm_export: /volume1/nfs-test
        fnm_mnt_path: /mnt/test
        fnm_state: absent
```

Technical Notes
---------------

This role uses both fstab and systemd. Unit mount and automount files are automatically generated for systemd if the default options are used. The unit files enable the NFS share attachment to persist across system reboots.

The systemd-mount man file (https://www.freedesktop.org/software/systemd/man/systemd.mount.html) outlines the steps to configure a file system mount in systemd noting the integration between `/etc/fstab` entries and systemd. The web page notes that "In general, configuring mount points through /etc/fstab is the preferred approach". This role follows that recommendation. I also suspect that users of this role will find more NFS examples that use fstab options online than examples that include systemd mount and automount unit files.

The three parameters used to create the NFS mount (the server hostname, the server NFS export, and the client host mount point) are all required for each use of this role in a playbook or task.

This role is very basic, designed to provide the needed flexibility for configuring NFS clients on a small fleet of machines powering a local Kubernetes cluster (e.g. multiple VMs or Raspberry Pis) with a Fedora OS (currently Fedora 33). At somepoint, this may be extended to also support Fedora CoreOS. It is not designed as a general purpose NFS client so please keep my goals in mind when evaluating it for your use.

The initial use case is to create and configure an NFS file share for the DNF local repository plugin and to attach NFS shares to nodes that can be used for applications hosted in a kubernetes cluster.

License
-------

BSD

Author Information
------------------

Author: Brad Smith

email<EMAIL_ADDRESS>


text:
# Multi::Analytics::Turbolinks

Turbolinks page changes are often not detected with event tracking frameworks such as
Google Analytics, Baidu Tongji and Bing UET.

Facebook's Pixel appears to work with turbolinks without problems.

These analytics and ad/event tracking products are also the
worlds largest search providers. This gem adds support to fire these
events on page changes, to more accurately work with turbolinks.

This gem was forked from joshdvir's google-analytics-turbolinks

**Use with Rails and Asset Pipeline**

## Installation

Add this line to your application's Gemfile:

    gem 'multi-analytics-turbolinks'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install multi-analytics-turbolinks

## Usage

Signup to

  * [Google Analytics](http://analytics.google.com/)
  * Baidu Tongji [join](http://tongji.baidu.com/open/api/more?p=howToJoin) and [login](http://tongji.baidu.com/web/welcome/login)
  * [Bing UET](https://secure.bingads.microsoft.com/) (credit-card not required)

Add the JS you need to your Javascript manifest file (typically application.js)

```html
	//= require google-analytics-turbolinks
	//= require baidu-tongji-turbolinks
	//= require bing-uet-turbolinks
```

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

## License

Check LICENSE, MIT.

repository: trammel/multi-analytics-turbolinks

gha_language: Ruby

repo_name: trammel/multi-analytics-turbolinks


text:
# Reverse_complement_DNA
Find the reverse complement of the given DNA strand (ROSALIND SOLUTION)

Nucleic acids are long, chain-like molecules that express one's genetic information. Each nucleic acid contains four of the five bases: Adenine (A), Guanine (G), Cytosine (C), Thymine (T), and Uracil (U). Thymine (T) is found in DNA, while Uracil (U) is found in RNA. In this problem we will be focusing on DNA's complementary pairs: A and T, C and G.

In this problem, you will use `import argparse` to read in a file called DNA.txt and find the complement of each base in the provided DNA string and reverse it (i.e. "GTCA" is "TGAC"). The output will be written to a default file called "out.txt".

# Expected Behavior
The DNA string and outfile are both required, so be sure to set `required=True` when creating it with `parser.add_argument` so the program makes a usage statement when no arguments are provided:

````
$ ./DNA-example.py
usage: DNA-example.py [-h] [-o FILE] -d FILE
DNA-example.py: error: the following arguments are required: -d/--DNA
````

Create help page on `-h` or `--help`:

````
$ ./DNA-example.py -h
usage: DNA-example.py [-h] [-o FILE] -d FILE

Reverse complement the DNA strand

optional arguments:
  -h, --help            show this help message and exit
  -o FILE, --outfile FILE
                        File of the Reversed DNA strand (default: out.txt)
  -d FILE, --DNA FILE   File with DNA strand (default: DNA.txt)
  ````
Die when wrong file argument is given:

  ````
$ ./DNA-example.py -d foo
"foo" is not a DNA strand
````
Note: To start off with a smaller section of the given string, you can view the first 20 characters in DNA.txt by using
````
$ command | cut -c1-20 DNA.txt
GTCTGCCCCTAGACCAGTAA
````
# Expected Output
````
$ ./DNA-example.py -d DNA.txt
Output file written to "out.txt"
$ cat out.txt
CCAAGTTTAGATGGGCCGAAAAATTTCGCCCGTGATTGCCGGAACTTTAGGAACAAATGCAGTTCAGGTAGGTCA
TGAATGAGTGGTAGGTAATACTTCACTTCAGGGACGCACGCCCGGATTGTGCAGAACGTACCGCTTGCAAACGGT
GGGCTGAAAACGTCAGCTGATTACATCATCCATCCGTTTAGAACTTAAACATTGGTCGTCGTAATTCTTAACCTG
GTCGGGCCAAATGTCCAAACGTCGCTCGACGCACTGACATCACATCTTTAATCCAAGTATAATTCTTAGCCAACG
GTTCCAAAAGTGTACGCCGCCCATGTGATGCAATGCGTGGTTTTTCGACCGAGGCGTTCTTTAACACAGTTTAGC
TCAAACTAATGCTGGGCATGGGACGCATTTTCAGAAGTGGTTTGAGTTTGAAAGTCGCTCTTACTGACGTACTGC
TGAAGGGGATTAATACCTTAATTACACTCTGTTCATTAAAAGTCTGGATGTAGATTGCTTCCCGGCAGAAATGTC
CGGGTAGCCTGAGATACCCTTACTCACGACGCAGCGATGAAACGTGCGTTCTATTAAAAAGTACACCCGGCCCGA
CTTGGTCCACGGCATATCAAACAGTAGCAGTCATGCCGATCTAGGATGAGTGGGACGGCTACAGTGTTTAAGGAA
TATTCCTACGCTGGTGGATGAGCTGCCTTCCTCCGGCTCATAAAGAGCAATCGGAGAGAGGCACATCAACTAACG
AGCGGCCCCTGGTAGGAACCAGAAGAGTTCAACCGGGTCGCACGGCCGGCTATCATCAGGCTCCAATCTATCTAC
CCTCCTCTGATGAGCTACATTTCCGAAGTTCCCGAGGGTTTCCGCTCGTATCACTTAAGGAGATGTGAATTTACT
GGTCTAGGGGCAGAC
````

# Test Suite
Passing tests should look like:
````
$ make test
python3 -m pytest -v test.py
=================================================== test session starts ===================================================
platform darwin -- Python 3.7.0, pytest-4.1.1, py-1.7.0, pluggy-0.8.1 -- /Library/Frameworks/Python.framework/Versions/3.7/bin/python3
cachedir: .pytest_cache
rootdir: /Users/daniellelarson/Reverse_complement_DNA, inifile:
collected 3 items

test.py::test_usage PASSED                                                                                [ 33%]
test.py::test_bad_args PASSED                                                                                [ 66%]
test.py::test_good_input PASSED                                                                                [100%]

================================================ 3 passed in 1.02 seconds =================================================
````

Contact:
Danielle Larson
<EMAIL_ADDRESS>


text:
# Release Notes

The Citrix ADC `xds-adaptor` release notes describe new features, enhancements to existing features, fixed issues, and known issues available in the release. The latest version of `xds-adaptor` is available in the [Quay.io](https://quay.io/citrix/citrix-xds-adaptor) repository.

Release notes may include one or more of the following sections:

**What's new:** The new features and enhancements available in the current release.

**Fixed issues:** The issues that are fixed in the current release.

**Known issues:** The issues that exist in the current release and their workarounds, wherever applicable.

repository: aestheticbanan/citrix-xds-adaptor

repo_name: aestheticbanan/citrix-xds-adaptor


text:
# Cracking-Vigenere-Cipher
python code used to decrypt the vigenere cipher with kerchoffs method

In this method(Kerchoff), we decrypt the vigenere cipher without knowing the actual key

This code finds the top 6 possible key lengths and find the key for only first 4 key lengths

# Code-working conditions
cipher text should be alphabets only. It won't work with symbols.

Given cipher text length should be larger. so that there will maximum probability for finding correct key

# Assumptions
Key length will be between 1 to 30 letters.

But you can increase the value to your requirments by changing the value("30") code in line 16 [while k<30:]


text:
# Time of Use Plan Indicator

This Time of Use Plan Indicator is a [Node-RED][nodered] Flow for the [Raspberry Pi][raspberrypi] and [Ryanteck][ryanteck] TrafficHAT board that indicates active and upcoming [Time-based pricing][time-based-pricing] electric rates.

### Background

My local power company offers several pricing plans that offer discounted rates for most of the day in exchange for accepting higher rates during other times of the day. This plan can work to everyone's advantage when users minimize power consumption during [peak times][srp-tou].

As a household, we have already done many of the obvious improvements (LED lighting, pool pump timer only runs at night and solar hot water). Yet two large consumers remain: the oven and the clothes dryer. The oven is mostly self-correcting because it makes the house uncomfortably warm, however the clothes dryer is a little tricky and this project strives to simplify it.

It's not just a question of comparing the current time to the active winter or summer plan. It also involves ensuring power-consumer equipment isn't started such that it continues to run well into the next on-peak period.

### How it Works

The goal is to blink the green LED during off-peak times and blink the red LED during on-peak times. Also, during the hour immediately prior to the start of an on-peak period, the yellow LED will also blink.

The instructions to users are simply only use the dryer when the green LED is enabled. If the yellow LED is also enabled, ensure the load will complete before the top of the hour.

# Required Equipment

### TrafficHAT

The Ryanteck [TrafficHAT][ryanteck-traffichat] provides green, yellow and red LEDs, as well as a buzzer and a momentary switch. For this application, neither the buzzer nor the switch are necessary.

Raspberry Pi GPIO pins each have three names (for more information about that, see [Appendix 1 here][raspberrypi-40pin]). This table shows how the pins on the TrafficHAT are arranged:

| I/O       | GPI O               |
|-----------|:-------------------:|
| Green     | 15 - GPIO3  - BCM22 |
| Yellow    | 16 - GPIO4  - BCM23 |
| Red       | 18 - GPIO5  - BCM24 |
| Button(*) | 22 - GPIO6  - BCM25 |
| Buzzer    | 29 - GPIO21 - BCM5  |

(*) Suggest using the Raspberry Pi's internal pull up resistor.

### Raspberry Pi

A [Raspberry Pi][raspberrypi] model with [40 pins][raspberrypi-40pin] is also required. Like many others, I've not been able to get my hands on one to test, however, this should be a reasonable application of the [Raspberry Pi Zero][raspberrypi-zero].

Additionally, all the normal Raspberry Pi accessories (SD card, 5Vdc supply) will be needed.

# Software Setup

The ultimate goal for these instructions is to end up with a [Raspberry Pi][raspberrypi] running [Node-RED][nodered]. The following outlines the process I used to setup the software for this application. There are many ways to accomplish this, and many users may already have a Raspberry Pi already setup and ready to go. For those who might not, or want a quick start guide, this should get you there.

### Setup Raspbian Jessie Lite

1) Download the latest [Raspbian Jessie Lite][raspbian-jessie-lite]. The non-lite version can be used as well, if you have the need to use a display. Personally, the thought of have to use a video cable on this doesn't really fit the Nixie aesthetic.
2) Write the image to an SD card. This process is well documented elsewhere, here are some examples for [MAC][setup-mac] and [PC][setup-pc].

### Setup Node-RED

The previous step shows how to open a terminal shell into the Raspberry Pi. Continuing in that shell, the following instructions will get Node-RED started.

Depending on the path that lead to this point, it is possible Node-RED is already installed. Running the following command is a simple way to find out:
```sh
node-red-stop && node-red-start
```
If a message indicating `Start Node-RED` appears, then Node-RED is already installed and the rest of this section can be skipped. However if a message indicating `command not found` appears, then Node-RED will have to be installed. The following instructions outline one way to accomplish that.

Instructions appropriate for a Raspberry Pi are found on the [Node-RED Raspberry Pi][nodered-raspberrypi] getting started guide. In many cases, it just boils down to pasting this block of text in to a terminal window.

```sh
node-red-stop && \
sudo apt-get update && \
sudo apt-get install nodered && \
node-red-start
```

### Opening Node-RED

Once everything is assembled and Node-RED is running, you should be able to open it from a web browser. For a default installation, that will be `http://<raspberry-pi-IP-address>:1880/`. If that doesn't work, check that you have entered the correct IP address for the Raspberry PI. Also, inspect the `setting.js` file and locate the `uiPort` entry. Either of the following commands should help.
```sh
cat /home/pi/.node-red/settings.js | grep uiPort
```
or
```sh
sudo nano /home/pi/.node-red/settings.js
```

### Set the time zone

As this application concerns time, it is appropriate to ensure the local time zone is correctly established. The following command should guide that process. Once complete, it may be necessary to restart Node-RED or reboot the Raspberry Pi for the setting to take affect.
```sh
sudo dpkg-reconfigure tzdata
```

### Using TOU in Node-RED

With Node-RED open and an empty Flow tab visible, select the hamburger button in the upper right to open the menu. From the menu, select Import > Clipboard. Open the `time-of-use-traffic-hat` file, then select and copy it's contents. Return to Node-RED, paste the text and select Ok. Once the new Flow appears under the mouse, move it towards the upper left corner and click once. Select Deploy.

If your hat has a buzzer, it will chirp once when the flow is started.

# Customization for Other Electric Pricing Plans

Most likely your power company's pricing plan is will be different then mine, so feel fork this project and make it your own!

The meat of the project exists in the `Initialize Flow` node where it creates and adds the `findTouState` function. The primary products of this function are returned as the two boolean attributes `isOnPeak` and `isPeakAboutToStart` of `msg.payload`.

As date related calculations are known to be a significant opportunity for introducing errors, unit tests are your friend. Update the `findTouState unit tests` node to reflect changes to the Time Based Pricing structure, then trigger the unit tests. A summary of the results will be displayed in Node-RED's debug tab.

![Node-RED unit test](/images/tou-unit-test-node.png)

### Holidays

My utility does waives the on-peak rates for certain holidays. Initially I considered a solution for calculating when we observe these holidays, but the rules are non-trivial and would have required significant testing. Then I looked into calling a web service, but initially I couldn't find any reasonable options, plus that would have required all instances to have a continual connection to the Internet and possibly some more complicated than necessary caching.

Ultimately, the simplest solution won out: just precalculate these dates for the expected lifetime of the application. Currently, up until the year 2030 the application will work as expected. In 2031 and beyond, the application will treat holidays as peak days.

The specific holidays used by your utility may differ than the ones embedded into this flow. To make changes, open the Initialize Flow node and locate the tou.observedHolidays declaration.

Holidays are gleaned from the excellent [Holiday API][holiday-api] webservice with calls similar to the following. (It is my understanding it may now be required to request and add a API key.)
```
http://holidayapi.com/v1/holidays?country=us&year=2016&month=07
```

### Notes
Before saving the .json file, it was run through the excellent [JSONLint][jsonlint] tool. I have found doing so makes identifying changes from the repository significantly easier than raw Node-RED output.

### Version
1.0.0

### Picture
![Node-RED driving the display hardware](/images/tou-sample1.jpg)

### Tech
This project benefited from other projects:

* [Dillinger] - Made with "Dillinger, the Last Markdown Editor ever."

[//]: # (http://stackoverflow.com/questions/4823468/store-comments-in-markdown-syntax)

[ryanteck]: <https://ryanteck.uk/>
[ryanteck-traffichat]: <https://ryanteck.uk/hats/1-traffichat-0635648607122.html>
[dillinger]: <http://dillinger.io/>
[dillinger-gh]: <https://github.com/joemccann/dillinger>
[holiday-api]: <https://holidayapi.com/>
[jsonlint]: <http://jsonlint.com/>
[nodered]: <http://nodered.org/>
[nodered-raspberrypi]: <http://nodered.org/docs/hardware/raspberrypi>
[raspberrypi]: <https://www.raspberrypi.org/>
[raspberrypi-40pin]: <https://www.raspberrypi.org/documentation/usage/gpio-plus-and-raspi2/>
[raspberrypi-zero]: <https://www.raspberrypi.org/products/pi-zero/>
[raspbian-jessie-lite]: <https://www.raspberrypi.org/downloads/raspbian/>
[setup-mac]: <https://www.raspberrypi.org/forums/viewtopic.php?t=74176>
[setup-pc]: <http://www.circuitbasics.com/raspberry-pi-basics-setup-without-monitor-keyboard-headless-mode/>
[srp-tou]: <http://www.srpnet.com/prices/home/tou.aspx>
[time-based-pricing]: <https://en.wikipedia.org/wiki/Time-based_pricing>


text:
# Studio

## Reference
* [Create, Build, and Serve Apps with the Vue CLI - YouTube](https://www.youtube.com/watch?v=WmrawkHYMTg)
* [安装 | Vue CLI](https://cli.vuejs.org/zh/guide/installation.html)

gha_language: Vue


text:
---

layout: pattern-detail
group: user-interface
subgroup: tokens
permalink: /user-interface/tokens/tokens-heading

title: Heading
id: 10-tokens-10-globals-heading
plid: tokens-heading
description:
status:

meta:
- updated: April 2, 2019

---

## Getting Started

Headings help define the hierarchy and structure of content within a page by visually breaking text into sections and subsections. Headings also help identify content in terms of level of importance and groups content by overarching topics or themes. Proper usage of headings is especially crucial for accessibility.

###### EXPORT VIA GRUNT

```
grunt export:tokens-heading
```

### Description

The heading token allows you to include a heading within another pattern. All headings are rendered using the `.heading` class. Refer to our typography guide to preview our [Heading Styles][tokens-heading].

### Best Practices

- A page should only ever contain a single level one heading
- Heading levels should always decend hierarchically down the page

## Schema

Optionally, build a table to identify any pattern schematics that are pertinent for developers to be aware of. A sample schema table is given below.

| Name        | Type        | Description                                         | Value(s)            | Default   |
|-------------|-------------|-----------------------------------------------------|---------------------|-----------|
| level       | `Number`    | The level of the heading.                           | `1`-`6`             |           |
| heading     | `String`    | The heading text to be displayed.                   |                     |           |
| alternate   | `Boolean`   | Whether to use the alternate heading style, for heading levels `1` or `5`.  | `true` or `false` | `false`    |

[tokens-heading]: /patterns/00-meta-30-typography-headings/00-meta-30-typography-headings.html

repository: emory-libraries/style-guide-guide

gha_language: HTML

repo_name: emory-libraries/style-guide-guide


text:
# CRC32C

[![Crates.io](https://img.shields.io/crates/v/crc32c.svg)](https://crates.io/crates/crc32c)
[![Docs.rs](https://docs.rs/crc32c/badge.svg)](https://docs.rs/crc32c/)
[![Travis](https://travis-ci.org/zowens/crc32c.svg?branch=master)](https://travis-ci.org/zowens/crc32c/)

Rust implementation of the CRC-32-Castagnoli algorithm with hardware acceleration where possible.

Hardware accelleration on the following architectures:
1. **x84-64** with [SSE 4.2](https://software.intel.com/sites/default/files/m/8/b/8/D9156103.pdf)
    * All stable versions of Rust
    * If SSE 4.2 is enabled at compile time, it will only build the SSE implementation. Otherwise, the `cpuid` is used to find the best implementation at runtime.
1. **aarch64** with [crc feature](https://developer.arm.com/documentation/dui0801/g/A32-and-T32-Instructions/CRC32C)
    * Only available on nightly (enabled by default without feature)

All other processors utilize a software fallback.

## Usage

First, add this to your `Cargo.toml`:

```toml
[dependencies]
crc32c = "0.6"
```

```rust
extern crate crc32c;

fn main() {
    let message = b"Hello world!";
    let crc = crc32c::crc32c(message);

    println!("hash = {}", crc);
}
```

## License
You may use this code under either the [Apache 2.0 license](https://www.apache.org/licenses/LICENSE-2.0)
or the [MIT license](https://opensource.org/licenses/MIT), at your option.

gha_language: Rust


text:
# erbi-trime
a simple erbi keykoard and exported dictonary from “极点二笔 v7.15” for trime.apk on android device

## screenshot
the numbers and symbols keyboard pad are designed based on ios keybarod

![screenshot1](https://github.com/yeeac/erbi-trime/blob/main/screenshot1.png)

![screenshot1](https://github.com/yeeac/erbi-trime/blob/main/screenshot2.png)

## how to use
1. install trime.apk to your android device, run once then quit
2. upload *.yaml to your inner storage system, something like "/storage/emulated/0/rime"
3. run app trime again, choose your keyboard --> theme as 极点二笔, choose input --> scheme as 极点二笔
4. deploy and have fun to use it
5. I left enough key space for the key "123", intended to make a emoji key button, but not finished yet

repository: yeeac/erbi-trime

repo_name: yeeac/erbi-trime


text:
# GraphQL implementation for InterSystems Data Platforms

[![Gitter](https://img.shields.io/badge/chat-on%20telegram-blue.svg)](https://t.me/joinchat/FoZ4M0Gl5vGiZ-e0HvFOUQ)
[![Gitter](https://img.shields.io/badge/article-on%20community-blue.svg)](https://community.intersystems.com/post/graphql-intersystems-data-platforms)
[![Demo](https://img.shields.io/badge/Demo%20on-Cloud%20Run%20Deploy-F4A460)](https://graphql.demo.community.intersystems.com/graphiql/index.html):

## Install GraphQL
1) Download the [last release](https://github.com/intersystems-ru/GraphQL/releases).
2) Import it to the target Caché namespace, f.e. to `SAMPLES`.
3) Create new web aplication:
    - Name - `/`
    - Namespace - your target namespace, f.e. `SAMPLES`
    - Dispatch Class - `GraphQL.REST.Main`

## Install GraphiQL
1) Use an [available release](https://github.com/intersystems-ru/GraphQL/releases) or [build](https://github.com/graphql/graphiql) it on your own
2) Create new web aplication:
    - Name - `/graphiql`
    - Namespace - your target namespace, f.e. `SAMPLES`
    - CSP Files Physical Path - f.e. `C:\InterSystems\GraphiQL\`

## Installation with ZPM

If the current ZPM instance is not installed, then in one line you can install the latest version of ZPM even with a proxy.
```
s r=##class(%Net.HttpRequest).%New(),proxy=$System.Util.GetEnviron("https_proxy") Do ##class(%Net.URLParser).Parse(proxy,.pr) s:$G(pr("host"))'="" r.ProxyHTTPS=1,r.ProxyTunnel=1,r.ProxyPort=pr("port"),r.ProxyServer=pr("host") s:$G(pr("username"))'=""&&($G(pr("password"))'="") r.ProxyAuthorization="Basic "_$system.Encryption.Base64Encode(pr("username")_":"_pr("password")) set r.Server="pm.community.intersystems.com",r.SSLConfiguration="ISC.FeatureTracker.SSL.Config" d r.Get("/packages/zpm/latest/installer"),$system.OBJ.LoadStream(r.HttpResponse.Data,"c")
```
If ZPM is installed, then ZAPM can be set with the command
```
zpm:USER>install isc-graphql
```
## Installation with Docker

## Prerequisites
Make sure you have [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git) and [Docker desktop](https://www.docker.com/products/docker-desktop) installed.

## Installation
Clone/git pull the repo into any local directory

```
$ git clone https://github.com/intersystems-community/GraphQL.git
```

Open the terminal in this directory and run:

```
$ docker-compose build
```

3. Run the IRIS container with your project:

```
$ docker-compose up -d
```

## Example
Query and Result

![sample](https://pp.userapi.com/c837337/v837337052/61752/mXbbCHhBl9M.jpg)     ![sample](https://pp.userapi.com/c837337/v837337052/6173c/6elLjldPiRA.jpg)

![sample](https://pp.userapi.com/c837337/v837337052/61761/vPCZvIXgcJk.jpg)     ![sample](https://pp.userapi.com/c837337/v837337052/6174b/Zd2000W64HI.jpg)

## Example queries for copy and past on [![Demo](https://img.shields.io/badge/Demo%20on-Cloud%20Run%20Deploy-F4A460)](https://graphql.demo.community.intersystems.com/graphiql/index.html):

**Queries can be simple and complex for several sets of data**
```graphql
{
  Sample_Person{
    Name
    DOB
    FavoriteColors
    Office {
      City
      State
      Street
      Zip
    }
  }
  Sample_Company{
    Mission
    Name
    Revenue
  }
}
```

**Filtering**

At the moment, only strict equality is supported:

```graphql
{
  Sample_Person(id: 116){
    id
    Name
    DOB
    FavoriteColors
    Home {
      City
      State
      Street
      Zip
    }
    Office {
      City
      State
      Street
      Zip
    }
  }
}
```

**Pagination**

Pagination is supported through 4 functions that can be combined to achieve the necessary result:

- after: n – all records with id greater than n
- before: n – all records with id smaller than n
- first: n – first n records
- last: n – last n records

```graphql
{
  Sample_Employee(after: 120, before: 123){
    id
    Name
  }

  Sample_Person(first: 2){
    id
    Home {
      City
      State
      Street
      Zip
    }
  }
  Sample_Company(last: 3){
    id
    Name
  }
}
```

repository: intersystems-community/GraphQL

gha_language: Apex

repo_name: intersystems-community/GraphQL


text:
Staxel - Item hotbar mod

    <img src="https://img.shields.io/badge/Steam-release-blue.svg?style=flat" alt="v<IP_ADDRESS>" />

	Sunbeam source

This mod is derived from Sunbeam and replaces the item wheel in the bottom right of the screen for a more traditional item hotbar
that get's shown in the center at the bottom of the screen. The new item hotbar is more in line with the hotbars you see in
other games.

repository: BarryBadpak/Staxel-ItemWheelMod

repo_name: BarryBadpak/Staxel-ItemWheelMod


text:
---
layout: post
title: A good student is one who ?
category: life
---

For French class we had to write a short paragraph completing the sentence "A good student is one who ______". The next day, we started class by writing our responses on the chalkboard. When I took my seat, I started to read what my classmates had wrote. "Takes good notes", "gets good grades", "goes to office hours", and "always goes to class" were the most popular responses. I was shocked that nobody had written anything similar to me. My first sentence was *"Il adore apprendre"*, **"he loves to learn."**

After we had finished discussing the qualities of a good student, the instructor gave a follow up question: "a well-raised child is one who ______ ?" Again, we were sent to the chalkboard to transcribe our thoughts. *"Poli"* was the word on everyones' lips. **"Polite"**, good kids were polite. Again, the class seemed to confuse "well-raised" with "well-behaved". Not a single person mentioned being imaginative or creative or loving.

Maybe I have a different perspective because I am about to graduate and most of my classmates are freshmen and sophomores.

I am hoping that's it.

extension: markdown


text:
# mNeuron: A Matlab Plugin to Visualize Neurons from Convolutional Neural Network (CNN)

## Features:
- Result: [**Visualization Page**](http://vision03.csail.mit.edu/cnn_art/index.html), [**arxiv**](http://vision03.csail.mit.edu/cnn_art/data/cnn_visual_arxiv.pdf)
- Support models from [**caffe (June 2016)**](https://github.com/BVLC/caffe) and [**matconvnet (1.0-beta12, May 2015)**](http://www.vlfeat.org/matconvnet/)

(caffe support: AlexNet/VGG-16/NIN/GoogleNet; matconvet support: AlexNet)

## Download Pre-train Models:
- [**link**](http://vision03.csail.mit.edu/cnn_art/models/) and put under models/
- Edit **param_init.m**: caffe/matcaffe location

## Demos:
1. Visualize single neurons from CNN model:
  1. Edit and run: **V_neuronInv.m**

2. Image Completion
  1. Download object topics
     [**link**](http://vision03.csail.mit.edu/cnn_art/fc7-topic.zip) and put under data/fc7-topic/
  2. Edit and run: **V_inpaint.m**

3. Feature Inversion, same as [**deep-goggle**](https://github.com/aravindhm/deep-goggle)
  1. Edit and run: **V_featInv.m**

## Under Construction
1. Visualize Intra-class variation
2. Visualize hierarchical binary CNN code

## Update
- 2016.11: bug fixed
- 2016.08: code organization
    - update caffe version to June 2016
    - add links to compatible CNN models
- 2016.04: add object insertion
    - object insertion (V_app_inpaint.m)
- 2015.07: initial release
    - support caffe (July 2015) and matconvnet (1.0-beta12, May 2015)
    - single neuron visualization (V_neuron_single.m)

## Acknowledgement
The code is heavily based on aravindhm's [**deep-goggle**](https://github.com/aravindhm/deep-goggle)

repository: srividya-raju/mNeuron

repo_name: srividya-raju/mNeuron


text:
## AnyCode ##

This extension allows you to run any code in a docker container in Azure Container Instances

### Why is this awsome? ###
Using ACI (Azure Container Instances) form VSTS allows you to trigger any task that can be wrapped in a container from VSTS or TFS. This means you're no longer limited to what a specific agent provides - instead you fire up a container in ACI to do what you want it to do and run a given task. The logs of the container will be displayed in your VSTS logs.

### Quick steps to get started ###

Provide the following info:
 - Service Prinicpal: Your ID for your service principal on Azure
 - Password: Password of your service prinicpal
 - Tenant: Azure tenant to be used

 - Resource Group: Resource Group on Azure (will be created if it doesn't exist)
 - Container Name: Name of your container instance.

 - image: Name of container image. Currently no login credentials for a custom registry can be used.
 - environment variables: If you want to pass environment variables put them in this field. Do not comma-separate them.

### Known issue(s) - READ THIS

Currently this is a very early version which serves rather as a proof of concept than a product. Here a some issues:

- Supports Linux Containers only
- Make sure you use self-terminating containers (task containers) - otherwise they will run forever and cost you money!
- Errors within the task are not captured (at all!)
- Configuration of ACI instance is limited
- No support for custom container registry yet
- No support to pass & share files from and to the container in place (Workaround could be an additional environment variable you introduce)
- Service Prinicpal access required
- SP has to have permission to create resource groups
-

### Where's the source ###
Here: https://github.com/DanielMeixner/vsts-task-anycode

### Minimum supported environments ###

- Visual Studio Team Services, didn't try it on TFS.

### Feedback ###
- Add a review below. I'm mostly interested if this seems valuable to you at all. Thanks a lot.

repository: DanielMeixner/vsts-task-anycode

repo_name: DanielMeixner/vsts-task-anycode


text:
Returns a table of hosts and thers Trend Micro IDs.

## Script Data
---

| **Name** | **Description** |
| --- | --- |
| Script Type | python |
| Tags | Trend Micro |

## Dependencies
---
This script uses the following commands and scripts.
* trendmicro-host-retrieve-all

## Inputs
---

| **Argument Name** | **Description** |
| --- | --- |
| hostname | The ID's to retrieve from a given hostname. This can be a list. |

## Outputs
---
There are no outputs for this script.

repository: demisto/content

gha_language: Python

repo_name: demisto/content


text:
---
# An instance of the Experience widget.
# Documentation: https://wowchemy.com/docs/page-builder/
widget: experience

# This file represents a page section.
headless: true

# Order that this section appears on the page.
weight: 40

title: Experience
subtitle:

# Date format for experience
#   Refer to https://wowchemy.com/docs/customization/#date-format
date_format: Jan 2006

# Experiences.
#   Add/remove as many `experience` items below as you like.
#   Required fields are `title`, `company`, and `date_start`.
#   Leave `date_end` empty if it's your current employer.
#   Begin multi-line descriptions with YAML's `|2-` multi-line prefix.
experience:
  - title: Main Contributor
    company: NIUVS Team
    company_url: 'http://5guav.com.cn'
    location: Xi'an, Shaanxi
    date_start: '2019-04-01'
    date_end: ''
    description: |2-
        Responsibilities include:

        * **Computer Vision**: Implemented a set of deep learning and classical computer vision algorithms in Python (PyTorch) and OpenCV for object detection, tracking and aiming.
        * **Communication**: Enabled 5G broadband cellular communication for operating range exceeding 1K+ miles.
        * **Control Platform**: Established a Cloud-based data storage and processing system for real-time flight monitoring and management.
        * **Software**: Built a control application in C# and Linux, allowing two-way real-time flight control and flight data visualization.

  - title: Team Leader
    company: iGuaDa WeChat Mini Program
    company_url: 'https://www.ilovenpu.com/'
    location: Xi'an, Shaanxi
    date_start: '2019-04-01'
    date_end: '2020-10-15'
    description: |2-
        Responsibilities include:

        * Led a team develop a WeChat mini program to help users to quickly check the class schedule, remind of courses, and share learning materials on campus
        * Organized numerous meetings to drive brainstorming, alignment and troubleshooting
        * Significantly bolstered technical leadership and interpersonal skills

  - title: Team Member
    company: High dynamic obstacle avoidance technology of 5G network-connected UAV
    company_url: ''
    location: (National Engineering Laboratory of Big Data Application Technology for Air, Space, Ground and Sea Integration, NPU)
    date_start: '2020-07-10'
    date_end: '2020-08-20'
    description: |2-
        * A method of removing self movement from the stream of events proposed by Mitrokhin etc. was referenced. A density-based clustering algorithm and self-trained neural network were used to segment the target obstacles. Finally, the speed of the obstacle is calculated by the optical flow method, so that the UAV can avoid obstacles.
        * Establish a rapid obstacle avoidance system of the UAV, use an event camera (an open simulation data set) to conduct the environment perception of the unmanned system, reduce the environment perception time of the unmanned system to level 10MS.

  - title: Team Leader
    company: Intelligent Door Lock System Of A Vehicle Based On Artificial Intelligence
    company_url: 'https://www.ilovenpu.com/'
    location: Xi'an, Shaanxi
    date_start: '2018-04-01'
    date_end: '2019-04-01'
    description: |2-
        Responsibilities include:

        * Led a team of three to design and build a car door lock that could be unlocked by using face recognition without the key.
        * Design the mechanical structure of car door locks and make the prototype by 3D printing.
        * Integrate the bluetooth module, camera, Jetson nano and cloud system, enabling face recognition and remote unlock.

---


text:
# Change Log

All notable changes to this project will be documented in this file.
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

# [11.0.0](https://github.com/Botfuel/botfuel-dialog/compare/v10.0.2...v11.0.0) (2018-08-02)

**Note:** Version bump only for package test-complexentities

## [10.0.2](https://github.com/Botfuel/botfuel-dialog/compare/v10.0.1...v10.0.2) (2018-07-18)

# [10.0.0](https://github.com/Botfuel/botfuel-dialog/compare/v9.0.3...v10.0.0) (2018-07-18)

### Features

* Catch dialog and view allow the bot to gracefully handle errors. ([792a597](https://github.com/Botfuel/botfuel-dialog/commit/792a597))

# [9.0.0](https://github.com/Botfuel/botfuel-dialog/compare/v8.3.0...v9.0.0) (2018-07-03)

**Note:** Version bump only for package test-complexentities

## [8.0.4](https://github.com/Botfuel/botfuel-dialog/compare/v8.0.3...v8.0.4) (2018-06-06)

**Note:** Version bump only for package test-complexentities

# [8.0.0](https://github.com/Botfuel/bot-sdk2/compare/v7.2.6...v8.0.0) (2018-05-22)

### Bug Fixes

* fix links to concepts and getting-started in new doc ([7db8e28](https://github.com/Botfuel/bot-sdk2/commit/7db8e28))

# [7.0.0](https://github.com/Botfuel/bot-sdk2/compare/v5.1.7...v7.0.0) (2018-04-18)

**Note:** Version bump only for package test-complexentities

## [5.1.1](https://github.com/Botfuel/botfuel-dialog/compare/v5.1.0...v5.1.1) (2018-04-16)

**Note:** Version bump only for package test-complexentities

# [5.1.0](https://github.com/Botfuel/botfuel-dialog/compare/v5.0.0...v5.1.0) (2018-04-16)

### Bug Fixes

* Fix lerna run style ([b7206ea](https://github.com/Botfuel/botfuel-dialog/commit/b7206ea))

# [5.0.0](https://github.com/Botfuel/botfuel-dialog/compare/v4.4.3...v5.0.0) (2018-04-03)

### Bug Fixes

* fix style ([3108976](https://github.com/Botfuel/botfuel-dialog/commit/3108976))

### Code Refactoring

* (breaking change) store prompt dialog in brain with new strucutre {entities: ..., question:...} ([599b8c8](https://github.com/Botfuel/botfuel-dialog/commit/599b8c8))

### BREAKING CHANGES

* this can cause conflict on running bot with MongoBrain

# [4.0.0](https://github.com/Botfuel/botfuel-dialog/compare/v3.0.1...v4.0.0) (2018-03-02)

### Bug Fixes

* Fix greetings dialog ([de03b2e](https://github.com/Botfuel/botfuel-dialog/commit/de03b2e))

## [2.1.1](https://github.com/Botfuel/botfuel-dialog/compare/v2.1.0...v2.1.1) (2018-02-15)

**Note:** Version bump only for package test-complexentities

## [1.8.3](https://github.com/Botfuel/bot-sdk2/compare/v1.8.2...v1.8.3) (2018-02-09)

**Note:** Version bump only for package test-complexentities

## [1.8.2](https://github.com/Botfuel/botfuel-dialog/compare/v1.8.1...v1.8.2) (2018-02-06)

**Note:** Version bump only for package sample-botfuel-dialog-complexentities

# [1.8.0](https://github.com/Botfuel/bot-sdk2/compare/v1.7.1...v1.8.0) (2018-02-01)

**Note:** Version bump only for package sample-botfuel-dialog-complexentities

# [1.6.0](https://github.com/Botfuel/bot-sdk2/compare/v1.5.0...v1.6.0) (2018-01-22)

### Features

* Add changelog ([65660ef](https://github.com/Botfuel/bot-sdk2/commit/65660ef))

repository: rasata/botfuel-dialog

repo_name: rasata/botfuel-dialog


text:
# Crossfit Tracker RESTful API
PHP RESTful API for the Crossfit Tracker Application

## Stack
- PHP (v7)
- Symfony (v4)
- Doctrine (v2.5.11)

## Design Decisions
The Symfony framework was chosen when designing this API as the web client is written
in Angular and what both of these frameworks have in common is the use of Dependency Injection.

Doctrine was used as an Object Relational Mapping tool. Doctrine integrates seamlessly into
the Symfony framework.

I attempted to follow OOP principles as much as possible with the design of this application by ensuring
each object is responsible for its own behaviour and by abstracting the code as much as possible.

## Running the application

Ensure you have PHP and Composer installed before running any of the following commands.
Also ensure you have the curl extension enabled on your php.ini file.

Run the composer install:

    $ composer install

The most ideal way to run the application is using docker and docker compose.
If you have these installed, execute the following commands:

    $ docker-compose build
    $ docker-compose up -d

Now would be an ideal time to start up the frontend application as it takes roughly 5 seconds for the
API to start up.

If you do not have docker, you can run the following commands:

    $ composer install

Then you can run the dev web server:

    $ php -S localhost:8080 -t public

Make sure you have a local MySQL instance. The script to create the database is at the following location:

    $ .docker/mysql/scripts/init_db.sql

You will then need to modify the .env file to point to your local instance:

    DATABASE_URL=mysql://root:root@mysql:3306/crossfit_tracker
    # Comment out the above property and uncomment below for running locally
    #DATABASE_URL=mysql://root:root@localhost:3306/crossfit_tracker

From there, run the migrations to initialize the database:

    $ php bin/console doctrine:migrations:migrate --no-interaction --allow-no-migration

The API will be available at http://localhost:8080

repository: JOlsen-Neslo/crossfit-tracker-api

repo_name: JOlsen-Neslo/crossfit-tracker-api


text:
# Buttercup Vault Importer
> Import vaults from other password managers

[![npm](https://img.shields.io/npm/v/@buttercup/importer?color=green&label=%40buttercup%2Fimporter)](https://www.npmjs.com/package/@buttercup/importer) [![minium node version](https://img.shields.io/badge/node%20version-%3E%3D%208.x-blue.svg)](https://github.com/buttercup/buttercup-importer) [![Build Status](https://travis-ci.org/buttercup/buttercup-importer.svg?branch=master)](https://travis-ci.org/buttercup/buttercup-importer) ![npm downloads](https://img.shields.io/npm/dm/buttercup-importer.svg?maxAge=2592000)

## About

This vault importer coverts password vaults from other formats to the Buttercup vault format (BCUP).

### Usage

This library is not intended to be used as a standalone application. Its functionality is available via the Buttercup Desktop applications.

You can of course use the importer in your own projects, by importing the individual importers.

Eg.

```javascript
const { KDBXImporter } = require("@buttercup/importer");

KDBXImporter.loadFromFile("...");
```

Check out the [API documentation](API.md).

### Supported platforms
The importer requires Node **8** or higher.

### Supported password archive formats

* ![KDBX (keepass)](https://img.shields.io/badge/KDBX-Full-brightgreen.svg) KeePass 2 archives (KDBX v3 and v4)
* ![Lastpass](https://img.shields.io/badge/CSV-Full-brightgreen.svg) Lastpass archives
* ![1Password](https://img.shields.io/badge/1PIF-Most-brightgreen.svg) 1Password PIF files (exported)
* ![Buttercup](https://img.shields.io/badge/CSV-Most-brightgreen.svg) Buttercup archives (exported)
* ![CSV](https://img.shields.io/badge/CSV-Basic-brightgreen.svg) CSV files (generic)

### Importing from 3rd-party managers

#### KeePass

KeePass vaults can be imported using either of the 2 supported importers:

 * KeePass XML (version 2) - `KeePass2XMLImporter`
 * KDBX vaults (up to, and including, version 4) - `KDBXImporter`

This library supports both version 3 and 4 of the KDBX format, including the newly required argon2 hashing feature. Key files are also supported.

#### 1Password

1Password vaults can be imported from `1pif` directories using the `OnePasswordImporter` module.

Imported 1Password archives may lose some information regarding their type (eg. Credit cards). The 1Password Importer supports importing the following types:

* Web Forms
* Passwords
* Credit Cards
* Software Licenses
* Emails
* SSNs
* Router Passwords

#### LastPass

Lastpass credentials can be exported as CSV files, which can be imported using Buttercup importer.

#### Bitwarden

Bitwarden credentials can be exported as JSON files, which can be imported using Buttercup importer.

Imported bitwarden archives contain the username, password, the first url associated with the item, notes and any custom fields. Attachments are not currently supported.

### Buttercup

Buttercup vaults can be imported using the `ButtercupImporter`.

### Importing from Buttercup exports

Exported Buttercup vaults can be re-imported into a new Vault. Take the exported CSV file and import that in Buttercup Desktop.

repository: stuartm/buttercup-importer

repo_name: stuartm/buttercup-importer


text:
# DeckDeckGo - Gamepad

Create a PWA presentation using Web Components, [Ionic](http://ionicframework.com) components and HTML or Markdown 🚀

Cherry on the cake 🍒🎂 [DeckDeckGo] comes with a [Progressive Web App](https://deckdeckgo.app) to remote control your slides 📱

## Table of contents

- [Gamepad](#gamepad)
- [Getting Started](#getting-started)
  - [Using from a CDN](#using-from-a-cdn)
  - [Install from NPM](#install-from-npm)
  - [Framework integration](#framework-integration)
- [Usage](#usage)
- [Develop](#develop)
- [License](#license)

## Gamepad

This project allows you to control your [DeckDeckGo] presentation with a Gamepad. Under the hood, it relies on [@gamepad/core](https://github.com/natemoo-re/gamepad), a wrapper around the Web's [Gamepad API](https://developer.mozilla.org/en-US/docs/Web/API/Gamepad_API). Currently, it supports Nintendo's [Joy-Con](https://en.wikipedia.org/wiki/Joy-Con), but if you'd like to see support for your favorite controller, feel free to [open an issue](https://github.com/natemoo-re/gamepad/issues) on the Gamepad repository.

## Getting Started

If you just wish to give a try, jump to the [Develop](#develop) chapter of this readme.

Otherwise, start first your new new presentation like described in the quick  👉 [Getting Started guide](https://docs.deckdeckgo.com/docs) 👈

Once done, install this Web Component as described in the following chapters and implement its usage as described in the [Usage](#usage) chapter of this readme or have a look at the provided examples in [src/index.html](src/index.html).

### Using from a CDN

It's recommended to use [unpkg](https://unpkg.com/) to use this component from a CDN. To do so, add the following include script in the main HTML file of your project:

```
<script<EMAIL_ADDRESS>```

### Install from NPM

Install it in your project from [npm](https://www.npmjs.com/package/deckdeckgo) using the following command:

```bash
npm install deckdeckgo-gamepad
```

### Framework integration

The [Stencil documentation](https://stenciljs.com/docs/overview) provide examples of framework integration for [Angular](https://stenciljs.com/docs/angular), [React](https://stenciljs.com/docs/react), [Vue](https://stenciljs.com/docs/vue) and [Ember](https://stenciljs.com/docs/ember).

### Usage

```html
  <deckgo-gamepad></deckgo-gamepad>

  <deckgo-deck></deckgo-deck>
```

## Develop

To develop and run this Web Component locally, proceed as following:

```
git clone https://github.com/deckgo/deckdeckgo-gamepad
cd deckdeckgo-gamepad
npm install
npm run start
```

## License

MIT © [Nate Moore](https://natemoo.re) and [David Dal<EMAIL_ADDRESS>
[DeckDeckGo]: https://deckdeckgo.com

repository: deckgo-community/gamepad

repo_name: deckgo-community/gamepad


text:
# JavaScript Quiz
## Link to Site
 https://sir-meee.github.io/JavaScript-Quiz/
## BDD
 Specification: JavaScript Quiz
  * Mark out your answers
  * Submit answers
  * The program checks the results in the backend
  * The program returns the result.
#### A JavaScript Quiz App with questions on the topic., 24th September 2018
#### By **Sammy**
## Description
A JavaScript Quiz App with questions on the topic, that returns your result at the end.
## Setup/Installation Requirements
No setup required. All you need is internet connection.
## Known Bugs
No known bugs at the moment
## Technologies Used
HTML, CSS, BOOTSTRAP, JQUERY, JAVASCRIPT.
## Support and contact details
email<EMAIL_ADDRESS>### License
MIT License Copyright (c) 2018 Sammy Mutua Mbevi

repository: sir-meee/JavaScript-Quiz

repo_name: sir-meee/JavaScript-Quiz


text:
[总结](http://blog.csdn.net/Asun0204/article/details/78131609)

[Overview](http://ruder.io/optimizing-gradient-descent/index.html)

**What you should remember**:
- The difference between Gradient Descent, mini-batch Gradient Descent and stochastic Gradient Descent is the number of examples you use to perform one update step.
- You have to tune a learning rate hyperparameter **a(阿尔法)**
- With a well-turned mini-batch size, usually it outperforms either Gradient Descent or stochastic Gradient Descent (particularly when the training set is large).

### Gradient Descent
#### mini-batch Gradient Descent
if mini-batch size = m, => batch Gradient Descent
if mini-batch size = 1, => stochastic Gradient Descent
if mini-batch size between (1,m), =>

##### notes
- Shuffling and Partitioning are the two steps required to build mini_batches
- Powers of two are often chosen to be the mini-batch size

##### features
<!-- - not need to wait one epoch finished -->
- fast

#### SGD (stochastic Gradient Descent)
##### 3 for-loops in total
- Over the number of iterations
- Over the m training examples
- Over the layers (update parameters)

##### features
- never converge, always kind of oscillate and wander around the region of the minimum
- lose all your speed up from vertorization ( matrix calculate )
- decrease the learning_rate slowly,SGD shows the same convergence behavior like batch GD

### Optimization method
#### Momentum

> The momentum term increases for dimensions whose gradients point in the same directions and reduces updates for dimensions whose gradients change directions. As a result, we gain faster convergence and reduced oscillation

##### Formula
V(dW)t = beta1 * V(dW)t + (1 - beta1) * dW

W = W - learning_rate * V(dW)t

V(db)t = beta1 * V(db)t + (1 - beta1) * db

b = b - learning_rate * V(db)t

##### notes
- The velocity is initialized with zeros. So the algorithm will take a few iterations to "build up" velocity and start to take bigger steps. (or see **V(dW)t_corrected = V(dW)t / (1 - beta ^ t)**)
- `beta` = `0`, means normal Graident Descent
- the large beta, the smoother the update. (about 1/(1-beta), see Exponentially Weighted Averages)

#### RMSprop
##### Formula
S(dW)t = beta2 * S(dW)t + (1 - beta2) * dW^2

W = W - learning_rate * dW / sqrt(S(dW)t + e)

S(db)t = beta2 * S(db)t + (1 - beta2) * db^2

b = b - learning_rate * db / sqrt(S(db)t + e)

e ≈ 1e-8  (suggested)

#### Adam

##### Formula
V(dW)t = beta1 * V(dW)t + (1 - beta1) * dW

V(dW)t_corrected = V(dW)t / (1 - beta1 ^ t)

V(db)t = beta1 * V(db)t + (1 - beta1) * db

V(db)t_corrected = V(db)t / (1 - beta1 ^ t)

S(dW)t = beta2 * S(dW)t + (1 - beta2) * dW^2

S(db)t = beta2 * S(db)t + (1 - beta2) * db^2

W = W - learning_rate * V(dW)t_corrected / sqrt(S(dW)t + e)

b = b - learning_rate * V(db)t_corrected / sqrt(S(db)t + e)

beta1 -> 0.9

beta2 -> 0.999

e ≈ 10 ^ (-8)  (avoid dividint by zero)

#### Conclusion
- make sure mini-batch fit the CPU/GPU memory
- The difference between gradient descent, mini-batch gradient descent and stochastic gradient descent is the number of examples you use to perform one update step.
- You have to tune a learning rate hyperparameter  αα .
- With a well-turned mini-batch size, usually it outperforms either gradient descent or stochastic gradient descent (particularly when the training set is large).

repository: pppluto/ml

repo_name: pppluto/ml


text:
---
author: kubu4
comments: true
date: 2018-03-20 17:54:57+00:00
layout: post
slug: dna-isolation-quantification-geoduck-larvae-metagenome-filter-rinses
title: DNA Isolation & Quantification - Geoduck larvae metagenome filter rinses
wordpress_id: 3142
author:
  - kubu4
categories:
  - Miscellaneous
tags:
  - DNA Isolation
  - DNazol
  - geoduck
  - Panopea generosa
  - Qubit 3.0
  - Qubit dsDNA HS
---

Isolated DNA from two of the [geoduck hatchery metagenome samples Emma delivered on 20180313](https://robertslab.github.io/sams-notebook/2018/03/13/samples-received-geoduck-larvae-metagenome-filter-rinses.html) to get an idea of what type of yields we might get from these.

  * MG 5/15 #8

  * MG 5/19 #6

As mentioned in my notebook entry upon receipt of these samples, I'm a bit skeptical will get any sort of recovery, based on sample preservation.

Isolated DNA using [DNAzol (MRC, Inc.)(https://github.com/RobertsLab/resources/blob/master/protocols/Commercial_Protocols/MRC_DNAzol_GENOMIC_DNA_ISOLATION_REAGENT.pdf) in the following manner:

  1. Added 1mL of DNAzol to each sample; mixed by pipetting.

  2. Added 0.5mL of 100% ethanol; mixed by inversion.

  3. Pelleted DNA 5,000g x 5mins @ RT.

  4. Discarded supernatants.

  5. Wash pellets (not visible) with 1mL 75% ethanol by dribbling down side of tubes.

  6. Pelleted DNA 5,000g x 5mins @ RT.

  7. Discarded supernatants and dried pellets for 5mins.

  8. Resuspended DNA in 20uL of Buffer EB (Qiagen).

Samples were quantified using the Roberts Lab Qubit 3.0 with the Qubit High Sensitivity dsDNA Kit (Invitrogen).

5uL of each sample were used.

#### Results:

As expected, both samples did not yield any detectable DNA.

Will discuss with Steven on what should be done with the remaining samples.

repository: RobertsLab/sams-notebook

gha_language: Shell

repo_name: RobertsLab/sams-notebook


text:
---
name: Bug report Vertical tab
about: Report a bug with the "Tab Center Reborn" extension integration (gnomeTheme.extensions.tabCenterReborn)
title: "[Vertical tab - Extension]"
labels: bug
assignees: BirdInFire

---

**Describe the bug**
<!-- A clear and concise description of what the bug is. -->

**To Reproduce**
<!-- Steps to reproduce the behavior: -->
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error

**Expected behavior**
<!-- A clear and concise description of what you expected to happen.. -->

**Screenshots**
<!-- If applicable, add screenshots to help explain your problem. -->

**Setup information**
 - OS: <!-- e.g. Fedora, Ubuntu -->
 - Installation method: <!-- e.g. RPM, Flatpak, AUR -->
 - Firefox version: <!-- e.g. 108 -->
 - Theme version: <!-- e.g. v108, master, commit -->
 - Optional features enabled: <!-- e.g. gnomeTheme.hideSingleTab -->

**Additional context**
<!-- Add any other context about the problem here. -->

license: Unlicense

repository: rafaelmardojai/firefox-gnome-theme

gha_language: CSS

gha_license_id: Unlicense

repo_name: rafaelmardojai/firefox-gnome-theme


text:
# Lemon Cake

Gluten-free lemon cake.

*gluten-free, cake, lemons, dessert*

---

- *300g* dairy-free margarine (suitable for baking, at room temperature)
- *300g* gluten-free plain flour , plus extra for dusting
- *300g* golden caster sugar
- *4* large free-range eggs -or- egg replacement gloop for 4 eggs
- *3* lemons
- *2* oranges
- *2tsp* baking powder
- *½tsp* xanthan gum
- *100g* icing sugar

---

1. Preheat the oven to 180ºC. Grease a 20cm square cake tin with the margarine, then line the bottom with greaseproof paper and dust the sides with gluten-free flour.
1. In a bowl, beat the margarine and sugar for around 5 minutes, or until light and fluffy.
1. Add egg replacement gloop (or actual eggs), finely grate and add the zest from 2 lemons and 1 orange, then mix to combine.
1. Sieve the flour, baking powder and xanthan gum into the bowl, then fold through. Stir in the juice from 1 lemon and ½ an orange until you have a nice, smooth mixture.
1. Pour the mixture into the cake tin, smooth out to the edges, then place on the middle shelf of the hot oven for 35 minutes, or until golden and an inserted skewer comes out clean.
1. Leave to cool for 5 minutes, before turning the cake out onto a wire cooling rack, then leave to cool completely while you make the icing.
1. Combine the icing sugar with the zest and juice from ½ a lemon and ¼ of an orange. Once the cake has cooled, drizzle the icing on top, grate over a little lemon and orange zest, then serve.

repository: kronoc/recipes

repo_name: kronoc/recipes


text:
---
layout: default
---

# 1993-08-11 - Re: Secure voice software issues

## Header Data

From<EMAIL_ADDRESS>(Paul Robichaux)

To<EMAIL_ADDRESS>(Norman Hardy)

Message Hash: de787b6f515489d4e9d0c30a9135f700d83a90044ff727c02ee92aaf111eb5e0

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1993-08-11 22:02:06 UTC

Raw Date: Wed, 11 Aug 93 15:02:06 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Paul Robichaux)
Date: Wed, 11 Aug 93 15:02:06 PDT
To<EMAIL_ADDRESS>(Norman Hardy)
Subject: Re: Secure voice software issues
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

This was discussed a while back in the context of secure voice
hardware, but I don't remember whether anyone had been able to get
real-time CELP performance with any particular implementation.

I do know that ZyXEL's modems are able to do real-time CELP using a
68000 processor. The low-end models can do CELP encoding at 9600 baud,
and the faster ones do better-quality encoding (ACELP, I think they
call it) at 19200 baud.

The Mac OS also includes Apple's sound compression routines, which
aren't CELP (i.e. they're not optimized for voice) but allegedly can
do real-time compression.

-Paul

--
Paul Robichaux, KD4JZG     | "Crypto-anarchy means never having to say
<EMAIL_ADDRESS>        |  you're sorry." - Tim May<EMAIL_ADDRESS>Intergraph Federal Systems | Be a cryptography user- ask me how.

{% endraw %}
```

## Thread

+ Return to [August 1993](/archive/1993/08)

+ Return to "[Eric Blossom <eb@srlr14.sr.hp.com>](/authors/eric_blossom_eb_at_srlr14_sr_hp_com_)"
+ Return to<EMAIL_ADDRESS>(Miron Cuperman)](/authors/miron_at_extropia_wimsey_com_miron_cuperman_)"
+ Return to<EMAIL_ADDRESS>(Norman Hardy)](/authors/norm_at_netcom_com_norman_hardy_)"
+ Return to<EMAIL_ADDRESS>(Paul Robichaux)](/authors/paul_at_poboy_b17c_ingr_com_paul_robichaux_)"

+ 1993-08-11 (Wed, 11 Aug 93 14:37:23 PDT) - [Re: Secure voice software issues](/archive/1993/08/c1ec32af8516aa5870644b8a8fd3ae9fa4a5a8b651512b28231b1ebc2140b9e7) -<EMAIL_ADDRESS>(Norman Hardy)_
  + 1993-08-11 (Wed, 11 Aug 93 15:02:06 PDT) - Re: Secure voice software issues -<EMAIL_ADDRESS>(Paul Robichaux)_
    + 1993-08-11 (Wed, 11 Aug 93 16:12:28 PDT) - [Secure voice software issues](/archive/1993/08/d79a687172ef1cbcc39fa623faffd1d5de3b96188ecfefdf4835a259e365d2fb) - _Eric Blossom<EMAIL_ADDRESS>  + 1993-08-12 (Thu, 12 Aug 93 01:12:49 PDT) - [Re: Secure voice software issues](/archive/1993/08/b135cd1f0659920a935ceed8ca121eef781431f0ddb84194ff31d1c9a9c13f4f) -<EMAIL_ADDRESS>(Miron Cuperman)_


text:
---
layout: page
title: Terminology
date: 2017-12-15
tertiary-column: none
menuInclude: yes
menuTopTitle: Classic
menuSubs:
- title: Terminology
  index: 7
excerpt: The terminology used throughout the classic-jekyll-theme code base
---
When configuring the many options it is necessary to have a good view of the names used in the layout.

At the top level there are the following visible elements:

![top-level elements]({{ "/assets/img/top-level-layout.png" | relative_url }}){:.image-centered}

Of these the footer-separator and footer have no further internal decomposition.

The banner-area is the most complex as is displayed below. The column-panel is the main content panel and is divided into the following sub-components:

![column elements]({{ "/assets/img/column-panel-layout.png" | relative_url }}){:.image-centered}

The secondary-column and tertiary-column may be swapped in place, or disabled altogether.

The banner-area is build from the following components:

![column elements]({{ "/assets/img/banner-area-layout.png" | relative_url }}){:.image-centered}

Of these elements the menubar and menubar-bottom-separator may be made invisible by tapping or clicking the menu-symbol. The elements in the banner itself may be arranged differently, or may be absent.

All elements (except the primary-column) can be disabled.

It is also possible to insert an icon into the menubar and disable the banner. This means that the banner-area then only consist of the menubar and its separators (which can also be disabled).

repository: Balancingrock/classic-jekyll-theme

gha_language: SCSS

repo_name: Balancingrock/classic-jekyll-theme


text:
# Directory that contains functional and end to end tests

## Shared selectors

Notice that the two test suites share the same selectors, so modifying something in `selectors` folder
should reflect both test suties

## Functional tests
[Functional README](functional/README.md)

## End to End tests
[End to End README](end-to-end/README.md)

repository: uktrade/data-science-frontend

branch_name: refs/heads/develop

repo_name: uktrade/data-science-frontend