text:
---
layout: default
---

# 1994-12-14 - Re: Using HotWIRED without provoking junk mail

## Header Data

From<EMAIL_ADDRESS>(Eric Hughes)

To<EMAIL_ADDRESS>Message Hash: 93dfd575f684009c5f8bd6bf3f80e31ba2360fca7c0f1ddaa1d41c451f960ae7

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1994-12-14 15:08:56 UTC

Raw Date: Wed, 14 Dec 94 07:08:56 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Eric Hughes)
Date: Wed, 14 Dec 94 07:08:56 PST
To<EMAIL_ADDRESS>Subject: Re: Using HotWIRED without provoking junk mail
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

   From: Avi Harris Baumstein<EMAIL_ADDRESS>
   -at least this wired staffer was somewhat amused with the prospect
   (rather than annoyed, as i had expected).

I ran into one of the Hotwired guys at a couple of weeks ago.  Not
only didn't he mind particularly, he thought it most appropriate that
the general purpose pseudonym account was called 'cypherpunk'.

   -the account is well used.

In fact, the 'cypherpunk' is by far and away the No. 1 user of
Hotwired.  Maybe 'cypherpunks' will become number No. 2.

Eric

{% endraw %}
```

## Thread

+ Return to [December 1994](/archive/1994/12)

+ Return to "[Avi Harris Baumstein <avi@clas.ufl.edu>](/authors/avi_harris_baumstein_avi_at_clas_ufl_edu_)"
+ Return to<EMAIL_ADDRESS>(Eric Hughes)](/authors/eric_at_remailer_net_eric_hughes_)"
+ Return to "["L. McCarthy" <lmccarth@ducie.cs.umass.edu>](/authors/l_mccarthy_lmccarth_at_ducie_cs_umass_edu_)"

+ 1994-12-14 (Tue, 13 Dec 94 20:51:19 PST) - [Re: Using HotWIRED without provoking junk mail](/archive/1994/12/479332ddc32e22f0a6090a82010bdccebe145d6260743b62fbb66dcb865fd8c4) - _"L. McCarthy"<EMAIL_ADDRESS>  + 1994-12-14 (Wed, 14 Dec 94 05:58:40 PST) - [Re: Using HotWIRED without provoking junk mail](/archive/1994/12/ebfdc6d68b54daa3d4bef94db308ce078ea7a21665618cc703bdfece91f5f035) - _Avi Harris Baumstein<EMAIL_ADDRESS>    + 1994-12-14 (Wed, 14 Dec 94 07:08:56 PST) - Re: Using HotWIRED without provoking junk mail -<EMAIL_ADDRESS>(Eric Hughes)_


text:
---
title: "Transactions"
weight: 40
description: >
  Major differences between Ethereum and Solana transactions
---

Ethereum supports a few different types of transactions which can be created using a common set of parameters. These
include ETH transfers, smart contract calls, and new contract deploys. On Solana, all transactions are treated the
same and so all call on-chain programs (Solana has special programs for deploying contracts and transferring SOL).

Let's dig into the differences by looking at the structure of a transaction from each chain...

### Ethereum Transaction Structure

| Field      | Description                                                    |
|------------|----------------------------------------------------------------|
| `nonce`    | Number equal to the count of sender's processed transactions.  |
| `gasPrice` | The amount of Wei to be paid per unit of gas.                  |
| `gasLimit` | Max gas that can be consumed while processing the transaction. |
| `to`       | The recipient of ether and smart contract to be called.        |
| `value`    | The amount of ether to transfer to the `to` address.           |
| `v, r, s`  | Represents the `signature` and used to recover the `sender`    |

### Solana Transaction Structure

| Field             | Description                                                 |
|-------------------|-------------------------------------------------------------|
| `signatures`      | List of signatures.                                         |
| `accounts`        | List of accounts (read-only / read-write)                   |
| `recentBlockhash` | Blockhash of recently produced block used as nonce.         |
| `instructions`    | List of instructions which each call an on-chain program.   |

Despite their structural differences, these transactions have a very similar goal: calling a smart contract. Let's
walk through the fields to understand each approach.

### Mapping Ethereum transaction fields to Solana

#### `sender`

On Ethereum, the `sender` is the address of the keypair which signed this transaction. Inside a smart contract, we
know the `msg.sender` is an address that approved of the smart contract call because we trust Ethereum nodes to first
verify the transaction signature. Note: in Ethereum, the `sender` is actually recovered from the signature itself.

Also, the `sender` of a transaction is the account which will pay gas fees for the smart contract. By signing a
transaction, the `sender` authorizes payment of gas fees.

On Solana, the first `account` in the transaction `accounts` list is roughly the same thing as the `sender` in an
Ethereum transaction. It is the account that will be used to pay transaction fees and Solana will verify that the
first `signature` in the transaction `signatures` list was produced by that account.

#### `signature`

On Ethereum, each transaction contains a single signature. This signature is roughly the same as the first signature
in a Solana transaction's list of signatures. So why does Solana allow multiple signatures? Well, imagine you are
using a multisig wallet and need to create a transaction which shows that multiple keypairs have signed and approve
the transaction. On Ethereum, you would need to pass signatures inside transaction data and verify them inside a
smart contract. On Solana, signatures can be appended to the transaction signatures list and, since Solana nodes use
a GPU to verify signatures, will be verified much more efficiently than they would inside a program.

#### `nonce`

On Ethereum, each transaction includes a nonce which is used to prevent a single transaction from being processed
multiple times. Every time Ethereum processes a transaction, it requires that the transaction nonce value is equal to
the sender's total transaction count. So if you have sent 10 transactions, your next transaction will have a nonce
equal to 10 and after Ethereum checks the nonce and processes the transaction, it will increment the your transaction
count to 11 and wait for a transaction with that nonce.

Solana solves this problem in another way. Relatively old transactions cannot be processed again because each
transaction must specify a "recent" blockhash to be processed. Re-processing recent transactions is avoided by
requiring each node to keep a record of all the transactions for recent blocks. So transactions with an old
`recentBlockhash` are easily ignored and other transactions are ignored if they are already included in the recently
processed transaction list.

#### `to`

Ethereum transactions use `to` to specify an address to send ETH to or a smart contract to call.

Solana transactions can actually list multiple smart contracts to call and so they don't have a single `to` field.
Instead, they may list one or more "instructions" which each represent a smart contract call. Each instruction
specifies its own smart contract address and the input parameters for the call.

#### `value`

Ethereum transactions are always explicit about how much ether may be sent from a user's account when making a
transfer or invoking a smart contract. This amount is specified in the `value` field of a transaction and does not
include the gas cost of the transaction.

Solana transactions don't have an equivalent property which specifies how much SOL can be transferred. Instead, each
on-chain program has authority to withdraw lamports from any account it owns. By default, each account is owned by
the system program which requires an account to sign the transaction to perform a withdraw. Other programs may define
their own rules and typically support a withdraw or close account instruction which requires the account to sign.

#### `gasPrice` and `gasLimit`

Every operation in the EVM has an associated gas cost which must be paid by the transaction sender. Since transaction
throughput is limited by the amount of gas allowed in each block, gas price provides a way for transaction senders to
bid a higher price in order to be included in a block more quickly. Any transaction with a gas price that's too low
will get ignored by miners because they want to maximize their earnings in each block they mine. Gas limit is
specified to prevent a buggy smart contract from using way more gas than you intended and causing lost funds.

The Solana VM doesn't have the dynamic gas model for transactions. Instead, it has a fixed maximum compute cost which
currently cannot be adjusted. This means that each transaction roughly has the fixed cost and it naturally puts
pressure on developers to optimize on-chain code to fit within the system limits. Transactions do have fees on
Solana, though. Currently transaction fee calculation is very simple, each signature in a transaction costs an
additional 5000 lamports (there are 10^9 lamports in one SOL).

#### `data`

Ethereum transactions include a single `data` field for an unlimited size byte array. This data is passed directly to
a smart contract which if written with Solidity, will be decoded into a function and its parameters.

Solana transactions may include many "sub-transactions" called instructions. Each instruction has a `data` field
which is used in the same way as an Ethereum transaction's `data` field. However, note that an Solana instruction's
data is limited in size. The entire encoded size of a Solana transaction cannot exceed 1232 bytes. This constraint
allows Solana to optimize its networking layer for quickly passing transactions between nodes (smaller packets = less
delay).

### Understanding Solana transactions

#### `signatures`

Each Solana transaction allows for one or more signatures so that they can be efficiently verified by Solana
validator GPU's. This means multiple accounts can easily authorize operations in on-chain programs in the same
transaction. This contracts with Ethereum where any additional signatures beyond the sender must be verified inside a
smart contract.

#### `recentBlockhash`

Solana transactions must include the blockhash of a recently produced block. Blockhashes are considered recent if
they were produced in about the past 60 seconds. This field is used a nonce to ensure that no transaction can be
processed more than once by the blockchain.

#### `accounts`

Solana transactions must explicitly list each account that on-chain programs may read or write to. By specifying all
of the accounts up front, Solana validators can process transactions in parallel without fear of two transactions
modifying the same account. It is important that high-throughput applications split up state into multiple accounts
because if each transaction modifies the same account, transactions will have to be processed serially.

Accounts may be annotated as read-write or read-only accounts. If an on-chain program modifies a read-only account,
the transaction will be reverted. The first account will always be read-write since it is used to cover transaction
fees.

Solana's account access list is similar to the optional access list in
[EIP-2930](https://eips.ethereum.org/EIPS/eip-2930).

#### `instructions`

Solana transactions can be thought of as a bundle of Ethereum transactions. Each Solana transaction can include one
or more instructions which each specify an on-chain program address and inputs. There is no explicit limit on the
size of an instruction but note that the total serialized size of a transaction cannot exceed 1232 bytes. The compute
limit is fixed per instruction so each on-chain program should be optimized to use a small amount of compute units or
be split across multiple instructions for expensive operations.

Each instruction specifies the address of the on-chain program, a list of account inputs, and a byte array. Since
Solana on-chain programs don't have their own mutable storage, they must read and store data in separate accounts
which are loaded for the on-chain program when invoked.

repository: abacus-x/solana-wiki

branch_name: refs/heads/main

extension: md

license_type: permissive

repo_name: abacus-x/solana-wiki


text:
# Journal Zero

*[Dustin Ruskell](https://github.com/ventronik "Dustin Ruskell's GitHub")*

Journal Zero is a full stack App that allows users to post papers with different status'.

Journal Zero was created in 1 week.

### Deployed here: http://journal-zero.surge.sh/index.html
### Backend Deployed here: https://obscure-falls-76162.herokuapp.com
#### Frontend GitHub: https://github.com/Ventronik/JournalZeroFE
#### Backend GitHub: https://github.com/Ventronik/JournalZeroBE

## To deploy locally
- Fork and clone this repository
- npm install
- live-server is the recommended deployment method

## Features
- Send and retrieve authenticated data from server using REST API
- Login via jwt and bcrypt

## Technologies
#### Frontend
- JavaScript
- AJAX/axios

#### Backend
- Node.js
- Express.js
- Knex.js
- PostgreSQL
- Authentication via jwt and bcrypt
- Custom RESTful API
- JavaScript

## Screenshots

### Splash Page:
![Splash Page](screenshots/LandingPage.png)

### Published paper date:
![Public Published papers](screenshots/PublishedPaperModal.png)

### Logged In:
![What the user sees](screenshots/UserSigninLandingPage.png)

### Publishing a paper:
![How to change the paper status](screenshots/updatingPaper.png)

license: MIT

repository: Ventronik/JournalZeroFE

branch_name: refs/heads/master

repo_name: Ventronik/JournalZeroFE


text:
# SignPuddle 3 Development Tools

+ [README.md](README.md) - Markdown version
+ [index.html](index.html) - HTML version

These tools are required for SignPuddle 3 development.  Shell scripts and python scripts automate the building of the client and server applications.

> ONLINE: https://signpuddle.com
> DOWNLOAD: https://github.com/Slevinski/apitxt/archive/master.zip
> REPO: https://github.com/slevinski/apitxt
>
> AUTHOR: https://SteveSlevinski.me
> SUPPORT: https://www.patreon.com/signwriting

## Background

A [general introduction](https://slevinski.github.io/SuttonSignWriting/guide.html) to the foundational technologies of SignWriting is available in the Sutton SignWriting Project: [online](https://slevinski.github.io/SuttonSignWriting), [download](https://github.com/Slevinski/SuttonSignWriting/archive/master.zip), and [repo](https://github.com/Slevinski/SuttonSignWriting/).

SignPuddle 3 is a two-part project: the client for the average user and the server for the developer and power user.

Automated scripts build both the client and the server of SignPuddle 3.

The ApiTxt Format is a custom text markup used to define a RESTful API.

## Status
SignPuddle 3 is currently in alpha release.  It is under active development with rudimentary structures, basic outlines, and various functionality.  Some of the details will change.  This project is currently recommended for developers and power users.

The SignPuddle 3 Development Project is divided into five sections.  The **tools** use the **source** to create the **client** and **server**.  The **system** is required if the Apache web server isn't available.

```
  tools
    | - Python scripts and shell scripts
  source
    | - ApiTxt Format
  client
    | - HTML, CSS, and JavaScript
  server
    | - PHP PHP Server or Apache
  system
    | - Portable web server for Windows, Linux, and Mac
