text:
# LW-Daily-Codes
Daily Codes designed in LW

## DAY 3 :
* Detecting Face using Har-Cascade in photo and video
* Finding coordinates of eyes using Har-Cascade
* Understanding and Implementing Linux commands
* A brief about shell and bashrc file
* Intro to numpy
## Drive Link : https://drive.google.com/drive/folders/1HVSCWDFsDM8IyARP2Kx62fLV6qG8ikgq
## DAY 4 :
* Introduction to  AWS cloud
* Linear Regression and its concepts
* Using Linear Regression to predict Salaries of employees
* More about dockers and Linux
## Drive Link : https://drive.google.com/drive/folders/1nCsHQktGVmkhGeiDapgVO_5R_joGVTwJ

## DAY 5 :
* Dockers Sharing files between Host and docker Os
* Yum creation
* Httpd Web Servers
* About partitions
* Intro to pandas
##Drive Link : https://drive.google.com/drive/folders/1a-qmxneSJy4XqiH2M2uzNx9BiGDeNy8b

## DAY 6 :

* Python code to run multiple docker files with Unique ids and yum installed
* Using Ip Webcam App and python Script live stream video
  Link Here : https://play.google.com/store/apps/details?id=com.pas.webcam&hl=en_IN
## Drive Link : https://drive.google.com/drive/folders/1a-qmxneSJy4XqiH2M2uzNx9BiGDeNy8b

## DAY 7 :

* Train and Test split dataset for Machine Learning
* Mean absolute error and Mean squared error
* Lvm to combine hard disk space of two separate pendrives
* Running GUI based applications on Docker
##  Drive Link : https://drive.google.com/drive/folders/1AKZSF9H5qtImKPnVk264D_fcmd8Qr8mk

## DAY 8 :

* Multivariable Linear Regression
* Model Optimization

## DAY 9 :

* OLS model
* P values and Mean R squared
* Connect docker with camera
* Web Server in docker

## DAY 10 :

* Introduction to  Deep Learning
* Password Reset of root

# DAY 11 :

* Multivariable Deep Learning

repository: DiptoChakrabarty/LW-Daily-Codes

gha_language: Jupyter Notebook

repo_name: DiptoChakrabarty/LW-Daily-Codes


text:
# Mache skeleton for Grav CMS

![Mache Theme screenshot](screenshot.jpg)

