text:
---
title: TiDB 6.1.2 Release Notes
---

# TiDB 6.1.2 Release Notes

Release date: October 24, 2022

TiDB version: 6.1.2

Quick access: [Quick start](https://docs.pingcap.com/tidb/v6.1/quick-start-with-tidb) | [Production deployment](https://docs.pingcap.com/tidb/v6.1/production-deployment-using-tiup) | [Installation packages](https://www.pingcap.com/download/?version=v6.1.2#version-list)

## Improvements

+ TiDB

    - Allow setting placement rules and TiFlash replicas at the same time in one table [#37171](https://github.com/pingcap/tidb/issues/37171) @[lcwangchao](https://github.com/lcwangchao)

+ TiKV

    - Support configuring the `unreachable_backoff` item to avoid Raftstore broadcasting too many messages after one peer becomes unreachable [#13054](https://github.com/tikv/tikv/issues/13054) @[5kbpers](https://github.com/5kbpers)
    - Support configuring the RocksDB write stall settings to a value smaller than the flow control threshold [#13467](https://github.com/tikv/tikv/issues/13467) @[tabokie](https://github.com/tabokie)

+ Tools

    + TiDB Lightning

        - Add retryable errors during checksum to improve robustness [#37690](https://github.com/pingcap/tidb/issues/37690) @[D3Hunter](https://github.com/D3Hunter)

    + TiCDC

        - Enhance the performance of the region worker by handling resolved TS in a batch [#7078](https://github.com/pingcap/tiflow/issues/7078) @[sdojjy](https://github.com/sdojjy)

## Bug fixes

+ TiDB

    - Fix the issue that database-level privileges are incorrectly cleaned up [#38363](https://github.com/pingcap/tidb/issues/38363) @[dveeden](https://github.com/dveeden)
    - Fix the incorrect output of `SHOW CREATE PLACEMENT POLICY` [#37526](https://github.com/pingcap/tidb/issues/37526) @[xhebox](https://github.com/xhebox)
    - Fix the issue that when one PD node goes down, the query of `information_schema.TIKV_REGION_STATUS` fails due to not retrying other PD nodes [#35708](https://github.com/pingcap/tidb/issues/35708) @[tangenta](https://github.com/tangenta)
    - Fix the issue that the `UNION` operator might return unexpected empty result [#36903](https://github.com/pingcap/tidb/issues/36903) @[tiancaiamao](https://github.com/tiancaiamao)
    - Fix the wrong result that occurs when enabling dynamic mode in partitioned tables for TiFlash [#37254](https://github.com/pingcap/tidb/issues/37254) @[wshwsh12](https://github.com/wshwsh12)
    - Fix the issue that the Region cache is not cleaned up in time when the Region is merged [#37141](https://github.com/pingcap/tidb/issues/37141) @[sticnarf](https://github.com/sticnarf)
    - Fix the issue that the KV client sends unnecessary ping messages [#36861](https://github.com/pingcap/tidb/issues/36861) @[jackysp](https://github.com/jackysp)
    - Fix the issue that the `EXPLAIN ANALYZE` statement with DML executors might return result before the transaction commit finishes [#37373](https://github.com/pingcap/tidb/issues/37373) @[cfzjywxk](https://github.com/cfzjywxk)
    - Fix the issue that `GROUP CONCAT` with `ORDER BY` might fail when the `ORDER BY` clause contains a correlated subquery [#18216](https://github.com/pingcap/tidb/issues/18216) @[winoros](https://github.com/winoros)
    - Fix the issue that `Can't find column` is reported if an `UPDATE` statement contains common table expressions (CTE) [#35758](https://github.com/pingcap/tidb/issues/35758) @[AilinKid](https://github.com/AilinKid)
    - Fix the issue that the `EXECUTE` might throw an unexpected error in specific scenarios [#37187](https://github.com/pingcap/tidb/issues/37187) @[Reminiscent](https://github.com/Reminiscent)

+ TiKV

    - Fix the issue that the snapshot data might be incomplete caused by batch snapshot across Regions [#13553](https://github.com/tikv/tikv/issues/13553) @[SpadeA-Tang](https://github.com/SpadeA-Tang)
    - Fix the issue of QPS drop when flow control is enabled and `level0_slowdown_trigger` is set explicitly [#11424](https://github.com/tikv/tikv/issues/11424) @[Connor1996](https://github.com/Connor1996)
    - Fix the issue that causes permission denied error when TiKV gets an error from the web identity provider and fails back to the default provider [#13122](https://github.com/tikv/tikv/issues/13122) @[3pointer](https://github.com/3pointer)
    - Fix the issue that the TiKV service is unavailable for several minutes when a TiKV instance is in an isolated network environment [#12966](https://github.com/tikv/tikv/issues/12966) @[cosven](https://github.com/cosven)

+ PD

    - Fix the issue that the statistics of the Region tree might be inaccurate [#5318](https://github.com/tikv/pd/issues/5318) @[rleungx](https://github.com/rleungx)
    - Fix the issue that the TiFlash learner replica might not be created [#5401](https://github.com/tikv/pd/issues/5401) @[HunDunDM](https://github.com/HunDunDM)
    - Fix the issue that PD cannot correctly handle dashboard proxy requests [#5321](https://github.com/tikv/pd/issues/5321) @[HunDunDM](https://github.com/HunDunDM)
    - Fix the issue that unhealthy Region might cause PD panic [#5491](https://github.com/tikv/pd/issues/5491) @[nolouch](https://github.com/nolouch)

+ TiFlash

    - Fix the issue that I/O Limiter might incorrectly throttle the I/O throughput of query requests after bulk writes, which reduces the query performance [#5801](https://github.com/pingcap/tiflash/issues/5801) @[JinheLin](https://github.com/JinheLin)
    - Fix the issue that a window function might cause TiFlash to crash when the query is canceled [#5814](https://github.com/pingcap/tiflash/issues/5814) @[SeaRise](https://github.com/SeaRise)
    - Fix the panic that occurs after creating the primary index with a column containing the `NULL` value [#5859](https://github.com/pingcap/tiflash/issues/5859) @[JaySon-Huang](https://github.com/JaySon-Huang)

+ Tools

    + TiDB Lightning

        - Fix panic of TiDB Lightning caused by invalid metric counters [#37338](https://github.com/pingcap/tidb/issues/37338) @[D3Hunter](https://github.com/D3Hunter)

    + TiDB Data Migration (DM)

        - Fix the issue that upstream table structure information is lost when DM tasks enter the sync unit and are interrupted [#7159](https://github.com/pingcap/tiflow/issues/7159) @[lance6716](https://github.com/lance6716)
        - Fix large transaction errors by splitting SQL statements when saving checkpoints [#5010](https://github.com/pingcap/tiflow/issues/5010) @[lance6716](https://github.com/lance6716)
        - Fix the issue that DM precheck requires the `SELECT` privilege on `INFORMATION_SCHEMA` [#7317](https://github.com/pingcap/tiflow/issues/7317) @[lance6716](https://github.com/lance6716)
        - Fix the issue that DM-worker triggers a deadlock error after running DM tasks with fast/full validators [#7241](https://github.com/pingcap/tiflow/issues/7241) @[buchuitoudegou](https://github.com/buchuitoudegou)
        - Fix the issue that DM reports the `Specified key was too long` error [#5315](https://github.com/pingcap/tiflow/issues/5315) @[lance6716](https://github.com/lance6716)
        - Fix the issue that latin1 data might be corrupted during replication [#7028](https://github.com/pingcap/tiflow/issues/7028) @[lance6716](https://github.com/lance6716)

    + TiCDC

        - Fix the issue that the cdc server might panic if it receives an HTTP request before the cdc server fully starts [#6838](https://github.com/pingcap/tiflow/issues/6838) @[asddongmen](https://github.com/asddongmen)
        - Fix the log flooding issue during upgrade [#7235](https://github.com/pingcap/tiflow/issues/7235) @[hi-rustin](https://github.com/hi-rustin)
        - Fix the issue that changefeed's redo log files might be deleted by mistake [#6413](https://github.com/pingcap/tiflow/issues/6413) @[hi-rustin](https://github.com/hi-rustin)
        - Fix the issue that TiCDC might become unavailable when too many operations in an etcd transaction are committed [#7131](https://github.com/pingcap/tiflow/issues/7131) @[hi-rustin](https://github.com/hi-rustin)
        - Fix the issue that data inconsistency might occur when non-reentrant DDL statements in redo logs are executed twice [#6927](https://github.com/pingcap/tiflow/issues/6927) @[hicqu](https://github.com/hicqu)

    + Backup & Restore (BR)

        - Fix the issue that the regions are not balanced because the concurrency is set too large during the restoration [#37549](https://github.com/pingcap/tidb/issues/37549) @[3pointer](https://github.com/3pointer)
        - Fix the issue that might lead to backup and restoration failure if special characters exist in the authorization key of external storage [#37469](https://github.com/pingcap/tidb/issues/37469) @[MoCuishle28](https://github.com/MoCuishle28)


text:
---
title: Pull to refresh
desc: The QPullToRefresh Vue component allows the user to pull down in order to refresh or retrieve the newest content on a page.
keys: QPullToRefresh
examples: QPullToRefresh
related:
  - /vue-components/infinite-scroll
  - /vue-components/intersection
  - /vue-components/icon
---

The QPullToRefresh is a component that allows the user to pull down in order to refresh page content (or retrieve the newest content).

<doc-api file="QPullToRefresh" />

## Usage

### Basic

::: warning
In your `@refresh` function, don't forget to call the passed in `done()` function when you have finished loading more data.
:::

To refresh, pull down (with mouse or through finger touch) on the content below when the inner scroll position is the top.

<doc-example title="Basic" file="Basic" />

### Custom icon

<doc-example title="Custom icon" file="Icon" />

### Custom coloring

<doc-example title="Custom coloring" file="CustomColoring" />

## Tips

::: tip Scrolling container
Please read [here](/vue-components/scroll-observer#determining-scrolling-container) about how Quasar determines the container to attach scrolling events to.
:::

* If using a QLayout, then it's recommended that you put QPullToRefresh as direct child of QPage and wrap your page content with it.
* If you change the parent of this component, don't forget to call `updateScrollTarget()` on the QPullToRefresh Vue reference.
* QPullToRefresh also allows text selection, so if your content also has images, you might want to add `draggable="false"` to them, otherwise the native browser behavior might interfere in a negative way.

license: MIT

repository: quasarframework/quasar

branch_name: refs/heads/dev

extension: md

gha_language: JavaScript

gha_license_id: MIT

license_type: permissive

repo_name: quasarframework/quasar


text:
# Rottboellia exaltata L.f. SPECIES

#### Status
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Suppl. pl. 114. 1782 ("1781") (non (L. ) L. f. 1779)

#### Original name
null

### Remarks
null

repository: mdoering/backbone

path: /life/Plantae/Magnoliophyta/Liliopsida/Poales/Poaceae/Rottboellia/Rottboellia cochinchinensis/ Syn. Rottboellia exaltata/README.md

branch_name: refs/heads/master

repo_name: mdoering/backbone


text:
# Manifold-modeling flows

*Johann Brehmer and Kyle Cranmer 2019-2020*

[![arXiv](http://img.shields.io/badge/arXiv-2003.13913-B31B1B.svg)](https://arxiv.org/abs/2003.13913)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

![MFMF illustration figure](experiments/figures/manifold_density_illustration_combined.png)

In the paper [Flows for simultaneous manifold learning and density estimation](https://arxiv.org/abs/2003.13913) we introduce manifold-modeling flows (MFMFs), a new class of generative models that simultaneously learn the data manifold as well as a tractable probability density on that manifold. This repository contains our implementation of manifold-modeling flows as well as some other fow-based generative models, as well as the code for our experiments with them.

**Note that this repository is still under development and we're breaking and mending things constantly!**

## Getting started

Please make sure your Python environment satisfies the requirements in the [environment.yml](environment.yml). To use the MFMF-OT algorithm, please also follow the [installation instructions for geomloss](https://www.kernel-operations.io/geomloss/api/install.html).

## Data sets

Data set | Data dimension | Manifold dimension | Model parameters | Arguments to `generate_data.py`, `train.py`, and `evaluate.py`
--- | --- | --- | --- | ---
Gaussian on an `n`-sphere | `d` | `n` | - |  `--dataset spherical_gaussian --truelatentdim n --datadim d --epsilon eps`
Conditional Gaussian on a `n`-sphere | `d` | `n` | 2 | `--dataset conditional_spherical_gaussian --truelatentdim n --datadim d`
Mixture model on a polynomial manifold | 3 | 2 | 1 | `--dataset power`
Particle physics data (48-D) | 48 | 14 | 2 | `--dataset lhc`
Particle physics data (40-D, no angular features) | 40 | 14 | 2 | `--dataset lhc40d`
Particle physics data (2-D summary stats) | 2 | 2 | 2 | `--dataset lhc2d`

The data for the particle physics experiments is available upon request.

## Data generation

Necessary for the first three data sets in the table above. See [experiments/generate_data.py -h](experiments/generate_data.py).

## Training

See [experiments/train.py -h](experiments/train.py). Note that the algorithms have different internal names from the acronyms in the paper:

Algorithm | Acronym in paper | Arguments to `train.py`
--- | --- | ---
Ambient flow | AF | `--algorithm flow`
Flow on manifold | FOM | `--algorithm mf --specified`
Pseudo-invertible encoder | PIE | `--algorithm pie`
Manifold-modeling flow, simultaneous training (not recommended) | MFMF-S | `--algorithm mf`
Manifold-modeling flow, alternating M/D training | MFMF-M/D | `--algorithm mf --alternate`
Manifold-modeling flow, sequential M/D training | MFMF-M/D | `--algorithm mf --sequential`
Manifold-modeling flow, Optimal Transport training | MFMF-OT | `--algorithm gamf`
Manifold-modeling flow, alternating Optimal Transport training | MFMF-OT/D | `--algorithm gamf --alternate`
Manifold-modeling flow with sep. encoder, simultaneous training (not recommended) | MFMFE-S | `--algorithm emf`
Manifold-modeling flow with sep. encoder, alternating M/D training | MFMFE-M/D | `--algorithm emf --alternate`
Manifold-modeling flow with sep. encoder, sequential M/D training | MFMFE-M/D | `--algorithm emf --sequential`

## Evaluation

See [experiments/evaluate.py -h](experiments/evaluate.py) and the notebooks in [experiments/notebooks](experiments/notebooks). Note that the algorithms have different internal names from the acronyms in the paper:

Algorithm | Acronym in paper | Arguments to `evaluate.py`
--- | --- | ---
Ambient flow | AF | `--algorithm flow`
Flow on manifold | FOM | `--algorithm mf --specified`
Pseudo-invertible encoder | PIE | `--algorithm pie`
Manifold-modeling flow (except OT training) | MFMF | `--algorithm mf`
Manifold-modeling flow, Optimal Transport training | MFMF-OT | `--algorithm gamf`
Manifold-modeling flow with sep. encoder | MFMFE | `--algorithm emf`

## Acknowledgements

The code is largely based on the excellent [Neural Spline Flow code base](https://github.com/bayesiains/nsf) by C. Durkan, A. Bekasov, I. Murray, and G. Papamakarios, see [1906.04032](https://arxiv.org/abs/1906.04032) for their paper.


text:
## Factory Method Pattern

Factory Method Pattern is opposite of the Singleton pattern. It basicly depends on a simple static function that take a String or Enum for a parameter and return a instance according to that parameter.
The interface or abstract class should be there for client. For syntax it's looks a lot like Singleton.

- It is parameter driven and it solves complex creation.
- Does not expose instantiation logic.
- Defer to subclasses.
- All the clients knows about common interface that factory exposes.
- Specified by architecture, implemented by user.

Pitfalls of the Factory Method Pattern is complexity compare to other creational patterns.

#### Singleton vs Factory
While Singleton return same instance Factory returns various instances.
In Singleton there is no interface and subclasses but Factory Method Pattern is interface driven pattern and there are subclasses. In this pattern, adaptable to environment more easily.

repository: nakiscia/Design-Patterns-Java

repo_name: nakiscia/Design-Patterns-Java


text:
# Web Push

## Create an Application

### Step of creating an application:

#### Create an application:

Click the [Create Application] button;
![](image/create_application.png)

#### Configure application information：

Step 1: Basic information: enter the application name (required), and upload an icon;
![jpush_web](image/create_application_step1.png)

Step 2: Configure android platform information: after filling in the application package name, JPush system will generate the pushed Android application Demo in the background according to the package name you entered. The Demo will contain the configuration information.
![jpush_web](image/create_application_step2.png)

Step 3: Configure iOS platform information: upload the push certificate of relevant environment and fill in the password matching the certificate；
![jpush_web](image/create_application_step3.png)

Step 4: Configure WinPhone platform information: select whether to open it
![jpush_web](image/create_application_step4.png)

Step 5:  After the information is configured, check the application information as follows
![jpush_web](image/info_application.png)

## Application Management

Click [home] to return to the home page, you can browse all the application information. Click on the application name or settings to view the application details, click on the push to go to the send notification page, edit and push the notification. Click on the statistics, you can view all the statistics of the application ;
![jpush_web](image/manage_application_01.png)

![jpush_web](image/manage_application.png)

Application details are as follows
![jpush_web](image/info_application.png)

Application settings are as follows：
![jpush_web](image/application_moresetting.png)

## Group Management

After clicking [home] to return to the home page, click [Group Management] in the left navigation to browse the application's group management information and create a new group;
![jpush_web](image/manage_application_01.png)

![jpush_web](image/group_application.png)

## Report Download
After clicking [home] to return to the home page, click [Report download] at the left navigation center to download the report according to the time.
![jpush_web](image/manage_application_01.png)

![jpush_web](image/data_application.png)

## Send Notification
Path: Select Application -> Push -> Send Notification
After filling in the push content, click on the [Send Now] button at the bottom of the page
![jpush_web](image/send_notification.png)

The web interface will pop up a dialog box to prompt whether to send it or not. Select [Send it].
![jpush_web](image/send_.png)

After pushing the result, a dialog box will pop up and please click [go to see] to see the result
![jpush_web](image/send_success.png)

## Custom Message

Path: Select Application -> Push -> Custom Message After filling in the push content, click on the [Send Now] button at the bottom of the page
![jpush_web](image/send_message.png)

## Rich Media News

Path: Select Applications -> Push -> Rich Media Messages
A rich media message in the form of a landing page, a pop window, a message flow, or the like may be sent through a template, or a pre-edited page may be directly transmitted through a URL

##Send via landing page template

Step1: Path: Select Application -> Push -> Rich Media Messages -> Templates -> landing page. Currently the landing page only provides a generic template
![jpush_web](image/landingpage_1.png)

Step2: Enter the editing page of template content, fill in all the contents, preview the display effect of on the left, then click [Next]
![jpush_web](image/landingpage_2.png)

Step3: Click [Preview Rich Media Page] to preview the landing page template that has just been edited; click the [Send Now] button at the bottom of the page to complete the pushing of the landing page.
![jpush_web](image/landingpage_3.png)

## Send via popup template

Step1: Select Application -> Push -> Rich Media Messages -> Template -> Popup Window, to select the appropriate template
![jpush_web](image/popup_1.png)

Step2: Enter the editing page of template content, fill in all the contents, preview the display effect of on the left, then click [Next]
![jpush_web](image/popup_2.png)

Step3: Click [Preview Rich Media Page] to preview the popup template just edited. Click the [Send Now] button at the bottom of the page to complete the popup window's push.
![jpush_web](image/popup_3.png)

## Send via stream template

Step1: Path: Select Application -> Push -> Rich Media Messages -> Templates -> Information Flow, to select the appropriate template；
![jpush_web](image/Informationflow_1.png)

Step2: Enter the editing page of template content, fill in all the contents, preview the display effect of on the left, then click [Next]
![jpush_web](image/Informationflow_2.png)

Step3：Click [Preview Rich Media Page] to preview the popup template that has just been edited. Click the [Send Now] button at the bottom of the page to complete the push of this information flow
![jpush_web](image/informationflow_3.png)

## Send notifications via URL
Step1: Path: Select Application -> Push -> Rich Media Message -> URL, and click the [Next] button. Since the size of the notification is limited, the URL cannot be too long. If the URL exceeds the limit length, please convert it into a short address and enter it again;
![jpush_web](image/url_1.png)

Step2: URL does not provide page preview function. Please make sure to enter the correct URL. Click the [Send Now] button at the bottom of the page to complete the URL push
![jpush_web](image/url_2.png)

## Push History

Path: Select Application -> Push -> Push History
On the right, you can view the history of the push, including push time, content, type, IOS target | success, Android target | success, Winphone target | success, operation.
![jpush_web](image/send_history.png)

**Instructions**

+ Types include: broadcast, tag, alias, Registration ID
+ Operations include: forwarding, details, delete

**Note**

Push historical data only retains statistics for one month.

Details are as follows
![jpush_web](image/send_number.png)

Statistics example：
![jpush_web](image/total.png)

## Timed Push

Path: Select Applications -> Push -> Scheduled Messages
In the pull-down menu on the right, you can choose whether to send messages for [Notification] or [Custom Message]
![jpush_web](image/Schedule_send.png)

## Fixed-Speed Push

Fixed speed (minutes), in the application's "Push" module, click [Fixed-Speed Push].
![jpush_web](image/speed.png)

## User Group

Path: Select Application -> Push -> User Group -> Create User Group
User group can set one or more conditions of: label, geographical location, active user, system version, online user, and registered user
The name of the user group is required, and the name is used when the console sends groups to users.
The ID of the user group is generated after creation, and can be specified when the API is called
![jpush_web](image/segment_1.png)
![jpush_web](image/segment_2.png)

## Statistics and Report Description

### View Report

JPush's Web provides a variety of application-level statistics. As shown in the following figure, after the user logs in to the JPush account and selects a specific application, he can select “Statistics” in the top navigation bar.

####  Select report type
JPush statistics include: push statistics, user statistics, API statistics, active analysis, online retention rate, user group statistics, device information statistics, ranking statistics, region distribution, error list, loss analysis, return visit analysis.
![jpush_web](image/statistics_1.png)

#### Select statistical time

You can select the statistical time range in the upper right corner of the report, or you can customize the query range. The specific statistics period is shown in the figure below. The unit size is: hour, day, month.
Example: If you select "yesterday",
The data presented in the report is in units of hours; if you select “Last 7 days”, the data presented in the report is in days.
![jpush_web](image/statistics_time.png)

## Statistical Description

### Push statistics

The push report presents the status of "push quantity" and "user click". Some statistical effects need to implement the [Push Effect Feedback API](../client/Android/android_api/#api_2).

**Delivery quantity**

The total number of pushes received by Android users, including the number sent through the portal and sent via the API. Including notifications, also includes custom messages.

```
Because iOS and Window Phone systems have different principles, this curve shows the correct delivery of APNS and MPNS statistics.
```

**User clicks**

The number of times the user entered the application by clicking on the notification bar message.

```
For Android apps, you need to implement the statistical analysis API to have this statistic.
```

### User Statistics

**New Users**

"New user" refers to the newly added JPush registered user. When the application starts for the first time, the JPush SDK initiates an internal registration with JPush. iOS system does not take into account new user statistics if the user chooses to disable push on first use.

**Online Users**

“Online users” refers to the total number of users who have established a network connection with the JPush Server during the statistical period. If the statistical time is connected once, it is counted in the statistical item, and the same user does not repeat the calculation for multiple connections.

**Active Users**

"Active user" refers to the total number of users that have opened the application at least once within the statistical time. The difference between an active user and an online user is that the active user must have opened the application and the online user has a network on the user side to maintain connection with JPush.

```
Android systems need to implement the push effect feedback API to count active users.
```

### API statistics

**API statistics**

The total number of times the Push API was called within the statistics duration. Note: The number of APIs is different from the number of messages. One broadcast push and one alias push are both 1 API call.

### Active Analysis

**Push Quantity**

The definition is the same as above, which is mainly used as a comparison curve to measure the user's active effect after the push.

**User Opening Times**

The total number of times all users open the app. This indicator can be used to observe whether the user opens more applications as the number of pushes increases.

```
Android systems need to implement the push effect feedback API to have this statistic.
```

**User Usage Time (minutes)**

Total time spent by all users on using the app. This indicator can be used to observe whether users use the application for a longer time depending on the content of the push.

```
Android systems need to implement the push effect feedback API to have this statistic.
```

#### Online Retention Rate

Users added during a certain period of time and still connected to the JPush server after a period of time are called retained users. The ratio of retained users to new users at the time is called retention rate. "Online retention rate" can reflect the user's user retention more realistically.

```
Note: The definition of JPush's retention user is an online user, which refers to a user who still has a connection to the server (this can be done without opening the application but being online at the backend). This definition is different from other "active retention rate" based on user activity statistics. Since the user of iOS platform mechanism can be online only when opening the application, the retention is approximately equal to "active retention."
```

For example: Daily retention. The number of users added on some day is 100. After 3 days, the number of users who are still online among the 100 users is 50. Then, the 3-day retention rate for new users on this day is 50%

[0]: image/report_functions.png
[1]: image/report_functions2.png

## SMS Verification Code

### Data Overview

Path: Select Application -> SMS Verification Code -> Data Overview
SMS margin: the number of remaining text messages that can be sent, where the balance is the sum of the number of text messages that can be sent by all applications under the account.
SMS volume: the amount of text messages sent during today, the amount of text messages sent in this month, and the amount of text messages sent in last month. The amount of traffic generated here is the usage of the app;

### Sending Records
Path: Select Applications -> SMS Verification Code -> Send Record;
All SMS verification codes sent by the current application support the inquiry by mobile number and time;


text:
---
layout: default
---

## Wk 5 - Monday - HTML and CSS

**Challenge:** [Discuss Ruby](https://github.com/masonfmatthews/rails_assignments/blob/master/challenges/discuss_ruby.md)

**Problem of the Day:** [My First Website](https://github.com/masonfmatthews/rails_assignments/blob/master/exercises/my_first_website)

* Human Learning:
  * ON BOARD: Elaborate rather than review
* HTML
  * View source on `theironyard.com`
  * EXAMPLE: The Plutonium Yard, competitor to the Iron Yard
  * Tags and Nesting
  * Header and Body
  * Common tags
    * `h1` - `h6`
    * `p`
    * `a`
    * `div`
    * `span`
    * `ul`, `li`, `ol`
    * `table`, etc
    * `image`
    * Embedding content
  * Possible conflicts/inconsistent HTML
    * [XKCD on Tags](https://xkcd.com/1144/)
  * Attributes
    * `href`
    * `src`
* CSS
  * Three places to add style to HTML
    * Putting it in `style=` attributes - thumbs down.
    * Inside `<style>` tags - thumbs mostly down.
    * In separate files - thumbs up!
  * Basic Selectors
    * `id` and `class` attributes
    * `li {}` to select everything in all `li`s
    * `div li {}` to select every `li` inside a `div`
    * `li, p {}` to select everything in all `li`s and `p`s
    * `#id` to select the element with an `id` of "id"
    * `.class` to select everything with a `class` of "class"
    * `li.class` to select every `li` with a `class` of "class"
  * Properties and values
    * `border:`
    * `width:`
    * `color:`
    * What color means
    * [Odd color attributes](http://stackoverflow.com/questions/8318911/why-does-html-think-chucknorris-is-a-color?rq=1)
  * Advanced stuff
    * `box-shadow`
    * `transform`
  * Pseudo-selectors (learn for homework)

#### Lecture Notes

* [Class Video](https://youtu.be/N6o3TouuZMo)
* [Whiteboard - CSS Selectors](http://tiyd-rails.s3.amazonaws.com/pictures/uploaded_files/000/000/039/original/css_selectors.jpg?1443457544)

#### Example Links

Websites that are "static":

* [Headhunter Hair Styling](http://www.headhunterhairstyling.com/)
* [Do Nothing for 2 Minutes](http://www.donothingfor2minutes.com/)
* [Find the Invisible Cow](http://findtheinvisiblecow.com/) (Down?)
* [WeaveSilk](http://weavesilk.com/)

Webapps that do processing on the server (and/or have a database):

* [Is it Christmas](http://isitchristmas.com)
* [Potato-counter](https://potato-counter.herokuapp.com/)
* [How many people are in space right now](http://howmanypeopleareinspacerightnow.com)
* [Ship Your Enemies Glitter](http://shipyourenemiesglitter.com/)
* [Wikipedia](http://wikipedia.com)

#### Useful Links

* [Codepen](http://codepen.io)
* [MDN](https://developer.mozilla.org/en-US/) results are the best.
* [Google Trends](https://trends.google.com)
* [Palette Tool](http://paletton.com/#uid=13P0u0kllll70vXeaqEswg1G0aI)
* [Avoid Vibrating Color Combinations](http://webdesign.tutsplus.com/articles/why-you-should-avoid-vibrating-color-combinations--cms-25621)
* [Adobe Color](https://color.adobe.com)
* [Meet the Ipsums](http://meettheipsums.com)
* [Durham Ipsum](http://durhamipsum.com)

#### Evening Reading

* Preview Reading: [Rails Forms](http://guides.rubyonrails.org/form_helpers.html)
* Listening: [Ruby Rogues - Hacking Education](http://devchat.tv/ruby-rogues/159-rr-hacking-education-with-saron-yitbarek)

#### Assignment

* Assignment: [CSS Reverse Engineering](https://github.com/tiyd-rails-2016-01/css_reverse_engineering)
* Feedback: [CSS Reverse Engineering Feedback](feedback)


text:
# CN2
Python implementation of the CN2 (Clark and Niblett 1989) Induction Algorithm [1].

## How to run example
The provided code includes datasets from the UCI machine learning repository [2] and a ```cn2_tests.py``` example file.
In order to execute the example test code follow these steps:

1. Install the required packages

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

2. Execute the tests script

      ```$ python cn2_tests.py```

## References
[1] Clark, P., & Niblett, T. (1989). The CN2 induction algorithm. Machine Learning, 3(4), 261-283. doi: 10.1007/bf00116835

[2] Dheeru Dua and Casey Graff. UCI machine learning repository, 2017. https://archive.ics.uci.edu/ml/datasets

branch_name: refs/heads/main


text:
[//]: # (Image References)

[image1]: ./images/sample_dog_output.png "Sample Output"
[image2]: ./images/vgg16_model.png "VGG-16 Model Keras Layers"
[image3]: ./images/vgg16_model_draw.png "VGG16 Model Figure"

## Project Overview

Welcome to the Convolutional Neural Networks (CNN) project in the AI Nanodegree! In this project, you will learn how to build a pipeline that can be used within a web or mobile app to process real-world, user-supplied images.  Given an image of a dog, your algorithm will identify an estimate of the canine’s breed.  If supplied an image of a human, the code will identify the resembling dog breed.

![Sample Output][image1]

Along with exploring state-of-the-art CNN models for classification, you will make important design decisions about the user experience for your app.  Our goal is that by completing this lab, you understand the challenges involved in piecing together a series of models designed to perform various tasks in a data processing pipeline.  Each model has its strengths and weaknesses, and engineering a real-world application often involves solving many problems without a perfect answer.  Your imperfect solution will nonetheless create a fun user experience!

## Project Instructions

### Instructions

1. Clone the repository and navigate to the downloaded folder.
```
git clone https://github.com/udacity/dog-project.git
cd dog-project
```

2. Download the [dog dataset](https://s3-us-west-1.amazonaws.com/udacity-aind/dog-project/dogImages.zip).  Unzip the folder and place it in the repo, at location `path/to/dog-project/dogImages`.

3. Download the [human dataset](https://s3-us-west-1.amazonaws.com/udacity-aind/dog-project/lfw.zip).  Unzip the folder and place it in the repo, at location `path/to/dog-project/lfw`.  If you are using a Windows machine, you are encouraged to use [7zip](http://www.7-zip.org/) to extract the folder.

4. Download the [VGG-16 bottleneck features](https://s3-us-west-1.amazonaws.com/udacity-aind/dog-project/DogVGG16Data.npz) for the dog dataset.  Place it in the repo, at location `path/to/dog-project/bottleneck_features`.

5. (Optional) __If you plan to install TensorFlow with GPU support on your local machine__, follow [the guide](https://www.tensorflow.org/install/) to install the necessary NVIDIA software on your system.  If you are using an EC2 GPU instance, you can skip this step.

6. (Optional) **If you are running the project on your local machine (and not using AWS)**, create (and activate) a new environment.

	- __Linux__ (to install with __GPU support__, change `requirements/dog-linux.yml` to `requirements/dog-linux-gpu.yml`):
	```
	conda env create -f requirements/dog-linux.yml
	source activate dog-project
	```
	- __Mac__ (to install with __GPU support__, change `requirements/dog-mac.yml` to `requirements/dog-mac-gpu.yml`):
	```
	conda env create -f requirements/dog-mac.yml
	source activate dog-project
	```
	**NOTE:** Some Mac users may need to install a different version of OpenCV
	```
	conda install --channel https://conda.anaconda.org/menpo opencv3
	```
	- __Windows__ (to install with __GPU support__, change `requirements/dog-windows.yml` to `requirements/dog-windows-gpu.yml`):
	```
	conda env create -f requirements/dog-windows.yml
	activate dog-project
	```

7. (Optional) **If you are running the project on your local machine (and not using AWS)** and Step 6 throws errors, try this __alternative__ step to create your environment.

	- __Linux__ or __Mac__ (to install with __GPU support__, change `requirements/requirements.txt` to `requirements/requirements-gpu.txt`):
	```
	conda create --name dog-project python=3.5
	source activate dog-project
	pip install -r requirements/requirements.txt
	```
	**NOTE:** Some Mac users may need to install a different version of OpenCV
	```
	conda install --channel https://conda.anaconda.org/menpo opencv3
	```
	- __Windows__ (to install with __GPU support__, change `requirements/requirements.txt` to `requirements/requirements-gpu.txt`):
	```
	conda create --name dog-project python=3.5
	activate dog-project
	pip install -r requirements/requirements.txt
	```

8. (Optional) **If you are using AWS**, install Tensorflow.
```
sudo python3 -m pip install -r requirements/requirements-gpu.txt
```

9. Switch [Keras backend](https://keras.io/backend/) to TensorFlow.
	- __Linux__ or __Mac__:
		```
		KERAS_BACKEND=tensorflow python -c "from keras import backend"
		```
	- __Windows__:
		```
		set KERAS_BACKEND=tensorflow
		python -c "from keras import backend"
		```

10. (Optional) **If you are running the project on your local machine (and not using AWS)**, create an [IPython kernel](http://ipython.readthedocs.io/en/stable/install/kernel_install.html) for the `dog-project` environment.
```
python -m ipykernel install --user --name dog-project --display-name "dog-project"
```

11. Open the notebook.
```
jupyter notebook dog_app.ipynb
```

12. (Optional) **If you are running the project on your local machine (and not using AWS)**, before running code, change the kernel to match the dog-project environment by using the drop-down menu (**Kernel > Change kernel > dog-project**). Then, follow the instructions in the notebook.

__NOTE:__ While some code has already been implemented to get you started, you will need to implement additional functionality to successfully answer all of the questions included in the notebook. __Unless requested, do not modify code that has already been included.__

## Evaluation

Your project will be reviewed by a Udacity reviewer against the CNN project [rubric](https://review.udacity.com/#!/rubrics/810/view).  Review this rubric thoroughly, and self-evaluate your project before submission.  All criteria found in the rubric must meet specifications for you to pass.

## Project Submission

When you are ready to submit your project, collect the following files and compress them into a single archive for upload:
- The `dog_app.ipynb` file with fully functional code, all code cells executed and displaying output, and all questions answered.
- An HTML or PDF export of the project notebook with the name `report.html` or `report.pdf`.
- Any additional images used for the project that were not supplied to you for the project. __Please do not include the project data sets in the `dogImages/` or `lfw/` folders.  Likewise, please do not include the `bottleneck_features/` folder.__

Alternatively, your submission could consist of the GitHub link to your repository.

 # Archival Note
 This repository is deprecated; therefore, we are going to archive it. However, learners will be able to fork it to their personal Github account but cannot submit PRs to this repository. If you have any issues or suggestions to make, feel free to:
- Utilize the https://knowledge.udacity.com/ forum to seek help on content-specific issues.
- Submit a support ticket along with the link to your forked repository if (learners are) blocked for other reasons. Here are the links for the [retail consumers](https://udacity.zendesk.com/hc/en-us/requests/new) and [enterprise learners](https://udacityenterprise.zendesk.com/hc/en-us/requests/new?ticket_form_id=360000279131).

repository: udacity/dog-project

gha_language: Jupyter Notebook

repo_name: udacity/dog-project


text:
Gridsome Remark plugin to embed card about link.

This is a fork of [JaeYeopHan/gatsby-remark-link-card](https://github.com/JaeYeopHan/gatsby-remark-link-card) that is Gatsby plugin.

> You can preview the description of the link!

## Install

```sh
$ npm i colus-img/gridsome-plugin-remark-linkcard
```

## Usage

### in Markdown

```md
[$card](https://github.com/JaeYeopHan/gatsby-remark-link-card)
```

### with Config

Add in your `gridsome.config.js` like this:
```js
plugins: [
  {
    use: '@gridsome/vue-remark',
    options: {
      plugins: [
        [
          'gridsome-plugin-remark-linkcard', {
            // options
          }
        ]
      ],
    }
  }
]
```

## Options

| Property    | Type     | Default  | Description                        |
| ----------- | -------- | -------- | ---------------------------------- |
| `delimiter` | `string` | `$card`  | Title of the link to create a card |
| `image`     | `string` | data-uri | Default og image path              |
| `favicon`   | `string` | data-uri | Default favicon image path         |
| `error`     | `Object` | -        | Default config when error          |

## Inspiration
The credit for this plugin goes to JaeYeopHan. I only borrowed what they did for Gatsby. Thank you so much!

[JaeYeopHan/gatsby-remark-link-card： ⛳ Gatsby Remark plugin to embed card about link. Just write markdown syntax with your delimeter and build! puppeter gather data!](https://github.com/JaeYeopHan/gatsby-remark-link-card)

### Original Author

👤 **JaeYeopHan (Jbee)**

- Github: [@JaeYeopHan](https://github.com/JaeYeopHan)
- Twitter: [@JbeeLjyhanll](https://twitter.com/JbeeLjyhanll)


text:
# Centrality algorithms
cuGraph Pagerank is implemented using our graph primitive library

## Pagerank

The unit test code is the best place to search for examples on calling pagerank.

 * [SG Implementation](../../tests/pagerank/pagerank_test.cpp)
 * [MG Implementation](../../tests/pagerank/mg_pagerank_test.cpp)

## Simple pagerank

The example assumes that you create an SG or MG graph somehow.  The caller must create the pageranks vector in device memory and pass in the raw pointer to that vector into the pagerank function.

```cpp
#include <cugraph/algorithms.hpp>
...
using vertex_t = int32_t;       // or int64_t, whichever is appropriate
using weight_t = float;         // or double, whichever is appropriate
using result_t = weight_t;      // could specify float or double also
raft::handle_t handle;          // Must be configured if MG
auto graph_view = graph.view(); // assumes you have created a graph somehow

result_t constexpr alpha{0.85};
result_t constexpr epsilon{1e-6};

rmm::device_uvector<result_t> pageranks_v(graph_view.number_of_vertices(), handle.get_stream());

// pagerank optionally supports three additional parameters:
//     max_iterations     - maximum number of iterations, if pagerank doesn't coverge by
//                          then we abort
//     has_initial_guess  - if true, values in the pagerank array when the call is initiated
//                          will be used as the initial pagerank values.  These values will
//                          be normalized before use.  If false (the default), the values
//                          in the pagerank array will be set to 1/num_vertices before
//                          starting the computation.
//     do_expensive_check - perform extensive validation of the input data before
//                          executing algorithm.  Off by default.  Note: turning this on
//                          is expensive
cugraph::pagerank(handle, graph_view, nullptr, nullptr, nullptr, vertex_t{0},
                                pageranks_v.data(), alpha, epsilon);
```

## Personalized Pagerank

The example assumes that you create an SG or MG graph somehow.  The caller must create the pageranks vector in device memory and pass in the raw pointer to that vector into the pagerank function.  Additionally, the caller must create personalization_vertices and personalized_values vectors in device memory, populate them and pass in the raw pointers to those vectors.

```cpp
#include <cugraph/algorithms.hpp>
...
using vertex_t = int32_t;                    // or int64_t, whichever is appropriate
using weight_t = float;                      // or double, whichever is appropriate
using result_t = weight_t;                   // could specify float or double also
raft::handle_t handle;                       // Must be configured if MG
auto graph_view = graph.view();              // assumes you have created a graph somehow
vertex_t number_of_personalization_vertices; // Provided by caller

result_t constexpr alpha{0.85};
result_t constexpr epsilon{1e-6};

rmm::device_uvector<result_t> pageranks_v(graph_view.number_of_vertices(), handle.get_stream());
rmm::device_uvector<vertex_t> personalization_vertices(number_of_personalization_vertices, handle.get_stream());
rmm::device_uvector<result_t> personalization_values(number_of_personalization_vertices, handle.get_stream());

//  Populate personalization_vertices, personalization_values with user provided data

// pagerank optionally supports three additional parameters:
//     max_iterations     - maximum number of iterations, if pagerank doesn't coverge by
//                          then we abort
//     has_initial_guess  - if true, values in the pagerank array when the call is initiated
//                          will be used as the initial pagerank values.  These values will
//                          be normalized before use.  If false (the default), the values
//                          in the pagerank array will be set to 1/num_vertices before
//                          starting the computation.
//     do_expensive_check - perform extensive validation of the input data before
//                          executing algorithm.  Off by default.  Note: turning this on
//                          is expensive
cugraph::pagerank(handle, graph_view, nullptr, personalization_vertices.data(),
                                personalization_values.data(), number_of_personalization_vertices,
                                pageranks_v.data(), alpha, epsilon);
```

repository: rapidsai/cugraph

gha_language: Cuda

repo_name: rapidsai/cugraph


text:
---
title: fusion (2.1.0)

categories:

- other

---
<!-- COMPUTER GENERATED PAGE!!! DO NOT EDIT DIRECTLY  -->
<!--    must be changed in scripts/templates.py which is processed by scripts/update_refs.py -->

Long form: fusion

Short form: fus

`fusion()` or `fus()` expressions can be used in place of a namespace value within a gene, RNA, or protein abundance function to represent a hybrid gene, or gene product formed from two previously separate genes. `fusion()` expressions take the general form:

    fus(ns5':v5', "range5'", ns3':v3', "range3'")

where `ns5':v5'` is a namespace and value for the 5' fusion partner, `range5'` is the sequence coordinates of the 5' partner, `ns3':v3'` is a namespace and value for the 3' partner, and `range3'` is the sequence coordinates for the 3' partner.  Ranges need to be in quotes.

### Function Signatures

##### fusion(NSArg, StrArg, NSArg, StrArg)

1. Namespace argument of following type(s): Gene, RNA, Micro_RNA, Protein

1. String argument of following type(s): /\S+/

1. Namespace argument of following type(s): Gene, RNA, Micro_RNA, Protein

1. String argument of following type(s): /\S+/

### Examples

## RNA abundance of fusion with known breakpoints

The __r.__ designation in the range fields indicates that the numbering uses the RNA sequence as the reference. RNA sequence numbering starts at the transcription initiation site.  You use __c.___ for g() fusions and __p.___ for p() fusions.  These __r.__, __c.__, and __p.__ designations come from http://www.hgvs.org[HGVS variation description] convention.

    r(fus(HGNC:TMPRSS2, "r.1_79", HGNC:ERG, "r.312_5034"))

RNA abundance of fusion with unspecified breakpoints

    r(fus(HGNC:TMPRSS2, "?", HGNC:ERG, "?"))

---
##### [Request an Edit](https://github.com/belbio/bel_lang_ws/issues/new?title=Doc edit request - fusion (2.1.0))


text:
# Attention this repository is no longer maintained
Please refer to [https://github.com/VRI-UFPR/ANDA](https://github.com/VRI-UFPR/ANDA) from now on.

## ANDA:  A Novel Data Augmentation Technique Applied to Salient Object Detection
Official code for the ICAR 2019 paper ["ANDA:  A Novel Data Augmentation Technique Applied to Salient Object Detection"](https://arxiv.org/abs/1910.01256)

## REQUIREMENTS:
We recommend the use of conda alternatively miniconda for python environment management. For the scripts, refer to the requirements.txt in the root folder, for the PConvInpainting refer to PConvInpainting/requirements.txt.

## STEP BY STEP USAGE:

- Download MSRA10K at [https://mmcheng.net/msra10k/](https://mmcheng.net/msra10k/)
- Run scripts/protocol.sh PATH ; e.g. MSRA10K_Imgs_GT/Imgs
- Run PConvInpainting/inpaintMSRA10K.py ; --help for parameter instructions
- Run scripts/featureRelated/computeKnn.py ; --help for parameter instructions
- Run scripts/featureRelated/anda.py ; --help for parameter instructions

A bash script for the entire process is available at scripts/run.sh

```
cd scripts
bash run.sh
```

### CITATION:
If you found this code useful for your research, please cite:
```
@INPROCEEDINGS{ruiz2019anda,
author={D. V. {Ruiz} and B. A. {Krinski} and E. {Todt}},
booktitle={2019 19th International Conference on Advanced Robotics (ICAR)},
title={ANDA: A Novel Data Augmentation Technique Applied to Salient Object Detection},
year={2019},
pages={487-492},
keywords={feature extraction;learning (artificial intelligence);neural nets;object detection;video signal processing;image cropping;ANDA technique;labeled salient objects;image inpainting;background information;data augmentation technique;salient object detection context;mean absolute error;F-measure},
doi={10.1109/ICAR46387.2019.8981655},
ISSN={null},
month={Dec},}
```

### DISCLAIMER:

- This is a research code, so compatibility issues might happen.
- The PConvInpainting folder contain code from the [REPOSITORY](https://github.com/MathiasGruber/PConv-Keras).

repository: ruizvitor/ANDA

repo_name: ruizvitor/ANDA


text:
---
layout: post
title: '"On Code Review" - Glen Sanford'
date: 2018-01-29 16:35:55 -0500
external-url: https://medium.com/@9len/on-code-review-16ea85f7c585
---

Code Review is a central part of every programmer's process: generate an
idea, write the idea as code (including tests!), submit for review,
incorporate review notes, merge to mainline. It's also the only time in
this process that _other people_ are required. You can come up with your
own idea and code it and write tests and merge back into mainline without
any input from anyone else! But code review is essentially the idea that
your code has fewer bugs and greater logical coherence when it's reviewed
thoroughly by someone else. So.

Glen argues two things:

1. Make reviewing your teammates' code your top priority
2. Make the code & pull requests you write a pleasure to review

**Timely code review is crucial to feature throughput of a team.**

This article hit home when Glen wrote this:

> Pending code review represent blocked threads of execution.
> ...
> In the best case, an engineer blocked on code review is able to make progress on some other change, at the cost of (1) context switching and (2) increased memory allocation.
> ...
> In the worst case, an engineer blocked on code review can’t make any progress at all, because the work allocated to them is serialized on the review.

All the allegories to computers aside, this is exactly my frustration as a
programmer. I tend to do 10 or 12 different things because I get blocked on
code review. Then a month goes by and I forget to ping the reviewers again
and oh goodness now the code is totally outdated and I may as well give up.
Wasted work!

Glen also makes the case that we should review others' code promptly.
"Expect to spend time on code review every day, throughout the day," he
writes. Shortening iterations between reviewing, responding to review,
and re-reviewing can drastically increase work throughput of the team.

repository: parkr/stuff

extension: markdown

gha_language: HTML

repo_name: parkr/stuff


text:
# Airbnb Nashville
**Assignment Goal**

Create a polished 'slidedoc', aimed at a targeted audience, that analyzes a data set of your choosing. This slidedoc should clearly present a hypothesis and analysis of a real-world problem for your audience.

**Partners**

* [Rastko Stojin](https://github.com/ok-tsar)
* [Shaswat Rajput](https://github.com/shaswat01)

**Purpose**

Over the past several years, Nashville has been one of the fastest growing cities in the county. A side effect of this growth is that hotels have reached $300-$500 per night for a room. Many tourists and visitors are resorting to short-term rentals With over 7,000 listings, how do you pick the right one?

**Audience**

General consumers, in particular those not very familiar with short-term rentals (Airbnb, VRBO, etc.), looking to stay in Nashville. We assumed they are not intimately familiar with the area and have no strong inclinations about where to stay.

### About the Data
Unofficial Airbnb data for the Nashville-metro area was created by [Inside Airbnb](http://insideairbnb.com). Available data includes publicly available property listings and reviews as of 9/20/19.
On their website, Inside Airbnb does call out significant caveats related to their collected data. Below are a few of the most important ones relative to our analysis.
* Calendar Data: Data is sourced from the Airbnb calendar. This does not differentiate between a booked night and an unavailable night. In addition, this is dependent on a Host keeping this calendar up to date.
** Due to these factors, we did not use the Calendar data set or availability data in the Listing data.
* Price: Unclear how this was collected, as price varies signfiicantly based on day of the week, holidays, etc.

For our analysis, we focused on listing data. If we were to expand or continue our analysis we would also perform a textual analysis of property reviews.

### Description of files
* airbnb_nashville.rmd - Working document for analysis and vizualziations

* presentation.pdf - Completed presentation

### Technology Used
* R (tidyverse, ggplot2, ggcorplot, stringr)
* Tableau


text:
---
title: Hyde is first housing association to use online benefits/employment platform,
  BetterOff
date: 2016-10-14 00:00:00 Z
categories:
- BetterOff
- Housing
author: Rhea Cunio
---

The Hyde Group will be the first housing association to use BetterOff, the online platform which brings benefits and employment together in one, easy, digital space.

BetterOff, developed by Kirklees Council’s digital team, LookingLocal, combines benefits eligibility, applications, appeals and comprehensive employment tools.

This helps to ensure tenants are better off with the benefits they’re entitled to, have improved job prospects, and are able to pay their rent on time.

> We, at Hyde, are working towards digitally transforming most of our current services as we recognise that tenants increasingly want to access services (and information) in this way. Where possible, we’re aiming to offer our tenants a self-serve option, so BetterOff seemed a perfect fit.
>
><cite>Jahanara Rajkoomar, Head of Community Investment</cite>

At Hyde, benefit, money advice and employment support is delivered by a number of teams, and  together they see around 8,500 people every year in need of some form of assistance.

 BetterOff will extend the reach of these teams, reduce the cost of providing advice in outlying  geographies, and deliver time efficiencies. It pulls multiple jobs databases together creating a  one-stop shop for jobseekers, so this employment support will also deliver genuine value to Hyde.

"Using BetterOff means we’re able to offer our tenants a high-quality self-serve advice service and ensure no-one will fall through the net.” explained Jahanara.

In addition, BetterOff Hyde will save Hyde money by creating an excellent self-serve option that drives residents on-line. The co-browsing feature has the potential to reduce the need for home visits to tenants. On average, we expect residents using BetterOff to gain £635 each in unclaimed benefits.

BetterOff is a fully responsive site which can be accessed on computers, smartphone and tablets.

In implementing BetterOff, Hyde joins Kirklees Council, Stockport Council and the London Borough of Enfield where the platform is already live.


text:
# Client-Side Form Validation

Before submitting data to the server, it is important to ensure that the user has filled out all required form controls and done so in the correct format. Knowing that this is a common use of JavaScript, I wanted to make sure that I received additional practice outside of the OSU coding bootcamp. Therefore I followed a tutorial to help me reinforce my form validation skills.

# Some topics covered in this tutorial included:
- HTML form elements, setting IDs and classes to interact with CSS/JS
- CSS absolute and relative positioning of elements
- Client-side form validation with JS
- JS error messages (without any prompts or alerts)
- Dynamically inserting classes with JS

# Preview
![Form Validation Screencap](https://raw.githubusercontent.com/mdurst365/form_validation/main/Capture.JPG)

# Link to Tutorial
https://www.youtube.com/watch?v=rsd4FNGTRBw&ab_channel=FlorinPop


text:
---
layout: page
title: Reconnecting with other Alumni
permalink: /get-involved/alumni
---

# Alumni Board
While the Alumni Board is comprised of specific positions, we encourage any and everyone to be active within the alumni group. Even if you can only spare a few minutes of your time, we could always use it! Please contact [Alex<EMAIL_ADDRESS>to get on our Alumni Executive Board email list.

{% include spotlight-inline.html
  name="Wilmer Lidke"
  position="Alumni President"
<EMAIL_ADDRESS>  cover-image="/assets/img/people/wilmer.jpg"
content="
"%}

{% include spotlight-inline.html
  name="Troy Bouman"
  init-year="09"
  position="Alumni Treasurer"
<EMAIL_ADDRESS>  cover-image="/assets/img/people/troy.jpg"
  content="
I graduated from Tech in 2012 after 5 awesome years. During my time as an active I was the VP of New Member Education and Treasurer!
"%}

{% include spotlight-inline.html
  name="Alex Ott"
  init-year="11"
  position="Alumni Secretary"
<EMAIL_ADDRESS>  cover-image="/assets/img/people/Ott-Photo.jpg"
  content="
I graduated from Michigan Tech in 2016 with a BS in Engineering Management, after 4 years as an active and 1 year as an alumnus. I served in a number of positions, including VP of Member Development and as the Alumni Relations Chair.
"%}

# Committees

Committees are established to better serve the Alumni and Active Organizations. While there may be any number of provisional committees at any time, these committees in particular are intended to provide long-term and in-depth support to the Fraternity.

## Member Development Committee
{% include spotlight-inline.html
  name="Jeff Kellogg"
  position="Housing Committee Chair"
  init-year="12"
<EMAIL_ADDRESS>  cover-image="/assets/img/people/kellogg.png"
  content="
Jeff joined Triangle in the spring of 2012, and graduated with a degree in Chemical Engineering. He now works in Charles City, IA.

Jeff volunteered to head the Housing Committee, citing prior experience with homeownership. If you would like to get involved with this committee, please contact Jeff.
"%}

{% include spotlight-inline.html
  name="Mike Spenle"
  position="Alumni Member Development Committee Chair"
  init-year="13"
<EMAIL_ADDRESS>  cover-image="/assets/img/people/spenle.png"
  content="
Mike joined Triangle in the spring of 2013, and has been very involved since then. He currently lives and works in the Ann Arbor area.

If you would like to get involved with this committee, please contact Mike.
"%}

{% for file in site.static_files %}
{% if file.path contains "/assets/docs/newsletters/" %}
- [{{ file.basename }}]({{ file.path | relative_url }})
{% endif %}
{% endfor %}

# Donations

{% include paypal-card.html paypal-id="VDS37JZR7LQAQ" header="Alumni Organization" content="
- Reimbursement of Pledge Fees for Dean's List achievers
- Equipment for Winter Carnival
- Travel assistances for National events
- Alumni National Chapter Fee
"%}

{% include paypal-card.html paypal-id="K86DXC576MLZL" header="Housing Fund" content="
- Housing Improvements
"%}

{% include paypal-card.html paypal-id="D2BA3SJRMPVSS" header="Monthly Donation" content='
<select name="os0" class="form-control" id="monthlyAmount">
  <option value="Mr. T">Mr. T: $100.00</option>
  <option value="Mr. Bigshot">Mr. Bigshot: $75.00</option>
  <option value="Half Way There">Half Way There: $50.00</option>
  <option value="I\'ll Share The Wealth">I\'ll Share The Wealth: $30.00</option>
  <option value="Wilmer\'s Club">Wilmer\'s Club: $20.00</option>
  <option value="I\'m giving her all she\'s got!">I\'m giving her all she\'s got!: $10.00</option>
  <option value="I still got loans man!">I still got loans man!: $5.00</option>
</select>
'%}

# Alumni Communities


text:
# GC Auth

Auth application for [Graffiticode](https://graffiticode.org) applications.

## API

- `uid`: user id, in practice this is a non `0x` prefixed ethereum address.

### `GET /certs`

Gets a JSON Web Key Set for the current set of keys being used to sign tokens.

- __AUTH__: `none`

### `GET /authenticate/ethereum/:address`

Returns the current nonce for an ethereum address. This will generate a nonce if one does not currently exist.

- __AUTH__: `none`
- Request
  - `address`: used as the user id
- Response
  - `nonce`: Opaque random string used for authenticating with ethereum.

### `POST /authenticate/ethereum/:address`

Performs Sign In With Ethereum processing for an address. If authentication succeeds a `accessToken` and `refreshToken` are issued to the caller.

- __AUTH__: `none`
- Request
  - `address`: used as the user id
  - `signature`: signed ethereum message with contents "Nonce: \<nonce\>"
- Response
  - `accessToken`: a short lived JWT that can be used to make authenticated calls to GC APIs (i.e. compilers or the API). This is optimization over the client having to call `POST /authenticate/refresh_token`.
  - `refreshToken`: a long lived opaque token for retrieving auth `accessToken`s.

### `POST /authenticate/refresh_token`

Exchanges a `refreshToken` issued during authentication for a short lived JWT that can be used to make authenticated calls to the GC APIs.

- __AUTH__: `none`
- Request
  - `refreshToken`: the token issued during authentication
- Response
  - `accessToken`: a short lived JWT that can be used to make authenticated calls to GC APIs.

## Development

1. Start firebase emulators (_NOTE_: you only to do this once per GCP project).

```bash
npx firebase emulators:start
```

1. Run GC Auth application (in another terminal)

```bash
npm run dev
```

1. Run example usage

```bash
# Generate a signing key
curl -i -X POST http://localhost:4100/certs

node tools/run-ethereum.js
```

repository: graffiticode/graffiticode

repo_name: graffiticode/graffiticode


text:
# Lavalink

`twilight-lavalink` is a client for [Lavalink] for use with [model] events from
the [gateway].

It includes support for managing multiple nodes, a player manager for
conveniently using players to send events and retrieve information for each
guild, and an HTTP module for creating requests using the http crate and
providing models to deserialize their responses.

## Features

### HTTP Support

The `http-support` feature adds types for creating requests and deserializing
response bodies of Lavalink's HTTP routes via the `http` crate.

This is enabled by default.

### TLS

`twilight-lavalink` has features to enable [`async-tungstenite`]'s TLS features.
These features are mutually exclusive.

`rustls` is enabled by default.

#### Native

The `native` feature enables [`async-tungstenite`]'s `tokio-native-tls` feature.
This will use native TLS support, for example OpenSSL on Linux.

#### RusTLS

The `rustls` feature enables [`async-tungstenite`]'s `tokio-rustls` which uses
the [RusTLS] crate as the TLS backend.

This is enabled by default.

## Examples

Create a [client], add a [node], and give events to the client to [process]
events:

```rust,no_run
use futures::StreamExt;
use std::{
    env,
    error::Error,
    net::SocketAddr,
    str::FromStr,
};
use twilight_gateway::{Intents, Shard};
use twilight_http::Client as HttpClient;
use twilight_lavalink::Lavalink;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
    let token = env::var("DISCORD_TOKEN")?;
    let lavalink_host = SocketAddr::from_str(&env::var("LAVALINK_HOST")?)?;
    let lavalink_auth = env::var("LAVALINK_AUTHORIZATION")?;
    let shard_count = 1_u64;

    let http = HttpClient::new(&token);
    let user_id = http.current_user().await?.id;

    let lavalink = Lavalink::new(user_id, shard_count);
    lavalink.add(lavalink_host, lavalink_auth).await?;

    let intents = Intents::GUILD_MESSAGES | Intents::GUILD_VOICE_STATES;
    let (mut shard, mut events) = Shard::new(token, intents);

    shard.start().await?;

    while let Some(event) = events.next().await {
        lavalink.process(&event).await?;
    }

    Ok(())
}
```

## Links

**source**: <https://github.com/twilight-rs/twilight/tree/main/lavalink>

**docs**: <https://docs.rs/twilight-lavalink>

**crates.io**: <https://crates.io/crates/twilight-lavalink>

[RusTLS]: https://crates.io/crates/rustls
[Lavalink]: https://github.com/Frederikam/Lavalink
[client]: https://twilight-rs.github.io/twilight/twilight_lavalink/client/struct.Lavalink.html
[gateway]: ../section_3_gateway.html
[model]: ../section_1_model.html
[node]: https://twilight-rs.github.io/twilight/twilight_lavalink/node/struct.Node.html
[process]: https://twilight-rs.github.io/twilight/twilight_lavalink/client/struct.Lavalink.html#method.process
[`async-tungstenite`]: https://crates.io/crates/async-tungstenite

license: ISC

branch_name: refs/heads/docs

gha_language: Rust

gha_license_id: ISC


text:
# Changelog

## v2.1.2 (2017-11-22)
### Fixed
* Issue with space in getTable function

## v2.1.1 (2017-11-21)
### Fixed
* Constructor parameters

## v2.1.0 (2017-11-13)
### Added
* Constructor parameters

### Changed
* Encode function to make it modular

## v2.0.1 (2017-11-10)
### Fixed
* Warning from the setLang function

## v2.0.0 (2017-04-27)
### Added
* setLang function which will set the language for the object
* getTable function which will load the selected table (Private member)
* table.xml which contains the new tables
* Build with dependencies in the makefile

### Removed
* Old versions of the CT1, CT37, and Code tables that were hard coded were removed

## v1.0.0 (2017-03-29)
### Added
* Encode function to encode the text with the selected table
* Decode function to decode the text with the selected table
* CT1 table used as a table to encode or decode text
* CT37 table used as a table to encode or decode text
* Code table used to shorten or lengthen text being encoded or decoded

repository: ryanrupert/StraddlingCheckerboards

repo_name: ryanrupert/StraddlingCheckerboards


text:
This is a fork of [playsound](https://github.com/TaylorSMarks/playsound) that I will try to maintain. I forked this repo from https://github.com/driedler/playsound, a fork of https://github.com/TaylorSMarks/playsound that fixed a memory leak for Windows.

playsoundv2
=========
*Pure Python, cross platform, single function module with no dependencies for playing sounds.*

Installation
============
Installation:

```
$ pip install playsound
```

The Github Repo with the source code is: https://github.com/kethan1/playsound2

Quick Start
===========
Once you've installed, you can really quickly verified that it works with just this:

```
>>> from playsound2 import playsound
>>> playsound('/path/to/a/sound/file/you/want/to/play.mp3')
```

Documentation
=============
The playsound module contains only one thing - the function (also named) playsound.

It requires one argument - the path to the file with the sound you'd like to play. This may be a local file, or a URL.

There's an optional second argument, block, which is set to True by default. Setting it to False makes the function run asynchronously.

On Windows, uses windll.winmm. WAVE and MP3 have been tested and are known to work. Other file formats may work as well.

On OS X, uses AppKit.NSSound. WAVE and MP3 have been tested and are known to work. In general, anything QuickTime can play, playsound should be able to play, for OS X.

On Linux, uses GStreamer. Known to work on Ubuntu 14.04 and ElementaryOS
Loki. Support for the `block` argument is currently not implemented.

Requirements
============
I have only tested this module on Windows 10 with Python 3.8 and Python 3.9, though it should work with other OSes and versions.

If you are getting this error on Linux:
```
ImportError: No module named 'gi'
```
Then run the below commands:
```
sudo apt install python3-gi
pip3 install vext
pip3 install vext.gi
```

Copyright
=========
Original software is Copyright (c) 2016 Taylor Marks<EMAIL_ADDRESS>Modified software is Copyright (c) 2021 Kethan Vegunta<EMAIL_ADDRESS>

See the bundled LICENSE file for more information.


text:
---
title: When a table game can think for itself, how do you tell it what to do?
date: 2016-10-17 12:00:00 -04:00
tags:
- design
person: Nick Bentley
---

Last week we offered [a peek](http://move38.com/blog/a-board-game-that-thinks/) at the game platform we're developing, called Blinks (for now).

![Fracture_hands_01.jpg](/uploads/Fracture_hands_01.jpg)

To recap:

> the game pieces are little computers. They can think, remember, communicate with players and each other, and you can load new games into them. They’re open source so you can invent your own games for them, and they’re easy to program (Arduino!), so they’re also a tool for kids to learn code.

This past weekend, a game designed by [Celia Pearce](http://www.northeastern.edu/camd/gamedesign/people/celia-pearce/), [Mike Lazer-Walker](http://lazerwalker.com/) (his real name / not his Star Wars name) and company was a finalist at [IndieCade](http://www.indiecade.com/). For 3 days, Jonathan watched hundreds up people play, in the words of Mike, "a futuristic cyber chess".

In keeping with our open philosophy, today I'm discussing a design issue we're facing. We hope you'll read it and offer your opinion. It has to do with this bit:

> you can load new games into them

The question is: how?

Right now, you load games into the tiles one-by-one, by removing their covers and getting into the hardware, like this:

![IMG_0992.JPG](/uploads/IMG_0992.JPG)

...which is fine for tinkerers and programmers but not for people who just want to play games. We've learned 6-12 year olds are crazy in love with the tiles, so switching games must be easy even for them.

We need a loading method with the following characteristics:

1. downloading a game should happen at the press of a button

2. the user shouldn't have to load tiles one-by-one.

3. downloading shouldn't require taking the tiles apart

We have two options which meet these criteria, but we haven't decided which to implement:

## option #1 - download from phone via Bluetooth

One of the tiles will communicate with your phone by Bluetooth, and there'll be an app that comes with the tiles. When you want to play a new game, you open the app and select the game you want to play. The phone zaps the instructions to the tile with Bluetooth, and when that tile is attached to all the other tiles, it sends instructions to them via their normal communication (infrared)

## option #2  - games on tiles

Each tile will come with a game preprogrammed on it. When you want to play a new game, you attach the tile with the game you want to all the other tiles and hold and press its top. It then sends instructions to all the other tiles.

Here are the strengths and weaknesses of these options as we now understand them:

![Screen Shot 2016-10-17 at 8.56.44 AM.png](/uploads/Screen%20Shot%202016-10-17%20at%208.56.44%20AM.png)

But we're not sure we fully understand the parameters of the problem yet. If you have a preference for one of these options, or know of strengths or weaknesses we've missed, let us know in the comments. That's our entire reason for posting this.

If you or someone you know is one, likes where we're headed, and gets the process of building open source hardware (i.e. Arduino), contact<EMAIL_ADDRESS>
If you'd like to follow our work (and be alerted when our games launch), sign up here:

<link href="//cdn-images.mailchimp.com/embedcode/classic-10_7.css" rel="stylesheet" type="text/css">

<form action="//automatiles.us14.list-manage.com/subscribe/post?u=7857fa104de3ffc5bbe78d94c&id=c82a234f7c" method="post" id="mc-embedded-subscribe-form" name="mc-embedded-subscribe-form" class="validate" target="_blank" novalidate>

Email Address
<input type="email" value="" name="EMAIL" class="required email" id="mce-EMAIL">

<input type="text" name="b_7857fa104de3ffc5bbe78d94c_c82a234f7c" tabindex="-1" value="">

<input type="submit" value="Subscribe" name="subscribe" id="mc-embedded-subscribe" class="button">

</form>


text:
## nsa-plymouth

A cool NSA-style plymouth bootsplash for Ubuntu.

## Installation Instructions

The theme can be easily installed by running the **install.sh** file.
Alternatively it can be done manually too by using the following commands.

#### Manual installation

* make a directory in plymouth directory as stated below where the theme will be stored
`mkdir /lib/plymouth/themes/my-theme`

* copy the directory holding the theme files to the new place
`cp --recursive /path/to/my-theme /lib/plymouth/themes/my-theme`

* set it as default boot splash theme
`sudo ln -sf /lib/plymouth/themes/my-theme/my-theme.plymouth /etc/alternatives/default.plymouth`

In order to get back to the system default theme:
`sudo update-alternatives --config default.plymouth` and select the default theme you want, then `sudo update-initramfs -u`

## Previewing the theme

Simply run the **preview.sh** file. It will install **plymouth-x11** if required. Then follow the instructions.

#### Current Preview
![](http://imgur.com/pyqrmvO.png)

#### Animated Preview
[animated preview nsa-plymouth](http://gph.is/1IzkUZI)

## LICENSE
Copyright (c) 2016 SHOBHIT
Permission is hereby granted, free of charge, to any person obtaining copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


text:
# Interpreting Machines

While a state machine/statechart with a pure `.transition()` function is useful for flexibility, purity, and testability, in order for it to have any use in a real-life application, something needs to:

- Keep track of the current state, and persist it
- Execute side-effects
- Handle delayed transitions and events
- Communicate with external services

The **interpreter** is responsible for _interpreting_ the state machine/statechart and doing all of the above - that is, parsing and executing it in a runtime environment. An interpreted, running instance of a statechart is called a **service**.

## Interpreter <Badge text="4.0+" />

An optional interpreter is provided that you can use to run your statecharts. The interpreter handles:

- State transitions
- Executing actions (side-effects)
- Delayed events with cancellation
- Activities (ongoing actions)
- Invoking/spawning child statechart services
- Support for multiple listeners for state transitions, context changes, events, etc.
- And more!

```js
import { createMachine, interpret } from 'xstate';

const machine = createMachine(/* machine config */);

// Interpret the machine, and add a listener for whenever a transition occurs.
const service = interpret(machine).onTransition((state) => {
  console.log(state.value);
});

// Start the service
service.start();

// Send events
service.send({ type: 'SOME_EVENT' });

// Stop the service when you are no longer using it.
service.stop();
```

## Sending Events

Events are sent to a running service by calling `service.send(event)`. There are 3 ways an event can be sent:

```js {5,8,12}
service.start();

// As an object (preferred):
service.send({ type: 'CLICK', x: 40, y: 21 });

// As a string:
// (same as service.send({ type: 'CLICK' }))
service.send('CLICK');

// As a string with an object payload:
// (same as service.send({ type: 'CLICK', x: 40, y: 21 }))
service.send('CLICK', { x: 40, y: 21 });
```

- As an event object (e.g., `.send({ type: 'CLICK', x: 40, y: 21 })`)
  - The event object must have a `type: ...` string property.
- As a string (e.g., `.send('CLICK')`, which resolves to sending `{ type: 'CLICK' }`)
  - The string represents the event type.
- As a string followed by an object payload (e.g., `.send('CLICK', { x: 40, y: 21 })`) <Badge text="4.5+"/>
  - The first string argument represents the event type.
  - The second argument must be an object without a `type: ...` property.

::: warning
If the service is not initialized (that is, if `service.start()` wasn't called yet), events will be **deferred** until the service is started. This means that the events won't be processed until `service.start()` is called, and then they will all be sequentially processed.

This behavior can be changed by setting `{ deferEvents: false }` in the [service options](#options). When `deferEvents` is `false`, sending an event to an uninitialized service will throw an error.
:::

## Batched Events

Multiple events can be sent as a group, or "batch", to a running service by calling `service.send(events)` with an array of events:

```js
service.send([
  // String events
  'CLICK',
  'CLICK',
  'ANOTHER_EVENT',
  // Event objects
  { type: 'CLICK', x: 40, y: 21 },
  { type: 'KEYDOWN', key: 'Escape' }
]);
```

This will immediately schedule all batched events to be processed sequentially. Since each event causes a state transition that might have actions to execute, actions in intermediate states are deferred until all events are processed, and then they are executed with the state they were created in (not the end state).

This means that the end state (after all events are processed) will have an `.actions` array of _all_ of the accumulated actions from the intermediate states. Each of these actions will be bound to their respective intermediate states.

::: warning

Only one state -- the **end state** (i.e., the resulting state after all events are processed) -- will be sent to the `.onTransition(...)` listener(s). This makes batched events an optimized approach for performance.

:::

::: tip

Batched events are useful for [event sourcing](https://martinfowler.com/eaaDev/EventSourcing.html) approaches. A log of events can be stored and later replayed by sending the batched events to a service to arrive at the same state.

:::

## Transitions

Listeners for state transitions are registered via the `.onTransition(...)` method, which takes a state listener. State listeners are called every time a state transition (including the initial state) happens, with the current [`state` instance](./states.md):

```js
// Interpret the machine
const service = interpret(machine);

// Add a state listener, which is called whenever a state transition occurs.
service.onTransition((state) => {
  console.log(state.value);
});

service.start();
```

::: tip

If you only want the `.onTransition(...)` handler(s) to be called when the state changes (that is, when the `state.value` changes, the `state.context` changes, or there are new `state.actions`), use [`state.changed`](https://xstate.js.org/docs/guides/states.html#state-changed):

```js {2}
service.onTransition((state) => {
  if (state.changed) {
    console.log(state.value);
  }
});
```

:::

## Starting and Stopping

The service can be initialized (i.e., started) and stopped with `.start()` and `.stop()`. Calling `.start()` will immediately transition the service to its initial state. Calling `.stop()` will remove all listeners from the service, and do any listener cleanup, if applicable.

```js
const service = interpret(machine);

// Start the machine
service.start();

// Stop the machine
service.stop();

// Restart the machine
service.start();
```

Services can be started from a specific [state](./states.md) by passing the `state` into `service.start(state)`. This is useful when rehydrating the service from a previously saved state.

```js
// Starts the service from the specified state,
// instead of from the machine's initial state.
service.start(previousState);
```

## Executing Actions

[Actions (side-effects)](./actions.md) are, by default, executed immediately when the state transitions. This is configurable by setting the `{ execute: false }` option (see example). Each action object specified on the `state` might have an `.exec` property, which is called with the state's `context` and `event` object.

Actions can be executed manually by calling `service.execute(state)`. This is useful when you want to control when actions are executed:

```js
const service = interpret(machine, {
  execute: false // do not execute actions on state transitions
});

service.onTransition((state) => {
  // execute actions on next animation frame
  // instead of immediately
  requestAnimationFrame(() => service.execute(state));
});

service.start();
```

## Options

The following options can be passed into the interpreter as the 2nd argument (`interpret(machine, options)`):

- `execute` (boolean) - Signifies whether state actions should be executed upon transition. Defaults to `true`.
  - See [Executing Actions](#executing-actions) for customizing this behavior.
- `deferEvents` (boolean) <Badge text="4.4+"/> - Signifies whether events sent to an uninitialized service (i.e., prior to calling `service.start()`) should be deferred until the service is initialized. Defaults to `true`.
  - If `false`, events sent to an uninitialized service will throw an error.
- `devTools` (boolean) - Signifies whether events should be sent to the [Redux DevTools extension](https://github.com/zalmoxisus/redux-devtools-extension). Defaults to `false`.
- `logger` - Specifies the logger to be used for `log(...)` actions. Defaults to the native `console.log` method.
- `clock` - Specifies the [clock interface for delayed actions](./delays.md#interpretation). Defaults to the native `setTimeout` and `clearTimeout` functions.

## Custom Interpreters

You may use any interpreter (or create your own) to run your state machine/statechart. Here's an example minimal implementation that demonstrates how flexible interpretation can be (despite the amount of boilerplate):

```js
const machine = createMachine(/* machine config */);

// Keep track of the current state, and start
// with the initial state
let currentState = machine.initialState;

// Keep track of the listeners
const listeners = new Set();

// Have a way of sending/dispatching events
function send(event) {
  // Remember: machine.transition() is a pure function
  currentState = machine.transition(currentState, event);

  // Get the side-effect actions to execute
  const { actions } = currentState;

  actions.forEach((action) => {
    // If the action is executable, execute it
    typeof action.exec === 'function' && action.exec();
  });

  // Notify the listeners
  listeners.forEach((listener) => listener(currentState));
}

function listen(listener) {
  listeners.add(listener);
}

function unlisten(listener) {
  listeners.delete(listener);
}

// Now you can listen and send events to update state
listen((state) => {
  console.log(state.value);
});

send('SOME_EVENT');
```

## Notes

- The `interpret` function is exported directly from `xstate` since 4.3+ (i.e., `import { interpret } from 'xstate'`). For prior versions, it is imported from `'xstate/lib/interpreter'`.
- Most interpreter methods can be chained:

```js
const service = interpret(machine)
  .onTransition((state) => console.log(state))
  .onDone(() => console.log('done'))
  .start(); // returns started service
```

- Do not call `service.send(...)` directly from actions. This impedes testing, visualization, and analysis. Instead, [use `invoke`](./communication.md).

repository: michaelfriedman/xstate

repo_name: michaelfriedman/xstate


text:
# Third-party dependencies

Slate builds upon the following third-party software packages.

## Generic

* [Node.js](https://nodejs.org/)
* [TypeScript](https://www.typescriptlang.org/)
* [fullstack-typescript](https://github.com/gilamran/fullstack-typescript) template
* [markdown-escape](https://github.com/kemitchell/markdown-escape.js)

## Frontend

* [React](https://reactjs.org/)
* [react-split-pane](https://github.com/tomkp/react-split-pane)
* [react-alert](https://github.com/schiehll/react-alert)
* [react-loading-animation](https://github.com/nathanhoad/react-loading-animation)
* [react-portal-tooltip](https://github.com/romainberger/react-portal-tooltip)
* [react-responsive-modal](https://github.com/pradel/react-responsive-modal)
* [remarkable-react](https://github.com/HHogg/remarkable-react)
* [react-simplemde-editor](https://github.com/RIP21/react-simplemde-editor)
* [clsx](https://github.com/lukeed/clsx)
* [unicodeit](https://github.com/svenkreiss/unicodeit)
* Fonts from [MathJax](https://www.mathjax.org/) and [GUST](http://www.gust.org.pl/projects/e-foundry/latin-modern)

## Backend

* [Express](https://expressjs.com/)
* [http-proxy-middleware](https://github.com/chimurai/http-proxy-middleware)
* [node-fetch](https://github.com/node-fetch/node-fetch)
* [Nodemailer](https://nodemailer.com/)

## Other

For the full list, see [package.json](https://github.com/SReichelt/slate/blob/master/package.json).

Slate itself is licensed under the [MIT license](https://github.com/SReichelt/slate/blob/master/LICENSE). To review the licensing terms of third-party components, please consult their respective documentation.

repository: SReichelt/slate

gha_language: TypeScript

repo_name: SReichelt/slate


text:
### [CVE-2015-0316](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2015-0316)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

Adobe Flash Player before <IP_ADDRESS>9 and 14.x through 16.x before <IP_ADDRESS>5 on Windows and OS X and before <IP_ADDRESS>2 on Linux allows attackers to execute arbitrary code or cause a denial of service (memory corruption) via unspecified vectors, a different vulnerability than CVE-2015-0314, CVE-2015-0318, CVE-2015-0321, CVE-2015-0329, and CVE-2015-0330.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/ARPSyndicate/cvemon
- https://github.com/CAF-Extended/external_honggfuzz
- https://github.com/Corvus-AOSP/android_external_honggfuzz
- https://github.com/DennissimOS/platform_external_honggfuzz
- https://github.com/ForkLineageOS/external_honggfuzz
- https://github.com/HavocR/external_honggfuzz
- https://github.com/Ozone-OS/external_honggfuzz
- https://github.com/ProtonAOSP-platina/android_external_honggfuzz
- https://github.com/ProtonAOSP/android_external_honggfuzz
- https://github.com/StatiXOS/android_external_honggfuzz
- https://github.com/TheXPerienceProject/android_external_honggfuzz
- https://github.com/TinkerBoard-Android/external-honggfuzz
- https://github.com/TinkerBoard-Android/rockchip-android-external-honggfuzz
- https://github.com/TinkerBoard2-Android/external-honggfuzz
- https://github.com/TinkerEdgeR-Android/external_honggfuzz
- https://github.com/Tomoms/android_external_honggfuzz
- https://github.com/aosp-caf-upstream/platform_external_honggfuzz
- https://github.com/bananadroid/android_external_honggfuzz
- https://github.com/crdroid-r/external_honggfuzz
- https://github.com/crdroidandroid/android_external_honggfuzz
- https://github.com/ep-infosec/50_google_honggfuzz
- https://github.com/google/honggfuzz
- https://github.com/imbaya2466/honggfuzz_READ
- https://github.com/jingpad-bsp/android_external_honggfuzz
- https://github.com/khadas/android_external_honggfuzz
- https://github.com/lllnx/lllnx
- https://github.com/r3p3r/nixawk-honggfuzz
- https://github.com/random-aosp-stuff/android_external_honggfuzz
- https://github.com/yaap/external_honggfuzz

repository: trickest/cve

repo_name: trickest/cve


text:
# HTML Sieve
---

An implementation of the Sieve of Eratosthenes in JavaScript and visually displayed( With color! )
in HTML.

I have not attached a license and anyone viewing this repo can do whatever they want with the code.

![Excelsior](http://goo.gl/74J7Qc)


text:
# StrongStationaryTimes

## Introduction

We consider a certain random walk on the Heisenberg group, with coefficients valued in $\mathbb{Z}/ M \mathbb{Z}$. In the jupyter notebook
```bash
$ ./iynb/RandomWalk.ipynb
```
we showcase the sampling of trajectories, and analyze the convergence speed to equilibrium.

This repository is an implementation of strong stationary times, following the paper [Strong stationary times for finite Heisenberg walks](https://hal.archives-ouvertes.fr/hal-03016958) by [Laurent Miclo](https://perso.math.univ-toulouse.fr/miclo/). It is structured as follows.
```bash
--- ./iynb/:                    Contains jupyter notebooks for demo
 |- ./strong_stationary_times/: Core of the repository
 |- ./tests/:                   Unit tests for the core

```

In particular, ```./iynb/StrongTimes.ipynb``` samples iid realizations of two stopping times $T_M$ and $S_M$ suggested in the aforementioned paper. The question is whether these strong times are optimal or not, i.e how do they scale with $M$. Plots give:

![How T scales](./ipynb/T_log_mean_vs_M.png "How T scales")
![How S scales](./ipynb/S_log_mean_vs_M.png "How S scales")

The file ```./iynb/Multiprocessed_StrongTimes.ipynb``` showcases the same thing, using Python's multiprocessing for parallel excecution on multiple cores. (Warning: This needs Python>=3.8)

## Installation for Linux

1. Create new virtual environment

```bash
$ python3 -m venv .virtualenv
```

(Do
sudo apt install python3-venv
if needed)

3. Activate virtual environment

```bash
$ source .virtualenv/bin/activate
```

4. Upgrade pip, wheel and setuptools

```bash
$ pip install --upgrade pip
$ pip install --upgrade setuptools
$ pip install wheel
```

5. Install the `strong_stationary_times` package.

```bash
python setup.py develop
```

6. (Optional) In order to use Jupyter with this virtual environment .virtualenv (see this [blog](https://janakiev.com/blog/jupyter-virtual-envs/) for details)
```bash
pip install ipykernel
python -m ipykernel install --user --name=.virtualenv
```

## Configuration
Nothing to do

repository: redachhaibi/StrongStationaryTimes

repo_name: redachhaibi/StrongStationaryTimes


text:
# Swift-Http-Networking

[![CI Status](http://img.shields.io/travis/Igor Prysyazhnyuk/Swift-Http-Networking.svg?style=flat)](https://travis-ci.org/Igor Prysyazhnyuk/Swift-Http-Networking)
[![Version](https://img.shields.io/cocoapods/v/Swift-Http-Networking.svg?style=flat)](http://cocoapods.org/pods/Swift-Http-Networking)
[![License](https://img.shields.io/cocoapods/l/Swift-Http-Networking.svg?style=flat)](http://cocoapods.org/pods/Swift-Http-Networking)
[![Platform](https://img.shields.io/cocoapods/p/Swift-Http-Networking.svg?style=flat)](http://cocoapods.org/pods/Swift-Http-Networking)

## Example

To run the example project, clone the repo, and run `pod install` from the Example directory first.

## Requirements

## Installation

Swift-Http-Networking is available through [CocoaPods](http://cocoapods.org). To install
it, simply add the following line to your Podfile:

```ruby
pod "Swift-Http-Networking"
```

## Author

Igor Prysyazhnyuk<EMAIL_ADDRESS>
## License

Swift-Http-Networking is available under the MIT license. See the LICENSE file for more info.

repository: iPrysyazhnyuk/Swift-Http-Networking

repo_name: iPrysyazhnyuk/Swift-Http-Networking


text:
# Strip Payment Workflow

The typical Vanilo Payments workflow with Stripe consists of the
following steps:

1. Create an **Order** (or any ["Payable"](https://vanilo.io/docs/2.x/payments#payables))
2. Obtain the **payment method** from the checkout<sup>*</sup>
3. Get the appropriate **gateway instance** associated with the payment method
4. Generate a **payment request** using the gateway
5. Inject the **HTML snippet** on the checkout/thankyou page
6. The HTML snippet ...
7. The return url (?)
8. ...

## Obtain Gateway Instance

Once you have an order (or any other payable), then the starting point
of payment operations is obtaining a gateway instance:

```php
$gateway = \Vanilo\Payment\PaymentGateways::make('stripe');
// Vanilo\Stripe\StripePaymentGateway
```

The gateway provides you two essential methods:

- `createPaymentRequest` - Assembles the payment initiation request from
  an order (payable) that can be injected on your checkout page.
- `processPaymentResponse` - Processes the HTTP response returning from
  Stripe after a payment attempt.

## Starting Online Payments

**Controller:**

```php
use Vanilo\Framework\Models\Order;
use Vanilo\Payment\Factories\PaymentFactory;
use Vanilo\Payment\Models\PaymentMethod;
use Vanilo\Payment\PaymentGateways;

class OrderController
{
    public function submit(Request $request)
    {
        $order = Order::createFrom($request);
        $paymentMethod = PaymentMethod::find($request->get('paymentMethod'));
        $payment = PaymentFactory::createFromPayable($order, $paymentMethod);
        $gateway = PaymentGateways::make('stripe');
        $paymentRequest = $gateway->createPaymentRequest($payment);

        return view('order.confirmation', [
            'order' => $order,
            'paymentRequest' => $paymentRequest
        ]);
    }
}
```

**Blade Template:**

```blade
{!! $paymentRequest->getHtmlSnippet(); !!}
```

The generated HTML snippet will contain a prepared, HTML Form ...

You can pass an array to the `getHtmlSnippet()` method that recognizes
the following keys:

```blade
{!! $paymentRequest->getHtmlSnippet(); !!}
```

### Payment Request Options

The gateway's `createPaymentRequest` method accepts additional
parameters that can be used to customize the generated request.

The signature of the method is the following:

```php
public function createPaymentRequest(
    Payment $payment,
    Address $shippingAddress = null,
    array $options = []
    ): PaymentRequest
```

1. The first parameter is the `$payment`. Every attempt to settle a
   payable is a new `Payment` record.
2. The second one is the `$shippingAddress` in case it differs from
   billing address. It can be left NULL.
3. The third parameters is an array with possible `$options`.

You can pass the following values in the `$options` array:

| Array Key | Example                | Description                                                                                |
|:----------|:-----------------------|:------------------------------------------------------------------------------------------------------------------------------------------------|
| `xxx`     | xxx                    |                                                                                |
| `yyy`     | yyy                    |                                                                                |
| `view`    | `payment.stripe._form` | By default it's `stripe::_request` You can use a custom blade view to render the HTML snippet instead of the default one this library provides. |

**Example**:

```php
$options = [
    'xxx'  => 'xxx',
    'yyy'  => 'yyy',
    'view' => 'payment.stripe._form',
];
$gateway->createPaymentRequest($payment, null, $options);
```

#### Customizing The Generated HTML

Apart from passing the `view` option to the `createPaymentRequest` (see
above), there's an even more simple way: Laravel lets you
[override the views from vendor packages](https://laravel.com/docs/8.x/packages#overriding-package-views)
like this.

Simply put, if you create the
`resources/views/vendor/stripe/_request.blade.php` file in your
application, then this blade view will be used instead of the one
supplied by the package.

To get the default view from the package and start customizing it, use
this command:

```bash
php artisan vendor:publish --tag=vanilo-stripe
```

This will copy the default blade view used to render the HTML form into
the `resources/views/vendor/stripe/` folder of your application. After
that, the `getHtmlSnippet()` method will use the copied blade template
to render the HTML snippet for Stripe payment requests.

## Confirm And Return URLs

...

### The Return URL

...

### The Cancel URL

...

---

**Next**: [Examples »](examples.md)


text:
# Week2Wed

#### This repo contains several "Applications" that were built in order to practice using Jquery, Javascript, HTML and CSS. Specifically for loops and branching. Built during my 2nd week at Epicodus.

#### By Kyle Derrick

## Setup/Installation Requirements

* Clone this repository
* Open in a standard web browser

## Known Bugs

No known bugs.

## Support and contact details

Contact kderrick through github.

## Technologies Used

This project was built using HTML, CSS, Bootstrap, Jquery and Javascript

### License
MIT License.

Copyright (c) 2016  **Kyle Derrick**


text:
---
title: Vue.js
homepage: https://vuejs.org/
description: The Progressive JavaScript Framework
twitter: vuejs
github: https://github.com/vuejs/vue
cosmicapplink: https://www.cosmicjs.com/apps/simple-vue-blog
icon: https://cdn.cosmicjs.com/858dda70-6288-11e7-ab3d-9ddd8313526f-96da6390-e18a-11e6-a19e-716cc90a0c51-Vue.js_Logo.svg
---

## Approachable
Already know HTML, CSS and JavaScript? Read the guide and start building things in no time!

## Versatile
An incrementally adoptable ecosystem that scales between a library and a full-featured framework.

## Performant
20KB min+gzip Runtime
Blazing Fast Virtual DOM
Minimal Optimization Efforts

repository: cosmicjs/javascriptframework

repo_name: cosmicjs/javascriptframework