```

The [client](../client) is available for preview, with some structure to demo.  The client includes [developer documentation](../client/doc) and [basic tools](../client/api) for accessing the server API.

The [server](../server) is available for use, with [some functionality](../client/doc).  Standard GET requests can be typed in any browser URL, such as [http://signpuddle.com/server/fsw/svg/S10000](http://signpuddle.com/server/fsw/svg/S10000).  The server can be accessed using JavaScript with the HTTP methods of GET, POST, PUT, and DELETE.  Additionally, the client [API pages](../client/api) provide total access and full details of live server requests.

## Group Install
SignPuddle 3 can be installed on a computer or USB drive.  The source code is available using [git](https://git-scm.com/).

```` shell
# INSTALL
cd Desktop

# Either install in a new SignPuddle3 directory
git clone https://github.com/slevinski/apitxt SignPuddle3

# Or install in current directory
git clone https://github.com/slevinski/apitxt .
````

Software updates are also available through git.

```` shell
# UPDATE
cd SignPuddle3
git pull
````

The server requires some configuration before it can be used.

```` shell
# CONFIGURE
cd SignPuddle3/server
unzip Slim.zip
````

If an [Apache web server](https://apache.org/) is not available, you can start the system using the [PHP builtin server](https://secure.php.net/manual/en/features.commandline.webserver.php).  While the client code can function without a webserver, the server code requires a web server to function.

```` shell
# START
cd SignPuddle3/system

# Windows
start_system.bat

# Mac or Linux
./start_system.sh
````

Once started, SignPuddle 3 will be available on the same computer with two default URLs.

+ http://localhost:8888/
+ http://<IP_ADDRESS>:8888/

To access SignPuddle 3 on a different computer or device, use the computer's individual IP Address available from the output of the **start_system** script.

```` shell
./start_system.sh
        inet <IP_ADDRESS> netmask 0xffffff00 broadcast <IP_ADDRESS>
PHP 7.1.16 Development Server started at Wed Sep 19 11:15:04 2018
Listening on http://<IP_ADDRESS>:8888
Document root is /Users/slevinski/Desktop/SignPuddle3
Press Ctrl-C to quit.
````

In this example, SignPuddle 3 will be available with this URL.

+ http://<IP_ADDRESS>:8888

## Group Client

Most users will access SignPuddle 3 with the client section: a combination of HTML, CSS, and JavaScript.  The client section presents information graphically.

The client section can be used online or downloaded as part of the ApiTxt project.  The client section can be opened using the file system and any standard browser.

### Application
* [client](../client)
* [https://SignPuddle.com/client](https://signpuddle.com/client)

### Resources
+ Source: [ApiTxt format](../client/src/index.txt) and [JSON objects](../client/src/index.json)
+ Documents: [API Blueprint](../client/doc/index.md) and [Stand Alone HTML](../client/doc/index.htm)
+ Live Page: [API Interface](../client/api/index.html) and [JavaScript](../client/api/index.js)

## Group Server
The server section is a functional RESTful API written in PHP using the Slim Framework v2.

The server section requires an Apache webserver that can use rewrite rules.  The rules are written in the **server/.htaccess** file.

Alternatively, the server section can use the built-in PHP webserver.  See the [system](../system) directory for more information.

### Application
* [server](../server)
* [https://SignPuddle.com/server](https://signpuddle.com/server)

## Group Source

Document segments are written in the [source](../source) directory using [ApiTxt Format](../client/doc/apitxt.htm): a highly structured plain text markup that fully defines a RESTful API. Each line in an ApiTxt document is a self-contained element which starts with a name and is followed by <TAB> separated fields.

ApiTxt Format uses eleven types of element to define an RESTful API: root, group, route, parameter, method, request, response, header, line, code, and body.

## Group Tools
Python programs and shell scripts are used to read and write a variety of data formats including ApiTxt Format, JSON data, API Blueprint, HTML, JavaScript, and PHP scripts.

* txt2json.py - From ApiTxt Format to an array of JSON objects.
* json2txt.py - From an array of JSON objects back to ApiTxt Format.
* json2md.py - From an array of JSON objects to API Blueprint written in markdown.
* json2php.py - From an array of JSON objects to a functional PHP server using the Slim Framework v2.
* json2html.py - From an array of JSON objects to API Interface.
* json2js.py - From an array of JSON objects to JavaScript.

All of the tools use command line arguments.  Use -h for help.

```` shell
python txt2json.py -h
usage: txt2json.py [-h] [-i INPUT] [-o OUTPUT] [-e]

Conversion of plain text lines to an array of JSON objects

optional arguments:
  -h, --help            show this help message and exit
  -i INPUT, --input INPUT
                        name of input file
  -o OUTPUT, --output OUTPUT
                        write to output file
  -e, --errors          check for errors and report
````

### Make and Build
The **tools/make.sh** file is used to create the build script.

The **tools/build.sh** file is used to create the client and server sections.

```` shell
cd SignPuddle3/tools
./make.sh
./build.sh
````

### Snowboard ([bukalapak/snowboard](https://github.com/bukalapak/snowboard/))
Used in the build script, snowboard can parse API Blueprint documents.  Snowboard offers three different transformations: lint, html, and mock.
Snowboard lint will check the structure of the markdown text and report errors.
Snowboard html will create a stand-alone html document using a template.
Snowboard mock will analyze the responses of the markdown document and serve static responses over HTTP.

## Group System

The [system directory](../system) contains a portable web server for Windows, Linux, and Mac.  The system directory is useful for individual computers or private networks.

For public servers, do not use the system directory, instead use the [Apache web server](http://apache.org) with rewrite rules.

repository: Brenokx/apitxt

repo_name: Brenokx/apitxt


text:
Scons building system userguid
============================

# Scons building system install
- [**Scons installation guide **](https://www.rt-thread.org/document/site/rtthread-development-guide/rtthread-manual-doc/zh/1chapters/10-chapter_scons/)

# announcements
we using arm-none-eabi- toolchain, don't using linux version gcc toolchain. The project use the newlib of the GCC toolchain.

# building
starry_fmu build dirctory in starry_fmu/Project/stm32f40x. Before building, we first change current work dir to stm32f40x.
building step
- cd starry_fmu/Project/stm32f40x
- scons -j4

When finished, you will get starry_fmu.bin and starry_fmu.px4. starry_fmu.px4 is firmware in px4 format.


text:
# Lentinus echinulatus (Murrill) Overh. SPECIES

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
in Seaver & Chardón, Botany of Porto Rico and the Virgin Islands: Mycology 172 (1926)

#### Original name
Crinipellis echinulata Murrill

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# A bitmapped vector trie for Rust

[![Build Status](https://travis-ci.org/pliniker/bitmaptrie-rs.svg?branch=master)](https://travis-ci.org/pliniker/bitmaptrie-rs)
[![Latest Version](https://img.shields.io/crates/v/bitmaptrie.svg)](https://crates.io/crates/bitmaptrie)

## [Documentation](https://crates.fyi/crates/bitmaptrie/)

Requires Rust-nightly due to use of low-level unstable APIs.

This is a non-persistent bitmapped vector trie with word-size indexing: thus
on a 32-bit system the indexing is 32 bits; on 64-bit it is 64 bits.

It essentially behaves as an unbounded (except by the word-size index) sparse
vector.

Performance is good for spatially-close accesses but deteriorates for random
spatially-sparse accesses. Performance improves significantly if compiled
with popcnt and lzcnt instructions.
See [wiki](https://github.com/pliniker/bitmaptrie-rs/wiki/Benchmark-information)
for more.

The last access path is cached to accelerate the next nearby access.

Multi-path-cache methods are available for accelerating read-only accesses
at multiple positions but the current design causes write performance to
degrade.

### Usage

```rust
extern crate bitmaptrie;
use bitmaptrie::Trie;