Mache skelenton is a skeleton for Mache theme, a port of [Mache](https://freetemplates.pro/downloads/mache-html-template-for-business/) by [freetemplates.pro](https://freetemplates.pro/), original PSD design by [symu.co](https://symu.co/freebies/templates-4/mache-psd-template/).

# Features

## Grav Features:
 * Blueprint support: Edit all content in Admin plugin
 * [JSComments plugin](https://github.com/sommerregen/grav-plugin-jscomments) support
 * [SimpleSearch plugin](https://github.com/getgrav/grav-plugin-simplesearch) support
 * [Related Page plugin](https://github.com/getgrav/grav-plugin-relatedpages) support

## HTML Features:

 * HTML5 & CSS3
 * Preloaders
 * Bootstrap Grid
 * Google Fonts
 * One Page Template
 * Smooth Scrolling
 * Cross Browser Compatibility
 * Pricing Options
 * Sticky Header
 * Sticky Menu/Navigation

## jQuery Plugins:

 * jQuery Waypoints
 * BxSlider
 * Fastclick
 * Responsive-nav

# Installation

## New Grav site

1. Download the latest release in this repository.
2. Unzip the package into your web root folder.
3. Access your site via web browser.

## Existing Grav site

You can just install [Mache theme](https://github.com/tranduyhung/grav-theme-mache), but page content will need to reference the Mache theme's supported templates. It is strongly advised to at least install the Mache skeleton package to see the theme's capabilities in action.

To install  **just** the theme:

```
$ bin/gpm install mache
```

license: MIT

repository: hieuliem/chungnhan

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: hieuliem/chungnhan


text:
# OpenCV4js

![npm](https://img.shields.io/npm/v/opencv4js)
![npm bundle size](https://img.shields.io/bundlephobia/min/opencv4js)
![Libraries.io SourceRank](https://img.shields.io/librariesio/sourcerank/npm/opencv4js)
![Snyk Vulnerabilities for npm package](https://img.shields.io/snyk/vulnerabilities/npm/opencv4js)
![npm](https://img.shields.io/npm/dt/opencv4js)
![NPM](https://img.shields.io/npm/l/opencv4js?color=blue)

## Description
This is the official OpenCV.js file packaged into a npm package for ease of use with no modifications in code whatsoever.

Please note that this package is not maintained by the OpenCV team/contributors.

## Why OpenCV4js?

This package is updated whenever a new OpenCV version is released officially. By using the package in your OpenCV based Node.js project, you don't need to manually place the opencv.js file or worry about keeping it up to date later.

`npm update` will automatically fetch the updates, if any, just like any other package.

Also, the release numbers are synced with the official OpenCV releases for easy tracking. (Available 3.0+ only)

## Installation

[![NPM](https://nodei.co/npm/opencv4js.png)](https://nodei.co/npm/opencv4js/)

### Install from command line
`npm i --save opencv4js`

## Usage

With this package, you can skip placing the opencv.js file (as mentioned in the tutorials) and use the following code to import it:
```javascript
cv = require('opencv4js');
```

instead of

```javascript
cv = require('./opencv.js');
```

Or

Replace
```javascript
global.cv = require('./opencv.js');
```
with
```javascript
global.cv = require('opencv4js');
```

Rest of the usage will be similar to the official docs and no other changes are required.

## License
OpenCV4js is published under the Apache 2.0, same license as the official OpenCV.
For more information, see the accompanying LICENSE file.


text:
---
title: 'Speech to text app using inbuilt browser api'
description: 'Create a speech to text app using the SpeechRecognition object in the browser to generate text for your speech without using any third party packages'
path: '/blogs/speech-to-text-browser-api'
thumbnail: './cover.jpg'
author: 'allenabraham777'
name: 'Allen K Abraham'
published: true
date: '21-Feb-2020'
---

Speech recognition is been used across a wide variety of projects to help us achieve a better life. There are huge amount of services available based on this tech, even you will be trying to make something out of this. Whenever you get into the speech recognition the initial thing that we must take care is converting speech to text, most of you may create a model to achieve this by creating or collecting datasets, train and save the model and some will use pretraied models which may be free or paid. These all requires you to take some effort in setting it up and there is no guarantee that it would work in every system.

Out in the market there is an easy and compatible solution available which requires almost zero effort from your side, that is by using the web browsers. The web browsers which we are using are having a speech recognition engine shipped with it. Using this would save a lot of time in setting up a speech to text system for our NLP projects.

## How to use it

The `SpeechRecognition`  interface for the of Web Speech API is used for the speech recognition in browsers. The interface names will be different based on the browsers, but it's easy to solve it.

For **Mozilla Firefox** the name of the interface is simply ```SpeechRecognition``` and for the **Google Chrome** it's ```webkitSpeechRecognition```, so initially you need to set the speech recognition engine.

### Setting up the engine

```javascript
const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition
//SpeechRecognition = window.SpeechRecognition for Chrome
//SpeechRecognition = window.webkitSpeechRecognition for Firefox
```

### Initialisation
Next you'll need to create a constructor and set up its properties, there are huge number of properties available refer [MDN Docs](https://developer.mozilla.org/en-US/docs/Web/API/SpeechRecognition#properties) for more details. Here I'll be setting the lang property.

```javascript
const recognition = new SpeechRecognition();
recognition.lang = 'en-US'
```

### Start or Stop the mic

You could turn on and off the mic using the ```start()``` and ```stop()``` functions in the `recognition` object

```javascript
recognition.start(); //Starts the mic
recognition.stop();  //Stops  the mic
```

### Generating the transcript

After starting the mic you could speak through it. When you stop recording the results will be generated and stored in the `recognition` object. It could be recovered using the ```onresult()``` event.

```javascript
recognition.onresult = e => {
    const lastIndex = e.results.length - 1;
    const transcript = e.results[lastIndex][0].transcript;
    console.log(transcript);
}
```

There are no better resource than the official docs. You may refer [MDN docs](https://developer.mozilla.org/en-US/docs/Web/API/SpeechRecognition) to learn more.

# Peace Out ✌

branch_name: refs/heads/main


text:
# Ansible Playbook Nvidia GPU Docker Demo

This playbook is to show off an easy method to install Docker with Nvidia GPU support on a supported linux host.
The playbook can run against a bare metal machine, virtual machine or cloud based machine. [Datadrivers GmbH](http://www.datadrivers.de "Datadrivers GmbH") is prefering to use it with an AWS EC2 instance from the P2-, P3- or G3-series.

## Requirements

* Ansible 2.1+
* SSH access and sudo permissions (login user!)
* target host with installed linux OS with systemd
* for nvidia-docker usage: a host with a compatible Nvidia graphic card
* Internet access to get the packages and gpg keys

## Supported platforms

* CentOS 7
* RedHat 7

## Usage

### Preparations

* open a terminal / console

* git clone the repository on your system and switch into the directory

* use ansible-galaxy to install the required role: `ansible-galaxy install -v -r requirements.yml`

* edit the inventory file `inventory/hosts` to match the target server

* edit the definition file for the role `group_vars/docker-host` to deactivate/activate Nvidia-GPU installation steps

### Run the playbook

Please use instead of user `centos`, the right user to get SSH access and sudo permissions on the target system.

* start the playbook run: `ansible-playbook demo.yml --user centos --diff -v`

* If you install the Nvidia-docker2 parts, please reboot the target system after the completion!

### Test the Docker environment

Log onto the target system and try to start an example Nvidia CUDA container: `sudo docker run --rm nvidia/cuda nvidia-smi`

## License

* MIT license (check file `LICENSE` for more details)

## Issue Tracker

Please use the [Github Repository Issue tracker](https://github.com/datadrivers/ansible-playbook-nvidia_gpu_docker_demo/issues) to report us bugs.

## Contributions

Feel free to clone the code, make a branch and to hack your stuff. After that make a pull request and we can check it. We are open for improvements.

## Author Information

* Markus Rekkenbeil - [(Datadrivers GmbH)](http://www.datadrivers.de "Datadrivers GmbH")


text:
# HTTP Abstraction Layer for Android SDKs

## What?

A couple of interfaces that define a minimal HTTP client contract, inspired by [OkHttp3](https://square.github.io/okhttp/) interfaces.

## Why?

We should not couple SDKs to any specific HTTP client implemenetation. If an SDK leaks this implementation detail we are locked into supporting that library until the next major version.

Here are a few Examples:

```java
public class EngineClient {
    // BaseRequest subclasses com.android.volley.Request
    public BaseRequest<TokenResult> token(TokenParam param, Response.Listener<TokenResult> listener, Response.ErrorListener errorListener) {
        // ...
    }
}

// usage

EngineClient client = // ..
// ↓ exposing & forcing volley ↓
RequestQueue queue = // ...
RequestFuture<TokenResult> future = RequestFuture.newFuture();
client.token(param, future, future)
        .setTag(LoginConfig.REQUESTTAG_AUTH_IGNORE)
        .queue(queue);
TokenResult result = future.get(10, TimeUnit.SECONDS);
```

```java
public class Tracker {
    // the queue is a com.android.volley.RequestQueue
    public static Tracker initialize(Context context, RequestQueue queue) {
        // ...
    }
}

// usage

Context context = // ..
RequestQueue queue = // ...
Tracker tracker = Tracker.initialize(context, queue);
```

## How?

This repo defines a module of java interfaces that describe the contract for different HTTP clients to implement. Other modules are adapaters that convert common HTTP client libraries to that contract. With these tools we can remove coupling with implementation details 🤗.

Here are the examples from above, fixed with our HTTP interfaces:

```java
public class EngineClient {
    Http.Client client;

    // no more volley specific code in SDK public interface 🤗
    public EngineClient(Http.Client client) {
        this.client = client;
    }

    // no more volley specific code in SDK public interface 🤗
    public Call<TokenResult> token(TokenParam param) {
        // ...
    }
}

RequestQueue queue = // ...
EngineClient client = new EngineClient(new VolleyClient(queue)); // using volley adapter
// ↓ exposing HTTP abstraction layer  ↓
Http.Call call = client.token(param);
Http.Response response = call.execute();
TokenResult result = TokenResult.fromJson(response.string());
```

```java
public class Tracker {
    // no more volley specific code in SDK public interface 🤗
    public static Tracker initialize(Context context, Http.Client client) {
        // ...
    }
}

// usage (in app)

Context context = // ..
RequestQueue queue = // ...
Tracker tracker = Tracker.initialize(context, new VolleyClient(queue)); // using volley adapter
```

repository: PAISHackathon/android-http-interface

gha_language: Java

repo_name: PAISHackathon/android-http-interface


text:
# fast-wc
An word counter utility implemented with Golang

### Usage
fast-wc [OPTION] FILE

cat FILE | fast-wc

**OPTION**:
- -l, --lines, count lines
- -w, --words, count words
- -c, --bytes, count bytes

repository: mingzhangyang/fast-wc

repo_name: mingzhangyang/fast-wc


text:
	JRune is a Game Engine for Java that is focused on role-playing games.
    It is openly available under terms of the MIT License and concentrates on providing essential features
    without distraction.

Features

* Management of game objects
* Handle two-dimensional maps
* Script intelligence with Lua

repository: lycis/jrune

repo_name: lycis/jrune


text:
# Data

---
Record:
> (**SDL-FINGER**)

Fields:
> ***id*** : ID of a finger.

> ***x*** : X-pos of a finger input.

> ***y*** : Y-pos of a finger input.

> ***p*** : Pressure of a finger input.

# Keyboard Support

---
Procedure:
>(**SDL-GET-KEY-FROM-NAME** *name*) → number

Parameters:
>***name*** : A string. Name of the [keycode.](data.md#scancodes-keycodes)

Returns:
>A number corresponding to it's keycode.

C Function Name:
>`SDL_GetKeyFromName`

---
Procedure:
>(**SDL-GET-KEY-FROM-SCANCODE** *scancode*) → number

Parameters:
>***scancode*** : Value of a [scancode.](data.md#scancodes-keycodes)

Returns:
>A number corresponding to it's keycode.

C Function Name:
>`SDL_GetKeyFromScancode`

---
Procedure:
>(**SDL-GET-KEY-NAME** *key*) → string

Parameters:
>***key*** : Value of a [keycode.](data.md#scancodes-keycodes)

Returns:
>A string containing the name of a keycode.

C Function Name:
>`SDL_GetKeyName`

---
Procedure:
>(**SDL-GET-KEYBOARD-FOCUS**) → SDL-WINDOW

Returns:
>A window object that has the keyboard focus.

C Function Name:
>`SDL_GetKeyboardFocus`

---
Procedure:
>(**SDL-GET-KEYBOARD-STATE**) → (LAMBDA SCANCODE) → boolean

Returns:
>A procedure that when passed a [scancode](data.md#scancodes-keycodes) returns `#t` if the key is pressed otherwise `#f`.

C Function Name:
>`SDL_GetKeyboardState`

Examples:
```scheme
(define key-state
  (sdl-get-keyboard-state))

(if (key-state SDL-SCANCODE-RETURN)
    (printf "<RETURN> key pressed.~n"))

(if (and (key-state SDL-SCANCODE-RIGHT)
         (key-state SDL-SCANCODE-UP))
    (printf "Right and Up Keys Pressed.~n"))
```

---
Procedure:
>(**SDL-GET-MOD-STATE**) → int

Returns:
>A number that's bits have been set with [key modifer values.](data.md#key-modifers)

C Function Name:
>`SDL_GetModState`

---
Procedure:
>(**SDL-GET-SCANCODE-FROM-KEY** *key*) → int

Parameters:
>***key*** : Value of a [keycode.](data.md#scancodes-keycodes)

Returns:
>Scancode equivalent of keycode.

C Function Name:
>`SDL_GetScancodeFromKey`

---
Procedure:
>(**SDL-GET-SCANCODE-FROM-NAME** *name*) → int

Parameters:
>***name*** : The name of a scancode as a string.

Returns:
>Scancode value of the string.

C Function Name:
>`SDL_GetScancodeFromName`

---
Procedure:
>(**SDL-GET-SCANCODE-NAME** *code*) → string

Parameters:
>***code*** : Value of a [scancode.](data.md#scancodes-keycodes)

Returns:
>String value of a scancode.

C Function Name:
>`SDL_GetScancodeName`

---
Procedure:
>(**SDL-HAS-SCREEN-KEYBOARD-SUPPORT?**) → boolean

Returns:
>`#t` if screen has keyboard support or `#f` otherwise.

C Function Name:
>`SDL_HasScreenKeyboardSupport`

---
Procedure:
>(**SDL-IS-SCREEN-KEYBOARD-SHOWN?** *window*) → boolean

Parameters:
>***window*** : A SDL-WINDOW object.

Returns:
>`#t` if screen's keyboard is shown or `#f` otherwise.

C Function Name:
>`SDL_IsScreenKeyboardShown`

---
Procedure:
>(**SDL-IS-TEXT-INPUT-ACTIVE?**) → boolean

Returns:
>`#t` if the text input is active or `#f` otherwise.

C Function Name:
>`SDL_IsTextInputActive`

---
Procedure:
>(**SDL-SET-MOD-STATE!** *mods*) → '()

Parameters:
> ***mods*** : A series of [key modifer values.](data.md#key-modifers)

C Function Name:
>`SDL_SetModState`

Examples:
```scheme
(sdl-set-mod-state! KMOD-LSHIFT
                    KMOD-CAPS
		    KMOD-RCTRL)
```

---
Procedure:
>(**SDL-SET-TEXT-INPUT-RECT!** *rect*) → '()

Parameters:
> ***rect*** : A SDL-RECT record. (Optional)

C Function Name:
>`SDL_SetTextInputRect`

Notes:
> ***Not implemented.***

---
Procedure:
>(**SDL-START-TEXT-INPUT**) → '()

C Function Name:
>`SDL_StartTextInput`

---
Procedure:
>(**SDL-STOP-TEXT-INPUT**) → '()

C Function Name:
>`SDL_StopTextInput`

# Mouse Support

---
Procedure:
>(**SDL-CAPTURE-MOUSE** *enable*) → boolean

Parameters:
> ***enable*** : Sets whether mouse should be captured or ignored.

Returns:
>`#t` if set succeeded `#f` otherwise.

C Function Name:
>`SDL_CaptureMouse`

---
Procedure:
>(**SDL-CREATE-COLOR-CURSOR** *image* *hot-x* *hot-y*) → SDL-CURSOR

Parameters:
>***image*** : A SDL-SURFACT object.

>***hot-x*** : The x-position of the cursor hot spot.

>***hot-y*** : The y-position of the cursor hot spot.

Returns:
>A SDL-CURSOR object or `'()` on failure.

C Function Name:
>`SDL_CreateColorCursor`

Notes:
> ***Not up to specifications.***

---
Procedure:
>(**SDL-CREATE-SYSTEM-CURSOR** *id*) → SDL-CURSOR

Parameters:
>| *id* : symbol                |
 | :--------------------------- |
 | SDL-SYSTEM-CURSOR-ARROW      |
 | SDL-SYSTEM-CURSOR-IBEAM      |
 | SDL-SYSTEM-CURSOR-WAIT       |
 | SDL-SYSTEM-CURSOR-CROSSHAIR  |
 | SDL-SYSTEM-CURSOR-WAIT-ARROW |
 | SDL-SYSTEM-CURSOR-SIZE-NWSE  |
 | SDL-SYSTEM-CURSOR-SIZE-NESW  |
 | SDL-SYSTEM-CURSOR-SIZE-WE    |
 | SDL-SYSTEM-CURSOR-SIZE-NS    |
 | SDL-SYSTEM-CURSOR-SIZE-ALL   |
 | SDL-SYSTEM-CURSOR-NO         |
 | SDL-SYSTEM-CURSOR-HAND       |

Returns:
>A SDL-CURSOR object or `'()` on failure.

C Function Name:
>`SDL_CreateSystemCursor`

Notes:
> ***Not up to specifications.***

---
Procedure:
>(**SDL-FREE-CURSOR** *cursor*) → '()

Parameters:
>***cursor*** : A SDL-CURSOR object.

C Function Name:
>`SDL_FreeCursor`

Notes:
> ***Not up to specifications.***

---
Procedure:
>(**SDL-GET-CURSOR**) → SDL-CURSOR

Returns:
>The current cursor as a SDL-CURSOR object.

C Function Name:
>`SDL_GetCursor`

---
Procedure:
>(**SDL-FREE-CURSOR** *toggle*) → number

Parameters:
>***toggle*** : A [device query value.](data.md#device-queries)

Returns:
>The value of SDL-ENABLE if cursor is shown, SDL-DISABLE if cursor is hidden, or a negative value indicating error.

C Function Name:
>`SDL_ShowCursor`

---
Procedure:
>(**SDL-GET-MOUSE-FOCUS**) → SDL-WINDOW

Returns:
>The SDL-WINDOW object that has the mouse focus.

C Function Name:
>`SDL_GetMouseFocus`

---
Procedure:
>(**SDL-GET-DEFAULT-CURSOR**) → SDL-CURSOR

Returns:
>A SDL-CURSOR object that is the system's default cursor.

C Function Name:
>`SDL_GetDefaultCursor`

---
Procedure:
>(**SDL-WARP-MOUSE-IN-WINDOW** *window* *x* *y*) → '()

Parameters:
>***window*** : A SDL-WINDOW object.

>***x*** : The x-coordinate within the window.

>***y*** : The y-coordinate within the window.

C Function Name:
>`SDL_WarpMouseInWindow`

---
Procedure:
>(**SDL-WARP-MOUSE-GLOBAL** *x* *y*) → number

Returns:
>0 on success or a negative number on failure.

Parameters:
>***x*** : The x-coordinate.

>***y*** : The y-coordinate.

C Function Name:
>`SDL_WarpMouseInWindow`

---
Procedure:
>(**SDL-SET-CURSOR!** *cursor*) → '()

Parameters:
>***cursor*** : A SDL-CURSOR object.

C Function Name:
>`SDL_SetCursor`

---
Procedure:
>(**SDL-SET-RELATIVE-MOUSE-MODE!** *enable*) → number

Parameters:
>***enable*** : A boolean. Value to set mouse relative mode.

Returns:
>0 on success or a negative number on failure.

C Function Name:
>`SDL_SetRelativeMouseMode`

---
Procedure:
>(**SDL-GET-RELATIVE-MOUSE-MODE!**) → boolean

Returns:
>`#t` if mouse is in relative mode or `#f` otherwise.

C Function Name:
>`SDL_GetRelativeMouseMode`

---
Procedure:
>(**SDL-CREATE-CURSOR**) → SDL-CURSOR

C Function Name:
>`SDL_CreateCursor`

Notes:
> ***Unimplemented***

---
Procedure:
>(**SDL-GET-RELATIVE-MOUSE-STATE**) → number

C Function Name:
>`SDL_GetRelativeMouseState`

Notes:
> ***Unimplemented***

---
Procedure:
>(**SDL-GET-GLOBAL-MOUSE-STATE**) → number

C Function Name:
>`SDL_GetGlobalMouseState`

Notes:
> ***Unimplemented***

---
Procedure:
>(**SDL-GET-MOUSE-STATE**) → number

C Function Name:
>`SDL_GetMouseState`

Notes:
> ***Unimplemented***

# Joystick Support

---
Procedure:
>(**SDL-JOYSTICK-OPEN** *index*) → SDL-JOYSTICK

Parameters:
>***index*** : The index of the joystick.

Returns:
> The SDL-JOYSTICK object or `'()`.

C Function Name:
>`SDL_JoystickOpen`

Notes:
> ***Not up to specifications.***

---
Procedure:
>(**SDL-JOYSTICK-CLOSE** *joystick*) → '()

Parameters:
>***joystick*** : A SDL-JOYSTICK object.

C Function Name:
>`SDL_JoystickClose`

Notes:
> ***Not up to specifications.***

---
Procedure:
>(**SDL-JOYSTICK-NUM**) → number

Returns:
> The amount of joysticks that can be accessed.

C Function Name:
>`SDL_NumJoystick`

---
Procedure:
>(**SDL-JOYSTICK-CURRENT-POWER-LEVEL** *joystick*) → symbol

Parameters:
>***joystick*** : A SDL-JOYSTICK object.

Returns:
>| *levels* : sybmol          |
 | :------------------------- |
 | SDL-JOYSTICK-POWER-UNKNOWN |
 | SDL-JOYSTICK-POWER-EMPTY   |
 | SDL-JOYSTICK-POWER-LOW     |
 | SDL-JOYSTICK-POWER-MEDIUM  |
 | SDL-JOYSTICK-POWER-FULL    |
 | SDL-JOYSTICK-POWER-WIRED   |
 | SDL-JOYSTICK-POWER-MAX     |

C Function Name:
>`SDL_JoystickCurrentPowerLevel`

---
Procedure:
>(**SDL-JOYSTICK-EVENT-STATE** *state*) → number

Parameters:
>***state*** : Can be `SDL-QUERY`, `SDL-IGNORE`, or `SDL-ENABLE`.

Returns:
> `1` if enabled, `0` if disabled, or a negative error code.

C Function Name:
>`SDL_JoystickEventState`

---
Procedure:
>(**SDL-JOYSTICK-FROM-INSTANCE-ID** *instance-id*) → SDL-JOYSTICK

Parameters:
>***instance-id*** : Instance ID from the event system.

Returns:
> The SDL-JOYSTICK object or `'()`.

C Function Name:
>`SDL_JoystickFromInstanceID`

---
Procedure:
>(**SDL-JOYSTICK-IS-ATTACHED?** *joystick*) → boolean

Parameters:
>***joystick*** : A SDL-JOYSTICK object.

Returns:
> `#t` if joystick is attached or `#f` otherwise.

C Function Name:
>`SDL_JoystickGetAttached`

---
Procedure:
>(**SDL-JOYSTICK-GET-AXIS** *joystick* *axis*) → number

Parameters:
>***joystick*** : A SDL-JOYSTICK object.

>***axis*** : A number. The index of the axis.

Returns:
> The value of the axis or 0 on failure.

C Function Name:
>`SDL_JoystickGetAxis`

---
Procedure:
>(**SDL-JOYSTICK-GET-BALL** *joystick* *ball*) → list

Parameters:
>***joystick*** : A SDL-JOYSTICK object.

>***ball*** : A number. The index of the ball.

Returns:
> A list `(dx dy)` or `'()`.

C Function Name:
>`SDL_JoystickGetBall`

---
Procedure:
>(**SDL-JOYSTICK-IS-BUTTON-PRESSED?** *joystick* *button*) → boolean

Parameters:
>***joystick*** : A SDL-JOYSTICK object.

>***button*** : A number. The index of the button.

Returns:
> `#t` if button was pressed or `#f` otherwise.

C Function Name:
>`SDL_JoystickGetButton`

---
Procedure:
>(**SDL-JOYSTICK-GET-HAT** *joystick* *hat*) → symbol

Parameters:
>***joystick*** : A SDL-JOYSTICK object.

>***hat*** : A number. The index of the hat.

Returns:
>| *positions* : symbol |
 | :------------------- |
 | SDL-HAT-CENTERED     |
 | SDL-HAT-UP           |
 | SDL-HAT-RIGHT        |
 | SDL-HAT-DOWN         |
 | SDL-HAT-LEFT         |
 | SDL-HAT-RIGHT-UP     |
 | SDL-HAT-RIGHT-DOWN   |
 | SDL-HAT-LEFT-UP      |
 | SDL-HAT-LEFT-DOWN    |

C Function Name:
>`SDL_JoystickGetHat`

---
Procedure:
>(**SDL-JOYSTICK-INSTANCE-ID** *joystick*) → number

Parameters:
>***joystick*** : A SDL-JOYSTICK object.

Returns:
> Instance ID of the SDL-JOYSTICK object.

C Function Name:
>`SDL_JoystickInstanceID`

---
Procedure:
>(**SDL-JOYSTICK-INSTANCE-ID** *joystick*) → string

Parameters:
>***joystick*** : A SDL-JOYSTICK object.

Returns:
> Name of the SDL-JOYSTICK object.

C Function Name:
>`SDL_JoystickName`

---
Procedure:
>(**SDL-JOYSTICK-NAME-FOR-INDEX** *index*) → string

Parameters:
>***index*** : A number. Index of the joystick.

Returns:
> Name of the joystick at index.

C Function Name:
>`SDL_JoystickNameForIndex`

---
Procedure:
>(**SDL-JOYSTICK-NUM-AXES** *joystick*) → number

Parameters:
>***joystick*** : A SDL-JOYSTICK object.

Returns:
> Number of axes the joystick has.

C Function Name:
>`SDL_JoystickNumAxes`

---
Procedure:
>(**SDL-JOYSTICK-NUM-BALLS** *joystick*) → number

Parameters:
>***joystick*** : A SDL-JOYSTICK object.

Returns:
> Number of balls the joystick has.

C Function Name:
>`SDL_JoystickNumBalls`

---
Procedure:
>(**SDL-JOYSTICK-NUM-BALLS** *joystick*) → number

Parameters:
>***joystick*** : A SDL-JOYSTICK object.

Returns:
> Number of buttons the joystick has.

C Function Name:
>`SDL_JoystickNumButtons`

---
Procedure:
>(**SDL-JOYSTICK-NUM-HATS** *joystick*) → number

Parameters:
>***joystick*** : A SDL-JOYSTICK object.

Returns:
> Number of hats the joystick has.

C Function Name:
>`SDL_JoystickNumHats`

---
Procedure:
>(**SDL-JOYSTICK-GET-DEVICE-GUID**) → SDL-JOYSTICK-GUID

C Function Name:
>`SDL_JoystickGetDeviceGUID`

Notes:
> ***Unimplemented***

---
Procedure:
>(**SDL-JOYSTICK-GET-GUID**) → SDL-JOYSTICK-GUID

C Function Name:
>`SDL_JoystickGetGUID`

Notes:
> ***Unimplemented***

---
Procedure:
>(**SDL-JOYSTICK-GUID-FROM-STRING**) → SDL-JOYSTICK-GUID

C Function Name:
>`SDL_JoystickGetGUIDFromString`

Notes:
> ***Unimplemented***

---
Procedure:
>(**SDL-JOYSTICK-GET-GUID-STRING**) → SDL-JOYSTICK-GUID

C Function Name:
>`SDL_JoystickGetGUIDString`

Notes:
> ***Unimplemented***

# Game Controller Support

---
Procedure:
>(**SDL-GAME-CONTROLLER?** *index*) → boolean

Parameters:
>***index*** : A number. Index of the game controller/joystick.

Returns:
> `#t` if joystick is a game controller or `#f` otherwise.

C Function Name:
>`SDL_IsGameController`

---
Procedure:
>(**SDL-GAME-CONTROLLER-ATTACHED?** *controller*) → boolean

Parameters:
>***controller*** : A SDL-GAME-CONTROLLER object.

Returns:
> `#t` if game controller is attached or `#f` otherwise.

C Function Name:
>`SDL_GameControllerGetAttached`

---
Procedure:
>(**SDL-GAME-CONTROLLER-BUTTON-PRESSED?** *controller* *button*) → boolean

Parameters:
>***controller*** : A SDL-GAME-CONTROLLER object.

>| *button* : symbol                    |
 | :----------------------------------- |
 | SDL-CONTROLLER-BUTTON-A              |
 | SDL-CONTROLLER-BUTTON-B              |
 | SDL-CONTROLLER-BUTTON-X              |
 | SDL-CONTROLLER-BUTTON-Y              |
 | SDL-CONTROLLER-BUTTON-BACK           |
 | SDL-CONTROLLER-BUTTON-GUIDE          |
 | SDL-CONTROLLER-BUTTON-START          |
 | SDL-CONTROLLER-BUTTON-LEFT-STICK     |
 | SDL-CONTROLLER-BUTTON-RIGHT-STICK    |
 | SDL-CONTROLLER-BUTTON-LEFT-SHOULDER  |
 | SDL-CONTROLLER-BUTTON-RIGHT-SHOULDER |
 | SDL-CONTROLLER-BUTTON-UP             |
 | SDL-CONTROLLER-BUTTON-DOWN           |
 | SDL-CONTROLLER-BUTTON-LEFT           |
 | SDL-CONTROLLER-BUTTON-RIGHT          |

Returns:
> `#t` if button is pressed or `#f` otherwise.

C Function Name:
>`SDL_GameControllerGetButton`

---
Procedure:
>(**SDL-GAME-CONTROLLER-AXIS** *controller* *axis*) → number

Parameters:
>***controller*** : A SDL-GAME-CONTROLLER object.

>| *axis* : symbol                   |
 | :-------------------------------- |
 | SDL-CONTROLLER-AXIS-LEFT-X        |
 | SDL-CONTROLLER-AXIS-LEFT-Y        |
 | SDL-CONTROLLER-AXIS-RIGHT-X       |
 | SDL-CONTROLLER-AXIS-RIGHT-Y       |
 | SDL-CONTROLLER-AXIS-TRIGGER-LEFT  |
 | SDL-CONTROLLER-AXIS-TRIGGER-RIGHT |

Returns:
> The value of the axis.

C Function Name:
>`SDL_GameControllerGetAxis`

---
Procedure:
>(**SDL-GAME-CONTROLLER-OPEN** *index*) → SDL-GAME-CONTROLLER

Parameters:
>***index*** : The joystick to open as a game controller.

Returns:
> A SDL-GAME-CONTROLLER object or `'()`.

C Function Name:
>`SDL_GameControllerOpen`

---
Procedure:
>(**SDL-GAME-CONTROLLER-CLOSE** *controller*) → '()

Parameters:
>***controller*** : A SDL-GAME-CONTROLLER object.

C Function Name:
>`SDL_GameControllerClose`

---
Procedure:
>(**SDL-GAME-CONTROLLER-UPDATE**) → '()

C Function Name:
>`SDL_GameControllerUpdate`

---
Procedure:
>(**SDL-GAME-CONTROLLER-NAME** *controller*) → string

Parameters:
>***controller*** : A SDL-GAME-CONTROLLER object.

Returns:
> A string containing the name of the device.

C Function Name:
>`SDL_GameControllerName`

---
Procedure:
>(**SDL-GAME-CONTROLLER-FOR-INDEX** *index*) → string

Parameters:
>***index*** : A number. The index of the game controller.

Returns:
> A string containing the name of the device.

C Function Name:
>`SDL_GameControllerNameForIndex`

---
Procedure:
>(**SDL-GAME-CONTROLLER-MAPPING** *controller*) → string

Parameters:
>***controller*** : A SDL-GAME-CONTROLLER object.

Returns:
> A string containing the button mapping of the device.

C Function Name:
>`SDL_GameControllerMapping`

---
Procedure:
>(**SDL-BUTTON->STRING** *button*) → string

Parameters:
>| *button* : symbol                    |
 | :----------------------------------- |
 | SDL-CONTROLLER-BUTTON-A              |
 | SDL-CONTROLLER-BUTTON-B              |
 | SDL-CONTROLLER-BUTTON-X              |
 | SDL-CONTROLLER-BUTTON-Y              |
 | SDL-CONTROLLER-BUTTON-BACK           |
 | SDL-CONTROLLER-BUTTON-GUIDE          |
 | SDL-CONTROLLER-BUTTON-START          |
 | SDL-CONTROLLER-BUTTON-LEFT-STICK     |
 | SDL-CONTROLLER-BUTTON-RIGHT-STICK    |
 | SDL-CONTROLLER-BUTTON-LEFT-SHOULDER  |
 | SDL-CONTROLLER-BUTTON-RIGHT-SHOULDER |
 | SDL-CONTROLLER-BUTTON-UP             |
 | SDL-CONTROLLER-BUTTON-DOWN           |
 | SDL-CONTROLLER-BUTTON-LEFT           |
 | SDL-CONTROLLER-BUTTON-RIGHT          |

Returns:
> A string containing name of a button.

C Function Name:
>`SDL_GameControllerGetStringForButton`

---
Procedure:
>(**SDL-AXIS->STRING** *axis*) → string

Parameters:
>| *axis* : symbol                   |
 | :-------------------------------- |
 | SDL-CONTROLLER-AXIS-LEFT-X        |
 | SDL-CONTROLLER-AXIS-LEFT-Y        |
 | SDL-CONTROLLER-AXIS-RIGHT-X       |
 | SDL-CONTROLLER-AXIS-RIGHT-Y       |
 | SDL-CONTROLLER-AXIS-TRIGGER-LEFT  |
 | SDL-CONTROLLER-AXIS-TRIGGER-RIGHT |

Returns:
> A string containing the name of the axis.

C Function Name:
>`SDL_GameControllerGetStringForAxis`

---
Procedure:
>(**SDL-GAME-CONTROLLER-MAPPING** *name*) → symbol

Parameters:
>***name*** : A string. Name of the button.

Returns:
>||
 | :----------------------------------- |
 | SDL-CONTROLLER-BUTTON-A              |
 | SDL-CONTROLLER-BUTTON-B              |
 | SDL-CONTROLLER-BUTTON-X              |
 | SDL-CONTROLLER-BUTTON-Y              |
 | SDL-CONTROLLER-BUTTON-BACK           |
 | SDL-CONTROLLER-BUTTON-GUIDE          |
 | SDL-CONTROLLER-BUTTON-START          |
 | SDL-CONTROLLER-BUTTON-LEFT-STICK     |
 | SDL-CONTROLLER-BUTTON-RIGHT-STICK    |
 | SDL-CONTROLLER-BUTTON-LEFT-SHOULDER  |
 | SDL-CONTROLLER-BUTTON-RIGHT-SHOULDER |
 | SDL-CONTROLLER-BUTTON-UP             |
 | SDL-CONTROLLER-BUTTON-DOWN           |
 | SDL-CONTROLLER-BUTTON-LEFT           |
 | SDL-CONTROLLER-BUTTON-RIGHT          |
 | SDL-CONTROLLER-BUTTON-INVALID        |

C Function Name:
>`SDL_GameControllerGetButtonFromString`

---
Procedure:
>(**STRING->SDL-AXIS** *name*) → symbol

Parameters:
>***name*** : A string. Name of the axis.

Returns:
>||
 | :-------------------------------- |
 | SDL-CONTROLLER-AXIS-LEFT-X        |
 | SDL-CONTROLLER-AXIS-LEFT-Y        |
 | SDL-CONTROLLER-AXIS-RIGHT-X       |
 | SDL-CONTROLLER-AXIS-RIGHT-Y       |
 | SDL-CONTROLLER-AXIS-TRIGGER-LEFT  |
 | SDL-CONTROLLER-AXIS-TRIGGER-RIGHT |
 | SDL-CONTROLLER-AXIS-INVALID       |

C Function Name:
>`SDL_GameControllerGetAxisFromString`

---
Procedure:
>(**SDL-CONTROLLER->SDL-JOYSTICK** *controller*) → SDL-JOYSTICK

Parameters:
>***controller*** : A SDL-GAME-CONTROLLER object.

Returns:
> The SDL-JOYSTICK object corresponding to the SDL-GAME-CONTROLLER object.

C Function Name:
>`SDL_GameControllerGetJoystick`

---
Procedure:
>(**SDL-JOYSTICK-ID->SDL-CONTROLLER** *id*) → SDL-GAME-CONTROLLER

Parameters:
>***id*** : Joystick's instance ID.

Returns:
> The SDL-GAME-CONTROLLER object or `'()`.

C Function Name:
>`SDL_GameControllerFromInstanceID`

Notes:
> ***Not up to specifications.***

---
Procedure:
>(**SDL-GAME-CONTROLLER-EVENT-STATE**) → number

C Function Name:
>`SDL_GameControllerEventState`

Notes:
> ***Unimplemented***

---
Procedure:
>(**SDL-GAME-CONTROLLER-GET-BIND-FOR-BUTTON**) → ???

C Function Name:
>`SDL_GameControllerGetBindForButton`

Notes:
> ***Unimplemented***

---
Procedure:
>(**SDL-GAME-CONTROLLER-GET-BIND-FOR-AXIS**) → ???

C Function Name:
>`SDL_GameControllerGetBindForAxis`

Notes:
> ***Unimplemented***

---
Procedure:
>(**SDL-GAME-CONTROLLER-MAPPING-FOR-GUID**) → string

C Function Name:
>`SDL_GameControllerMappingForGUID`

Notes:
> ***Unimplemented***

---
Procedure:
>(**SDL-GAME-CONTROLLER-ADD-MAPPING-FROM-RW**) → number

C Function Name:
>`SDL_GameControllerAddMappingsFromRW`

Notes:
> ***Unimplemented***

---
Procedure:
>(**SDL-GAME-CONTROLLER-ADD-MAPPING-FROM-FILE**) → number

C Function Name:
>`SDL_GameControllerAddMappingsFromFile`

Notes:
> ***Unimplemented***

---
Procedure:
>(**SDL-GAME-CONTROLLER-ADD-MAPPING**) → number

C Function Name:
>`SDL_GameControllerAddMapping`

Notes:
> ***Unimplemented***

# Touch

---
Procedure:
>(**SDL-GET-NUM-TOUCH-DEVICES**) → number

Returns:
> Number of touch devices available.

C Function Name:
>`SDL_GetNumTouchDevices`

---
Procedure:
>(**SDL-GET-TOUCH-DEVICE** *index*) → number

Parameters:
>***index*** : A number. Index of the touch device.

Returns:
> The ID of the touch device.

C Function Name:
>`SDL_GetTouchDevice`

---
Procedure:
>(**SDL-GET-NUM-TOUCH-FINGERS** *touch-id*) → number

Parameters:
>***touch-id*** : The ID of the touch device.

Returns:
> The number of active fingers.

C Function Name:
>`SDL_GetNumTouchFingers`

---
Procedure:
>(**SDL-GET-TOUCH-FINGER** *touch-id* *index*) → SDL-FINGER

Parameters:
>***touch-id*** : The ID of the touch device.

>***index*** : The index of a finger.

Returns:
> A SDL-FINGER record or `'()`.

C Function Name:
>`SDL_GetTouchFinger`

Notes:
> ***Not up to specifications.***

gha_language: Scheme


text:
# Glossary {#openvino_docs_OV_Glossary}

@sphinxdirective

.. meta::
   :description: Check the list of acronyms, abbreviations and terms used in
                 Intel® Distribution of OpenVINO™ toolkit.

Acronyms and Abbreviations
#################################################

==================  ===========================================================================
 Abbreviation        Description
==================  ===========================================================================
 API                 Application Programming Interface
 AVX                 Advanced Vector Extensions
 clDNN               Compute Library for Deep Neural Networks
 CLI                 Command Line Interface
 CNN                 Convolutional Neural Network
 CPU                 Central Processing Unit
 CV                  Computer Vision
 DL                  Deep Learning
 DLL                 Dynamic Link Library
 DNN                 Deep Neural Networks
 ELU                 Exponential Linear rectification Unit
 FCN                 Fully Convolutional Network
 FP                  Floating Point
 GCC                 GNU Compiler Collection
 GPU                 Graphics Processing Unit
 HD                  High Definition
 IR                  Intermediate Representation
 JIT                 Just In Time
 JTAG                Joint Test Action Group
 LPR                 License-Plate Recognition
 LRN                 Local Response Normalization
 mAP                 Mean Average Precision
 Intel® OneDNN       Intel® OneAPI Deep Neural Network Library
 `mo`                Command-line tool for model conversion, CLI for ``tools.mo.convert_model``
 MVN                 Mean Variance Normalization
 NCDHW               Number of images, Channels, Depth, Height, Width
 NCHW                Number of images, Channels, Height, Width
 NHWC                Number of images, Height, Width, Channels
 NMS                 Non-Maximum Suppression
 NN                  Neural Network
 NST                 Neural Style Transfer
 OD                  Object Detection
 OS                  Operating System
 PCI                 Peripheral Component Interconnect
 PReLU               Parametric Rectified Linear Unit
 PSROI               Position Sensitive Region Of Interest
 RCNN, R-CNN         Region-based Convolutional Neural Network
 ReLU                Rectified Linear Unit
 ROI                 Region Of Interest
 SDK                 Software Development Kit
 SSD                 Single Shot multibox Detector
 SSE                 Streaming SIMD Extensions
 USB                 Universal Serial Bus
 VGG                 Visual Geometry Group
 VOC                 Visual Object Classes
 WINAPI              Windows Application Programming Interface
==================  ===========================================================================

Terms
#################################################

Glossary of terms used in OpenVINO™

| *Batch*
|   Number of images to analyze during one call of infer. Maximum batch size is a property of the model set before its compilation. In NHWC, NCHW, and NCDHW image data layout representations, the 'N' refers to the number of images in the batch.

| *Device Affinity*
|   A preferred hardware device to run inference (CPU, GPU, GNA, etc.).

| *Extensibility mechanism, Custom layers*
|   The mechanism that provides you with capabilities to extend the OpenVINO™ Runtime and model conversion API so that they can work with models containing operations that are not yet supported.

| *layer / operation*
|   In OpenVINO, both terms are treated synonymously. To avoid confusion, "layer" is being pushed out and "operation" is the currently accepted term.

| *Model conversion API*
|   A component of OpenVINO Development Tools. The API is used to import, convert, and optimize models trained in popular frameworks to a format usable by other OpenVINO components. In ``openvino.tools.mo`` namespace, model conversion API is represented by a Python ``mo.convert_model()`` method  and ``mo`` command-line tool.

| *OpenVINO™ Core*
|   OpenVINO™ Core is a software component that manages inference on certain Intel(R) hardware devices: CPU, GPU, GNA, etc.

| *OpenVINO™ API*
|   The basic default API for all supported devices, which allows you to load a model from Intermediate Representation or convert from ONNX, PaddlePaddle, TensorFlow, TensorFlow Lite file formats, set input and output formats and execute the model on various devices.

| *OpenVINO™ Runtime*
|   A C++ library with a set of classes that you can use in your application to infer input tensors and get the results.

| *ov::Model*
|   A class of the Model that OpenVINO™ Runtime reads from IR or converts from ONNX, PaddlePaddle, TensorFlow, TensorFlow Lite formats. Consists of model structure, weights and biases.

| *ov::CompiledModel*
|   An instance of the compiled model which allows the OpenVINO™ Runtime to request (several) infer requests and perform inference synchronously or asynchronously.

| *ov::InferRequest*
|   A class that represents the end point of inference on the model compiled by the device and represented by a compiled model. Inputs are set here, outputs should be requested from this interface as well.

| *ov::ProfilingInfo*
|   Represents basic inference profiling information per operation.

| *ov::Layout*
|   Image data layout refers to the representation of images batch. Layout shows a sequence of 4D or 5D tensor data in memory. A typical NCHW format represents pixel in horizontal direction, rows by vertical dimension, planes by channel and images into batch. See also [Layout API Overview](./OV_Runtime_UG/layout_overview.md).

| *ov::element::Type*
|   Represents data element type. For example, f32 is 32-bit floating point, f16 is 16-bit floating point.

| *plugin / Inference Device / Inference Mode*
|   OpenVINO makes hardware available for inference based on several core components. They used to be called "plugins" in earlier versions of documentation and you may still find this term in some articles. Because of their role in the software, they are now referred to as Devices and Modes ("virtual" devices). For a detailed description of the concept, refer to [Inference Modes](@ref openvino_docs_Runtime_Inference_Modes_Overview) and [Inference Devices](@ref openvino_docs_OV_UG_Working_with_devices).

| *Tensor*
|   A memory container used for storing inputs and outputs of the model, as well as weights and biases of the operations.

See Also
#################################################
* :doc:`Available Operations Sets <openvino_docs_ops_opset>`
* :doc:`Terminology <openvino_docs_OV_UG_supported_plugins_Supported_Devices>`

@endsphinxdirective

repository: openvinotoolkit/openvino

repo_name: openvinotoolkit/openvino


text:
# License
 IcoFont is an open source initiative by ShapeBootstrap.
IcoFont is a single font that offers 2105 infinitely scalable vector icons absolutely for free.
Here are the license terms regarding the project.
## Using IcoFont
You may download IcoFont for free from icofont.com and use it in any legal personal or business project.
Crediting is appreciated but not mandatory.
## Not for Sale or Redistribute
You may not offer the font/icons, modified or unmodified, for redistribution or resale.
You can only use IcoFont as an asset to build other personal or commercial end products.

## Support
We don’t provide any technical support for IcoFont, but you should check our help section to get basic uses instructions.

## Disclaimer
The software is provided “as is”, without any kind of warranty.
In no event or situation shall the author or copyright holder be liable for any type of claim, liability or damage.

## Brand Icons
The brand logos or icons used in IcoFont project are trademarks owned by the respective entities.
IcoFont doesn’t endorse them or isn’t endorsed by them with these icons.
You are not permitted to use any of the brand icons in an inappropriate/misleading way.

## Brand Icons
IcoFont authority reserves the right to change or modify the above license terms any time without any prior notice.

*These terms were last modified on April 20, 2016.*

repository: sirwesley/extjs-icofont

repo_name: sirwesley/extjs-icofont


text:
%%%
layout: post
title: Entering the Breve accent in MacOS X using the Keyboard
date: 2014-05-25 01:50
comments: true
tags: Tweaks
%%%

Today I had the need to enter English text into a document that used breve and macron accents.  These symbols are generally
used to denote "short" and "long" vowel pronunciations for introductory English learning material, and look like these:

ă ā

In Mac OS X, it is possible out of the box to enter modified letters simply by holding the base key on the keyboard until
a popup is displayed.  Then one would simply select the desired letter.

![Popup](/stuff/2014/05/a-character-popup.png)

However, notice that this popup contains a version of the letter a with the macron accent but not one with the breve accent.
I needed a way to enter this character using the keyboard.

Mac OS X, like many other operating systems, has a system called "dead keys", which allows the user to enter a key that,
when used by itself does not produce a character. Instead, this key modifies the next character pressed. For example, it is
possible to type Option-E to produce the dead key for ´, which would modify the next key by applying an acute accent.

[Option-E][a] → á

The following screen shot shows the layout of these dead keys on my keyboard, as seen through the keyboard viewer tool.

![U.S.](/stuff/2014/05/us-opt.png)

The keys displayed here in orange are the dead keys.  But notice that our breve accent is not one of the dead keys!
How can I get the breve accent?

It turns out that by switching the keyboard layout from U.S. to one called U.S. Extended, different dead keys appear when
the option key is pressed:

![U.S. Extended](/stuff/2014/05/us-ext-opt.png)

Now it is possible to access the breve accent by using Option-B.

[Option-B][a] → ă

My next question at this point is this: is there a way to enter the connecting double breve: o͝o ?

It doesn't really look like it yet.  I looked, but it doesn't seem to be available on the keyboard, even using the U.S.
Extended keyboard layout.  In HTML it's possible to achieve using the &#861; character between the two characters
being linked.  And for use in documents / presentations, I'll just have to copy and paste from the generated HTML for now.

[HTML] o&#861;o → o͝o


text:
Reflection
===============
Created by Steven Zilberberg

## Background

This project idea was inspired by Reddit user [/u/vbafm](https://www.reddit.com/user/vbafm/). His [post](https://www.reddit.com/r/learnpython/comments/ahyt7w/build_something_to_learn_just_build_something_i/) was discovered by me and I decided to try to perform his example. I have always wanted to explore web development and learn python so I thought this would be a good example.

I decided to turn this into a [GitHub Project](https://github.com/srz2/Reflection) to track my progress (since I am learning) and I do plan on sharing this when it is complete.

## Reflection

Reflection is a website which allows you to "watch" a particular person's profile. It could techincally be used for anyone's but the idea was to track your own.

## License

This project is licensed by an [MIT License](LICENSE)


text:
Title: Google IO Summation
Generator: org-pelican
Author: Nathan Mador-House
Author_Gravatar: http://www.gravatar.com/avatar/30ab82b51f4e3f7d703fd9f845a05b50
Date: 2016-05-23
Lang: en
Summary: Google IO included talk of Android N, Google Assistant, two new services Allo and Duo and much more.
Status: published
Category: Tech News
Tags: Google Tech

# Table of Contents

1.  [Google I/O](#org71b73cd)
2.  [Google Home Assistant](#org7c6acbc)
3.  [Allo & Duo](#orga9dc64d)
4.  [Android N(anaimo Bar)](#orgce0c112)
5.  [Conclusion](#org47dd400)

# Google I/O

Google IO (Input/Output) is one of the major tech events that happen each year. 2016 marks the 10th anniversary of the presentation. While I expected more fanfare for the 10th (it certainly debuted with a high energy musical/video performance), it was a pleasure to see a somewhat relaxed and calmer keynote.

Some companies host events like this for the press, others have booths at consumer events, but Google's audience at IO consists of press, consumers, and a large selection of developers. Having development experience is not mandatory to attend any of the lectures, but it certainly helps when discussing the intricate details of new APIs or programs. Even though my main programming language is Python, I know enough Java to follow along with the developer talks. These talks are a boon of tips and tricks to using some to the new APIs.

# Google Home Assistant

Presenting the Google Assistant was Mario Querioz. Even though Google Assistant is a software implementation, the main implementation is with a device named Google Home. I have to say that when introduced, my mind leapt to a comparison with the old Microsoft Clippy.

At the start of the segment Mr.Querioz alluded to other companies with similar products on the market. When revealed, it is obvious the Google Home device takes inspiration from the [Amazon Echo](<http://www.amazon.com/Amazon-Echo-Bluetooth-Speaker-with-WiFi-Alexa/dp/B00X4WHP5E>). The 'Home' features all the connectivity that you would expect, including most of the functionality inherent in a Chromecast. Much of the focus of this segment was on the improvements in Google's backend machine learning and AI.

# Allo & Duo

Allo and Duo are two new complementary communication services, where Allo is text-based and Duo is for video calling, presented by Erik Kay. Why Google decided to add yet another messaging app to their suite instead of fixing their current selection is beyond me. The question is whether anything  was revealed besides basic text and chat functionality that we have seen from their earlier offerings (Messenger, Hangouts). To be honest, I was quite surprised by their 'headline' feature which they are calling 'Whisper/Shout'. To put it simply, it is just font scaling. Smaller text for whispering and larger for shouting, chosen with a slider. The other features introduced were much more interesting to me. Allo will be fully integrated with Google Assistant, including machine learning for picture recognition and smart reply. Finally, Allo will allow for 'Incognito' chat, enabling End-to-End encryption.

Duo is the video application counterpart to Allo. Duo includes many of the features of Allo, such as End-to-End encryption. With Facebook video calling, Skype, and FaceTime crowding the market, it is interesting to see how Google is trying to differentiate Duo. Duo takes hints from its competitors, such as cross-platform availability from Skype and Facebook and phone number based identification from FaceTime.

# Android N(anaimo Bar)

There are always so many new features in Android updates that it becomes hard to summarize all of the changes properly. The major areas of innovation are in Visual Layouts and Virtual Reality. In terms of layouts, N brings multitasking to a new level with split screen multi-windows. It also introduces Picture-in-Picture mode for Android TV, which apparently is not useful for tablets or phones.  Finally, Google has announced ['Daydream'](google-daydream.html), explained by Clay Bevor as a new platform for VR. The platform includes detailed specifications for software, new phone hardware, and a physical headset. What I found of particular interest was the inclusion of a headband, which has been a topic of debate for previous Google VR implementations (Cardboard).

# Conclusion

Overall it was a keynote filled with some novel ideas, fake excitement, and a whole lot of 'pass the buck.' What was the star of Google IO so far? Undoubtedly the machine learning and AI teams behind all of the interesting tech. I look forward to writing about the rest of IO and hope there are more juicy tech stories to come.

repository: NathanMH/MusicNate

repo_name: NathanMH/MusicNate


text:
# IRIS FLOWER DATA SET PROJECT

This project contains analysis of Fisher's Iris flower dataset. It includes research of the dataset, analysis, documentation and code written in the Python programming language. This is a project for the course Programming and Scripting, in partial fulfillment of the requirements for Higher Diploma in Data Analytics.

## 1. Summary of Fishers Iris Flower Dataset

The dataset used in this project was introduced by Ronald Fisher in 1936 from his paper "The use of multiple measurements in taxonomic problems." This is considered to be best known database in pattern recognition literature [1]. Fishers Iris flower dataset contains measurements of three classes of Iris flower, the setosa, versicolor and virginica. Measurements from fifty samples are recorded from each of the flowers' petal length, petal width, sepal length and sepal width. Through a statistical method of linear discriminant analysis, Fisher used the measurements "to discriminate the species as distincly as possible[2]." The dataset can be opened or viewed in the repository in a folder named [datum](https://github.com/NurseQ/Project-Iris-Flower-Dataset/tree/master/datum).

## 2. Investigations regarding the dataset in Python
This section presents the steps taken to analyse the data set. A brief narrative to explain the procedure and extracts of code are inserted to present how the data set is manipulated. A link to the whole code is provided for each section.

### 2a. Opening csv files
Fisher's dataset can be downloaded as a csv file from [UCI machine learning repository](http://archive.ics.uci.edu/ml/machine-learning-databases/iris/). The code inserted below shows how the csv file is opened using python code within this project. There are many ways to open or read csv files, please see [exercise5.py](https://github.com/NurseQ/Project-Iris-Flower-Dataset/blob/master/exercise5.py) in the repository for a different way of reading the same csv file and formatting the output for better readability.

```python
import numpy
# read the file
data = numpy.genfromtxt("datum/iris.csv", delimiter=",")
print(data)
```
### 2b. Counting the dataset
The number of rows within Fishers dataset are counted using the code inserted below. The code takes the first column and uses the range function to count each of the rows. Opening the csv file from the repository will also show the number of rows and columns. The code in the repository is [count.py](https://github.com/NurseQ/Project-Iris-Flower-Dataset/blob/master/count.py).

```python
import numpy

# read the file
data = numpy.genfromtxt("datum/iris.csv", delimiter=",")

# splits the array and takes the first column of the entire dataset
firstcol = data[:,0]

i = 0

# loop to count the length of the first column
while i < len(firstcol):
    # print i and whatever i is in the list
    print(i, firstcol[i])
    i = i + 1
```
### 2c. Splitting the columns
The inserted code below first splits the dataset into each column then divides each column by fifty. This will assign each group of fifty measurements into each flowers petal length, petal width, sepal length and sepal width. When the measurements are grouped into each flowers appropriate heading, further analysis can be employed. See this code in the repository [scatpetlength.py](https://github.com/NurseQ/Project-Iris-Flower-Dataset/blob/master/scatpetlength.py).

```python
import numpy

data = numpy.genfromtxt("datum/iris.csv", delimiter=",")

# splits the array and takes the first 4 columns of the entire dataset
firstcol = data[:,0]
seccol = data[:,1]
thirdcol = data[:,2]
fourthcol = data[:,3]

#The first column is the petal length and split into each flower
setosaPlength = firstcol[0:50]
versicolorPlength = firstcol [50:100]
virginicaPlength = firstcol[100:150]

```

### 2d. Python libraries
As seen from the sample snippets of code above, the numpy python library is imported. For additional functionality and graphical visualization, matplolib.pyplot is imported and used in the code. Please see two examples inserted below. Code 1 shows use of a plot placing flower measurements in the y axis and the sample number on the x axis. Code 2 shows the petal length of the Iris setosa on the x axis and the petal width on the y axis. See code 1 in the repository [scatpetlength.py](https://github.com/NurseQ/Project-Iris-Flower-Dataset/blob/master/scatpetlength.py), code 2 [setosa.py](https://github.com/NurseQ/Project-Iris-Flower-Dataset/blob/master/setosa.py).

**Code 1**
```python
# imported library for visualization of data
import matplotlib.pyplot as mp

# provides the x axis with a range up to 50
x = range(0,50)

# command for plotting petal length into a histogram
# argument can be changed to either flower
mp.hist(setosaPlength)
# command to print out histogram chart
mp.show()

# plots each data point to visualize general petal length of flower, adds color to each data point
se = mp.scatter(x,setosaPlength,c="b")
ve = mp.scatter(x,versicolorPlength,c="r")
vi = mp.scatter(x, virginicaPlength, c="g")

# creates a label along the y axis
mp.ylabel("Petal length in cm")

# creates a legend in the graph with appropriate colors
mp.legend((se,ve,vi),("Setosa", "Versicolor", "Virginica"))
mp.show()
```

**Code 2**

```python

# plots petal length on x axis and petal width on y axis
# arguments can be changed to sepal length and width
mp.scatter(a,b,c="r")

mp.xlabel("petal length in cm")
mp.ylabel("petal width in cm ")
mp.show()
```

### 2e. Statistical Values
The inserted sample code shows code used to calculate the maximum measurements, minimum measurements and the average of each group or heading. See this code in the repository [scatpetlength.py](https://github.com/NurseQ/Project-Iris-Flower-Dataset/blob/master/scatpetlength.py).
```python
#calculate the mean, max, min of petal length of each flower
meanDataA = numpy.mean(setosaPlength)
meanDataB = numpy.mean(versicolorPlength)
meanDataC = numpy.mean(virginicaPlength)

minset = numpy.min(setosaPlength)
minver = numpy.min(versicolorPlength)
minvirg = numpy.min(virginicaPlength)

maxset = numpy.max(setosaPlength)
maxver = numpy.max(versicolorPlength)
maxvirg = numpy.max(virginicaPlength)

```

## 3. Observations and Analysis
The paper by Fisher was found to be mathematically challenging to use as a basis for the conduct of this project. The programming skills of the researcher was also deficient to offer more complex solutions to try and classify the flowers. The paper by Hoey [3] offered a simpler solution and less complicated method to classify the flowers from the dataset. Hoey looked at the dataset and drew patterns to see how each of the class of flowers differed from each other. This project attempts to use Hoey's method to produce a distinction between each of the flowers. The conclusions drawn from this project are generalizations and would require more advanced statistical analysis including standard deviation and variance to offer more accurate distinctions. The use of other python data analytics libraries might also be needed to output more intuitive graphical representation or graphs for a more detailed analysis of the dataset.

Figures 1 and 2 show more overlap in the measurements in the dataset which is reflected with narrower distances between the statistical values. Figures 3 and 4 show more distinct separation and is also reflected in the measurements of statistical values.

**Figure 1** - This scatter plot compares the petal length with the classification of flower. Observations drawn from figure 1 are listed below and the maximum, minimum and mean support the listed conclusions. See the code [scatpetlength.py](https://github.com/NurseQ/Project-Iris-Flower-Dataset/blob/master/scatpetlength.py).
1. The Iris Setosa has the shortest petal with a some overlap with the second shortest, the Iris Versicolor. There is also a few overlap with Virginica.
2. The Iris Versicolor has a medium petal in relation to the other flowers but with more overlap with Virginica.
3. The Iris Virginica has the longest petals with much overlap with Versicolor.

**Statistical values**

The average petal length of the Iris-Setosa is:  5.006\
The average petal length of the Iris-Versicolor is:  5.936\
The average petal length of the Iris-Virginica is:  6.588\
The minimum petal length of the Iris-Setosa is:  4.3\
The minimum petal length of the Iris-Versicolor is:  4.9\
The minimum petal length of the Iris-Virginica is:  4.9\
The maximum petal length of the Iris-Setosa is:  5.8\
The maximum petal length of the Iris-Versicolor is:  7.0\
The maximum petal length of the Iris-Virginica is:  7.9

![Scatter plot of petal length](https://github.com/NurseQ/Project-Iris-Flower-Dataset/blob/master/Images/Scatter%20petal%20length.png)

**Figure 2** - This scatter plot compares the petal width with the classification of flower. There appears to be more overlap in this figure but conclusions can still be drawn from the figure. This is also reflected in the values from the maximum, minimum and mean where the values are numerically closer to each other. See the code [scatpetwidth.py](https://github.com/NurseQ/Project-Iris-Flower-Dataset/blob/master/scatpetwidth.py).
1. The Iris Setosa has the widest petal but show much overlap with Virginica and some overlap with Versicolor.
2. The Iris Virginica has a medium petal in relation to the other flowers, measurements overlap with both other flowers.
3. The Iris Versicolor has the narrowest petals but has a close overlap with Virginica and some overlap with Setosa.

**Statistical values**

The average petal width of the Iris-Setosa is:  3.418\
The average petal width of the Iris-Versicolor is:  2.77\
The average petal width of the Iris-Virginica is:  2.974\
The minimum petal width of the Iris-Setosa is:  2.3\
The minimum petal width of the Iris-Versicolor is:  2.0\
The minimum petal width of the Iris-Virginica is:  2.2\
The maximum petal width of the Iris-Setosa is:  4.4\
The maximum petal width of the Iris-Versicolor is:  3.4\
The maximum petal width of the Iris-Virginica is:  3.8
![Scatter plot petal width](https://github.com/NurseQ/Project-Iris-Flower-Dataset/blob/master/Images/Scatter%20petal%20width.png)

**Figure 3** - This scatter plot compares the sepal length with the classification of flower. Observations drawn from figure 3 are listed below and the maximum, minimum and mean support the listed conclusions. See the code [scatsepallen.py](https://github.com/NurseQ/Project-Iris-Flower-Dataset/blob/master/scatsepallen.py).
1. The Iris Setosa has the shortest sepal length with no overlap from the other flowers.
2. The Iris Versicolor has a medium sepal length in relation to the other flowers.
3. The Iris Virginica has the longest sepal length with little overlap with the Iris Versicolor.

**Statistical values**

The average sepal length of the Iris-Setosa is:  1.464\
The average sepal length of the Iris-Versicolor is:  4.26\
The average sepal length of the Iris-Virginica is:  5.552\
The minimum sepal length of the Iris-Setosa is:  1.0\
The minimum sepal length of the Iris-Versicolor is:  3.0\
The minimum sepal length of the Iris-Virginica is:  4.5\
The maximum sepal length of the Iris-Setosa is:  1.9\
The maximum sepal length of the Iris-Versicolor is:  5.1\
The maximum sepal length of the Iris-Virginica is:  6.9

![Scatter plot sepal length](https://github.com/NurseQ/Project-Iris-Flower-Dataset/blob/master/Images/Scatter%20sepal%20length.png)

**Figure 4** - This scatter plot compares the sepal width with the classification of flower. Observations drawn from figure 3 are listed below and the maximum, minimum and mean support the listed conclusions. See the code [scatsepalwid.py](https://github.com/NurseQ/Project-Iris-Flower-Dataset/blob/master/scatsepalwid.py)
1. The Iris Setosa has the narrowest petal with clear distinction from the other flowers.
2. The Iris Versicolor has a medium sepal width in relation to the other flowers.
3. The Iris Virginica has the widest sepals with very little overlap with the Iris Versicolor.

**Statistical values**

The average sepal width of the Iris-Setosa is:  0.244\
The average sepal width of the Iris-Versicolor is:  1.326\
The average sepal width of the Iris-Virginica is:  2.026\
The minimum sepal width of the Iris-Setosa is:  0.1\
The minimum sepal width of the Iris-Versicolor is:  1.0\
The minimum sepal width of the Iris-Virginica is:  1.4\
The maximum sepal width of the Iris-Setosa is:  0.6\
The maximum sepal width of the Iris-Versicolor is:  1.8\
The maximum sepal width of the Iris-Virginica is:  2.5

![Scatter plot sepal width](https://github.com/NurseQ/Project-Iris-Flower-Dataset/blob/master/Images/Scatter%20sepal%20width.png)

**Figure 5** - Scatter plot of the Iris Setosa, plotting petal length on the x axis and petal width on the y axis . It is expected that further anlysis will use similar plots and placing the flower species in the same graph. The code is in [setosa.py](https://github.com/NurseQ/Project-Iris-Flower-Dataset/blob/master/setosa.py).

![petal length vs width](https://github.com/NurseQ/Project-Iris-Flower-Dataset/blob/master/Images/Scatter%20plot%20petal%20length%20vs%20width.png)

### 3a. Histograms
Other supporting graphs used in the project are histograms, which also show the underlying frequency distribution of the dataset. Histograms allow visualization of the shape of continous data including skewness and outliers within the dataset.

 Available: https://archive.ics.uci.edu/ml/datasets/iris. [Accessed: April 11,2018].

[2] R. A. Fisher, "The use of multiple measurements in taxonomic problems," *The Annals of Human Genetics, 1936,* [Online] Available: https://onlinelibrary.wiley.com/doi/pdf/10.1111/j.1469-1809.1936.tb02137.x. [Accessed: April 11, 2018].

[3] P. S. Hoey, "Statistical analysis of the Iris Flower Dataset", University of Massachusetts, [Online]. Available: http://patrickhoey.com/downloads/Computer_Science/03_Patrick_Hoey_Data_Visualization_Dataset_paper.pdf. [Accessed: April 11,2018].

repository: NurseQ/Project-Iris-Flower-Dataset

repo_name: NurseQ/Project-Iris-Flower-Dataset


text:
# Opscientia Open Web Fellowship: \<PROJECT TITLE>
  name: \<name>, email: \<email address>, location: \<location>, timezone: \<timezone>, discordID: \<discord id>, discourseID:
  \<discourse id>, current role: \<student, degree, institution, class>

  mentor: \<mentor>, category: <cloud-services/semantic-web/token-community/other>

  ## Overview
  What is the goal of the project? Why is this important? What problems will it solve?

  ## Implementation Plan
  How will the work proceed in general?

  ### Minimum Deliverables
  What are the general minimum deliverables? How do they address the goal?

  #### Aim/Deliverable 1
  What is the first aim of the project? List the software packages you will be using. Provide examples of workflow or code to test this aim. Use flowcharts when necessary to communicate complex ideas.  What are your expected results? How will you interpret these results?

  #### Aim/Deliverable 2
  Describe the next aim.

  ### Timeline
  Describe the timeline in brief. Then fill out the table below describing how you will break up work over the period of the fellowship.

| Week      | Activity |
| ----------- | ----------- |
| 1      | Deliverable : Description of work       |
| 2      | Deliverable : Description of work       |
| 3      | Deliverable : Description of work       |
| 4      | Deliverable : Description of work       |
| 5      | Deliverable : Description of work       |
| 6      | Deliverable : Description of work, **Mid-term performance review / community feedback**       |
| 7      | Deliverable : Description of work       |
| 8      | Deliverable : Description of work       |
| 9      | Deliverable : Description of work       |
| 10      | Deliverable : Description of work       |
| 11      | Deliverable : Description of work       |
| 12      | Deliverable : Description of work,   **Submit Final Report + Code/Materials on Discourse #pulse**    |

### Ethical Review
Does your work involve human or animal subjects? If so, has your work been approved by an Institutional Review Board or gone through any Ethical Review process? If so, please provide a link to your IRB/Ethical Review protocol.

### Plan for Communication with Mentor
What is the plan to communicate with your mentor? What forms will you use and how regularly will you meet?

### Plans to Continue with Project
Are you interested in continuing to work on the project, either as a support role or expanding activities/features?

## Candidate Details

### Motivation
Why are you working on this project?

### Background
How does your background make you a good fit for this project?

### Working time and commitments
How much time do you plan to committ to this? Are there potential conflicts? How will you navigate issues if you reach a block and can't continue on your own?

### Curricula Vitae
(link to your CV, social media, or portfolio)

### References
Please list any references, software packages, or other resources in APA format

repository: opscientia/open-web-fellowship

repo_name: opscientia/open-web-fellowship


text:
# Introducing `?`

Sometimes we just want the simplicity of `unwrap` without the possibility of
a `panic`. Until now, `unwrap` has forced us to nest deeper and deeper when
what we really wanted was to get the variable *out*. This is exactly the purpose of `?`.

Upon finding an `Err`, there are two valid actions to take:

1. `panic!` which we already decided to try to avoid if possible
2. `return` because an `Err` means it cannot be handled

`?` is *almost*[^†] exactly equivalent to an `unwrap` which `return`s
instead of `panic`king on `Err`s. Let's see how we can simplify the earlier
example that used combinators:

```rust,editable
use std::num::ParseIntError;

fn multiply(first_number_str: &str, second_number_str: &str) -> Result<i32, ParseIntError> {
    let first_number = first_number_str.parse::<i32>()?;
    let second_number = second_number_str.parse::<i32>()?;

    Ok(first_number * second_number)
}

fn print(result: Result<i32, ParseIntError>) {
    match result {
        Ok(n)  => println!("n is {}", n),
        Err(e) => println!("Error: {}", e),
    }
}

fn main() {
    print(multiply("10", "2"));
    print(multiply("t", "2"));
}
```

## The `try!` macro

Before there was `?`, the same functionality was achieved with the `try!` macro.
The `?` operator is now recommended, but you may still find `try!` when looking
at older code. The same `multiply` function from the previous example
would look like this using `try!`:

```rust,editable,edition2015
// To compile and run this example without errors, while using Cargo, change the value
// of the `edition` field, in the `[package]` section of the `Cargo.toml` file, to "2015".

use std::num::ParseIntError;

fn multiply(first_number_str: &str, second_number_str: &str) -> Result<i32, ParseIntError> {
    let first_number = try!(first_number_str.parse::<i32>());
    let second_number = try!(second_number_str.parse::<i32>());

    Ok(first_number * second_number)
}

fn print(result: Result<i32, ParseIntError>) {
    match result {
        Ok(n)  => println!("n is {}", n),
        Err(e) => println!("Error: {}", e),
    }
}

fn main() {
    print(multiply("10", "2"));
    print(multiply("t", "2"));
}
```

[^†]: See [re-enter ?][re_enter_?] for more details.

[re_enter_?]: ../multiple_error_types/reenter_question_mark.md

repository: rust-lang/rust-by-example

repo_name: rust-lang/rust-by-example


text:
Examples showing different features of the Gauge JS plugin.

This directory is a Gauge project created using `gauge init js`. Each test implementation file in the `tests/` sub-directory highlights each feature:

- `module.exports`: [tests/vowels.js](tests/vowels.js)
- `require`: [tests/step_implementations.js](tests/step_implementations.js)

repository: getgauge/gauge-js

gha_language: JavaScript

gha_license_id: MIT

repo_name: getgauge/gauge-js


text:
# Posting Data To The Server With A Form

## Skills

- Can create a form that does an HTTP `GET` request
- Can create a form that does an HTTP `POST` request
- Can describe the difference between HTTP query params and HTTP body params
- Can describe the difference between a relative and absolute HTTP URL path
- Can describe an HTTP redirect

## Search Terms

```
html forms
express form handling
html forms method get post
how to parse a body of a request express
```

## Suggested Resources

### Reading

- https://www.w3schools.com/html/html_forms.asp
- https://www.hacksparrow.com/form-handling-processing-in-express-js.html

### Watching

- https://www.youtube.com/watch?v=rin7gb9kdpk
- https://www.youtube.com/watch?v=vKlybue_yMQ

### Lectures

- [Trevor's Lecture on "Posting Data To The Server With A Form"](https://www.youtube.com/watch?v=DzSwBuMfo0g)

## Exercises

### Part 1

- Complete the following sections in the `Express Basics` course in [TeamTreeHouse](https://teamtreehouse.com/library/express-basics)
  - Using Templates with Express

### Part 2

Build a basic web app using Express which can send data to the server via an HTML `<form>` element. You will be required to create two simple pages on the app. The mockups are provided below (notice that while the forms are nearly identical, they have two distinct differences, the URL, and the method attached to the form). When this is completed you should be able to navigate to both URLs and see the same form, but the form at the URL `'/form-get'` should use a `GET` method, while the form that is rendered at the URL `'/form-post'` should use a `POST` method. You could achieve this by creating two seperate views, or for an extra challenge, create one view, that depending on which URL you navigate to, dynamically sets the method of the form as appropriate.

#### Form Get Page

The `action` property of the form should be set to `/submit-form`

![form-get](./data/form-get.png)

#### Form Post Page

The `action` property of the form should be set to `/submit-form`

![form-post](./data/form-post.png)

#### Server Routes

The server should have the following routes:
1. A route to render the `/form-get` page
    - url: `/form-get`
    - http method: `GET`
    - response: renders the `<form>` with its method set to `GET`, and its `action` set to `/submit-form`.
2. A route to render the `/form-post` page
    - url: `/form-post`
    - http method: `GET`
    - response: renders the `<form>` with its method set to `POST`,  and its `action` set to `/submit-form`
3. A route which handles the form submissions
    - url: `/submit-form`
    - http method: `ANY`
    - response: returns a JSON response of the request's body params and the request's query params
    - example response: `{"body-params": {"artist": "bonobo", "country": "uk"}, "query-params": {}}`

repository: eobaah/curriculum-app

repo_name: eobaah/curriculum-app


text:
# COVID-19 Lungs-CT-Segmentation

This is a project of the Google Developer Student Club of FPT University Da Nang, built by members, and entered the TOP 10 finalists at the FPT Edu Hackathon 2021 in Hanoi, Vietnam.

Project name: Deep Learning application to detect patients infected with Covid-19 from chest CT images.

Folder Gdrive details about project (includes code file, video demo, presentation) [here](https://drive.google.com/drive/folders/1bM-GdL_Y1QXwXYOp5sPtXgkzVoVpNiLM?usp=sharing)

Contact me by email if you want any suggestions (dataset, R&D guildline<EMAIL_ADDRESS>
## Summary of ideas

The COVID-19 pandemic is causing major outbreaks in 150 countries around the world, severely affecting the health and lives of many people around the globe.
Over the course of our research, we've found that one of the key steps in fighting COVID-19 is the ability to detect infected patients early enough and get them into intensive care. Detecting this disease from an X-ray is probably one of the fastest ways to diagnose the disease in a patient.

## Problems

Excerpts from a number of international studies show that Cough is the more common symptom and occurs in 68-83% of people infected with Covid-19 and it is the late stage of this symptom that is one of the most common causes. pneumonia leading to patient death. In addition, the actual diagnosis can be complicated because the pneumonia caused by Covid-19 is barely visible or difficult to predict on radiographs,
Inspired by previous works, the team studied the application of a deep learning model (Deep Learning) to detect patients infected with COVID-19 from their chest X-ray images.

Up to the present time, Vietnam has recorded many cases of death diagnosed due to severe pneumonia, progressive respiratory failure due to COVID-19. In addition, the unpredictable change of the new SARS-CoV-2 virus variant will increase the number of cases and the possibility of respiratory transmission. Without the application of advanced medical technology research, it will be difficult for doctors to diagnose and perform clinical examination for continuously hospitalized infections.
Therefore, the project wants to help experts, doctors and nurses in Vietnam and around the world to overcome the challenges of the COVID-19 pandemic.

##  Let's solve it!

The team hopes that the project's research method characteristic can be tested and contributed to the diagnosis and examination process from initial infections to acute pneumonia, especially as a potential contribution. performance in diagnosing multiple cases at the same time.

We used the Image Instance problem to quantify and measure the volume of the pneumonia infection area caused by the COVID-19 virus based on Deep Learning algorithms, basic and advanced Machine Learning methods. . From there, it can provide useful information about fighting the COVID-19 pandemic.

Model towards: U - NET architecture based on Convolutional Neural Networks (CNN) model.

Tools that the team uses include: TensorFlow, Keras, Pandas, Google Collab, PyCharm, 3D Slicer, ...

##  Potential
The team hopes that the project's research method characteristic can be tested and contributed to the diagnosis and examination process from initial infections to acute pneumonia, especially as a potential contribution. performance in diagnosing multiple cases at the same time.

Briefly describe the effectiveness of the product when implemented in practice:

To date, X-ray and CT imaging has been an affordable, common, detailed screening tool that effectively visualizes and accelerates the assessment of severity of COVID-19 lesions. For this research project, the team aimed to demonstrate the utility of an automated tool to segment and measure pneumonia based on computer simulations on data sets. The tool's strengths include its ability to quantify lesions, help visualize infected areas, and quickly monitor disease progression.
Furthermore, the team's research holds great promise in its plan to combine imaging data with clinical manifestations and test results to help better test, detect and diagnose COVID-19.

As the COVID-19 pandemic will continue to spread around the world on an unpredictable trajectory, the team hopes that the research can be suggested for large-scale clinical applications; contribute to building cutting-edge tools for health systems, and collectively face similar challenges, including abnormalities caused by viruses and other diseases.

## License

MIT


text:
# FROST

FROST is for people who write desktop applications that read text based input
file decks. The apps often end up having to read and parse a number of files in
a whole variety of formats. Maybe a mix of XML, JSON, CSV, text delimitted etc.
The file formats are often not standardised and can be frankly eccentric.

Consequently, a great deal of time is expended in writing file parsers and
interpreters in multiple languages and for multiple platforms.

Frost seeks to replace this with a single web service API that sucks in all the
files in an input directory, makes a stab at deducing what the formats mean,
and then returning the whole thing as one big structured JSON representation.

It tries to recognize lists and tables etc rather like a human being would. It
doesn't expect to get this right. But it does expect to make it repeatable,
which removes much of the heavy lifting from the original coder.

It serves interactive web pages too as well as the API. It's written in Go and
the current work in progress is hosted on Google App Engine here

http://frost-1001.appspot.com/quickstart

You can read more in the docs directory.


text:
#A briefe memento to the present un-parliamentary junto touching their present intentions and proceedings, to depose & execute Charles Steward, their lawfull King. By William Prynne Esquire, a Member of the House of Commons, and prisoner under the Armies tyranny; who, it seemes, have levyed war against the Houses of Parliament, their quandam-masters whose Members they now forcibly take and detaine captives, during their lawfull pleasures.#

##Prynne, William, 1600-1669.##
A briefe memento to the present un-parliamentary junto touching their present intentions and proceedings, to depose & execute Charles Steward, their lawfull King. By William Prynne Esquire, a Member of the House of Commons, and prisoner under the Armies tyranny; who, it seemes, have levyed war against the Houses of Parliament, their quandam-masters whose Members they now forcibly take and detaine captives, during their lawfull pleasures.
Prynne, William, 1600-1669.

##General Summary##

**Links**

[TCP catalogue](http://www.ota.ox.ac.uk/tcp/)  •
[HTML](http://tei.it.ox.ac.uk/tcp/Texts-HTML/free/A56/A56138.html)  •
[EPUB](http://tei.it.ox.ac.uk/tcp/Texts-EPUB/free/A56/A56138.epub) •
[Page images (Historical Texts)](https://data.historicaltexts.jisc.ac.uk/view?pubId=eebo-99825241e&pageId=eebo-99825241e-29618-1)

**Availability**

This keyboarded and encoded edition of the
	       work described above is co-owned by the institutions
	       providing financial support to the Early English Books
	       Online Text Creation Partnership. This Phase I text is
	       available for reuse, according to the terms of Creative
	       Commons 0 1.0 Universal. The text can be copied,
	       modified, distributed and performed, even for
	       commercial purposes, all without asking permission.

**Major revisions**

1. __2002-04__ __TCP__ *Assigned for keying and markup*
1. __2002-04__ __Apex CoVantage__ *Keyed and coded from ProQuest page images*
1. __2002-05__ __TCP Staff (Michigan)__ *Sampled and proofread*
1. __2002-05__ __Allison Liefer__ *Text and markup reviewed and edited*
1. __2002-06__ __pfs__ *Batch review (QC) and XML conversion*

##Content Summary##

#####Front#####

1. An Ordinance for declaring all Votes, Orders, and Ordinances, passed in one or both Houses, since the force on both Houses, Iuly 26. untill the sixth of this present August, 1647. to be null and voyd.

#####Body#####

1. A breif Memento to the present Vnparliamentary Iunto, touching their present intentions and proceedings to Depose and Execute CHARLES STEWARD, their law•…ull King of ENGLAND, &c.

1. Prov. 28. 23.

1. A POSTSCRIPT.

**Types of content**

  * Oh, Mr. Jourdain, there is **prose** in there!

There are 285 **ommitted** fragments!
 @__reason__ (285) : illegible (285)  •  @__resp__ (285) : #APEX (285)  •  @__extent__ (285) : 1+ letters (157), 1 word (127), 1 span (1)

**Character listing**

|Text|string(s)|codepoint(s)|
|---|---|---|
|Latin-1 Supplement|óé|243 233|
|Combining             Diacritical Marks|̄|772|
|General Punctuation|•…|8226 8230|
|Geometric Shapes|◊|9674|
|CJKSymbolsandPunctuation|〈〉|12296 12297|

##Tag Usage Summary##

###Header Tag Usage###

|No|element name|occ|attributes|
|---|---|---|---|
|1.|__author__|2||
|2.|__availability__|1||
|3.|__biblFull__|1||
|4.|__change__|5||
|5.|__date__|8| @__when__ (1) : 2003-01 (1)|
|6.|__edition__|1||
|7.|__editionStmt__|1||
|8.|__editorialDecl__|1||
|9.|__extent__|2||
|10.|__idno__|6| @__type__ (6) : DLPS (1), STC (2), EEBO-CITATION (1), PROQUEST (1), VID (1)|
|11.|__keywords__|1| @__scheme__ (1) : http://authorities.loc.gov/ (1)|
|12.|__label__|5||
|13.|__langUsage__|1||
|14.|__language__|1| @__ident__ (1) : eng (1)|
|15.|__listPrefixDef__|1||
|16.|__note__|6||
|17.|__notesStmt__|2||
|18.|__p__|11||
|19.|__prefixDef__|2| @__ident__ (2) : tcp (1), char (1)  •  @__matchPattern__ (2) : ([0-9\-]+):([0-9IVX]+) (1), (.+) (1)  •  @__replacementPattern__ (2) : http://eebo.chadwyck.com/downloadtiff?vid=$1&page=$2 (1), https://raw.githubusercontent.com/textcreationpartnership/Texts/master/tcpchars.xml#$1 (1)|
|20.|__projectDesc__|1||
|21.|__pubPlace__|2||
|22.|__publicationStmt__|2||
|23.|__publisher__|2||
|24.|__ref__|2| @__target__ (2) : https://creativecommons.org/publicdomain/zero/1.0/ (1), http://www.textcreationpartnership.org/docs/. (1)|
|25.|__seriesStmt__|1||
|26.|__sourceDesc__|1||
|27.|__term__|3||
|28.|__textClass__|1||
|29.|__title__|3||
|30.|__titleStmt__|2||

###Text Tag Usage###

|No|element name|occ|attributes|
|---|---|---|---|
|1.|__closer__|2||
|2.|__date__|2||
|3.|__dateline__|2||
|4.|__desc__|285||
|5.|__div__|5| @__type__ (5) : title_page (1), ordinance (1), commentary (1), Scripture (1), postscript (1)|
|6.|__g__|125| @__ref__ (125) : char:EOLhyphen (124), char:cmbAbbrStroke (1)|
|7.|__gap__|285| @__reason__ (285) : illegible (285)  •  @__resp__ (285) : #APEX (285)  •  @__extent__ (285) : 1+ letters (157), 1 word (127), 1 span (1)|
|8.|__head__|4||
|9.|__hi__|381||
|10.|__note__|28| @__n__ (18) : * (18)  •  @__place__ (28) : margin (28)|
|11.|__opener__|2||
|12.|__p__|21| @__n__ (10) : 1 (1), 2 (1), 3 (1), 4 (1), 5 (1), 6 (1), 7 (1), 8 (1), 9 (1), 10 (1)|
|13.|__pb__|18| @__facs__ (18) : tcp:29618:1 (2), tcp:29618:2 (2), tcp:29618:3 (2), tcp:29618:4 (2), tcp:29618:5 (2), tcp:29618:6 (2), tcp:29618:7 (2), tcp:29618:8 (2), tcp:29618:9 (2)  •  @__rendition__ (2) : simple:additions (2)  •  @__n__ (15) : 2 (1), 3 (1), 4 (1), 5 (1), 6 (1), 7 (1), 8 (1), 9 (1), 10 (1), 11 (1), 12 (1), 13 (2), 15 (1), 16 (1)|
|14.|__q__|5||
|15.|__salute__|1||
|16.|__seg__|1| @__rend__ (1) : decorInit (1)|
|17.|__signed__|2||
|18.|__trailer__|1||


text:
# guld-git-remote-cli

Manage git remotes the guld way.

### Example Output

### Install

```
npm i -g guld-git-remote-cli
```

### Usage

##### CLI

```
  Usage: guld-git-remote [options] [command]

  Manage git remotes the guld way.

  Options:

    -V, --version         output the version number
    -h, --help            output usage information

  Commands:

    remove|delete [name]  Remove one or all remotes from the given or current directory.
    add [options] [slug]  Add one or all user branch remotes to the current directory.
```

branch_name: refs/heads/isysd


text:
**_Important_: This documentation is out of date but the project itself has been updated to work with Swift 5 and Xcode14**

# iOS Dynamic Embedded Framework Loading

An example project showing embedded framework with conditional dynamic class loading based on scheme.

## DynamicLoader.framework
The interfaces to any dynamically loaded classes are defined in a seperate framework that is always available to the app.  It is both *embedded* and *linked* with the app `DynamicLoaderExampleApp.app`.

```swift
public protocol AnInterfaceAvailableToApp {
    static func doSomething()
    static func doSomethingElse() -> String
}
```

## DynamicFramework.framework
This is the framework that is conditionally included in the app.  The framework is always *embedded* but **not** *linked* with the app `DynamicLoaderExampleApp.app`. It is *"linked"* with the framework that defines its interface `DynamicLoader.framework`.

Any class that we want to dynamically load must implement an interface that the app is aware of.

```swift
public class DynamicClassExample : AnInterfaceAvailableToApp {

    public static func doSomething() {
        print("loaded dynamic class")
    }

    public static func doSomethingElse() -> String {
        return "Hello, World!"
    }

}
```

The framework is loaded before the class is retrieved by name.
```swift
let bundleURL = NSBundle.URLForResource("DynamicFramework", withExtension: "framework", subdirectory: "Frameworks", inBundleWithURL: NSBundle.mainBundle().bundleURL)
let bundle = NSBundle(URL: bundleURL)
bundle.load()
```

Swift class names should include the module name.
```swift
 let aClass = NSClassFromString("DynamicFramework.DynamicClassExample")
```

## DynamicLoaderExampleApp.app
The app uses the interfaces provided by the `DynamicLoader.framework` and nothing from `DynamicFramework.framework` directly.
```swift
 guard let aConformingClass = aClass as? AnInterfaceAvailableToApp.Type else {
    //the class was not loaded
    return
 }

 //the class was loaded and we can do something
 aConformingClass.doSomething()
```

There is an additional build phase for the app that will conditionally remove dynamic framework `DynamicFramework.framework` depending on the scheme being run.  This is often helpful for inlcuding additional code during development or testing but leaving it out of the a release.
```bash
if [ "${CONFIGURATION}" == "Release" ]; then
rm -rf "${BUILT_PRODUCTS_DIR}/${PRODUCT_NAME}.app/Frameworks/DynamicFramework.framework"
fi
```

repository: nicholascross/iOSDynamicLoaderExample

repo_name: nicholascross/iOSDynamicLoaderExample


text:
Putting It All Together
=======================
In previous chapters we've seen how to define our application's data types which will be used for interacting with Raft, we've seen how to implement the `RaftNetwork` trait, we've seen how to implement the `RaftStorage` trait, and we've reviewed the `Raft` API itself. Now its time to put all of these components together. Let's do this.

For this chapter, we're going to use snippets of the code found in the `memstore` crate, which is an in-memory implementation of the `RaftStorage` trait for demo and testing purposes, which also happens to be used for all of the integration tests of `async-raft` itself.

### Recap On Our Data Types
As we've seen earlier, here are our `AppData` and `AppDataResponse` types/impls.

```rust
/// The application data request type which the `MemStore` works with.
///
/// Conceptually, for demo purposes, this represents an update to a client's status info,
/// returning the previously recorded status.
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ClientRequest {
    /// The ID of the client which has sent the request.
    pub client: String,
    /// The serial number of this request.
    pub serial: u64,
    /// A string describing the status of the client. For a real application, this should probably
    /// be an enum representing all of the various types of requests / operations which a client
    /// can perform.
    pub status: String,
}

impl AppData for ClientRequest {}

/// The application data response type which the `MemStore` works with.
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ClientResponse(Result<Option<String>, ClientError>);

impl AppDataResponse for ClientResponse {}
```

### RaftNetwork impl
We've already discussed the `RaftNetwork` trait in a previous chapter. Here is an abbreviated snippet of what the `RaftNetwork` impl looks like in the `async-raft` integration test suite.

```rust
// We use anyhow::Result in our impl below.
use anyhow::Result;

/// A type which emulates a network transport and implements the `RaftNetwork` trait.
pub struct RaftRouter {
    // ... some internal state ...
}

#[async_trait]
impl RaftNetwork<ClientRequest> for RaftRouter {
    /// Send an AppendEntries RPC to the target Raft node (§5).
    async fn append_entries(&self, target: u64, rpc: AppendEntriesRequest<ClientRequest>) -> Result<AppendEntriesResponse> {
        // ... snip ...
    }

    /// Send an InstallSnapshot RPC to the target Raft node (§7).
    async fn install_snapshot(&self, target: u64, rpc: InstallSnapshotRequest) -> Result<InstallSnapshotResponse> {
        // ... snip ...
    }

    /// Send a RequestVote RPC to the target Raft node (§5).
    async fn vote(&self, target: u64, rpc: VoteRequest) -> Result<VoteResponse> {
        // ... snip ...
    }
}
```

### RaftStorage impl
We've already got a `RaftStorage` impl to work with from the `memstore` crate. Here is an abbreviated snippet of the code.

```rust
// We use anyhow::Result in our impl below.
use anyhow::Result;

#[async_trait]
impl RaftStorage<ClientRequest, ClientResponse> for MemStore {
    type Snapshot = Cursor<Vec<u8>>;
    type ShutdownError = ShutdownError;

    async fn get_membership_config(&self) -> Result<MembershipConfig> {
        // ... snip ...
    }

    async fn get_initial_state(&self) -> Result<InitialState> {
        // ... snip ...
    }

    // The remainder of our methods are implemented below.
    // ... snip ...
}
```

### Raft Type Alias
For better readability in your application's code, it would be beneficial to define a type alias which fully qualifies all of the types which your Raft instance will be using. This is quite simple. The example below is taken directly from this project's integration test suite, which uses the `memstore` crate and a specialized `RaftNetwork` impl designed specifically for testing.

```rust
/// A concrete Raft type used during testing.
pub type MemRaft = Raft<ClientRequest, ClientResponse, RaftRouter, MemStore>;
```

### Give It The Boot
Though applications will be much more complex than this contrived example, booting a Raft node is dead simple. Even if your application uses a multi-Raft pattern for managing different segments / shards of data, the same principal applies. Boot a Raft node, and retain its instance for API usage.

```rust
//! This code assumes the code samples above.

#[tokio::main]
async fn main() {
    // Get our node's ID from stable storage.
    let node_id = get_id_from_storage().await;

    // Build our Raft runtime config, then instantiate our
    // RaftNetwork & RaftStorage impls.
    let config = Arc::new(Config::build("primary-raft-group".into())
        .validate()
        .expect("failed to build Raft config"));
    let network = Arc::new(RaftRouter::new(config.clone()));
    let storage = Arc::new(MemStore::new(node_id));

    // Create a new Raft node, which spawns an async task which
    // runs the Raft core logic. Keep this Raft instance around
    // for calling API methods based on events in your app.
    let raft = Raft::new(node_id, config, network, storage);

    run_app(raft).await; // This is subjective. Do it your own way.
                         // Just run your app, feeding Raft & client
                         // RPCs into the Raft node as they arrive.
}
```

----

You've officially ascended to the next level of AWESOME! Next, let's take a look at cluster lifecycle controls, dynamic membership, and the like.

repository: async-raft/async-raft

gha_language: Rust

gha_license_id: NOASSERTION

repo_name: async-raft/async-raft


text:
# capybara-ios-emulation-driver

[![Build Status](https://travis-ci.org/sunaot/capybara-ios-emulation-driver.png)](https://travis-ci.org/sunaot/capybara-ios-emulation-driver)

Enable drivers to emulate iOS user agent.

## Installation

Add this line to your application's Gemfile:

    gem 'capybara-ios-emulation-driver'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install capybara-ios-emulation-driver

## Usage

```
# chrome
Capybara.register_driver :ios_chrome do |app|
  Capybara::Selenium::Driver::Ios.chrome_driver
end
Capybara.default_driver = :ios_chrome

# firefox
Capybara.register_driver :ios_ff do |app|
  Capybara::Selenium::Driver::Ios.firefox_driver
end
Capybara.default_driver = :ios_ff

# rack test
Capybara.register_driver :ios_rack_test do |app|
  Capybara::RackTest::Driver::Ios.rack_test_driver :app => app
end
Capybara.default_driver = :ios_rack_test
```

## Contributing

1. Fork it ( http://github.com/sunaot/capybara-ios-emulation-driver/fork )
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

repository: rcorreia/capybara-ios-emulation-driver

gha_language: Ruby

repo_name: rcorreia/capybara-ios-emulation-driver


text:
# BevyGame

Work in progress game.

## Building and running

To build this project, you need to install the latest version of the Rust nightly compiler from [rustup.rs](https://rustup.rs/).
Ensure that you have the correct version installed by running these commands:

```sh
rustup self update
rustup override set nightly
rustup update
```

Additionally, you may need to install the following packages on your computer:

- clang (Linux)
- lld (Linux) / zld (Mac OSX)

Finally, compile and run the game via the following commands:

```sh
cd engine
cargo run # Add flags here
```

Possible flags:

- `--features trace`: Add tracing output usable by chrome://tracing
- `--release`: Takes longer to compile, but optimizes the build output
   - Certain CPU-specific optimizations may be performed by release builds, so ensure you build on the computer you intend to run it from

repository: TehPers/BevyGame

repo_name: TehPers/BevyGame


text:
The following chrome extension will enable you to manage the Jira tickets directly from the Pull Request page. It will allow you to move the ticket into Code Review when opening a new pull request. When you are ready to merge the ticket you can then move the ticket into Dev Complete.

The extension extracts the ticket information from the branch name so be sure to follow the Branch Naming strategy mentioned below.

You can install the chrome extension from the [Chrome Web Store](https://chrome.google.com/webstore/detail/github-itv-jira/ggagmghbcfegjeekpjcplcmokpjhmajh)

![](https://lh3.googleusercontent.com/iFYxH9czXUvEm0f7i9GhwB2U1wMfF-wu3gVpS1uL-1sF9t2gBCbm8EV7_sqiOT_eBOoKo645=w640-h400-e365)

![](https://lh3.googleusercontent.com/SLzJ_tMDHBob1ZpFXrlvz5HERQwsA7wGu-Tiia-9mDvgy0SaZ5-_mlBZZP0o_8honHBoYItMhfU=w640-h400-e365)

![](https://lh3.googleusercontent.com/SWozYH5wO86R6Yy5akJkrgc2A3EBM_9znjRUp0638dI0JLO7p4v-rdJYKNSwrpxuXAjqsGIBxw=w640-h400-e365)

**Branching strategy**

# Feature branches

When creating a new feature you will need to create a new branch from `develop` with the format below. In the examples below `IHIA-1234` refers to the `id` of the ticket that relates to the feature. Using this `id` will allow the branches to link with Jira. Everything after `IHIA-1234` in the examples below describes the feature using `_` as a separator. This style is also used for branches for bug fixes.

```
feature/IHIA-1234_some_iOS_feature
```

# Release branches

To create a release branch you need to take a branch from `develop` using the format in the example below where `1.5` represents the version number. If features are needed to be added to the release you can take a branch from the release branch adding the ticket `id` (`IHIA-1234` in the example below) and description as shown in the examples below. In the example below `release/1.5` is the main release branch and the other examples are features that will be merged back into the release branch.

```
release/1.5
release_1_5/IHIA-1234_some_iOS_feature
```

# Work in progress branches

Work in progress branches are used for long running features that may need to be excluded from `develop` for some reason, for example perhaps ITV want to build the feature but want to delay its release so it cannot be included in the main `develop` branch. In the example below `wip_long_running_feature/wip` is the main work in progress branch and the other examples are features that will be merged back into the work in progress branch.

```
wip_long_running_feature/wip
wip_long_running_feature/IHIA-1234_some_iOS_feature
```

repository: Jride/Github-ITV-Jira-Chrome-Ext

repo_name: Jride/Github-ITV-Jira-Chrome-Ext