text:
---
rid: 1462806
bid: fish-shell
rcd: install
srcpath: fish-shell/install.md
title: インストールと設定
date: 2016/05/10
layout: refill.jade
---

## Install fish shell

```bash
$ brew install fish
$ echo "/usr/local/bin/fish" | sudo tee -a /etc/shells
$ chsh -s /usr/local/bin/fish
```

#### Required fish version: v2.3.0 on Fisherman
https://github.com/fisherman/fisherman#what-is-the-required-fish-version

```bash
$ brew up; and brew upgrade --HEAD fish
```

## Install Fisherman
[fisherman/fisherman: fish plugin manager http://fisherman.sh](https://github.com/fisherman/fisherman)

### config

```bash
# config file
$ vim .config/fish/config.fish
```

```bash
# reload config
$ source .config/fish/config.fish
```

#### writing config.fish

```bash
# .bashrc
export PATH=$HOME/.nodebrew/current/bin:$PATH

# config.fish (command like, space separated)
set PATH $PATH $HOME/.nodebrew/current/bin
```

### set export

```bash
set -gx http_proxy http://localhost:8080
```

repository: GuiltyMorishita/refills

repo_name: GuiltyMorishita/refills


text:
# Gary Zhao's Submission for Asana WebDev Take-Home Exercise

Hi! 👋🏼
This is my submission for the [Asana's Web Development Take-Home Exercise](https://github.com/Asana/webdev-take-home-exercise). My focus of choice was Design.

Please see the functional website here: https://www.garyzhao.com/asana-coding-challenge/

Technology I used:

- [Gatsby](https://www.gatsbyjs.org/)
- [Styled Components](https://www.styled-components.com/)

If there is any questions, please feel free to reach out to me.

Thanks for stopping by! 🙏🏼

license: MIT

repository: garyjzhao/asana-coding-challenge

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

gha_license_id: MIT

license_type: permissive

repo_name: garyjzhao/asana-coding-challenge


text:
## Parameters

`object`
`order`
`scope`
`operand`
See the table below.

## Description

These operations perform arithmetic and bitwise computations. All of
these operations are applicable to an object of any atomic integer type.
The key, operator, and computation correspondence is given in the table
below:

| key                  | op                   | computation           |
| --- | --- | --- |
|  `add`                |  \+                   |  addition              |
|  `sub`                |  \-                   |  subtraction           |
|  `or`                 |||
|  `xor`                |  ^                    |  bitwise exclusive or  |
|  `and`                |  &                    |  bitwise and           |
|  `min`                |  min                  |  compute min           |
|  `max`                |  max                  |  compute max           |

For atomic\_fetch and modify functions with key = add or sub on atomic
types `atomic_intptr_t` and `atomic_uintptr_t`, `M` is `ptrdiff_t`. For
atomic\_fetch and modify functions with key = or, xor, and, min and max
on atomic types `atomic_intptr_t` and `atomic_uintptr_t`, `M` is
`intptr_t` and `uintptr_t`.

Atomically replaces the value pointed to by `object` with the result of
the computation applied to the value pointed to by `object` and the
given operand. Memory is affected according to the value of `order`.
These operations are atomic read-modify-write operations (as defined by
section <IP_ADDRESS> of the C11 specification). For signed integer types,
arithmetic is defined to use two’s complement representation with silent
wrap-around on overflow; there are no undefined results. For address
types, the result may be an undefined address, but the operations
otherwise have no undefined behavior. Returns atomically, the value
pointed to by `object` immediately before the effects.

In these operation definitions:

-   An `A` refers to one of the atomic types.

-   A `C` refers to its corresponding non-atomic type.

-   An `M` refers to the type of the other argument for arithmetic
    operations. For atomic integer types, `M` is `C`.

-   The functions not ending in explicit have the same semantics as the
    corresponding explicit function with `memory_order_seq_cst` for the
    `memory_order` argument.

-   The functions that do not have `memory_scope` argument have the same
    semantics as the corresponding functions with the `memory_scope`
    argument set to `memory_scope_device`.

|   |   |
---|---|
|  Note                              |  With fine-grained system SVM,       sharing happens at the              granularity of individual loads     and stores anywhere in host         memory. Memory consistency is       always guaranteed at                synchronization points, but to      obtain finer control over           consistency, the OpenCL atomics     functions may be used to ensure     that the updates to individual      data values made by one unit of     execution are visible to other      execution units. In particular,     when a host thread needs fine       control over the consistency of     memory that is shared with one or   more OpenCL devices, it must use    atomic and fence operations that    are compatible with the C11         atomic operations.                |

We can’t require C11 atomics since host programs can be implemented in
other programming languages and versions of C or C++, but we do require
that the host programs use atomics and that those atomics be compatible
with those in C11.

Restrictions

All operations on atomic types must be performed using the built-in
atomic functions. C11 and C++11 support operators on atomic types.
OpenCL C does not support operators with atomic types. Using atomic
types with operators should result in a compilation error.

The `atomic_bool`, `atomic_char`, `atomic_uchar`, `atomic_short`,
`atomic_ushort`, `atomic_intmax_t` and `atomic_uintmax_t` types are not
supported by OpenCL C.

OpenCL C requires that the built-in atomic functions on atomic types are
lock-free.

The `_Atomic` type specifier and `_Atomic` type qualifier are not
supported by OpenCL C.

The behavior of atomic operations where pointer arguments to the atomic
functions refers to an atomic type in the private address space is
undefined.

## Also see

[Atomic Functions](atomicFunctions.html)

## Specification

[OpenCL 2.0 C Language Specification, page
109](https://www.khronos.org/registry/cl/specs/opencl-2.0-openclc.pdf#page=109)

## Copyright

[Copyright © 2007-2017 The Khronos Group Inc.](copyright.html)

repository: Galarius/vscode-opencl

gha_language: TypeScript

repo_name: Galarius/vscode-opencl


text:
# kintone-oauth-token-rs

A command to get a OAuth token for Kintone.

**This command uses a self-signed certificate, so please use this at your own risk.**

## Requirements

- If you use Chrome, you have to change the setting to allow insecure accesses.
    - Open `chrome://flags`
    - Enable `#allow-insecure-localhost`
    - I recommend disabling the setting again after you've gotten an OAuth token.
- Set the following environment variables.
    - `KINTONE_BASE_URL`
    - `KINTONE_OAUTH_CLIENT_ID`
    - `KINTONE_OAUTH_CLIENT_SECRET_ID`
    - `KINTONE_OAUTH_SCOPE`
    - See the details on the page.
        - https://developer.kintone.io/hc/en-us/articles/360001562353-How-to-add-OAuth-clients

If you use multiple scopes, you have to specify the following.

```
k:app_record:read%20k:app_record:write
```

## How to use

You can download the binary on the GitHub release page.

```
./kintone-oauth-token
```

## LICENSE

- [MIT](LICENSE)


text:
<!--
SPDX-FileCopyrightText: 2020-present Open Networking Foundation<EMAIL_ADDRESS>
SPDX-License-Identifier: Apache-2.0
-->

# GUI Development Prerequisites
This document provides an overview of the tools and packages needed to work on and to build onos-gui.
Developers are expected to have these tools installed on the machine where the project is built.

## Reusing tools from an existing ONOS installation
If you already have the legacy ONOS project code checked out and built using Bazel
on your system, then you already have all the tools you need.
Add the following 2 entries to your $PATH environment variable to give access
to the `npm` and the `ng` command respectively

* `[bazel output_base]/external/nodejs_linux_amd64/bin/nodejs/bin`
* `~/onos/web/gui2/node_modules/@angular/cli/bin`

where **[bazel output_base]** above can be found from running the command:
```bash
bazel info output_base
```

After setting the PATH it should be possible to see the version of **node** and **npm**:
```bash
node -v
npm -v
which ng
```

## NodeJS
If legacy ONOS is not available install the latest Long Term Support version of NodeJS on your system.

* Downloads are available from <https://nodejs.org/en/download/>
    * Please use **v10.16.0** or greater
* Instructions for installing on Linux are at <https://github.com/nodejs/help/wiki/Installation>

After installing it should be possible to see the version of **node** and **npm**
(which is bundled with it) that you installed with:
```bash
node -v
npm -v
```

## Angular CLI
If legacy ONOS is not available install Angular CLI to provide the **ng** tools. Installation instructions are at
<https://angular.io/guide/setup-local>

The following command can be run from any folder:
```bash
npm install -g @angular/cli
```

## Checkout the onos-gui code from Git
Using a process described [contributing.md](../../developers/contributing.md)
the Git repo should be forked in your own name on
[github.com/onosproject/onos-gui](https://github.com/onosproject/onos-gui).

```bash
git clone https://github.com/$GIT_USER/onos-gui.git
# or:
git clone git@github.com:$GIT_USER/onos-gui.git
```

```bash
cd $ONOS_ROOT/onos-gui
git remote add upstream https://github.com/onosproject/onos-gui.git
# or: git remote add upstream git@github.com:onosproject/onos-gui.git

# Never push to upstream master
git remote set-url --push upstream no_push

# Confirm that your remotes make sense:
git remote -v
```

## Set up Angular for local development
After this install (and after changing to the `web/onos-gui` folder) it should be
possible to see the Angular CLI version:
```bash
cd web/onos-gui
ng version
```
This should give a result like:

```bash
     _                      _                 ____ _     ___
    / \   _ __   __ _ _   _| | __ _ _ __     / ___| |   |_ _|
   / △ \ | '_ \ / _` | | | | |/ _` | '__|   | |   | |    | |
  / ___ \| | | | (_| | |_| | | (_| | |      | |___| |___ | |
 /_/   \_\_| |_|\__, |\__,_|_|\__,_|_|       \____|_____|___|
                |___/

Angular CLI: 8.3.20
Node: 10.16.0
OS: linux x64
Angular: 8.2.14
... animations, common, compiler, compiler-cli, core, forms
... language-service, platform-browser, platform-browser-dynamic
... router
...
```

## Angular dependencies
Staying inside the `web/onos-gui` folder, the Angular dependencies must be installed.
This is as simple as running `npm install` in the folder. This takes the dependencies
listed in `package.json` and installs them in the temporary folder `node_modules`:
```bash
npm install
```

## Docker
[Docker] is required to build the project Docker images and also to compile `*.proto` files into TypeScript source files.

## Local kubernetes environment
Some form of local kubernetes development environment is also needed.
The core team uses [Kind], but there are other options such as [Minikube] and [Microk8s] for Ubuntu.
The **[onit]** (ONOS Integration Test tool) should be used to set up the cluster,
or [deploy] gives more details on a Helm installation.

## IDE
Some form of an integrated development environment that supports Web Development
with TypeScript is also recommended. The core team uses the Intellij
[WebStorm IDE] from JetBrains, but there are many other options.
The [Atom] editor is a lightweight solution supporting TypeScript and Git integration.
[Visual Studio Code] is another option that supports TypeScript.

## License
The project requires that all Typescript source files are properly annotated using the Apache 2.0 License.
Since this requirement is enforced by the CI process, it is strongly recommended that developers
setup their IDE to include the [license text](https://github.com/onosproject/onos-gui/blob/master/build/licensing/boilerplate.ts.txt)
automatically.

[Docker]: https://docs.docker.com/install/
[Kind]: https://github.com/kubernetes-sigs/kind
[Minikube]: https://kubernetes.io/docs/tasks/tools/install-minikube/
[MicroK8s]: https://microk8s.io/

[WebStorm IDE]: https://www.jetbrains.com/webstorm/
[Atom]: https://atom.io/
[Visual Studio Code]: https://code.visualstudio.com

[onit]: ../../onos-test/docs/setup.md
[deploy]: ../../onos-config/docs/deployment.md

repository: onosproject/onos-gui

repo_name: onosproject/onos-gui


text:
Little Loader
=============

A lightweight, IE8+ JavaScript loader.

[![Travis Status][trav_img]][trav_site]

<!--
[![Coverage Status][cov_img]][cov_site]

[![Sauce Test Status][sauce_img]][sauce_site]
-->

### Goals

* Crafted to be inlined tightly in a page.
* Tested all the way down to IE8, but not further to keep the script as small
  as possible.
* Reliably calls back after script loads.
* ... and **that's it**!

### Usage

Little loader attaches to `window._lload` for use in your JavaScript.

```html
<script>
  window._lload("http://example.com/foo.js", function () {
    // foo.js is loaded!
  }/*, [optional context variable here] */);
</script>
```

[trav_img]: https://api.travis-ci.org/walmartlabs/little-loader.svg
[trav_site]: https://travis-ci.org/walmartlabs/little-loader
[sauce]: https://saucelabs.com
[sauce_img]: https://saucelabs.com/browser-matrix/wml-little-loader.svg
[sauce_site]: https://saucelabs.com/u/wml-little-loader
[cov]: https://coveralls.io
[cov_img]: https://img.shields.io/coveralls/walmartlabs/little-loader.svg
[cov_site]: https://coveralls.io/r/walmartlabs/little-loader

repository: exogen/little-loader

repo_name: exogen/little-loader


text:
# Measures

A collection of various distance/similarity, set theoretic and statistical measures in Java 8.

Set theoretic measures:

- Jaccard index
- Mutual information
- Overlap coefficient
- Simple Matching coefficient
- Sorensen-Dice coefficient

Rank correlation measures:
- Kendall rank correlation coefficient
- Spearman's rank correlation coefficient

Quantity correlation measures:
- Cosine similarity
- Pearson correlation coefficient

## Using

Measures is published to
[jcenter](https://bintray.com/gstamatelat/measures/measures). You
can add a dependency from your project as follows:

Using Maven

```xml
<dependency>
  <groupId>gr.james</groupId>
  <artifactId>measures</artifactId>
  <version>0.1</version>
</dependency>
```

Using Gradle

```
compile 'gr.james:measures:0.1'
```

repository: andy-wagner/measures

repo_name: andy-wagner/measures


text:
<% if (isJekyll) { %>---
title: NativeScript CLI
position: 1
---<% } %>

# NativeScript CLI

Usage | Synopsis
------|-------
General | `$ tns <Command> [Command Parameters] [--command <Options>]`
Alias | `$ nativescript <Command> [Command Parameters] [--command <Options>]`

## General Commands

Command | Description
-------|----------
[help `<Command>`](general/help.html) | Shows additional information about the commands in this list in the browser.
[autocomplete](general/autocomplete.html) | Configures your current command-line completion settings.
[usage-reporting](general/usage-reporting.html) | Configures anonymous usage reporting for the NativeScript CLI.
[error-reporting](general/error-reporting.html) | Configures anonymous error reporting for the NativeScript CLI.
[doctor `<platform>`](general/doctor.html) | Checks your system for configuration problems which might prevent the NativeScript CLI from working properly for the specified platform, if configured.
[info](general/info.html) | Displays version information about the NativeScript CLI, core modules, and runtimes.
[proxy](general/proxy.html) | Displays proxy settings.
[migrate](general/migrate.html) | Migrates the app dependencies to a form compatible with NativeScript 6.0.
[update](general/update.html) | Updates the project with the latest versions of iOS/Android runtimes and cross-platform modules.
[package-manager](general/package-manager.html) | Prints the value of the current package manager.

## Project Development Commands
Command | Description
---|---
[create](project/creation/create.html) | Creates a new project for native development with NativeScript.
[clean](general/clean.html) | Cleans project artifacts.
[platform add `<Platform>`](project/configuration/platform-add.html) | Configures the current project to target the selected platform.
[platform list](project/configuration/platform.html) | Lists all platforms that the project currently targets.
[platform remove `<Platform>`](project/configuration/platform-remove.html) | Removes the selected platform from the platforms that the project currently targets. This operation deletes all platform-specific files and subdirectories from your project.
[platform update `<Platform>`](project/configuration/platform-update.html) | Updates the NativeScript runtime for the specified platform.
[resources update](project/configuration/resources/resources-update.html) | Updates the App_Resources/<platform>'s internal folder structure to conform to that of an Android Studio project.
[resources generate splashes](project/configuration/resources/resources-generate-splashes.html) | Generates all splashscreens for Android and iOS platforms and places the generated images in the correct directories under `App_Resources/<platform>` directory.
[resources generate icons](project/configuration/resources/resources-generate-icons.html) | Generates all icons for Android and iOS platforms and places the generated images in the correct directories under `App_Resources/<platform>` directory.
[prepare `<Platform>`](project/configuration/prepare.html) | Copies relevant content from the app directory to the subdirectory for the selected target platform to let you build the project.
[build `<Platform>`](project/testing/build.html) | Builds the project for the selected target platform and produces an application package or an emulator package.
[deploy `<Platform>`](project/testing/deploy.html) | Deploys the project to a connected physical or virtual device.
[typings `<Platform>`](project/testing/typings.html) | Generate iOS & Android typings
[run](project/testing/run.html) | Runs your project on a connected device or in the native emulator, if configured.
[run `<Platform>`](project/testing/run.html) | Runs your project on a connected device or in the native emulator for the specified platform, if configured.
[debug `<Platform>`](project/testing/debug.html) | Debugs your project on a connected physical or virtual device.
[test init](project/testing/test-init.html) | Configures your project for unit testing with a selected framework.
[test `<Platform>`](project/testing/test.html) | Runs the unit tests in your project on a connected physical or virtual device.
[install](project/configuration/install.html) | Installs all platforms and dependencies described in the `package.json` file in the current directory.
[plugin](lib-management/plugin.html) | Lets you manage the plugins for your project.

## Publishing Commands
Command | Description
---|---
[appstore](publishing/appstore.html) | Lists applications registered in iTunes Connect.
[appstore upload](publishing/appstore-upload.html) | Uploads project to iTunes Connect.

## Device Commands
Command | Description
---|---
[device](device/device.html) | Lists all recognized connected physical or virtual devices.
[device log](device/device-log.html) | Opens the log stream for the selected device.
[device run](device/device-run.html) | Runs the selected application on a connected device.
[device list-applications](device/device-list-applications.html) | Lists the installed applications on all connected devices.

## Environment Configuration Commands
Command | Description
---|---
[setup](env-configuration/setup.html) | Run the setup script to try to automatically configure your environment for local builds.
[setup cloud](cloud/cloud-setup.html) | Install the `nativescript-cloud extension` to configure your environment for cloud builds.

## Global Options
Option | Description
-------|---------
--help, -h, /? | Prints help about the selected command in the console.
--path `<Directory>` | Specifies the directory that contains the project. If not set, the project is searched for in the current directory and all directories above it.
--config | Specifies the name of the Nativescript configuration file to load (relative to the project directory). The default is `nativescript.config.ts` or `nativescript.config.js` (as a fallback).
--version | Prints the client version.
--log trace | Prints a detailed diagnostic log for the execution of the current command.

repository: NativeScript/nativescript-cli

branch_name: refs/heads/main

repo_name: NativeScript/nativescript-cli


text:
# Chapter 0 - Introduction

## The Golden Rule

                         Multi-tasking does not exist.

You can study only one thing at a time, so close the browser tabs that are not related to the study topic, remove all the books that are not relevant, and **focus completely and exclusively on that task**. This is the only way of making effective use of time. Everything else is time-wasting.

## General Strategy

We want to find a learning strategy that is at the same effective and efficient. We don't want to go around in circles, nor repeat the same thing over and over again. For these purpose we need:

1. Clear understanding and memory techniques.
2. Spaced repetition.
3. Hands-on practice. A lot of it.

- Skim through the chapter. What are the individual sections about?
- Read the whole chapter once, looking into the notebook to make sure that theory and code are matching. Don't write code yet. Just get the gist of the topic.
- At the end of a section, stop and repeat in your head. Can you identify parts that you haven't understood?
- Now implement variations of what you have read in a notebook. It doesn't have to be pretty, it's just a learning sandbox. Identify the weak spots and the possible extensions.

repository: fudp/handsonml

repo_name: fudp/handsonml


text:
Generally, any way of representing something using numbers, letters and
symbols. For instance:

- codes are used for security; we turn words and sentences into strings
of numbers, letters and symbols, which are hard to decode.

- codes are used in computer programming; instructions which humans can
read are turned into code (numbers, letters and symbols) which a
computer can read.

- a bar code represents information, often the name and price of a
product, using a series of vertical lines.


text:
Pattern: Use of unknown function

Issue: -

## Description

Considers functions defined in the CSS Specifications to be known.

This rule ignores double-dashed custom functions, e.g. `--custom-function()`.

## Examples

The following patterns are considered violations:

```css
a { transform: unknown(1); }
```

The following patterns are *not* considered violations:

```css
a { transform: scale(1); }
```

```css
a { transform: --custom-function(1); }
```

## Further Reading

* [stylelint - function-no-unknown](https://stylelint.io/user-guide/rules/list/function-no-unknown)

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

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


text:
## Custom Fields

> Text or Date field

```
{
  "customPropertyValues": [
    {
     "customPropertyFieldId": "best-friend-name",
     "value" : "Kenta"
    }
  ]
}
```

> Dropdown field (case-sensitive)

```
{
  "customPropertyValues": [
    {
      "customPropertyFieldId": "favorite-color",
      "customOptionSelections": ["Red"]
    }
  ]
}
```

> Text and dropdown Field

```
{
  "customPropertyValues": [
    {
      "customPropertyFieldId": "favorite-color",
      "customOptionSelections": ["Red"]
    },
    {
     "customPropertyFieldId": "best-friend-name",
     "value" : "Kenta"
    }
  ]
}
```

Custom properties allow you to setup and store any additional fields you want to with a student.

**Custom fields are unique to each individual office.** *When creating
new student with custom properties, you must ensure that the office you are assigning the student to has the custom properties that you wish to store with the student.*

You can create custom fields in your **Settings** under the **Agency** tab.

There are 3 types of custom fields. Text/Dropdown/Date

Please be aware that *Dropdown* is case sensitive and that you must send the exact text.

When you create a Custom field, you will get a *Field ID*. Use this ID as your 'customPropertyFieldId'. Please refer to the right to see how your data should be structured.

![agency](customField.png)

gha_license_id: NOASSERTION


text:
---
layout: post
title: Lesson 11b - Word frequency module (import)
categories: [custom module, functions, open()]
---

Our client wants a module to generate word tags for blog posts and other types of articles. It is time to write our word frequency module, we will implement what we learned last week.

Become a Patron!

Looking back at what we learned last week, and understading, our client wants a module, that can generate a list with most frequently used words from any text, it is probably good practice to first setup our module file structure and then begin to program.

* Project directory
* The `string_file.txt` file
* The `wordy.py` file
* The `open_file.py` file

## Project directory

To ensure our project works properly, I will setup the simplest file structure to minimize any file path errors.

For this project we are going to create a folder, in your preferred location, name it **module_project**. Inside we can create three files.

* Inside the **module_project** folder create the following files.

[]({{ site.baseurl }}/images/11b_project_structure.png)

| File name       | File description                                              |
| --------------- | ------------------------------------------------------------- |
| open_file.py    | Our top script importing wordy.py and opening string_file.txt |
| string_file.txt | text file holding text string                                 |
| wordy.py        | The word frequency module                                     |

With the file structure in place, we should be able to compleat our project.

## The `string_file.txt` file

Instead of writing our test string in one of the actual scripts, as they can be very long, we are going to place our test string in it's own file, `string_file.txt`.

I would suggest to find a nice article of interest to you, copy the text and paste it in `string_file.txt`, as is. Save it and close the file.

## The `wordy.py` file

This will be the actual module that will be imported into `open_file.py`, first we are going to format the document and then we will write the script.

1. First we write a module description
2. Right after, we leave space for imports and body
3. Lastly we write the footer

```python
""" Word frequency module, count number of word instances
in a string, returning a list of tuples with
world and count """

# imports here

# script body here

if __name__ == '__main__':
    # local script
```

### imports

right after our module description we will import any necessary modules. As we import this script into another modules, all imports here will be available to the script being imported into.

1. We will import `string`
2. and `from collections import Counter`

```python
""" Word frequency module, count number of word instances
in a string, returning a list of tuples with
world and count """

import string
from collections import Counter

# script body here

if __name__ == '__main__':
    # local script
```

### functions

We are adapting our word frequency script from before into a module, for this we are going to write two functions. An utilitarian function to manage the stopwords and another function to handle the string processing.

| Function    | Description                                                                                |
| ----------- | -------------------------------------------------------------------------------------------------------------------------------------- |
| stp_words() | Utilitarian function to be used by frequency(), takes one argument returns a list with default stop words and additional words if any. |
| frequency() | Returns a list of tuples, each tuple holds word with count, depending on most frequent value.                                          |

#### stp_words()

The `stp_words()` function will be use by `thefrequency()` function. The `stp_words()` is able to take additional stop words and add them to the stopwords already stored in `stp_words()`.

If there aren't any extra stopwords passed as a function argument, the function returns the list of stopwords already stored in the function.

If there are extra words passed as a function argument (string separated by commas), then function takes the string argument, turns the string to lower case, it then splits the string in every `", "` found.

Finally, the function returns a list with all the stored stopwords combined with any additional stopwords the user may have passed.

> Notes: The code below reflects the description above. Everything below the function definition is indented four spaces.

```python
def stp_words(ext_stw):
    """
    Utilitarian function used by frequency(), takes one argument
    returns a list with default stopwords and additional stopwords if any
    """

# abrivated stop word list
    stopwords = ['they', 'for', 'she', 'is', 'to', 'it', 'get', 'you', 'by', 'any', 'your', 'all']

    if ext_stw == """""":
        return stopwords
    else:
        extra_words = ext_stw.lower().split(", ")
        return stopwords + extra_words
```

#### frequency()

Lets write our primary function, by defining it and calling it `frequency()`. It will take one positional argument and three keyword arguments. This function will return a list of tuples based on the most frequent words.

| Arguments      | Description                                                        |
| -------------- | ------------------------------------------------------------------ |
| InputString    | This is the raw string that will be analyzed.                      |
| extraChr       | Any extra character to parse out.                                  |
| extraStopwords | Any extra stop words to be added and removed.                      |
| mstCommon      | number of most common words to returned by `.most_common()` method.|

```python
def frequency(InputString, extraChr="", extraStopwords="", mstCommon=6):
    """Returns a list of tuples, each tuple holds word with count,
    depending on most frequent value"""

    stop_words = stp_words(extraStopwords)  # (1.)
    lower_str = InputString.lower()  # (2.)
    char_template = str.maketrans("", "", string.punctuation + extraChr)  # (3.)
    cleanned_str = lower_str.translate(char_template)  # (4.)
    word_list = cleanned_str.split()  # (5.)

    for stopword in stop_words:  # (6.)
        for word in word_list:
            if word == stopword:
                word_list.remove(word)

    return Counter(word_list).most_common(mstCommon)  # (7.)

if __name__ == '__main__':
    pass  # temporary pass
```

Above, `(1.)` we first call our utilitarian function, `stp_words()`, Notice the argument, `extraStopwords` we take it through `frequency()` and pass it to `stp_words()`

* `stop_words = stp_words(extraStopwords)`

Much like in our original word frequency script, `(2.)` here we take the `InputString` and pre process it, by turning it into lower case.

We create text character template `(3.)` by calling the `str.maketrans()` method. we pass the `string.punctuation` plus any extra characters through `extraChr`, these are combined by the `+` sign. All of this is assigned to the  `char_template` variable.

We remove any string punctuation `(4.)` by calling our `lower_str` string through the `translate(char_template)` method using `char_template` as an argument. We assign this to `cleanned_str`

We can create a list of words `(5.)` from `cleanned_str` string by using the `split()` method. By default it splits on any space.

---

For example a string with the split method.

* `"word1 word2 word3".split()`

Will return the following list.

* `['word1', 'word2', 'word3']`

---

We assign the newly created list, `cleanned_str.split()`, to the `word_list`

* `word_list = cleanned_str.split()`

We will use our nested loop `(6.)` to iterate through each `stopword`, and a nested loop to iterate through each `word` in `word_list`. If a `word` is equal to a `stopword` then we remove that word from `word_list`. We are left with a list without any of the stop words.

And finally we return `(7.)` the `Counter()` function with the `.most_common()` method. passing `word_list` as an argument.

* Returning a list of ordered tuples, with the word and count.
  * `[('word1', 6), ('word2', 4), ('word3', 2), ('word4', 2), ('word5', 2)]`

The returned list can be unpacked and formated.

### Scope condition

To run our script as a stand alone program or a module we need to add the scope condition line at the bottom of the script.

* `if __name__ == '__main__':`

If the scope of the script is equal to the name of the file, run any code below the condition, if the scope of the file is used as a module, don't run the code below the conditional line.

We can test our code by writing our script below the conditional line.

We can write the logic by first assigning string arguments to variables. `(8.)`

Then we can pass the variables to the `frequency()` function, as arguments. `(9.)`

* `test_str` as the first positional argument.
* `extra_chr` as keyword argument for `extraChr`
* `ext_stopwords` as keyword argument for `extraStopwords`
* integer, `5`, as keyword argument for `mstCommon`

We can then `print()` the return values for the `frequency()` function. `(10.)`

```python

# I truncated the script to save space.
    return Counter(word_list).most_common(mstCommon)  # (7.)

if __name__ == '__main__':

    test_str = """It forbids you to:
    Hold the authors  and license owners liable for damages as Bootstrap is provided without warranty
    Hold the creators or copyright holders of Bootstrap liable
    Redistribute any piece of Bootstrap without proper attribution
    Use any marks owned by Twitter in any way that might state or imply that Twitter endorses your distribution
    Use any marks owned by Twitter in any way that might state or imply that you created the Twitter software in question"""  # (8.)

    ext_stopwords = "Use, piece"  # (8.)
    extra_chr = ""  # (8.)

    word_frequency = frequency(test_str,
                               extraChr=extra_chr,
                               extraStopwords=extra_stw,
                               mstCommon=5)  # (9.)

    print()
    print(word_frequency)  # (10.)
```

When we run the script above as a main, we will get the following

* `[('twitter', 4), ('bootstrap', 3), ('hold', 2), ('liable', 2), ('without', 2)]`

> Alternativley: if we are ok with the default keyword arguments, we just pass the first positional argument. `frequency(test_string)` and omit the ones we don't want to change.

We can also import this script/module into another script and use the `frequency()` function. I will show you in our next file.

## The `open_file.py` file

Now we are going to write a script where we import the custom module, `wordy.py` and open our text file.

[]({{ site.baseurl }}/images/11b_file_structure.svg)

Open `open_file.py` `(1.)`

We can start by importing our module `wordy`. Notice we don't type the `.py` file extention.

```python
import wordy  # (1.)

string_file = open('string_file.txt', 'r')  # (2.)
test_string = string_file.read()  # (3.)
string_file.close()  # (4.)

extra_stw = ""  # (5.)
extra_chr = "•"  # (6.)

word_frequency = wordy.frequency(test_string,
                                 extraChr=extra_chr,
                                 extraStopwords=extra_stw,
                                 mstCommon=5)  # (7.)

print()

wf_list = []  # (8.)
for k, v in word_frequency:  # (9.)
    wf_list.append(k)

print(wf_list)  # (10.)
```

Above, We then want to open `string_file.txt` in **read** mode. `(2.)`

Read the file into memory `(3.)` by using the `.read()` method.

* `string_file.read()` assigning it to `test_string`

Close the `string_file` with the `.close()` method. `(4.)`

Create two variables to hold additional stopwords and punctuations

* `extra_stw = ""` - `(5.)`
* `extra_chr = ""` - `(6.)`

To call the `frequency()` function `(7.)` we must preside it by the module name separated by a `.`

* `wordy.frequency()`

We can pass our arguments,`test_string`, `extraChr`, `extraStopwords`, `mstCommon`. `(7.)`

We can assign the `wordy.frequency()` function to the `word_frequency` variable `(7.)`. The function will return a list of tuples.

We want a list with just the words sorted by most common `(8.)`. In order to get this we have to iterate `(9.)` through the returned list of tuples and append the empty list with just the words.

We can then pass the list `(10.)` to another operation, `print()`.

You will get a list of most frequent words, in the same format as the one below but with words reflecting your text file.

```sql
['python', 'language', 'says', 'van', 'rossum', 'programming']
```

As you can see we can call our module from any script, pass a string and with the return value we can do other operations.

With that we end our lesson on custom modules, import and opening files.

---

## Next tutorial

An introduction to list comprehencion

## Things to try

* Try modifying the arguments in `wordy.frequency()`
* Find a different way to use the returnned value. Try unpacking values and formatting them differently.

## Question

* Can you think of a problem `stp_words()` may have? if so how would you fix it?
* Can your shorten the following code to one line?

```python
wf_list = []
for k, v in word_frequency:
    wf_list.append(k)
```

Become a Patron!


text:
# Vue Template Loader Jest

With vue-template-loader it is possible to extract the html from a typescript single file component to a separate
`.html` file (see https://github.com/ktsn/vue-template-loader). But loading the components in jest tests is not possible
anymore.

Here this library comes into play. It is basically just a custom transformer for jest that is using
 `vue-template-loader` to compile the template.

 ## Reception

 This is untested at all and I only care about my issues. Contributors are highly welcome. Feel free to open pull
 requests and issues. Write when you are interested in maintaining it.

 ## Usage

 Just install this library and add it to your jest config `.*html: 'vue-template-loader-jest'`. Example:

 ```json
 {
    "jest": {
        "moduleFileExtensions": [
          "js",
          "ts",
          "html"
        ],
        "transform": {
          "^.+\\.tsx?$": "ts-jest",
          "^.+\\.html$": "vue-template-loader-jest"
        },
        "moduleNameMapper": {
          "@view/(.*)": "<rootDir>/resources/views/components/$1"
        }
    }
}
```

> As you can see I'm also using a custom alias for views.

repository: tflori/vue-template-loader-jest

repo_name: tflori/vue-template-loader-jest


text:
---
title: influx transpile
description: >
  The 'influx transpile' command transpiles an InfluxQL query to Flux source code.
menu:
  v2_0_ref:
    name: influx transpile
    parent: influx
weight: 101
v2.0/tags: [influxql, flux]
---

The `influx transpile` command transpiles an InfluxQL query to Flux source code.
The transpiled query assumes the bucket name is `<database>/<retention policy>`
and includes absolute time ranges using the provided `--now` time.

## Usage
```
influx transpile [InfluxQL query] [flags]
```

## Flags
| Flag           | Description                                                                |
|:----           |:-----------                                                                |
| `-h`, `--help` | Help for the `transpile` command                                           |
| `--now`        | RFC3339Nano timestamp to use as `now()` time (default is current UTC time) |

{{% cli/influx-global-flags %}}


text:
---
title: Contributing
---

# Contribute to Tock

The Tock project is open to contribution and any feedback is welcome!

This page details the source structure and coding conventions for the platform.

## TL;DR

See [`CONTRIBUTING.md`](https://github.com/theopenconversationkit/tock/blob/master/CONTRIBUTING.md).

## Main technologies

Tock components can run as _containers_ (provided implementation for [Docker](https://www.docker.com/)).

The application runs on [JVM](https://fr.wikipedia.org/wiki/Machine_virtuelle_Java) platforms.
The reference language is [Kotlin](https://kotlinlang.org/), but other programming languages can be leveraged through the available APIs.

On the server side, Tock relies on [Vert.x](http://vertx.io/) and [MongoDB](https://www.mongodb.com ) <sup>(alt. [DocumentDB](https://aws.amazon.com/fr/documentdb/))</sup>.
Various _NLU_ libraries and algorithms can be used, but Tock does not depend on them directly.

_Tock Studio_ graphical user interfaces are built with [Angular](https://angular.io/) in [Typescript](https://www.typescriptlang.org/).

[React](https://reactjs.org) and [Flutter](https://flutter.dev/) toolkits are provided for Web and Mobile integrations.

## Source structure

### Repositories

* [`tock`](https://github.com/theopenconversationkit/tock): main source repository, including the framework
and platform components under the [Apache 2 license](https://github.com/theopenconversationkit/tock/blob/master/LICENSE).

* [`tock-corenlp`](https://github.com/theopenconversationkit/tock-corenlp): optional module, leveraging a dependency to
[Stanford CoreNLP](https://stanfordnlp.github.io/CoreNLP/) (instead of [Apache OpenNLP](https://opennlp.apache.org/)),
under [GPL license](https://fr.wikipedia.org/wiki/Licence_publique_g%C3%A9n%C3%A9rale_GNU).

* [`tock-docker`](https://github.com/theopenconversationkit/tock-docker): [Docker](https://www.docker.com/)
and [Docker Compose](https://docs.docker.com/compose/) images/descriptors, for platform hands-on and fast deployment
of various configurations.

* [`tock-bot-samples`](https://github.com/theopenconversationkit/tock-bot-samples): code samples, in particular the _WebHook_ and _WebSocket_ modes examples from
[Tock programming guides](../dev/bot-api).

* [`tock-bot-open-data`](https://github.com/theopenconversationkit/tock-bot-open-data): a bot example, based on
the [SNCF _Open Data_ API](https://www.digital.sncf.com/startup/api), also implementing basic internationalization (_i18n_)
 mecanisms with two distinct languages.

### The `tock` repository

> TODO : detail modules and repo structure

### Le `tock-docker` repository

> TODO : detail modules and repo structure, how Maven and Docker builds work, etc.

## Build & run

### Build Tock from sources

#### Tock (core)

Tock is built with [Maven](https://maven.apache.org/), including the Web modules leveraging
[NPM](https://www.npmjs.com/) et [Angular](https://angular.io/):

`$ mvn package`

Continuous integration build jobs are available on [Travis](https://travis-ci.org/theopenconversationkit/tock).

#### Docker images

Tock Docker images can be rebuilt from sources, included in repository [`tock-docker`](https://github.com/theopenconversationkit/tock-docker).
One can use [Maven](https://maven.apache.org/) to trigger the [Docker](https://www.docker.com/) build:

`$ mvn package docker:build`

Docker containers can then be instantiated from images, or Docker Compose stacks from the various descriptors
at the root of the repository.

### Run Tock in IDE

> To run Tock using Docker Compose outside the IDE, rather see [Deploy Tock with Docker](../getting-started).

Tock components (NLU, Studio, bot...) can run in an IDE, such as
[IntelliJ](https://www.jetbrains.com/idea/), [Eclipse](https://www.eclipse.org/) or [Visual Studio Code](https://code.visualstudio.com/) for instance.

Beside the [Docker images](https://github.com/theopenconversationkit/tock-docker/blob/master/docker-compose.yml),
IntelliJ configurations are provided with Tock sources:

- The _Tock Studio_ interfaces/server: [BotAdmin](https://github.com/theopenconversationkit/tock/blob/master/.idea/runConfigurations/BotAdmin.xml)
- The alternative standalone NLU interfaces/server: [Admin](https://github.com/theopenconversationkit/tock/blob/master/.idea/runConfigurations/Admin.xml)
- The NLU service: [NlpService](https://github.com/theopenconversationkit/tock/blob/master/.idea/runConfigurations/NlpService.xml)
- The Duckling entity-recognition service: [Duckling](https://github.com/theopenconversationkit/tock/blob/master/.idea/runConfigurations/Duckling.xml)
- The NLU model-builder service: [BuildWorker](https://github.com/theopenconversationkit/tock/blob/master/.idea/runConfigurations/BuildWorker.xml)
- The script compilation service: [KotlinCompilerServer](https://github.com/theopenconversationkit/tock/blob/master/.idea/runConfigurations/KotlinCompilerServer.xml)

The _OpenDataBot_ example also has a run configuration available:

- [OpenDataBot](https://github.com/theopenconversationkit/tock-bot-open-data/blob/master/.idea/runConfigurations/OpenDataBot.xml)

To start the _Tock Studio_ interfaces, please refer to the commands described in the following pages:

- [Full _Tock Studio_ server commands](https://github.com/theopenconversationkit/tock/blob/master/bot/admin/web/README)
- [Standalone NLU server commands](https://github.com/theopenconversationkit/tock/blob/master/nlp/admin/web/README)

## Code

### Commits & merge requests

To submit a feature or bugfix:

1. [Create an _issue_](https://github.com/theopenconversationkit/tock/issues/new):
    - Reccommended format for the title:
        - `[Component] Title` where component might be
    _Studio_, _Core_, _Doc_, etc. and title usually is like _Do or fix something_
2. [Create a _pull request_](https://github.com/theopenconversationkit/tock/pulls) and link it to the issue(s):
    - All commits should be [_signed_](https://help.github.com/en/github/authenticating-to-github/managing-commit-signature-verification)
    - Please rebase and squash unnecessary commits (tips: PR can be tagged as _Draft_) before submitting
    - Recommended format for the branch name :
        - `ISSUEID_short_title`
    - Recommended format for the commit(s) message(s):
        - `resolves #ISSUEID Component: title` for features
        - `fixes #ISSUEID Component: title` for fixes
3. To be merged, a _pull request_ must pass the tests and be reviewed by at least two of these developers:
    - [@vsct-jburet](https://github.com/vsct-jburet),
    [@francoisno](https://github.com/francoisno),
    [@NainJaune](https://github.com/NainJaune),
    [@elebescond](https://github.com/elebescond),
    [@SarukaUsagi](https://github.com/SarukaUsagi),
    [@MaximeLeFrancois](https://github.com/MaximeLeFrancois),
    [@bakic](https://github.com/bakic),
    [@broxmik](https://github.com/broxmik),
    [@mrboizo](https://github.com/mrboizo)

### Code conventions

[Kotlin Code Conventions](https://kotlinlang.org/docs/reference/coding-conventions.html) are used.

### Unit tests

Every new feature or fix should embed its unit test(s).

## Contact us

To contribute to the project or to known more about the implementation, feel free to [contact us](../contact).
Ideas and feedback is more than welcome.

repository: djowalker/tock

repo_name: djowalker/tock


text:
---
layout: post
title:      "Level Up Your UX!"
date:       2019-03-03 18:04:53 +0000
permalink:  level_up_your_ux
---

One aspect that developers, especially frontend developers, need to understand in order to create excellent products is the user experience. At the end of the day, we're making technology for humans, not machines, so there's a lot of factors that we need to consider when developing our applications. It's important that we take a look at UX development principles and create empathy based technology.

Let's start with Peter Morville's User Experience Honeycomb:

![https://i.imgur.com/f7GUUlM.jpg](https://i.imgur.com/f7GUUlM.jpg)

In his [article](http://semanticstudios.com/user_experience_design/), he explains each facet of the user experience so let's go into each of his points and explain them further.

* **Useful**
   * 	Our products need to be an innovative solution, make our users lives' easier, and be constantly striving to improve functionality.  We should be evaluating each feature of our applications to ensure they are useful.
   * Remember, we're building our products for humans so everything needs to be shaped to be helpful. For example, error messages should be detailed whenever possible and our sites should anticipate user error.
Instead of something like this:

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

We should make error messages more friendly, helpful, and human-like:

![https://i.imgur.com/XJj17JJ.jpg](https://i.imgur.com/XJj17JJ.jpg)

* **Usable**
   * It's vital that our applications are as easy to use as possible and that the interface between the user and our product is simple and clear. Be clear and concise. Show that you understand what the user needs. The user shouldn't have to scour through irrelevant information before reaching the objective.
   * Be **intuitive**. “Reduce the user’s cognitive workload whenever possible. Be consistent and clear, and establish a strong visual hierarchy.” — [www.uxmatters.com](www.uxmatters.com)
   * Be **learnable**: make your product easy to learn. If we improve learnability, perhaps more people will adopt its use into their lives.
   * Be **efficient**. Tasks should be performed quickly and smoothly.

* **Desirable**
   * Developers must balance efficiency with **image, identity, and brand** (considered elements of emotional design). How users view our application is incredibly important and we need to stay consistent with company brand.
   * Be **contextual**. Just as Jordan Julien says, "Think of a user journey like a story book." Users should be able to understand where they are in the story.
   * We want to be **memorable**.

* **Findable/Discoverable**
   * We need to design navigable web sites and locatable objects so users can find exactly what they need.
   * Aspects of our application need to be obvious, purposeful, and discoverable. Otherwise, why have it?
   * [UX Navigation Design](https://www.justinmind.com/blog/navigation-design-almost-everything-you-need-to-know/)

* **Accessible**
   * Our websites need to be accessible to people with disabilities, just as our buildings have elevators and ramps. It's both good business and the ethical thing to do.
   * Learn more about accessible design features [here](https://www.interaction-design.org/literature/topics/accessibility).

* **Credible**
   * Users need to be able to trust and believe in us. Without trust, users will not even consider our product. With the Web Credibility Project, we're better able to understand the design elements that influence whether users trust and believe in a site.
   * [**Stanford's Web Credibility Project Guidelines:**](http://credibility.stanford.edu/guidelines/index.html)

 1. Make it easy to verify the accuracy of the information on your site.
 2. Show that there's a real organization behind your site.
 3. Highlight the expertise in your organization and in the content and services you provide.
 4. Show that honest and trustworthy people stand behind your site.
 5. Make it easy to contact you.
 6. Design your site so it looks professional (or is appropriate for your purpose).
 7. Make your site easy to use -- and useful.
 8. Update your site's content often (at least show it's been reviewed recently).
 9. Use restraint with any promotional content (e.g., ads, offers).
 10. Avoid errors of all types, no matter how small they seem.

* **Valuable**
   *  The product must always align with our mission. We have to deliver value in everything that we do. Every aspect of our applications should be centered around the value we're able to provide to the user.

By following these principles, our products are able to offer our users the best possible experience.
We're solving problems and making lives easier, and isn't that the goal of all development?

![https://i.imgur.com/awfH6XL.jpg?1](https://i.imgur.com/awfH6XL.jpg?1)

![https://i.imgur.com/MAgDBVu.jpg](https://i.imgur.com/MAgDBVu.jpg)

Pete Yu also wrote a great article highlighting a lot of these aspects [here](https://codeburst.io/10-ux-design-fundamentals-developers-should-learn-2aa6fc5ecbf9), and it's definitely worth a read!

extension: markdown


text:
# Developing

CoderDojo mobile's development is managed via [GitHub](https://github.com/CoderDojoBrianza/CoderDojo-Mobile-Toolbox)

## Tools

Some tools you might want to use:

- Code editing (text editor): [Notepad++](https://notepad-plus-plus.org/download/v7.5.7.html)
- Viewing markdown files: [Markdown Viewer extension for Chrome](https://chrome.google.com/webstore/detail/markdown-viewer/ckkdlimhmcjmikdlpkmbgfkaikojcbjk)
- Working with GitHub in Windows: [TortoiseGit](https://tortoisegit.org/)
- Working with the database: [DB Browser for sqlite](https://sqlitebrowser.org/)
- To work with translations, use [Gettex for windows](https://mlocati.github.io/articles/gettext-iconv-windows.html)

## Localization

To generate locale files, run the `django-admin makemessages` command with the desired language:

```
django-admin makemessages -l en -e py,html
django-admin makemessages -l it -e py,html
```

or, for all languages:

```
django-admin makemessages -a -e py,html
```

after providing actual translations, you have to compile message files:

```
django-admin compilemessages
```

## Documentation

For correctly managing Markdown lists / code blocks, see [This Gist](https://gist.github.com/clintel/1155906#file-gistfile1-md)

gha_language: Python


text:
Gumshoe User Guide
==================

Overview
--------

Gumshoe intercepts java calls to sockets and captures network statistics.
Data can be logged to a file or viewed live.

[Features](features.md)
-----------------------

- Network I/O analysis (TCP and UDP)
- CPU utilization analysis
- unclosed socket detection
- file I/O analysis

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

- Examples
- ELI5: Performance tuning
- Components of gumshoe
- Step by step

Generating Reports
------------------

- [About the hooks](hooks.md)
- [Configuring the probe](probe.md)
- [Using filters](filters.md)
- [Running your program](run.md)

Viewing Reports
---------------

- Running gumshoe GUI from your JVM
- Running standalone GUI
- Selecting a data report
- Navigating the graph
- Graph display options
- Configuring filters

Understanding Performance
-------------------------

- Identifying bottlenecks
- Stacks vs Statistics
- Scalability

repository: DukeDai/gumshoe

repo_name: DukeDai/gumshoe


text:
# GRAV Plugin: Raspberry Pi Core Temperature

If your [GRAV CMS](https://getgrav.org/) is running on a LINUX-powered Raspberry Pi, this plugin let's you show the Pi's SoC core temperature (in degree celsius). This plugin uses file_get_contents() to read the value from `/sys/class/thermal/thermal_zone0/temp`, so a device/OS supporting the interface for thermal zone devices (sensors) via sysfs is needed. Tested on Raspberry Pi 4B running [Manjaro ARM](https://manjaro.org/download/#raspberry-pi-4)

**Hint:** This plugin might work on other Linux operating systems, if the kernel provides [sysfs](https://en.wikipedia.org/wiki/Sysfs). But then you need to know which sensor exports its data at `thermal_zone0`.

## Installation

Installing the Raspberry Pi Cpu Temperature plugin can be done in one of three ways: The GPM (Grav Package Manager) installation method lets you quickly install the plugin with a simple terminal command, the manual method lets you do so via a zip file, and the admin method lets you do so via the Admin Plugin.

### GPM Installation (Preferred)

To install the plugin via the [GPM](http://learn.getgrav.org/advanced/grav-gpm), through your system's terminal (also called the command line), navigate to the root of your Grav-installation, and enter:

    bin/gpm install pi-cpu-temp

This will install the Raspberry Pi Cpu Temperature plugin into your `/user/plugins`-directory within Grav. Its files can be found under `/your/site/grav/user/plugins/pi-cpu-temp`.

### Manual Installation

To install the plugin manually, download the zip-version of this repository and unzip it under `/your/site/grav/user/plugins`. Then rename the folder to `pi-cpu-temp`. You can find these files on [GitHub](https://github.com/cron-ix/grav-plugin-pi-cpu-temp) or via [GetGrav.org](http://getgrav.org/downloads/plugins#extras).

You should now have all the plugin files under

    /your/site/grav/user/plugins/pi-cpu-temp

> NOTE: This plugin is a modular component for Grav which may require other plugins to operate, please see its [blueprints.yaml-file on GitHub](https://github.com/cron-ix/grav-plugin-pi-cpu-temp/blob/master/blueprints.yaml).

### Admin Plugin

If you use the Admin Plugin, you can install the plugin directly by browsing the `Plugins`-menu and clicking on the `Add` button.

## Configuration

Before configuring this plugin, you should copy the `user/plugins/pi-cpu-temp/pi-cpu-temp.yaml` to `user/config/plugins/pi-cpu-temp.yaml` and only edit that copy.

Here is the default configuration and an explanation of available options:

```yaml
enabled: true
```

Note that if you use the Admin Plugin, a file with your configuration named pi-cpu-temp.yaml will be saved in the `user/config/plugins/`-folder once the configuration is saved in the Admin.

## Usage

To use this plugin, you need to do three little steps: **1.** enable Twig processing; **2.** disable cache; **3.** insert code

1. Enable Twig proccessing for your page:
   a. Frontmatter:
    ```yaml
    process:
        twig: true
    ```

    b. Admin Plugin:
      * goto 'Page' and select your page
      * click on 'Advanced' tab
      * in section 'Overrides' enable 'Process' and enable 'Twig' (make sure it is checked)

2. As pages are cached by default you need to disable caching (per page) if you want to read the temperature on load:
    a. Frontmatter:
    ```yaml
    never_cache_twig: true
    ```
    b. Admin Plugin:
      * goto 'Page' and select your page
      * click on 'Advanced' tab
      * in section 'Overrides' enable 'Never Cache Twig ' and click on 'Yes'

3. Now you can use the following code in your page where you want to have the output:
    ```
    {{ piCpuTemp() }}
    ```
    This code snippet will be replaced with the output.

## To Do

- [ ] add option for Fahrenheit

repository: cron-ix/grav-plugin-pi-cpu-temp

repo_name: cron-ix/grav-plugin-pi-cpu-temp


text:
# zakabad
## Milestone 1 feedback

Your directory structure is perfect, and your HTML is done very well. The only problem with HTML that I can see is that you're missing a couple of things in your head. Look at the documentation in the future and add the needed things (such as utf-8).

Your purpose, audience, and goal is correct, and fits the scope of what you'll learn in the class for your site. Some sections seems incomplete, or maybe just worded wrong. Not a big deal, but make sure to use correct grammar in the future, especially for the final site.

Also, your goal needs a little more detail. I understand that companies can see what you've worked on, but I'd also like to know what your FINAL goal is with this site. Are you trying to get hired as a developer? Are you just building a site to showcase your skills? Tell us about that.

Your Persona is a great example of a freelance client, but there is some things I'm still wondering about.
  Technology: Android on what device? HP Pavillion using what version of windows? What browser does he use?

Use Case: Written very well. No issues there, although I do have more suggestions/information for you. First of all, your website will incorporate an email contact form. Also, specify why Jerry likes your site for what he wants done. Does he like the styling and format of the site? Does he like the things you showcase on it? Think about that as you proceed with development, because it will help you plan out a site that is appealing to the types of clients you want to do work for.

Otherwise, your Use Case does well in explaining everything you mentioned above. Great job with this.

#### Overall, great job. Some little issues here and there but nothing major. Watch the grammar, and keep up the good work for the next milestone. You've passed in tier 3.

## Milestone 2a Feedback
Your directory structure is perfect, but your HTML has one noticeable issue. Your meta charset tag needs to be within the head. Yours is above it. Make sure to fix this.

Otherwise, your HTML is good.

Considering I've seen the site you're basing this off of, I like your design. Make sure to think back to what I suggested. Make sure it's still visually appealing.

What's your Easter Egg going to do? Have you thought about that yet?

Your mobile layout may not work. I would try to stretch the content across the full page so it's not too small. That would of course affect the way your background image looks. I like your desktop design, but I would try to rethink your mobile design completely. You could still have the same basic design, but maybe add a filter over the entire background so it's very dark, and your text is still easily readable over the top of it.

I like your social media icons at the bottom. Make sure these fit with the design and don't look like they're just floating there. For the Social Media icons, have a look Font Awesome. Very easy to use, simple and straightforward. http://fontawesome.io/

Overall, you did a good job of replicating the site you showed me earlier. Try to make it a little more entertaining. Include some modals, or cool design changes so it's atleast a little different.

#### You've passed Milestone 2a in Tier III. Good job.

## Milestone 3 / Final Feedback
Beautiful job on your PWP. Your layout looks great on both desktop and mobile - you've done a great job using the Bootstrap grid system to your advantage here. You've also done a nice job keeping your layout and design choices simple yet effective. This is a great example of how a simple color palette combined with a clean layout and a good typeface can have strong visual impact. Your form appears to function well on my end - so check your email to see if you have received my test message.

Congrats on a PWP well done. Your project passes at [Tier III](https://bootcamp-coders.cnm.edu/projects/personal/rubric/). Nice work!


text:
Ergojack
========

My Ergodox Infinity layout. Includes DFU bins, and a json file for use with
Input Club Configurator ([website](https://input.club/configurator/) /
[github](https://github.com/kiibohd/KiiConf)).

![Layout diagram](./layout.png)

Considerations
--------------

I had two goals when designing this layout - I'll be using this for work, where
where as a programmer I'll spend half my life on this keyboard; and for gaming,
where I'll spend some of the other half. I play a variety of games, including
FPSes like Overwatch and Space sims, like Star Citizen.

### Why Ergodox

An Ergodox is a pretty natural fit for all of these tasks; the ergonomic nature
lends itself to spending many hours typing; a compact, left-hand keyboard is
all that's really necessary for most FPS games (other than trash talking in
chat - although a left-hand board DOES give you "gg", which is really all
anyone needs, right?); and finally, the thing that sent me overboard, is that
an Ergodox can surround both sides of a centered Joystick for space/flight sims.
It looks _really good_ with a HOTAS setup.

After an Ergodox and keycaps ordered on Massdrop
([devtty](https://www.massdrop.com/buy/massdrop-x-matt3o-devtty-custom-keycap-set?utm_source=linkshare&referer=CECUZJ)
and [carbon](https://www.massdrop.com/buy/carbon?utm_source=linkshare&referer=CECUZJ)),
it arrived, assembled quickly, and it was layout time.

### Why This Layout In Particular

I made a handful of differences from traditional keyboards, and a few more from
the default Ergodox Layout. The first major deviation I made from traditional
keyboard layouts, and especially from Mac keyboards, is to move the ctrl keys to
the thumbs. I find it much more comfortable to mash "ctrl-c" and "ctrl-d" this
way; it's absolutely miserable on a Mac keyboard without this switch, unless you
remap capslock (which I did, but I always forget about.)

I kept the left hand to "negative" actions - lower current layer, backspace,
delete. The right hand is "positive" actions - raise layer, space, enter.
Having some kind of organization helps me remember the new layout.

I a temporary "fn" key, which switches the keyboard to layer one, in the bottom
left; holding that allows me to use WASD as arrow keys, which otherwise don't
exist.

Lastly, when in layer two, you're in gaming mode; left ctrl, at my thumb's
natural resting position, becomes space; while capslock becomes control. That
makes running, jumping, etc as natural as any other keyboard. It also swaps
the top left "=" for an ESC button.

I'm too chicken to swap to Dvorak or Colemak or Workman or something quite yet.
Maybe someday.

![Picture of the actual keyboard](./keyboard.jpg)

license: Unlicense

repository: xaelectronics/Ergojack

repo_name: xaelectronics/Ergojack


text:
# Portfolio

#### _Week 1 solo project. Jan 10, 2020_

## Description

This project demonstrates an understanding of Epicodus week 1 concepts utilizing html, css, and bootstrap through Github.

## Setup

* Open Terminal
* Enter $ git clone https://github.com/mtaylorpdx/portfolio
* Open index.html in browser

## Support and Contact Details
Email [@Matt <EMAIL_ADDRESS>
## Github

[Github](https://github.com/mtaylorpdx/portfolio)

[Github Pages](https://mtaylorpdx.github.io/portfolio)

### License
Licensed under the MIT Licence
Copyright (c) 2019 **_Matt Taylor_**

repository: mtaylorpdx/portfolio

repo_name: mtaylorpdx/portfolio


text:
# ML Resources

Title | By | From | Year | Summary
------|----|------|------|---------
[Pattern Recognition and Machine Learning]() | Christopher M. Bishop | Microsoft Research | 2006 | Primary focus on pattern recognition in field of machine learning. Good book for any beginner.

## Reference Books:

Title | By | From | Year | Summary
------|----|------|------|---------
[Mathematics for Machine Learning](http://gwthomas.github.io/docs/math4ml.pdf) | Garrett Thomas | University of California, Berkeley | Jan 11, 2018 | Quick Math for ML Reference.
[A Comprehensive Guide to Machine Learning](http://snasiriany.me/files/ml-book.pdf) | Soroush Nasiriany, Garrett Thomas, William Wang, Alex Yang | University of California, Berkeley | Aug 13, 2018 | Book based on Berkeley Course CS 189.

gha_language: Jupyter Notebook


text:
# `systems data sources`

###### [Boris Steipe](https://orcid.org/0000-0002-1134-6758),
###### Department of Biochemistry and Department of Molecular Genetics,
###### University of Toronto
###### Canada
######<EMAIL_ADDRESS>
----

A collection of data sources that are relevant for computational systems biology.

----

### System

**A [system](http://steipe.biochemistry.utoronto.ca/abc/assets/BIN-SYS-Concepts.pdf) maps a set of collaborating components to its emergent behaviour.**

"System" is a concept. In order to understand biology, we apply the concept to observables.

* We identify *components*,
* we collect evidence of their *collaboration*,
* we analyze the system's *behaviour* and specify what is *emergent* about it,
* we organize our knowledge in a *system architecture model*.

**A system architecture describes the system's behaviour in terms of its subsystems and their relationships, given its context, within its boundaries.**

The observables in this analysis-by-modelling are:

* molecular components and sets of components
* their relationships
* the functional consequences

### Data resources

##### Resource collections
* **[The NAR Database Issue (2019)](https://academic.oup.com/nar/issue/47/D1)**
* **[The NAR Web Server Issue (2018)](https://academic.oup.com/nar/issue/46/W1)**

##### Molecular components

**Identifiers**

* `HGNC.RData`: reference symbols and identifiers for human genes.
* `HGNCdata.R`: The script that produced `HGNC.RData`

**Annotations**

* **[UCSC](https://genome.ucsc.edu/)**
* **[Conservation (EggNOG)](http://eggnogdb.embl.de/#/app/home)**
* **[Orthologues (OrthoDB)](https://www.orthodb.org/)**
* **[Gene Ontology Annotations](https://www.ebi.ac.uk/GOA)**
* **[SMART database](http://smart.embl-heidelberg.de/)**
* **[Pfam database](https://pfam.xfam.org/)**
* **[STRING](https://string-db.org/)**
* **[ENCODE](https://www.encodeproject.org/)**
* **[Human Protein Atlas](https://www.proteinatlas.org/)**
* **[PDB](https://www.rcsb.org/)**

**Dynamics**

* **[GEO expression profiles](https://www.ncbi.nlm.nih.gov/geo/)**
* **[iProx Proteome data](http://www.iprox.org/)**

##### Relationships (networks)

* **[STRING](https://string-db.org/)**
* **[IntAct](https://www.ebi.ac.uk/intact/)**
* **[iRefIndex](http://irefindex.org/)**
* **[BioGRID](https://thebiogrid.org/)**
* **[IntAct](https://www.ebi.ac.uk/intact/)**
* **[GO: semantic similarity (from Bioconductor tools)](https://www.bioconductor.org/help/search/index.html?q=%22semantic+similarity%22/)**
* phylogenetic profiling (?)
* **[CoExpress DB](http://coxpresdb.jp/)**
* **[CoExpedia](http://www.coexpedia.org/)**
* **[ENPD (Eukaryotic Nucleic Acid Binding Proteins)](http://qinlab.sls.cuhk.edu.hk/ENPD/)**

##### Modules

* **[MSigDB](http://software.broadinstitute.org/gsea/msigdb)**
* **[GeneMania](https://genemania.org/)**
* **[Reactome Pathway Browser](https://reactome.org/PathwayBrowser/#/)**
* **[Wikipathways](https://www.wikipathways.org/)**
* **[KEGG pathway database](https://www.genome.jp/kegg/pathway.html)**
* **[PANTHER protein annotation](https://www.nature.com/articles/nprot.2013.092)**
* **[NCI-Nature Pathway Interaction Database](http://pid.nci.nih.gov/)**
* **[Pathway Commons](http://www.pathwaycommons.org/)**
* **[Consensus Path DB(CPDB)](http://consensuspathdb.org/)**
* **[hu.MAP Protein complexes](http://proteincomplexes.org/)**
* **[CORUM](http://mips.helmholtz-muenchen.de/corum/)**
* **[GWAS catalog](https://www.ebi.ac.uk/gwas/)**

##### Function and phenotypes

* **[OMIM](https://www.omim.org/)**
* **[Human Disease Ontology](https://www.ebi.ac.uk/ols/ontologies/doid)**
* **[Human Phenotype Ontology](https://hpo.jax.org/app/)**
* **[COSMIC (Catalogue of Somatic Mutations in Cancer)](https://cancer.sanger.ac.uk/cosmic)**
* **[Navigome](https://omictools.com/navigome-tool)**
* **[DAVID](https://david.ncifcrf.gov/)**
* **[Bystro](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5801807/)**

<!-- END -->