fn main() {
    let mut trie: Trie<String> = Trie::new();

    trie.set(123usize, "testing 123".to_owned());

    if let Some(value) = trie.get_mut(123) {
        *value = "test pass".to_owned();
    }
}
```

### Author

Peter Liniker

### License

Dual MIT/Apache 2.0

repository: pliniker/bitmaptrie-rs

gha_language: Rust

repo_name: pliniker/bitmaptrie-rs


text:
# Frontrunner

Frontrunner is a daemon which triggers a reconfiguration of [HAProxy](http://haproxy.1wt.eu/),
when an application is modified on [Marathon](https://github.com/mesosphere/marathon).

It uses [node-zookeeper-client](https://github.com/alexguan/node-zookeeper-client)
to connect to the [ZooKeeper](http://zookeeper.apache.org/) cluster
used by [Marathon](https://github.com/mesosphere/marathon) and detect changes.

## Requirements

    * node.js 0.10+

## Installation

    git clone https://github.com/Wizcorp/frontrunner.git

To install dependencies, run the following command in the created directory:

    npm install --production

If you don't plan to use yaml config files, you can use the following:

    npm install --production  --no-optional

## Configuration

Frontrunner use [node-config](https://github.com/lorenwest/node-config) to manage its configuration files.
You can write your configuration files in JavaScript, JSON or YAML.

A default [configuration file](config/default.json) is provided.
It shouldn't be edited.

It contains the following options:
* `zookeeper.connectionString`: Comma separated host:port pairs,
each represents a ZooKeeper server.
* `marathon`: Marathon configuration.
    * `url`: Marathon API url used to get the tasks.
    * `retryDelay`: Delay between two attemps to get the tasks from the Marathon API,
      if the first request fails.
* `activeProxy`: The name of the proxy to use.
* `proxy`: Configuration objects for the supported proxies.
    Each object is as follows:
    * `templatePath`: Path to the proxy config generator.
    * `configFile`: Path to the proxy config file.
    * `reloadCommand`: Command to run to reload the proxy.
    * `reloadDelay`: The minimal time interval between two reload.

To override some values, you have to create a new file with your environment name.

    # config/production.yml

    zookeeper:
      connectionString: "<IP_ADDRESS>:2181,<IP_ADDRESS>:2181,<IP_ADDRESS>:2181"
    marathon:
      url: "http://<IP_ADDRESS>:8080"
    proxy:
      haproxy:
        templatePath: "haproxy_custom.cfg"
        reloadCommand: "service haproxy reload"

## Usage

To run Frontrunner in the production environment and use the config file, you've just created, run the following:

    NODE_ENV=production npm start

repository: Wizcorp/frontrunner

branch_name: refs/heads/develop

gha_language: JavaScript

repo_name: Wizcorp/frontrunner


text:
---
prev: false
next: false
---

# How to connect to a website with your @unikname?

:::warning Prerequisite
:heavy_check_mark: You've already installed My Unikname App on your smartphone.
<hbox>_See [How to install my Unikname App?](./howto-install-my-unikname-app)_</hbox>
:heavy_check_mark: You've got your own UniknameIDentifier.
<hbox>_See [How to get your @unikname?](./howto-get-individual-unikname)_</hbox>
:::

> Here we're going to demonstrate how to sign-up to our forum website. The process is the same on all partner websites that have integrated the Unikname Connect plugin.

## Your first Sign-up with your @unikname

Open a browser and go to [https://forum.unikname.com](https://forum.unikname.com), and click on `sign-up`.

<hpicture caption="Install example on a xaomi Red note8, with Chrome">
<video height="600" controls>
  <source src="./images/signup.mp4" type="video/mp4">
</video>
</hpicture>

## Login with your @unikname

If you already have an account on the website you want to login:

<hpicture noshadow>![ConnectWebsite](./images/forumheader-signuplogin.png)</hpicture>
1. click on the login button
1. enter your UniknameID
1. open `my unikname App` on your smartphone
1. unlock the app with your PIN code or your fingerprint
1. click on validate the connection request
1. You're logged in!

<hpicture noshadow>![enter your unid](./images/enteryourun.png)</hpicture>

## Troubleshooting

:::details After opening my unikname App on my smartphone, I don't see the connection request!?

:collision: **You took too long, comme back to the website and try again to connect.** Connection requests have a short lifetime, roughly one minute. If you open and unlock `my unikname app` after this time then the request won't appears.

:collision: **Check your data connection on your smartphone.** Your smartphone must communicate to authentication servers, without network the request won't appears.

:collision: **Check your @unikname spelling and try again.** If you enter a wrong @unikname then the request won't appears on your smartphone.
:::

:::details I don't receive any notification on my smartphone!
:collision: **Open `my unikname App` and click on the connection request.** Even without notification you can confirm or reject connection requests by opening the App. You can check "notifications" are enabled into your settings.
:::

repository: unik-name/help-unikname

gha_license_id: MIT

repo_name: unik-name/help-unikname


text:
Ansible Role for User configuration and more ..

[![Build Status](https://travis-ci.org/Mohitsharma44/ansible-userconfig.svg?branch=master)](https://travis-ci.org/Mohitsharma44/ansible-userconfig)

Role Name
=========

Role for use with Ubuntu systems. This role will
- Update the system
- Install packages using apt
- Add users and groups
- Modify sudoer's for passwordless access for admins (check below for more info)
- Setup SSH keys and only allow key-based entry (check Role Variables for more info)
- Delete users (w/ or w/o their home directories)

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

The Ubuntu system must have python installed and an active internet connection

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

Following variables can be customized (default values are mentioned below):

``` yaml
users_default_shell: /bin/bash
users_create_homedirs: true

uousers:
  - name: admin
    username: testadmin
    group: 'uo-admin'
    groups: ['root', 'sudo']
    uid: 1001
    shell: '{{users_default_shell}}'
    generate_ssh_key: yes
    key: https://github.com/mohitsharma44.keys
    profile: |
        alias ll='ls -lah'
    comment: "Admin user"

uogroups:
  - name: uo-admin
    groupname: uo-admin
    type: admin
    gid: 10000

delusers:
  - name: user
    username: testuser
    remove: yes
    force: yes

apt_installs: apt_packages.txt
```

``` yaml
# Example of apt_packages.txt
git
python-dev
htop
```

For installing packages using apt, pass the filename to `apt_installs` and make
sure it exists.

For `uousers`, apart from general parameters, you can additionally create a list of
multiple `groups` that the `uouser` needs to be part of. By default, the uouser
is *not an admin user*. This user doesn't have any sudo-privileges

If the uouser has a role of *admin*, the `group` must be `uo-admin`. All the other
groups that the user needs to belong to, can be added in `groups`.

If the `uogroup` is of `type`: `admin` then all the `uousers` belonging to that
group will have passwordless sudo access.

By default, when a `uouser` account is created, the user cannot login to the server
with a password. The `uouser` *MUST* have the keys loaded in github.com and should
be accessible via https://github.com/<uouser>.keys. For more information refer
the [github documentation](https://help.github.com/articles/adding-a-new-ssh-key-to-your-github-account/)

User's profile can also be customized by adding things such as `alias` etc.

User's default `home` folder can be changed but it is upto you to make sure that
the path for new `home` directory exists.

When removing the users, passing `force: yes` will delete the user's home dir

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

No Dependencies except the server must be running Python and should be able
accessible over ssh.

Example Playbook
----------------

Including an example of how to use your role (for instance, with variables passed in as parameters) is always nice for users too:

``` yaml
---

- hosts: all
  gather_facts: no

  tasks:
  - include_role:
    name: init-host
```

License
-------

MIT

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

Mohit Sharma<EMAIL_ADDRESS>


text:
recruitr
========

Recruitr is a modern online judge tool.

You can add coding challenges via the admin interface, specify test cases
(expected input/output), and make it available for visitors to try to solve them
by submitting code.

Currently, recruitr supports C, C++, Haskell, Java, Javascript (Node), Perl,
PHP, Python, Racket, Ruby, Scala, and Shell (Bash). The user submitted code is
run in a docker container, therefore very secure.

Recruitr is built in [Django](https://www.djangoproject.com), and
uses [Celery](http://www.celeryproject.org) for dispatching the code running
tasks asynchronously.


text:
## How to make searchable pdf with pdf extractor sdk in VBScript with ByteScout Premium Suite

### If you want to learn more then this tutorial will show how to make searchable pdf with pdf extractor sdk in VBScript

On this page you will learn from code samples for programming in VBScript.Writing of the code to make searchable pdf with pdf extractor sdk in VBScript can be executed by programmers of any level using ByteScout Premium Suite. Want to make searchable pdf with pdf extractor sdk in your VBScript app? ByteScout Premium Suite is designed for it. ByteScout Premium Suite is the bundle that includes twelve SDK products from ByteScout including tools and components for PDF, barcodes, spreadsheets, screen video recording.

This prolific sample source code in VBScript for ByteScout Premium Suite contains various functions and other necessary options you should do calling the API to make searchable pdf with pdf extractor sdk. Just copy and paste the code into your VBScript application’s code and follow the instructions. Check VBScript sample code samples to see if they respond to your needs and requirements for the project.

If you want to try other source code samples then the free trial version of ByteScout Premium Suite is available for download from our website. Just try other source code samples for VBScript.

## REQUEST FREE TECH SUPPORT

[Click here to get in touch](https://bytescout.zendesk.com/hc/en-us/requests/new?subject=ByteScout%20Premium%20Suite%20Question)

or just send email to [support@bytescout.com](mailto:support@bytescout.com?subject=ByteScout%20Premium%20Suite%20Question)

## ON-PREMISE OFFLINE SDK

[Get Your 60 Day Free Trial](https://bytescout.com/download/web-installer?utm_source=github-readme)
[Explore SDK Docs](https://bytescout.com/documentation/index.html?utm_source=github-readme)
[Sign Up For Online Training](https://academy.bytescout.com/)

## ON-DEMAND REST WEB API

[Get your API key](https://pdf.co/documentation/api?utm_source=github-readme)
[Explore Web API Documentation](https://pdf.co/documentation/api?utm_source=github-readme)
[Explore Web API Samples](https://github.com/bytescout/ByteScout-SDK-SourceCode/tree/master/PDF.co%20Web%20API)

## VIDEO REVIEW

[https://www.youtube.com/watch?v=NEwNs2b9YN8](https://www.youtube.com/watch?v=NEwNs2b9YN8)

<!-- code block begin -->

##### ****MakeSearchablePDF.vbs:**

```
' Create Bytescout.PDFExtractor.SearchablePDFMaker object
Set searchablePDFMaker = CreateObject("Bytescout.PDFExtractor.SearchablePDFMaker")
searchablePDFMaker.RegistrationName = "demo"
searchablePDFMaker.RegistrationKey = "demo"

' Load sample PDF document
searchablePDFMaker.LoadDocumentFromFile("..\..\sample_ocr.pdf")

' Set the location of OCR language data files
searchablePDFMaker.OCRLanguageDataFolder = "c:\Program Files\Bytescout PDF Extractor SDK\ocrdata_best"

' Set OCR language
' "eng" for english, "deu" for German, "fra" for French, "spa" for Spanish etc - according to files in "ocrdata" folder.
searchablePDFMaker.OCRLanguage = "eng"
' Find more language files at https://github.com/bytescout/ocrdata

' Set PDF document rendering resolution
searchablePDFMaker.OCRResolution = 300

' Process the document
searchablePDFMaker.MakePDFSearchable("result.pdf")

WScript.Echo "Searchable document saved as 'result.pdf'."
```

<!-- code block end -->

url: https://raw.githubusercontent.com/bytescout/ByteScout-SDK-SourceCode/67a20983df78dea26d2a8f25ec98000d3ec81928/Premium Suite/VBScript/Make searchable pdf with pdf extractor sdk/README.md

repository: bytescout/ByteScout-SDK-SourceCode

gha_language: HTML

repo_name: bytescout/ByteScout-SDK-SourceCode


text:
# HeatMap

You can see the heat rates in different New York Boroughs.
The data does not represent real rates.

https://okazkayasi.github.io/HeatMap/

repository: okazkayasi/HeatMap

repo_name: okazkayasi/HeatMap


text:
# react-through

## Declarative data mapping through react tree

**Extremal flexible and effective way to communicate between components.**

This library provides tools to map props directly from one component to another.
Source component may be specified in one place of react tree and destination
component which receives that props in another place of react tree.

This allows to create `agent` component (or set of agents) which maps some of
its props to named area and also allows to create `container` (or set of
containers) of that area from which that props are received.

And then all what you need is just to instantiate one or more created
`through-container` in one place(s) and specify some props for it in one or more
`through-agent` in another place(s) of react tree.

[![Npm package](https://img.shields.io/npm/v/react-through.svg?style=flat)](https://npmjs.com/package/react-through)
[![Npm downloads](https://img.shields.io/npm/dm/react-through.svg?style=flat)](https://npmjs.com/package/react-through)
[![Travis build status](http://img.shields.io/travis/oklas/react-through.svg?style=flat)](https://travis-ci.org/oklas/react-through)
[![Test Coverage](https://img.shields.io/codecov/c/github/oklas/react-through.svg)](https://codecov.io/gh/oklas/react-through)
[![Star it](https://img.shields.io/github/stars/oklas/react-through.svg?style=social&label=Star)](https://github.com/oklas/react-through)
[![Follow me](https://img.shields.io/twitter/follow/oklaspec.svg?style=social&label=Follow)](https://twitter.com/oklaspec)

***

Read the **[Documentation](https://react-through.js.org/basics/installation-and-setup)**

# Synopsis

``` javascript
  const Header = () => (
    Your ballance: <IndicatorContainer/> USD
  )

  const Content = () => (
    <IndicatorAgent balance=1000 />
  )

  <App>
    <Header />
    <Content />
  </App>
```

## LICENSE

#### [MIT](./LICENSE.md)


text:
Push Notification {#push}
========

Push notifications (not to be confused with @ref CotcSdk.PushNotification "the PushNotification class") are provided with the push notification package, which may be downloaded separately.

Additionally, push notifications require server side configuration. This documentation will describe how to set it up like any mobile application, and then how to integrate the SDK. We recommend that you perform the former steps first, since the changes made to the configuration on Google/Apple sides need some delay to take effect.

## Table of Contents

1. [Push Notification for iOS](#toc_push_1)
2. [Push Notification for Android](#toc_push_2)

- - - -

# Setup Notifications for iOS {#toc_push_1}

On iOS, push notifications use the Apple Push Notification Service, which we'll describe how to set up in the following paragraphs.

First, set up a certificate with Push notifications enabled on the [Apple Developer Center](http://developer.apple.com/)
![Create Certificate](./img/ios-push-1.png)
Download it,
![Download Certificate](./img/ios-push-2.png)
and convert it to .pem format with the following command:
~~~
openssl x509 -in certificate.cer -inform DER -outform PEM -out certificat-aps-dev
~~~

You'll also need to convert the **private** key used to generate this certificate to the .pem format. To do this, you first need to export your private key to p12 format by using the Keychain Access tool on your Mac. Launch Keychain Access and right click on the certificate that you have just downloaded and installed, and select the "Export" option, and then the .p12 format.
![Export your private key](./img/Keychain_Access.png)

Once this is done, just convert your private key to .pem format with the following command:
~~~
openssl pkcs12 -in private_push_key.p12 -out push-key-dev.pem -nodes
~~~

Once you've got your two .pem files, open a web page to our [Back Office](https://account.clanofthecloud.com), tick the iOS box inside the the "Push Notification Certificates" in your Status page, and fill respectively the "Certificate" and "Private Key" cells with the contents of the files you just created at the previous step (see above).
![Setting up your iOS push notifications with Clan of the Cloud back office](./img/CotC_iOS_PushNotifs.png)

Then, you simply have to import the Cotc.PushNotifications package. When you build your application, check that you are using the provisioning profile for the application for which you enabled push notifications. Everything should be automatic with Xcode though.

Push notifications require no further configuration on your side. You should not even have to implement anything: just placing the `CotcPushNotificationsGameObject` on your scenes will ensure that everything works fine. It will transparently ask for push notifications permission upon login done with the main CotC SDK Game Object and register the device for push notifications. When a message has been delivered successfully (processed by the SDK, raised via #CotcSdk.DomainEventLoop.ReceivedEvent), the application badge is reseted.

- - - -

# Setting up notifications for Android (GCM) {#toc_push_2}

In case you need some more information about how Google Cloud Messaging works, please have a look at the [official Google documentation](https://developer.android.com/google/gcm/gcm.html). Otherwise, by following the steps below, you should be able to have your application manage push notifications pretty quickly.

First, you need to setup a Google Application. Since this is changing quite rapidly at the time of writing, please follow the previous guide for information on how to do it. Once this is done, this Google Application needs to reference the Google Cloud Messaging for Android API. This is done from the APIs section of the Google Developer Console for your project.
![Activating Google Cloud Messaging](./img/Google_Messaging_Android.png)

In case you are using the new interface, it may look more like the following capture. In this case, when following the instructions above, follow the page [add Cloud Messaging to your existing app](https://developers.google.com/cloud-messaging/android/client) and click on the button "Get a configuration file". Then you need to input information about your application (remember to sign in with your Google Developer account first). In the next screen you will obtain everything needed to set up GCM: the API key to set in the backoffice and the sender ID to set in the manifest.
![Setting up Android push notifications with the newer Google Developer Console](./img/CotC_Android_PushNotifs2.png)

Next step is to create a Public API key. To do so, select the Credentials section, just below the APIs section in the previous step, scroll down to the bottom of the page, and click the "Create new Key" button for the Public API access list of keys. Then select "Server key" option, and then "Create", not modifying anything. You should now have a new, valid API key.
![Creating a new Server key](./img/Google_Public_API_Access.png)

Once this is done, you're almost finished with parameterization, and only some bits of code will be needed. But first, you need to declare your Google Application with Clan of the Cloud through your [Back Office web page](https://account.clanofthecloud.com). Now it's straightforward. Just tick the Android box inside the "Push Notification Certificates" in your Status page, and fill the "senderID" cell with the Google Application project number, and the "apiKey" cell with the key you just created at the previous step (see above).
![Setting up your Android push notifications with Clan of the Cloud back office](./img/CotC_Android_PushNotifs1.png)

Now everything's been done on the Google Application side, we need to add a few snippets of code, so your application can communicate with the Google Cloud Messaging servers. First thing to modify is your AndroidManifest.xml, which is located under Assets/Plugins/Android.

Inside the `<application>` tag, make sure to have the following entries:
~~~
	<meta-data android:name="cotc.GcmSenderId" android:value="\ XXXXXXXXXX" />
	<meta-data android:name="cotc.GcmNotificationIcon" android:resource="@drawable/ic_stat_ic_notification" />
	<meta-data android:name="cotc.GcmNotificationTitle" android:value="Cotc sample" />

	<receiver
		android:name="com.google.android.gms.gcm.GcmReceiver"
		android:exported="true"
		android:permission="com.google.android.c2dm.permission.SEND" >
		<intent-filter>
			<action android:name="com.google.android.c2dm.intent.RECEIVE" />
			<category android:name="com.clanofthecloud.sampleunityproject" />
		</intent-filter>
	</receiver>
~~~

You need to change the following:

- `<category android:name="com.clanofthecloud.sampleunityproject" />` to the Bundle Identifier of your application (under Player Settings, Android, Identification).
- `<meta-data android:name="cotc.GcmSenderId" android:value="\ XXXXXXXXXX" />` to the sender ID that you received when creating the application. Note that the first backslash + space are necessary, else the field will be interpreted as an integer and might overflow, breaking the application silently (if you spot an INVALID_PARAMETERS message in the log, double check that).
- `cotc.GcmNotificationIcon` node with the name of a resource to be used as icon.
- `cotc.GcmNotificationTitle` node with the name of your application.
- If you are using facebook, you may need to remove `android-support-v4.jar` under Assets/Plugins/Android/Facebook/libs.

Your application is now ready to receive push notifications from Google Cloud Messaging! No further configuration is required on your side: just placing the `CotcPushNotificationsGameObject` on your scenes will ensure that everything works fine. It will transparently register for notifications upon login done with the main CotC SDK Game Object. Notifications will be received via the standard GCM service (running in background on your device), that starts a small piece of code embedded in our SDK upon event, showing a notification using the parameters set in the manifest.

## Modifying the cotcpushnotifications plugin

Depending on your needs, you may want to modify the cotcpushnotifications native plugin in order to get more control on what happens upon receiving a push notification. This plugin is supplied with the sources of the SDK under PlatformSpecific/Android/cotcpushnotifications, and the parent folder can simply be opened with Android Studio.

This project is basically constituted of four classes:

- **Controller.java**: which you shouldn't change.
- **MyInstanceIDListenerService.java**: which you shouldn't change either.
- **RegistrationIntentService.java**: which you shouldn't change either.
- **MyGcmListenerService.java**: which is the most of interest.

In MyGcmListenerService.java, in particular there are two methods of interest:

- `onMessageReceived`: which is called by the system when a message is received (push notification),
- `sendNotification`: that creates an entry in the notification menu. You can modify this method in order to customize the sound that is played, the title and text of the notification and what happens when you click on the notification. In particular, the following code attaches the notification to the `UnityPlayerActivity` (if no activity is running; that is the notification was received while the application was not launched), or the currently active activity according to Unity. If you have customized the default Unity activity in the manifest, you should replace `activityToOpen` by the name of your main activity, since it is the one you want to open when starting the app as a result of clicking on a notification.

~~~{.java}
Activity currentAct = UnityPlayer.currentActivity;
Class activityToOpen = currentAct != null ? currentAct.getClass() : UnityPlayerActivity.class;
Intent intent = new Intent(this, activityToOpen);
~~~

You can then recompile the plugin using the command `./gradlew build` on the root of the project (PlatformSpecific/Android). This will recompile both the in-app purchase and push notification plugins. The resulting AAR (under build/outputs/aar/) is then copied in the sample Unity project. If you want to customize that behavior and automatically copy it elsewhere, you can modify the `build.gradle` file under cotcpushnotifications.

~~~
//task to delete the old jar
task deleteOldJar(type: Delete) {
	delete '../../../UnityProject/Assets/Plugins/Android/Cotc.PushNotifications.aar'
}

//task to export contents as jar
task exportJar(type: Copy) {
	from('build/outputs/aar/')
	into('../../../UnityProject/Assets/Plugins/Android/')
	include('cotcpushnotifications-release.aar')
	// Rename the jar
	rename('cotcpushnotifications-release.aar', 'Cotc.PushNotifications.aar')
}
~~~

repository: xtralifecloud/unity-sdk

repo_name: xtralifecloud/unity-sdk


text:
# Batatinha, a Java CHIP-8 and Super CHIP Emulator
## ***This repository wont be used anymore, check out the new one: [Batatinha v2](https://github.com/jbatistareis/batatinha-v2).**

I started this project because it was an interesting idea and looked fun, and it really was.

This program reads a CHIP-8 binary ROM and parses its execution calls like a processor.

+ The interface is made with JavaFX
+ The CPU speed is changebe from to 500Hz to 1000Hz
+ The 2 screen colors can be changed to any color
+ The speaker tone is generated with a sine wave function, you can even change the note played (currently only to A, B, C, D, E, F and G)
+ You can control with the on screen key board or with the following key map:
```
1 2 3 C -> 1 2 3 4
4 5 6 D -> Q W E R
7 8 9 E -> A S D F
A 0 B F -> Z X C V
```

![Screenshot](https://github.com/jbatistareis/batatinha/blob/master/images/screenshot.jpg)

repository: jbatistareis/batatinha

repo_name: jbatistareis/batatinha


text:
---
title: Sync API
navtitle: Sync
description: The sync API exposes a function, which expects as input a full dataset of records, and which returns the stringified CSV content.
keywords: ['csv', 'stringify', 'api', 'sync', 'memory', 'function']
sort: 3.3
---

# Sync API

The sync API behave like a [pure function](https://en.wikipedia.org/wiki/Pure_function). For a given input made of the input data set and its options, it always produce the same output data.

This represent a regular direct synchronous call to a function: you pass records and it return a CSV text. Because of its simplicity, this is the recommended approach if you don't need scalability and if your dataset fit in memory.

The module to import is `csv-stringify/sync` and the signature is `const data = stringify(records, [options])` as shown in the [sync example](https://github.com/adaltas/node-csv/blob/master/packages/csv-stringify/samples/api.sync.js):

`embed:packages/csv-stringify/samples/api.sync.js`

repository: adaltas/node-csv-docs

repo_name: adaltas/node-csv-docs


text:
# sql projects template
template for automated version / test upgrades

## prerequirements
* colordiff
* pg_extractor

```bash
dnf install colordiff
```

```bash
cd somewere
git clone https://github.com/omniti-labs/pg_extractor
cd pg_extractor
mv pg_extractor.py pg_extractor
ln -s /usr/bin/pg_extractor pg_extractor

ln -s /usr/bin/sql_manager sql_manager.py
```

## usage
* update files, create new files
* commit changes
* create tag
* make

## commands
* ```make dirs```  # create sql directories
* ```make``` # create $PROJECT_NAME--$VERSION.sql file (first time need run 2x, sort install.sql file)
* ```make test``` # test load $PROJECT_NAME--$VERSION.sql into database
* ```make upgrade``` create upgrade file $PROJECT_NAME--$OLD_VERSION--$VERSION.sql
* ```make test_upgrade``` # load $PROJECT_NAME--$VERSION.sql, $PROJECT_NAME--$OLD_VERSION.sql + upgrade $PROJECT_NAME--$OLD_VERSION--$VERSION.sql, extract DBs using pg_extractor and show diff (when everything is ok show empty diff)

## details
Make use local git, so you can make/update/delete tags before you push tags to upstream branch

```make```
make will create new sql install file $PROJECT_NAME--$VERSION.sql if no new files added/deleted, if not show diff install.sql file instead. You need remove/add lines in correct order if there is some dependencies and run make again.
* make new RPM, copy files from install dir, current $PROJECT_NAME--$VERSION.sql file and all upgrade files from sql/upgdares/*

## links
dirs created with [pg_extractor](https://github.com/omniti-labs/pg_extractor)
usage
`python3.4 pg_extractor.py --getall --gettriggers -U postgres -d dbname`

license: PostgreSQL


text:
# Composer Dist Plugin

A [Composer](https://getcomposer.org) plugin that allows zip files containing distributable assets to be downloaded and extracted within a package's directory when it's installed.

Useful for packages that need to ship compiled css/js files but don't want to track them within git.

> **Note**: This just downloads and extracts the zip.
> It doesn't compile or create them. To do that, check the the [Prerequisites](#prerequisites) section below.

## Example

Suppose you publish a PHP package `foo/bar` which expects your compiled dist assets to be located in `resources/dist`. Place this configuration in the `composer.json` for `foo/bar`:

``` json
{
  "name": "foo/bar",
  "require": {
    "pixelfear/composer-dist-plugin": "dev-master"
  },
  "extra": {
    "download-dist": {
      "url": "https://github.com/foo/bar/releases/download/{$version}/dist.tar.gz",
      "path": "resources/dist"
    }
  }
}
```

## Prerequisites

This plugin only downloads and extracts an existing zip from a URL. You will need to create the zip yourself.

A good solution for this could be using a GitHub Actions workflow.

For example, [this workflow](examples/github-workflow.yml) will do the following steps whenever you push a tag starting with `v`:

- Checkout your code using Git
- Run npm install
- Compile assets using Laravel Mix
- Create a tar.gz archive
- Create a GitHub release
- Upload the tar to the release

Of course, this means that archives will only exist for tagged releases. If you are installating a package using a branch like dev-master, the zip will 404. In this case you can manually compile your assets locally.

## Configuration

### Multiple bundles

In the example above, a single zip (bundle) is used. However, you may configure multiple bundles to be downloaded by providing an array of bundle objects.

``` json
  "extra": {
    "download-dist": [
      {
        "url": "...",
        "path": "dist/one",
      },
      {
        "url": "...",
        "path": "dist/two"
      }
    ]
  }
```

### Bundle options

For each bundle, the following options are available:

| Option | Description |
|--------|-------------|
| url | The URL of the zip to download. Supports `zip`, `tar`, or `tar.gz` files. You can include `{$version}` in the URL which will be replaced by the version of the package being installed (eg. `v1.0.0`).
| path | Where the zip should be extracted relative to your package's root. Defaults to `dist`.
| name | Name of the bundle which will be displayed in the Composer output. Defaults to `dist`.

repository: pixelfear/composer-dist-plugin

gha_language: PHP

repo_name: pixelfear/composer-dist-plugin


text:
# Collectr

Collectr is a Sinatra application built as a project for the Flatiron School. The application allows users to login and and manage a database of artworks (ostsensibly ones owned by them). A video demo is available at: https://vimeo.com/385857973 . A Heroku deployment is available at: https://collectr-app.herokuapp.com/

## Getting Started

To run the project locally, fork and clone the project:
`git@github.com:aohibbard/Collector.git` and change to the local directory. Ensure gem dependencies are installed with `bundle install`, and run `shotgun` to operate locally. Unless configured differently, the project will run at `localhost:9393`.

### Prerequisites

The project requires an internet connection. It is built with Ruby for Sinatra and runs on an sqlite database for development and uses PostgresQL for production. The Hyperclient gem is required to work with Artsy's API.

## Built With

* Sinatra
* Ruby

## Contributing

Please read [CONTRIBUTING.md](https://gist.github.com/PurpleBooth/b24679402957c63ec426) for details on our code of conduct, and the process for submitting pull requests to us.

## Versioning

We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/your/project/tags).

## Authors

* **Andrew Hibbard

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

## Acknowledgements
This project interacts with Artsy's API. Shout out to Artsy's development team.

repository: aohibbard/Collector

gha_language: Ruby

repo_name: aohibbard/Collector


text:
<!-- ---------------------------------------------------------------------------

🎉 THANK YOU FOR YOUR CONTRIBUTION! 🎉

We highly appreciate your time and effort to this project!

⚠ PLEASE READ THIS FIRST ⚠

1. If this is a fix for a security vulnerability you discovered please don't
just open this PR until we have privately discussed the vulnerability. Disclosing
it without contacting us can lead to severe implications for many applications
that run on this project.

2. Make sure you have read the contribution guidelines for this project in
order to raise the chance of getting your PR accepted. This saves you valuable
time and effort.

3. The following structure is a basic guideline. If a section does not apply you
can remove it.

4. Please keep it plain LaTex / pdflatex. No luatex, miktex, kontex, koma etc.
---------------------------------------------------------------------------- -->

## Summary
<!-- ---------------------------------------------------------------------------
⚠ Provide one or two paragraphs
---------------------------------------------------------------------------- -->
This is a fix / feature...

## Linked issue(s)
<!-- ---------------------------------------------------------------------------
⚠ If there is no issue for this PR we won't review it
---------------------------------------------------------------------------- -->

## Involved parts of the project
<!-- ---------------------------------------------------------------------------
⚠ Which parts of the code is affected, which templates are involved
---------------------------------------------------------------------------- -->

## Reproduction
<!-- ---------------------------------------------------------------------------
⚠ How can we reproduce your changes in an app? This is especially important
when new features are added
---------------------------------------------------------------------------- -->

repository: jankapunkt/latexcv

gha_language: TeX

repo_name: jankapunkt/latexcv


text:
![License](https://img.shields.io/badge/License-MIT-yellow.svg)

  # Online/Offline Budget Tracker

  ## Table of Contents
  * [Title](#title)
  * [Description](#description)
  * [Installation](#installation)
  * [Usage](#usage)
  * [License](#license)
  * [Contributing](#contributing)
  * [Questions](#questions)

  ## Description:
  This is a PWA application that allows for a user to add expenses and deposits to their budget with or without an internet connection. When entering transactions offline, they should populate the total when brought back online.

  ## Installation:
  After cloning or unzipping the repo, cd into the "develop" directory in teh bash terminal with node.js installed. Type "npm i" to install packages from the package-json (whichincludes the necessary libraries for the app to function.) After typing and entering "node server.js" the app should be available on localhost:3000 via your web browser.

  ## Usage:
  The user can enter deposits and expenses both online and offline, and when the user returns to an online environment, the entries should automatically be added to the tracker.

  ## Contributing:
  Daniel Sargent

  ## Questions
  Email<EMAIL_ADDRESS>| [Github Profile](https://github.com/undefined)


text:
---
id: 59
title: 'The “is dead” conversation is dead'
date: 2014-08-18T15:07:23+00:00
author: dmarges
layout: post
guid: http://www.donmarges.io/?p=59
permalink: /the-is-dead-conversation-is-dead/
categories:
  - Tech Discussions and Debates
tags:
  - hacker news
  - software development
  - tdd
  - test-driven-development
---
Although I’m somewhat late to the game on this, David Heinemeier Hansson (DHH) set the interwebs ablaze when he stated that Test Driven Development is dead. In fact, that was the name of his post. Whether I agree or disagree (I disagree for the record) is irrelevant. What I found odd was that this is still a headline that we still use. Indeed, in our industry many technologies or ideas die and are quickly replaced by new ones for better or for worse. My assertion is that something does not need to be declared as “dead”. Declaring a technology or idea as dead does not actually do anything, and in the days of Hacker News and somewhat “link-bait” headlines, actually has the opposite effect.

Ideas die or are replaced on their own. They have a lifespan and they are often stepping stones for the next idea. For example, the work of Sigmund Freud is pretty much obsolete in the world of Psychology. A professional Psychologist knows this and derides anyone who should happen to quote him. However, at the time his ideas pushed the profession forward. Although his ideas were largely incorrect, the question becomes: would the field of Psychology be what it is today without him? I’m not sure either way. However, to my knowledge, no one in the field officially declared his work as “dead” on a Psychology blog somewhere. It was PROVEN to be dead, and then later ACCEPTED to be dead. No formal declaration required.

My hope is that the industry of Software Development can move past this sensationalism and get back to a more scientific foundation in this regard. One of ideas proven through work, with a preponderance of evidence to support it.


text:
This is a simple sublime Text 3 plugin that shows the frequency of each line in a document

For example running this plugin on the following will result in,

```
raghu
raghu
raghu
ram
ram
```

```
{
    "raghu": 3,
    "ram": 2
}
```

## Usage

* Open the document where you want to find the frequency of each line
* Open "Command Palette" (keyboard shortcut is Ctrl+Shift+P)
* Search for the "Sublime Frequency: Lines" command, and run it

## Installation

**To be added after adding the package to https://packagecontrol.io/**

repository: krishraghuram/SublimeFrequency

repo_name: krishraghuram/SublimeFrequency


text:
# Exploration Policies

Exploration policies are often useful for Reinforcement Learning algorithm to choose an action that is different than the action given by the policy being learned (`on_policy`).

Exploration policies are subtype of the abstract `ExplorationPolicy` type and they follow the following interface:
`action(exploration_policy::ExplorationPolicy, on_policy::Policy, k, s)`. `k` is used to compute the value of the exploration parameter (see [Schedule](@ref)), and `s` is the current state or observation in which the agent is taking an action.

The `action` method is exported by [POMDPs.jl](https://github.com/JuliaPOMDP/POMDPs.jl).
To use exploration policies in a solver, you must use the four argument version of `action` where `on_policy` is the policy being learned (e.g. tabular policy or neural network policy).

This package provides two exploration policies: `EpsGreedyPolicy` and `SoftmaxPolicy`

```@docs
    EpsGreedyPolicy
    SoftmaxPolicy
```

## Schedule

Exploration policies often rely on a key parameter: $\epsilon$ in $\epsilon$-greedy and the temperature in softmax for example.
Reinforcement learning algorithms often require a decay schedule for these parameters.
Schedule can be passed to an exploration policy as functions. For example one can define an epsilon greedy policy with an exponential decay schedule as follow:
```julia
    m # your mdp or pomdp model
    exploration_policy = EpsGreedyPolicy(m, k->0.05*0.9^(k/10))
```

`POMDPPolicies.jl` exports a linear decay schedule object that can be used as well.

```@docs
    LinearDecaySchedule
```

gha_language: Julia


text:
[![Build Status](https://travis-ci.org/mlangbehn/drupal-on-kubernetes-sample.svg?branch=master)](https://travis-ci.org/mlangbehn/drupal-on-kubernetes-sample)

# Deploy Drupal on Kubernetes

In this Code Pattern, we will setup a Drupal site using Kubernetes and Postgres. Drupal is a popular free and open source content management system used as the backend for millions of web sites worldwide. By splitting out the services into containers, we have the ability to leverage the power of Kubernetes.

 User interacts with the Drupal web interface.
2. The Drupal container uses its persistent volume to store website data (but not content).
3. Drupal container connects to PostgreSQL container to access website content.
4. PostgreSQL container uses its persistent volume to store the database contents.

## Included components

* [Kubernetes Cluster](https://console.bluemix.net/docs/containers/container_index.html): Create and manage your own cloud infrastructure and use Kubernetes as your container orchestration engine.
* [PostgreSQL](https://www.postgresql.org/): Sophisticated open-source Object-Relational DBMS supporting almost all SQL constructs.

## Featured technologies

* [Cloud](https://www.ibm.com/developerworks/learn/cloud/): Accessing computer and information technology resources through the Internet.

## Watch the video

[![](http://img.youtube.com/vi/fQY8q6CjU68/0.jpg)](https://youtu.be/fQY8q6CjU68)

## Steps

[![Deploy to IBM Cloud](https://bluemix.net/deploy/button.png)](https://bluemix.net/deploy?repository=https://github.com/mlangbehn/drupal-on-kubernetes-sample)

Follow these steps to run Drupal on Kubernetes.

1. [Clone the repo](#1-clone-the-repo)
2. [Create Kubernetes cluster](#2-create-the-kubernetes-cluster)
   1. [Locally](#2.1-locally)
   2. [Hosted on IBM Cloud](#2.2-hosted-on-ibm-cloud)
3. [Create the service and deployment](#3-create-the-service-and-deployment)
4. [Access Drupal](#4-access-drupal)

### 1. Clone the repo

Clone the `drupal-on-kubernetes-sample` locally. In a terminal, run:

```
$ git clone https://github.com/mlangbehn/drupal-on-kubernetes
```

### 2. Create Kubernetes cluster

#### 2.1 Locally

Follow the instructions for [running Kubernetes locally via Minikube](https://kubernetes.io/docs/getting-started-guides/minikube/).

#### 2.2 Hosted on IBM Cloud
Follow the instructions for [creating a Kubernetes cluster in IBM Cloud](https://console.bluemix.net/docs/containers/container_index.html#clusters).

### 3. Create the service and deployment

Either run ['scripts/quickstart.sh'](scripts/quickstart.sh), or run the individual commands listed in it:

```shell
kubectl create -f kubernetes/local-volumes.yaml
kubectl create -f kubernetes/postgres.yaml
kubectl create -f kubernetes/drupal.yaml
```

### 4. Access Drupal

After deploying, we need to be sure that all pods are running. Check on the status via:

```shell
kubectl get pods -l app=drupal
```

Once all pod are running we need to know the IP adress of our Drupal.

If you are running in Minikube, run the following:

```shell
$ minikube service drupal --url
```

If you are running in IBM Cloud, we will need to run the following:

```shell
$ bx cs workers "$CLUSTER_NAME"
OK
ID                                                 Public IP        Private IP      Machine Type   State    Status
kube-dal13-cr896f6348d71b4fd1ba151bc7c32abd46-w1   <REDACTED>       <IP_ADDRESS>   free           normal   Ready
```

Access the newly deployed Drupal site via http://<IP_ADDRESS>:30080

## Learn more

* **Kubernetes on IBM Cloud**: Deliver your apps with the combined the power of [Kubernetes and Docker on IBM Cloud](https://www.ibm.com/cloud-computing/bluemix/containers)

## License
[Apache 2.0](LICENSE)

repository: mlangbehn/drupal-on-kubernetes-sample

repo_name: mlangbehn/drupal-on-kubernetes-sample


text:
# Changelog
All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).

## [Unreleased]
### Added
### Changed
### Deprecated
### Removed
### Fixed
### Security

## [1.3] - 2017-12-05
### Added
- Transform xml metadata before indexing. (optional)
- Plugins for search and indexing via elasticsearch.

### Changed
- ArangoDB: Add prefix attribute to stored XSD files.

## [1.0] - 2017-04-07
### Added
- Initial release with the following functionality
1. search term (full text search)
2. update partial mets
3. get partial mets
4. get mets converted to array(json/xml)
5. additional queries to ArangoDB

gha_language: Java


text:
## Intro

ROS wrapper for CFTld with multiple objects, a long-term visual tracker, Based on [CFTld tracker](https://github.com/klahaag/CFtld).
Forked from [CFTld ROS wrapper](https://github.com/AutonomyLab/cftld_ros),

## Misc

Debug the nodelet with GDB:

```bash
$ rosrun --prefix "gdb --args" nodelet nodelet standalone multi_cftld_ros/MultiCFtldRosNodelet```

### Some resources

- https://github.com/ros-perception/image_pipeline/tree/indigo/image_proc/src
- https://groups.google.com/forum/?utm_medium=email&utm_source=footer#!msg/ros-sig-perception/K5__71SX7eU/mxWwn3AeAwAJ
- http://wiki.ros.org/opencv3
- http://answers.ros.org/question/214043/use-ros-indigo-opencv3-alongside-248/
- https://github.com/ros-perception/vision_opencv/issues/91
- http://tayyabnaseer.blogspot.ca/2013/04/porting-nodes-to-nodelets-in-ros.html


text:
# cassandra-docker-pmm
Dockerfile with Cassandra and pmm-client

`docker-compose up -d`

On the Cassandra nodes:

`/usr/local/bin/configure-pmm-client.sh`

In Grafana, choose the Advanced Data Exploration tab from the upper left.

Import a good dashboard into Grafana from here:

https://github.com/fipar/docker-cassandra-prometheus/blob/master/cassandra_rev3.json

repository: fipar/cassandra-docker-pmm

gha_language: Shell

repo_name: fipar/cassandra-docker-pmm


text:
---
layout: about
title : About
---

🙋♀Personal Info
----------------
__Programmer__
`Name`: Yunmin Cho
`Currently`: Kaiserslautern, Germany
`Email`<EMAIL_ADDRESS>{:.message}

🏫Education
------------
* * *
* __Technical University of Kaiserslautern, Germany__ / Accepted on May.2020
* __Bachelor's degree in Computer Engineering Kyung Hee University, South Korea__ / Mar.2015 - Feb.2020

📌Academic Experience
----------------------
* * *
* __Korea Software Congress, South Korea__ / Dec.2019
    - “2D Human Joint Points Extraction Using Machine Learning and Adopting 3D Movement to  Character Using Kinect”: presented at the poster section. Awarded the third prize.
    - Utilized GLUT for displaying 3D motion and MATLAB for skeleton extraction by machine learning
* __SIGGRAPH 2019, USA__ / Jul.2019
    - Exhibited my project as a member of the *Perception and Computer Vision Lab* in Kyung Hee University
    - “3D Sketch Alive”: A 2D drawing shaped like a human was converted into a 3D character and imitated movement of a real person which was captured by Microsoft Kinect Camera.
* __Korea Computer Congress, South Korea__ / Jun.2019
    - “Automated Inspection of Printed Label Using Real-Time Object Detection”: presented at the oral section
    - “Automated Management of Food Expiration Date Using Text Recognition”: presented at the poster section. Awarded the second prize.
* __International Study in University of California, San Diego, USA__ / Jan.2018
    - Participated in a student exchange program and actively took several computer science & engineering courses in English

📌Work Experience
------------------
* * *
* __Seminar on Python programming for high school students, South Korea__ / Apr.2019 - Dec.2019
    - Instructed students how to code their own programs with python as a volunteer work
* __Internship at KIST Europe Smart Convergence Group, Germany__ / Aug.2018 - Jan.2019
    - Developed a windows GUI application with visual C++, connected hardware sensors, tested ethernet communication, and trained EAST algorithm for automated label inspection
    - Resulting paper: “Automated Inspection of Printed Label Using Real-Time Object Detection” was presented at Korea Computer Congress 2019
* __Research Student at Computer Vision Lab in Kyung Hee University, South Korea__ / Mar.2017 - Aug.2017
    - Surveyed some papers related to computer vision and mainly focused on “Robust Road Detection in
Shadow Conditions”: read, analyzed, and presented my analysis
* __Volunteer to VOU(Voice of University), University Broadcasting System, South Korea__ /Jun.2015 - Aug.2017
    - Participated as an engineer, a member of University Broadcasting System in Kyung Hee University
    - Took and edited videos, especially focused on 2D graphic animation video

📚Publications
---------------
* * *
* __YM Cho__, SK Lee, “2D Human Joint Points Extraction Using Machine Learning and Adopting 3D
Movement to Character Using Kinect” in KSC(Korea Software Congress), 2019, Pyeongchang,
Republic of Korea
* __YM Cho__, SJ Choi, “Automated Management of Food Expiration Date Using Text Recognition” in
KCC(Korea Computer Congress), 2019, Jeju-Island, Republic of Korea
* __YM Cho__, SH Suh, HB Lee, KB Kyoung, HM Oh, JW Hwang, “Automated Inspection of Printed Labels
Using Real-Time Object Detection” in KCC(Korea Computer Congress), 2019, Jeju-Island, Republic
of Korea
* __YM Cho__, HS Lim, YM Hwang, HL Nam, K Kim, “Developing Subway Using Helper Application”, in
KICS(The Korean Institute of Communications and Information Sciences), 2016, Republic of Korea

⚜Awards & Scholarship
----------------------
* * *
* 3rd Prize in KSC(Korea Software Congress) Undergraduates/Junior Paper Competition, 2019
* 2nd Prize, Kyung Hee Software Festival, 2019
* 2nd Prize in KCC(Korea Computer Congress) Undergraduates/Junior Paper Competition, 2019
* Grand Prize, Khuthon(Kyung Hee University Hackathon), 2017
* Honourable Mention, SW Talent Donation Challenge, 2016
* Scholarship for Academic Excellence, 2016
* Popularity Award, Good to Great E-Government, 2015
* Honourable Mention, IoT&ICT Startup Idea Contest, 2015

💻Technical Skills
-------------------
* * *
- Programming Technologies: C++, Python, MFC, Android, MATLAB
- Version Control: Git, GitHub, SVN

🗣Abailable Language
--------------------
* * *
- Korean (Native)
- English (Quite Fluent)


text:
# GeneticTetris
A genetic algorithm that learns how to beat the 1989 version of Tetris.

![demo](GeneticTetris/img/demo.gif)
Recording is the result of multiple generations of gameplay, eventually yielding chromosome {-0.50, 0.79, -0.37, -0.18} (See implementation section for more detail)

## Background for Genetic Algorithms

![ga diagram](GeneticTetris/img/ga.png)

For more information about genetic algorithms, check out [this](http://mat.uab.cat/~alseda/MasterOpt/Beasley93GA1.pdf) paper.

## Implementation for Tetris

### Chromosomes
Chromosomes were represented by four weights: aggregate height, completed lines, number of holes, and overall bumpiness. For instance, a chromosome represented by {-0.50, 0.79, -0.37, -0.18} would indicate an aggregate height weight of -0.5, completed lines weight of 0.79, holes weight of -0.37, and bumpiness weight of -0.18.

Aggregate height was calculated by summing the heights of each column. The number of completed lines is found by recording how many lines would be cleared if a piece was dropped in a specific location. Number of holes is the number of empty wells covered by a piece. Bumpiness was determined by finding absolute value differences in height between the columns.

### Reward Function
```
Reward = (a * aggregate height) + (b * completed lines) + (c * number of holes) + (d * overall bumpiness)
```
Variables a, b, c, and d are the weights that each generation is manipulating in attempt to optimize the overall fitness.

The reward was found for every possible location and permutation that a piece could be placed. Essentially, each individual in the population would try to find the best possible move according to the weights in their chromosome.

### Fitness
Fitness was represented by the score of the game once the game was lost, or when the move limit was reached.

## Installation

[FCEUX](http://fceux.com/web/home.html) is an emulator that supports Nintendo Entertainment  System (NES) along with other consoles. FCEUX is used as an environment to run the Lua code and is necessary in order to run the genetic algorithm.

FCEUX downloads can be found [here](http://fceux.com/web/download.html). FCEUX will also have to be added to the path so it can be called from the command line.

## Usage

To run the genetic algorithm, run the main.py file within the GeneticTetris folder.
```bash
python main.py
```
Running main.py will then run main.lua within the FCEUX emulator.

## License
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](/LICENSE)


text:
# VeloPayments::GetPaymentsForPayoutResponseV3Summary

## Properties

| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **payout_status** | **String** | The current status of the payout. | [optional] |
| **submitted_date_time** | **Time** | The date/time at which the payout was submitted. | [optional] |
| **instructed_date_time** | **Time** | The date/time at which the payout was instructed. | [optional] |
| **withdrawn_date_time** | **Time** | The date/time at which the payout was withdrawn. | [optional] |
| **payout_memo** | **String** | The memo attached to the payout. | [optional] |
| **total_payments** | **Integer** | The count of payments within the payout. | [optional] |
| **confirmed_payments** | **Integer** | The count of payments within the payout which have been confirmed. | [optional] |
| **released_payments** | **Integer** | The count of payments within the payout which have been released. | [optional] |
| **incomplete_payments** | **Integer** | The count of payments within the payout which are incomplete. | [optional] |
| **failed_payments** | **Integer** | The count of payments within the payout which have failed or been returned. | [optional] |

## Example

```ruby
require 'velopayments'

instance = VeloPayments::GetPaymentsForPayoutResponseV3Summary.new(
  payout_status: null,
  submitted_date_time: null,
  instructed_date_time: null,
  withdrawn_date_time: null,
  payout_memo: Payment Memo value,
  total_payments: 123,
  confirmed_payments: 123,
  released_payments: 123,
  incomplete_payments: 123,
  failed_payments: 0
)
```

repository: velopaymentsapi/velo-ruby

repo_name: velopaymentsapi/velo-ruby


text:
---
hrs_structure:
  division: '1'
  volume: '7'
  title: '20'
  chapter: '349'
  section: 349-6
type: hrs_section
tags:
  - Government
menu:
  hrs:
    identifier: HRS_0349-0006
    parent: HRS0349
    name: 349-6 State master plan for elders
weight: 19040
title: State master plan for elders
full_title: 349-6 State master plan for elders
---
**§349-6 State master plan for elders.** The executive office on aging shall be responsible for the continued development, implementation, and continuous updating of a comprehensive master plan for elders which shall include, but not be limited to, the following:

(1) Compilation of basic demographic data on elders in the State;

(2) Identification of the physical, sociological, psychological, and economic needs of elders in the State;

(3) Establishment of immediate and long-range goals pursuant to programs and services for elders in the State;

(4) Establishment of priorities for program implementation and of alternatives for program implementation; and

(5) Organization of administrative and program structure, including the use of facilities and personnel.

The state master plan for elders shall be developed in accordance with the requirements of the executive budget act. [L 1976, c 217, pt of §2; am L 1990, c 67, §8]

Case Notes

Justifying age sixty-five retirement policy on basis of conserving state funds would be inconsistent with this section. 56 H. 601, 546 P.2d 1005 (1976).

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# ExtendedCognition

Extended Cognition Legal Hackers Repo

Our first Extended Cognition Meetup is Scheduled for: October 20th, 7:00pm Eastern
Event working web page: http://legalhacktoronto.github.io/ExtendedCognition

* Registration will be available soon at: http://www.meetup.com/Legal-Hack-Toronto/
* Event working webpage: https://www.legalhackto.ca

repository: LegalHackToronto/ExtendedCognition

repo_name: LegalHackToronto/ExtendedCognition


text:
# flutter_barcode_listener

Listen for any hardware barcode scanner

## Problems with barcode scanning
If you need to get barcode scanned from some hardware barcode scanner you generally have few ways to do it.

1. implement some text input control (IE. TextEdit), call focus on it and make the scan
2. listen for some special system event (IE. intent fired from Android service)
3. listen for raw keyboard events

First aproach is simple, and if you're ok to catch scanned barcodes only when you have focus on text control you're good to go and you don't need this package.

If you however need to somehow get scanned barcodes even when you don't have focus on text input control (or no text input control at all) you're left with two other options.

Listening for special system events (IE. Anroid service intents) is always tied for specific manufacturer/device that usually comes with some kind of SDK you need to implement. This means you're implementation will support listening barcode scannes only for this devices you implemented. Plus, it's not really cross platform friendly

And there's third way, simply listen for raw keyboard events and figure out what's barcode and what's not. Downside of this solution is that you need to figure out what's actual user interaction and what's barcode scan. Upside is it doesn't require any per manufacturer/device implementation and you're pretty much suporting all barcode scanners, including external ones with bluetooth or wifi. And it's cross platform friendly.

## Implementation idea
All hardware barcode devices have few things in common
- they act as a keyboard when barcode is scanned
- all keyboard events are fired in extremly small time frame (less than 100 ms between each character)
- barcode is terminated with special character (enter in majority)

So to figure out what is actual barcode and what is simple keyboard event that should be ignored this package uses following logic
1. listen for physical keyboard raw key up event
2. filter out only 'REAL' characters (ASCII codes lower than 256, without special characters except enter)
3. on each new key check if previous key is older than `bufferDuration`, if it's older clear internal buffer.
4. check if new key is enter key, if it is call `onBarcodeScanned` callback and clear buffer
5. if it's not enter key just append it to internal buffer;

Basically it translates to: if you get bunch of keys comming really fast that end with enter key it's a BINGO.


text:
<br>
## A little about me

### What I do:
I'm David, I'm a programmer and System Administrator. I work at Accenture and my current role is OS Engineering Lead.
People in the Linux world tend to call me Nomius, as it was the username used in my first email address when I started to use Linux back in 1998.

### Music:
I love music, I play piano since I'm 7, and my favourites music artists are pretty variable: From the Reggae of Bob Marley, to the Rock of Nickelbak, Jannis Joppin or AC/DC, or the Acid Jazz of Jamiroquai, I also like some experimental/electronic rock like Massive Attack or Fluke. Chill out and Classical mussic are among my favourites as well.

### Reading:
When it comes to reading, my perfect titles are anything by Dan Brown, "A Brave New World", "1984", "Control Remoto" (by Daniel Gutman"), and the list goes more technical (things like Operating Systems/Computer Networks books' by Andy Tanenbaum or any Richard Stevens as well).

### Projects & Open Source:
All my public projects are open source (you can check out the most interesting ones in the navigation bar at tht top), I tend to free any of my projects under the BSD licence.

### Me on social networks (?):
Check my [Google+ page](https://plus.google.com/+DavidCortarello/posts) if you want to know more about me.

Take a look at my [GitHub profile](https://github.com/nomius) and my [GitHub repositories](https://github.com/nomius?tab=repositories) to see more of what I do.

### About this site:
I finally I have a good website, self made, beautiful, with the things that I use and without a messy WYSIWYG editor which does what he wants.
This whole website was created using [Vim](http://www.vim.org/), it's all written using github's markdown as formating syntax to write every page (even the weblog).

How I did this? Well, this site is now automatically generated by a 170 lines [python script](https://github.com/nomius/nomius.github.io/blob/master/generator.py). Cool isn't it? :-)

You can now take a look at the whole code and website (+content) at: <https://github.com/nomius/nomius.github.io>.

As you've probably already seen, the script that generate this site support links, tables, syntax highlighted code, images (although I don't use them too much), quotes, headings, all types of lists, mobile support thanks to bootstrap and a lot more. It includes an automated weblog (it can be disabled as well), and as said before, it uses a clean syntax that you really enjoy writing in like markdown. And finally, one of the coolest things: **_It has a really nice design_**.


text:
# Useful tutorials on software for ML

See https://software-carpentry.org/ for many useful tutorials.
We list a few more specific tutorials below,
with a bias towards ones that focus on ML/ datascience.

## Python

Below we list some excellent tutorials on Python.

|Link|Notes|
|-|----|
|[Dive into Python 3](https://www.diveinto.org/python3/table-of-contents.html)| Excellent free book by Mark Pilgrim|
|[Fluent Python: Clear, Concise, and Effective Programming](https://www.amazon.com/Fluent-Python-Concise-Effective-Programming/dp/1491946008)| Book by Luciano Ramalho|
[Whirlwind tour of Python](https://github.com/jakevdp/WhirlwindTourOfPython)  |by Jake Vanderplas|
|[Python Datascience Handbook](https://github.com/jakevdp/PythonDataScienceHandbook)| Excellent free book by Jake Vanderplas|
|[Datascience from scrtach](https://www.oreilly.com/library/view/data-science-from/9781492041122/)| Minimalistic Python implementations of standard ML methods |
|[Duke's BIOS821 course](http://people.duke.edu/~ccc14/bios-821-2017/index.html)| Intro to data analysis with Python |
|[Duke's STA663 course](http://people.duke.edu/~ccc14/sta-663-2019/)| Intro to statistical computing with Python |
|http://scipy-lectures.org/| Scipy tutorials |
|[Book on matplotlib](https://github.com/rougier/scientific-visualization-book) | Data visualization with Python |
|[JAX](https://github.com/google/jax)| Accelerated numpy plus autograd |

## Code editors

In datascience / ML, it is common to use  Jupyter notebooks
 or [Google colab](https://colab.research.google.com/github/probml/pyprobml/blob/master/notebooks/colab_intro.ipynb)
which mix code and results.
When developing larger software projects, it is often better to use an
 IDE (interactive development environment),
 which keeps the code separate from the results.
 There are many IDEs, such as
 JupyterLab,
Spyder,
PyCharm,
or VS code.
(The latter lets you edit locally on your laptop but run your code on a remote virtual machine,
such as Cloud TPU VM.)

repository: probml/pyprobml

gha_language: Jupyter Notebook

repo_name: probml/pyprobml


text:
# EXS-SimpleMongoBundle
A simple bundle to persist and execute queries on MongDB database for php7

## Installing the # EXS-SimpleMongoBundle in a new Symfony2 project

Edit composer.json file with # EXS-SimpleMongoBundle dependency:
``` js
//composer.json
//...
"require": {
    //other bundles
    "exs/simple-mongo-bundle": "^1.0"
},
```
Save the file and have composer update the project via the command line:
``` shell
composer update exs/simple-mongo-bundle
```

Update the app/AppKernel.php
``` php
//app/AppKernel.php
//...
public function registerBundles()
{
    $bundles = array(
    //Other bundles
    new EXS\SimpleMongoBundle\EXSSimpleMongoBundle(),
);
```

## Usage

Add your mongodb connection and dbname in the parameter file
``` php
    simple_mongo:
        connection: mongodb://localhost:27017
        dbname: YOUR_DB_NAME
```

Create the new collection(Optional)
``` shell
app/console exs:create:collection COLLECTION_NAME(Requires) OPTIONS
// Options
app/console exs:create:collection -h

```

In your controller or service
``` php
// Insert data to mongodb
$entity = new YourEntity();
$entity->setPropertyValue(THE_VALUE);
.
.

$manager = $this->get('exs_simple_mongo.service'); // get the service
$manager->persist($entity);
$result = $manager->flush(COLLECTION_NAME); // the result will store the number of inserted entries or error message
if(!is_int($result) || $result == 0) {
    throwException($result);
}

// Update
$filter = ['product' => 6];
$manager->update($filter, $entity);
$result = $manager->flush(COLLECTION_NAME);

// Get data with query
$filter = ['product' => 6];
$option = ['projection' => ['_id' => 0]];

$manager = $this->get('exs_simple_mongo.service'); // get the service
$result = $manager->exeQuery($filter, $option, COLLECTION_NAME);
// $result will contain results in an array
```

#### Contributing ####
Anyone and everyone is welcome to contribute.

If you have any questions or suggestions please [let us know][1].

[1]: http://www.ex-situ.com/

repository: ExSituMarketing/EXS-SimpleMongoBundle

repo_name: ExSituMarketing/EXS-SimpleMongoBundle


text:
<!--
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
-->

English | [简体中文](./README.zh-CN.md)

# Apache APISIX Dashboard

Dashboard for [Apache APISIX](https://github.com/apache/apisix)

[Online Demo](http://<IP_ADDRESS>/), Username/Password: `admin`.

## User Guide

Please refer to [User Guide](./docs/USER_GUIDE.md)

## Deployment

- [Deploy Manually](./docs/deploy.md)
- [Deploy with Docker](./compose/README.md)

## Development

- [Apache APISIX](https://github.com/apache/apisix)
- [Dashboard](./docs/develop.md)

## Milestones

- [2.0](https://github.com/apache/apisix-dashboard/milestone/4)
- [2.1](https://github.com/apache/apisix-dashboard/milestone/5)

## Contributing

See [CONTRIBUTING](./CONTRIBUTING.md) for details on submitting patches and the contribution workflow.

## FAQ

1. If you need the dashboard-1.0 which is built with Vue.js, please refer to [master-vue](https://github.com/apache/apisix-dashboard/tree/master-vue).

2. The dashboard 2.0 removes MySQL which [dashboard 1.5](https://github.com/apache/apisix-dashboard/tree/backup-1.5-latest) is relied on.

gha_language: Vue


text:
# [Going to the cinema](https://www.codewars.com/kata/going-to-the-cinema "https://www.codewars.com/kata/562f91ff6a8b77dfe900006e")

My friend John likes to go to the cinema. He can choose between system A and system B.
```
System A : buy a ticket (15 dollars) every time
System B : buy a card (500 dollars) and every time
    buy a ticket the price of which is 0.90 times the price he paid for the previous one.
```

## Example:

If John goes to the cinema 3 times:
```
System A : 15 * 3 = 45
System B : 500 + 15 * 0.90 + (15 * 0.90) * 0.90 + (15 * 0.90 * 0.90) * 0.90 ( =<PHONE_NUMBER>999999, no rounding for each ticket)
```
John wants to know how many times he must go to the cinema so that the *final result* of System B, when rounded *up* to the next dollar, will be cheaper than System A.

The function `movie` has 3 parameters: `card` (price of the card), `ticket` (normal price of
a ticket), `perc` (fraction of what he paid for the previous ticket) and returns the first `n` such that
```
ceil(price of System B) < price of System A.
```
More examples:
```
movie(500, 15, 0.9) should return 43
    (with card the total price is 634, with tickets 645)
movie(100, 10, 0.95) should return 24
    (with card the total price is 235, with tickets 240)
```

repository: ParanoidUser/codewars-handbook

repo_name: ParanoidUser/codewars-handbook