text:
# #100DaysOfCode

## Purpose

100 Days of Code is a challenge to write and research programming topics and fields you might be interested in learning more about over the course of about 100 days. The main purpose of it, overall, is to get yourself into the habit of working on personal projects or (if you work outside of the software development space) just coding for at least an hour a day. You can find a good article about the guy who brought the idea to the public [here](https://www.100daysofcode.com/). This can also be expanded to different concepts as well, like exercise, music production, cooking, and more. More info about those is given on the site as well.

## What is this repo?

This repo specifically hosts the progress logs, files, and projects of the Carb Pride Puter Frens during this challenge. In the overall scope of things, each person might do something similar or possibly different depending on what they want to learn. You can find info for each person in their README in their personal space.

## Rules

At the minimum, here are the rules we're giving ourselves:

- Spend at least an hour each day either researching topics of interest or (preferribly, if possible) writing code
- Try your best to do it every day for 100 days. Some days might be too busy or other things like work and school may come up, which is fine, but try your best to recoup your time when possible. The biggest point of this is to build a habit, not just get a bunch done, so be vigilant in at least finding an hour per day. *Don't skip more than two days in a row if possible*
- Keep track of your progress and what you're learning. At the minimum, keep track of what you did that day in a log, much like a journal. Feel free to talk about struggles, ask questions, or even write a whole essay if you want to though. If possible, commit code into your space. Here's the way MB is doing it:
    - In the logs folder, make a Markdown file with information on what you did that day.
    - In code_snips, put in snippits of code which don't consitute putting it in an entire project. It might be an answer to a ProjectEuler problem, a small portion of some HTML/CSS/JS that you found interesting, a basic runthrough of a language you don't know, etc.
    - In projects, put in full projects your working on. If possible, put READMEs inside of individual projects to explain what they are.
    - Try to trace back any extra files or projects you add into your log.
    - ***Feel free to organize in any way that's helpful to you***

```
logs/
  one.md
  two.md
  three.md
  ...
code_snips/
  small_thing_not_a_project/
    index.html
    grid.css
    index.js
  Three.java
  RubySample.rb
  ...
projects/
  project_name/
    ...
```

---

## Day One [Example Log]

### FreeCodeCamp

- Started on Front-End/Responsive Web Design lessons. I know HTML/CSS/JS, but am not an expert of it, so I would like to refresh on some more of the advance topics, especially for CSS.
- Did the following lessons: (list all you did below)
- Tested out a small thing I found, made a mini-website featuring it, you can find it here: (point to folder/wherever)

### GitHub

- Made a repo for the challenge
- Found some good resources on learning Git

### Projects

- Started a project for making a React SPA, you can find it here: (point to folder with the project)

### Research

- Read some about C, found some good resources to start copying from to learn more

---

## I'm interested in contributing or trying this out

Unfortunately, we're most likely not opening up this specific repo for forking unless you ask beforehand or we approve the PR that comes in, but totally feel free to take the format for yourself or your group of friends. Feel free also to open an issue if you have questions, comments, concerns, or would like to suggest something to one of us, like a project idea or resource.

## Git Practices for this repo (Members Only)

- Pull latest changes from origin/master
- Branch locally from master, starting with either your name or initials followed by what you're doing (i.e. mb-adding-log-five, liam-c-project-using-malloc, ad-hosting-code-to-cloud-deploy, etc.)
- If someone has made changes after you made your local branch, pull in the changes to your local master branch then rebase onto master. This will help avoid merge conflicts. Do be careful though as a misstep can mean losing files or commits forever. Consider making backups somewhere before doing this.
- Push branch to origin. Don't merge into master locally.
- Open a pull request with your change
    - For the most part, if it's just in your space, you can just merge, but do be courteous. If you made changes to another person's space, make sure they approve it before you merge
- Once all criteria is met, merge and delete your branch from GitHub
- Pull in changes from master
- Delete your local branch


text:
# IPL-Fantasy-League-Statistics

**Basic statistics is performed IPL Fantasy Leagues Teams file only for educational purpose**

This code is a Python script that is used to perform statistics on a IPL Fantasy League PDF Teams file which has various teams. It focuses on the distribution of Captain, Vice Captain and Individual Player in the PDF file through the use of GUI.

In the GUI, the user has to choose the file path and select the statistics you want and click **submit** button. After the statistics are performed, it clears all the inputs fields. Also, log can be seen in file **ipl_stats.log** file. The GUI will be similar to fil **GUI.png**.

The sample input PDF file is **csk.pdf**. And the converted sample Excel file to perform statistics is **csk.csv**. The ouput for statistics are **captains.png**,**vice_Captains.png**, and **all_players.png**.

**Pre-requisites needed to execute the Script:**

The following things are needed to be present to execute the IPL Fantasy League Statistics

* Python Compiler
* Python Qt 5 library
* Python Tabula library
* Python Matplotlib library
* Python Pandas library

The library tabula can be installed by using **pip install tabula-py**.

The screenshots of how the script works are provided in the repository. Execute the script **ipl_fantasy_stat.py** and basic statistics can be performed on the IPL Fantasy League Team files.

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Network Scritps to communicate with Arista and HPE Switches

1. show_ver.py

 Description: Collects active firmware, next boot firmware, serial number etc.

 Syntax: python3 show_ver.py arista.db

2. show_inven.py

 Description: This script provides transceiver inventory for a switch. It reads file with list of switches,
             uses RANCID clogin to login to the switch and collect the output

 Syntax: show_inven.py arista.db

3. push_multidevices.py

 Description: Sends block of commands to devices

 Syntax: python3 push_multidevices.py <cmd.list> <devices.db>

4. configuration.txt

 This is a common file for all the scripts:

 [Authentication]
 username=admin
 password=admin_password

 [EAPI]
 username=user2
 password=user2_password

repository: amughal/network

repo_name: amughal/network


text:
# Hello, world

A very simple introduction to Toro.

## Install

1. Copy this directory to your server/virtual host root
2. Grab a copy of `toro.php` from the repository and store adjacently with `index.php`

repository: oberd/ToroPHP

gha_language: PHP

gha_license_id: MIT

repo_name: oberd/ToroPHP


text:
# Saprolegnia eccentrica (Coker) R.L. Seym., 1970 SPECIES

#### Status
ACCEPTED

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

#### Published in
Nova Hedwigia 19(1-2): 53 (1970)

#### Original name
Isoachlya eccentrica Coker, 1923

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
![takahē](static/img/logo-128.png)

A *beta* Fediverse server for microblogging/"toots". Not fully functional yet -
we're still working towards a 1.0!

**Current version: [0.6.1](https://docs.jointakahe.org/en/latest/releases/0.6/)**

Key features:

- Multiple domain support
- Multiple identities per user (and can be shared between users)
- Desktop, mobile and PWA-compatible web UI (with minimal JavaScript)
- Mastodon-compatible client API (supports existing apps)
- Easy deployment (web worker, background worker, and one database)

For more background and information, see [jointakahe.org](https://jointakahe.org/).

## Deployment

See [our deployment documentation](https://docs.jointakahe.org/en/latest/installation/).

For changelog and update notes, visit [our releases documentation](https://docs.jointakahe.org/en/latest/releases/).

## Roadmap

Takahē is still under very active development towards a 1.0 release, and not
all functionality is supported yet.

For a detailed feature breakdown, see [the features page in our docs](https://docs.jointakahe.org/en/latest/features/).

For an idea of what features are currently in flight, see [our project board for the next release](https://github.com/orgs/jointakahe/projects/1/views/1).

## Contributing

If you'd like to contribute, please read [our contributing docs](https://docs.jointakahe.org/en/latest/contributing/).

repository: pombredanne/takahe

branch_name: refs/heads/main

repo_name: pombredanne/takahe


text:
# Final Capstone

#### Hello there! Welcome to Personal Expenses, your personal expenses managing application. The purpose of this project is to help people managing their expenses and achieving their personal financial goals.

##### This is a front-end application, which retrieves data from [this API](https://github.com/tadeuasarro/track-api/tree/milestone7) that I developed.

#### Features
- Register and login using only the username
- Create and reset goals of how much money the user plans to expend
- Track expenses and sort them into six different categories
- Check a dashboard which summarizes the expenses into the categories
- Check the history log which displays the expenses info

#### Screenshot

![screenshot](public/screenshot.png)

#### Livedemo

- [Heroku](https://nameless-gorge-08250.herokuapp.com/)

## Built With

- [React](https://reactjs.org/)
- [Redux](https://redux.js.org/)

## Packages
- [Eslint](https://eslint.org/)
- [PropTypes](https://www.npmjs.com/package/prop-types)
- [React-dom](https://www.npmjs.com/package/react-dom)
- [React-router-dom](https://www.npmjs.com/package/react-router-dom)
- [React-test-renderer](https://www.npmjs.com/package/react-test-renderer)
- [Redux-thunk](https://www.npmjs.com/package/redux-thunk)
- [Stylelint](https://stylelint.io/)
- [Webpack](https://webpack.js.org/)

## Getting started

### Setup

Clone the repo with

```
  https://github.com/tadeuasarro/track-app.git
```

Install packages with

```
  npm install
```

Start server with:

```
  npm start
```

Follow the instructions in [this repo](https://github.com/tadeuasarro/track-api/tree/milestone7) to start the local server.

Open `http://localhost:3000/` in your favorite browser.

### Run tests

```
  npm test
```

### Using

- The first time you access the app you will have to create a username.

- The next time you can login using that username.

- Before adding expenses the application will require you to create a target.

- After that all you have to do is add the expenses and you can check them out in the home and progress tabs.

### Authors

👤 This is me:

- [Tadeu A Sarro](https://tadeuasarro.me)

### Contributing

Contributions, issues and feature requests are welcome!

Feel free to check the [issues page](https://github.com/tadeuasarro/track-app/issues)

### Show your support

Give a star if you like this project!

### Acknowledgments

- [Track-API](https://github.com/tadeuasarro/track-api/tree/milestone7)
- [Microverse](https://www.microverse.org/)

### 📝 License

This project is MIT licensed.

repository: tadeuasarro/track-app

branch_name: refs/heads/development

gha_language: JavaScript

repo_name: tadeuasarro/track-app


text:
# cmt-fun

Some experimental code for generating ocaml-python bindings automatically from the ocaml compiler artifacts (cmti files).

This repo is out of date and has been merged in the main [pythonlib](https://github.com/janestreet/pythonlib) repo.

repository: LaurentMazare/cmt-fun

repo_name: LaurentMazare/cmt-fun


text:
# serilog-aspnetcore-mvc

[![Build Status](https://dev.azure.com/rossbuggins/serilog-aspnetcore-mvc/_apis/build/status/rossbuggins.serilog-aspnetcore-mvc?branchName=master)](https://dev.azure.com/rossbuggins/serilog-aspnetcore-mvc/_build/latest?definitionId=3&branchName=master)

Nuget feed:
https://pkgs.dev.azure.com/rossbuggins/serilog-aspnetcore-mvc/_packaging/serilog-aspnetcore-mvc-public/nuget/v3/index.json

MVC support for Serilog AspNetCore after discussion at https://github.com/serilog/serilog-aspnetcore/issues/131 and https://github.com/serilog/serilog-aspnetcore/pull/133

to use call
```
mvcBuilder.AddSerilogMvcLogging();
```

Project updated to use

- GitFlow
- GitVersion

## GitFlow Install
choco install GitVersion.Portable

##GitVersion VS2019 Install
https://marketplace.visualstudio.com/items?itemName=vs-publisher-57624.GitFlowforVisualStudio2019

repository: rossbuggins/serilog-aspnetcore-mvc

gha_language: C#

repo_name: rossbuggins/serilog-aspnetcore-mvc


text:
# Statistical Learning

This series of guides are mostly about scikit-learn and Jupyter.

# Jupyter hotkeys

## While in edit mode

* escape: enter command mode

## While in command mode

* enter: enter edit mode
* y: set cell to code
* m: set cell to markdown
* r: set cell to raw nbconvert
* a: insert cell above
* b: insert cell below
* d, d: delete cell
* up, down, left, right: move around

path: /Statistical Learning/README.md


text:
---
layout: default
---

# 1996-08-27 - A _REALLY_ Interesting Bet

## Header Data

From<EMAIL_ADDRESS>(Anonymous)

To<EMAIL_ADDRESS>Message Hash: e8d41bc9a21ca51fa3375d868c140ac8ac6d0f982e749a8255658fdb1dd6809d

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-08-27 22:42:11 UTC

Raw Date: Wed, 28 Aug 1996 06:42:11 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Anonymous)
Date: Wed, 28 Aug 1996 06:42:11 +0800
To<EMAIL_ADDRESS>Subject: A _REALLY_ Interesting Bet
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Betting on football is one thing, but some of us would be very
interested in the odds on US presidential election outcomes as
November approaches. This kind of betting is illegal here, and
I haven't looked lately for a "Ladbroke's" type site, but it is
interesting because the betting odds from across the Atlantic
more closely match eventual election results than the annoying
calls from Gallup & Roper during suppertime. I have posted here,
anonymously, on this topic before, but some of you are aware of
who I am. I'll thank you to keep that a secret. ;}

{% endraw %}
```

## Thread

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

+ Return to<EMAIL_ADDRESS><pstira@escape.com>](/authors/_pstira_at_escape_com__pstira_at_escape_com_)"
+ Return to "[Black Unicorn <unicorn@schloss.li>](/authors/black_unicorn_unicorn_at_schloss_li_)"
+ Return to "[Gary Howland <gary@systemics.com>](/authors/gary_howland_gary_at_systemics_com_)"
+ Return to "[Jim Gillogly <jim@ACM.ORG>](/authors/jim_gillogly_jim_at_acm_org_)"
+ Return to<EMAIL_ADDRESS>(Anonymous)](/authors/nobody_at_zifi_genetics_utah_edu_anonymous_)"

+ 1996-08-27 (Wed, 28 Aug 1996 06:42:11 +0800) - A _REALLY_ Interesting Bet -<EMAIL_ADDRESS>(Anonymous)_
  + 1996-08-28 (Wed, 28 Aug 1996 23:17:06 +0800) - [Re: A _REALLY_ Interesting Bet](/archive/1996/08/adec5430e65860c428a4e78a044a7109dea1d5f4d1f1acd659b90f60e66f2b2b) - _Gary Howland<EMAIL_ADDRESS>  + 1996-08-28 (Thu, 29 Aug 1996 03:45:51 +0800) - [Re: A _REALLY_ Interesting Bet](/archive/1996/08/668d8d9c1459cdf9c1be7f28c521d699cc2e8d5bc1237dd95a79b9c48cee21b7) - _Gary Howland<EMAIL_ADDRESS>    + 1996-08-29 (Thu, 29 Aug 1996 11:46:36 +0800) - [Re: A _REALLY_ Interesting Bet](/archive/1996/08/a641660e19844e3c30d4bb7c3300aab8c0ee590218d22561bcddf2c2f61b60fc) - _Black Unicorn<EMAIL_ADDRESS>      + 1996-08-29 (Thu, 29 Aug 1996 13:38:44 +0800) - [Re: A _REALLY_ Interesting Bet](/archive/1996/08/dd640c6a72741ebdc9c219d4eedbc219117106cd81160c2962cd9cdf62f51a62) - _Jim Gillogly<EMAIL_ADDRESS>        + 1996-08-29 (Thu, 29 Aug 1996 23:54:33 +0800) - [Re: A _REALLY_ Interesting Bet -[parallels]-](/archive/1996/08/9e5fff04939ab8b70cc5daeb38768b3981e3c74cc57a2c2b3ac7076660e72e9a) -<EMAIL_ADDRESS><EMAIL_ADDRESS>


text:
![Build Status](https://travis-ci.org/seandavi/SDST.svg)
![pypi downloads](https://img.shields.io/pypi/dm/SDST.svg)

# Overview

This is meant to be a collection of potentially useful routines to perform NGS data analysis tasks.  It also contains some documentation of commonly-used tools.  [Read the Docs for details]
(https://seqtools.readthedocs.org/).

repository: seandavi/SDST

gha_language: Python

repo_name: seandavi/SDST


text:
# Typescript Definitions for [Mithril 1.1](https://github.com/lhorie/mithril.js)

Requires TypeScript 2.x.

## Install

Install from npm with:

    npm install -D @types/mithril

### Promise support in ES5

Please note that while Mithril polyfills Promise support, this type definition does not include a type declaration for Promises. You may see an error like:

```
'Promise' only refers to a type, but is being used as a value here.
```

To use promises, you should add the `"es2015.promise"` library option to your compiler options. In `tsconfig.json`:

```JSON
{
  "compilerOptions": {
    "target": "es5",
    "lib": [
      "es2015.promise",
      ...
    ]
  }
}
```

---

### The Gist:

#### POJO `Component` example using `vnode.state`:

```typescript
import * as m from 'mithril';

export interface Attrs {
  name: string;
}

interface State {
  count: number;
}

export default {
  oninit (vnode) {
    vnode.state.count = 0;
  },
  view (vnode) {
    return m('span', `name: ${vnode.attrs.name}, count: ${vnode.state.count}`);
  }
} as m.Component<Attrs,State>;
```

Note that all types can be accessed via `m` as above.

#### POJO `Comp` example using `this` state:

```typescript
import * as m from 'mithril';

export interface Attrs {
  name: string;
}

interface State {
  count: number;
}

export default {
  count: 0,
  view ({attrs}) {
    return m('span', `name: ${attrs.name}, count: ${this.count}`);
  }
} as m.Comp<Attrs,State>;
```

#### `ClassComponent` example, importing types separately:

```typescript
import * as m from 'mithril';
import {ClassComponent, CVnode} from 'mithril';

export interface Attrs {
  name: string;
}

export default class MyComponent implements ClassComponent<Attrs> {
  count = 0;
  // Note that class methods cannot infer parameter types
  view ({attrs}: CVnode<Attrs>) {
    return m('span', `name: ${attrs.name}, count: ${this.count}`);
  }
}
```

#### `FactoryComponent` example:

```typescript
import * as m from 'mithril';

export interface Attrs {
  name: string;
}

const comp: m.FactoryComponent<Attrs> = function() {
  let count = 0;
  return {
    view ({attrs}) {
      return m('span', `name: ${attrs.name}, count: ${count}`);
    }
  }
};
export default comp;
```

#### `Stream` example:

```typescript
import * as stream from 'mithril/stream';
import {Stream} from 'mithril/stream';

const num = stream(1);
const text = stream<string>();
let s: Stream<Foo>;
s = stream(new Foo());
```
---

## Script/Global Usage

If you are adding mithril to your page as a separate script, then you can install the [global version](https://github.com/spacejack/mithril-global.d.ts) of these types.

---

For more example usage see the `test` folder.

**NOTE** This repo is not guaranteed to be in sync with DefinitelyTyped. Please use the DT types for your applications. This repo is maintained primarily for documentation and issues.

## Install this repo

    npm install

### Test lint

    npm run lint

You can also try compiling with `npm test` (which runs tsc) however there are intentional errors in the tests to ensure type checks will catch those errors.


text:
# tit.io framework
## Introduction

  A simple microservice framework based on grpc-go, which provides following features:

  1. Define services with protobuf3 and generate grpc server/client/RESTful gateway.
  2. Service discovery & registration with consul, and client-side load balancer.
  3. Distributed tracing with jeager.
  4. Monitoring by exposing metrics to promethues.
  5. Rate-limiting.
  6. Circuit-breaker.
  7. Authorization & Authentication.
  8. Logging with uniqe id per request.
  9. Validation support.

## Get started

### Validation support
Validation support through https://github.com/envoyproxy/protoc-gen-validate

  1. Install
  ```
  go get -d github.com/envoyproxy/protoc-gen-validate
  make build
  ```

repository: butters-mars/tiki

gha_language: Go

repo_name: butters-mars/tiki


text:
# FEZ Cerb Family Developers' Guide
---

The powerful firmware on a single chip design of the Cerb Family makes this core ideal for many uses. GHI offers the following Cerb Family products that all share the exact same processor (STM32F405RGT6) and firmware:

* [FEZ Cerberus](https://www.ghielectronics.com/catalog/product/349)
* [FEZ Cerbuino Bee](https://www.ghielectronics.com/catalog/product/351)
* [FEZ Cerbuino Net](https://www.ghielectronics.com/catalog/product/473)
* [FEZ Cerb40 II](https://www.ghielectronics.com/catalog/product/450)

## Memory Constraints
Due to the limited amount of memory on the Cerb Family, the following features are not supported:

* Wi-Fi RS9110
* PPP
* SQLite
* USB Host Webcam and Hub
* USB Client
* Extended Weak References
* InField Update
* Serial debugging
* SSL
* Cryptography

## Real Time Clock
To enable the Real Time Clock, you must connect a crystal with frequency 32.768KHz and load capacitance of 6pF between PC14 and PC15. VT200F-6PF20PPM from DigiKey will work. You must also supply the VBAT pin with 3V.
The FEZ Cerb40 II already does this. The FEZ Cerbuino Net and Bee expose PC14 and PC15 on pins D3 and D4 respectively on their headers. For the FEZ Cerberus, since PC14 and PC15 are not exposed, you must connect the crystal between C10 and C11 on the board on the side closest to the processor.

## Loader Update
The loader on the Cerb Family is updated using ST Microelectronics's STDFU Tester program. This program is installed by default with our SDK.
Under STMicroelectronics in the start menu, run the STDFU Tester program.
The board must be put in a special mode for the STDFU tool to recognize it. To do so, hold the LDR button on your board, power it, then release LDR.
If your board lacks an LDR button, short the two pads labeled either LDR or BOOT (depending on your board) together and then power your board.
If you have a FEZ Cerb40 II, hold the LODR pin high and then power the board.
Next, you will see "STM Device in DFU Mode" appear under Device in the STDFU tool. Click the Protocol tab.
Click the Create from Map button, select the Erase radio button, and then click Go. The program will take a few moments to erase the board.
**Once it has finished, select the download option on the left before downloading the loader file:**
Click the Load DFU File button and select the C:\Program Files (x86)\GHI Electronics\NETMF v4.3 SDK\Firmwares\Cerb Family\Loader.dfu file. Click the Download radio button and then click Go. The program will quickly load the new loader onto your board.
Reboot your board after it finishes and proceed to update the firmware using FEZ Config as detailed on the Firmware Update page.

> [!Warning]
> Make sure to follow these steps exactly. You could corrupt the loader file or overwrite certain parts of your device if you are not careful.

## PWMs
On the Cerb Family of products, the underlying processor groups PWMs in such a way that a change to the frequency in one PWM affects all PWMs in that group. The below list shows the groups of PWMs:

* PWM_3, PWM_11, PWM_12
* PWM_8, PWM_9, PWM_10, PWM_13
* PWM_4, PWM_5, PWM_6, PWM_7
* PWM_14, PWM_15
* PWM_0, PWM_2
* PWM_1

## FEZ Cerbuino Net Ethernet Initialization
The below code shows how to initialize the onboard Ethernet on the FEZ Cerbuino Net from a plain NETMF project. It requires the GHI.Networking, GHI.Pins, and Microsoft.SPOT.Net libraries. If you are using Gadgeteer, you can find the Ethernet object pre-created on the Mainboard.Ethernet object.

```c#
using GHI.Networking;
using GHI.Pins;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using Microsoft.SPOT.Net.NetworkInformation;

public class Program
{
	private static EthernetENC28J60 netif;

	public static void Main()
	{
		NetworkChange.NetworkAvailabilityChanged += NetworkChange_NetworkAvailabilityChanged;
		NetworkChange.NetworkAddressChanged += NetworkChange_NetworkAddressChanged;

		netif = new EthernetENC28J60(SPI.SPI_module.SPI1, Generic.GetPin('A', 13), Generic.GetPin('A', 14), Generic.GetPin('B', 10));
		netif.Open();
		netif.EnableDhcp();
		netif.EnableDynamicDns();
	}

	private static void NetworkChange_NetworkAddressChanged(object sender, Microsoft.SPOT.EventArgs e)
	{
		Debug.Print("Network address changed");

		if (netif.IPAddress != "<IP_ADDRESS>")
		{
			//The network is now ready to use.
		}
	}

	private static void NetworkChange_NetworkAvailabilityChanged(object sender, NetworkAvailabilityEventArgs e)
	{
		Debug.Print("Network availability: " + e.IsAvailable.ToString());
	}
}
```

## FEZ Cerbuino Bee and FEZ Cerbuino Net SD Card Detect
To detect whether or not an SD card is inserted in the onboard connector, you can sample pin PC2 with the pull-up resistor enabled. You can also use an interrupt to signal when the insertion state changes. Once you detect the presence of a card, you can create and mount the SDCard object.

## Known Issues
Socket 5 and 6 on the FEZ Cerberus are both marked as S and P (among others) and use the same SPI bus. The 3 main SPI pins and the 3 PWM pins both use the physical pins 7, 8, and 9 on a socket. As a result, when you use SPI or PWM on those sockets, neither SPI nor PWM will function on the other socket.

repository: bauland/Docs

repo_name: bauland/Docs


text:
# NetNeurons

This project includes several implementations of artificial neural networks.
This library being very lightweight, the source files should be directly included
in any project that uses them. The Makefile only exists to generate the documentation.

## ESN - Echo State Network

### Presentation

Echo State Networks are a type of recurrent neural network.
This library enables a basic usage of this type of networks.

However, it is **still at a development stage**.

## MLP - MultiLayered Perceptron

### Presentation

This part of the library contains two interfaces for creating multilayered perceptrons:

1. The Perceptron class, which is designed to be efficient and may be used with multiple threads.

2. The Neuron class and its BrainInterface, less efficient but more flexible.
Its main advantage is that you can connect neurons as you wish inside the brain -
as long as you do not create a loop. This functionality is an improvement that
many major libraries do not propose.

### Warning

Even though it does work, this implementation uses only Super-SAB as a learning algorithm,
and does not prevent being stuck in a potential well.

It does therefore **not give good results for the learning phase**.
You should use another implementation such as the FANN (Fast Artificial Neural Network) library,
which is well-known, documented, simple, and will have a more accurate learning,
even though you will probably still encounter those potential well problems.

license: ISC


text:
# GTD Templates for Remarkable
Contains templates for GTD writting in tex and utilities for generating svg/png files and uploads templates to remarkable.

DISCLAIMER: Usage of this software is at your own risk and you are responsible for loss of files other damages. Make sure to backup your Remarkable (and the templates) before using this software.

## Examples

|  |  |  |
| --- | --- | --- |
| ![Inbox](examples/inbox.png) | ![Day Planner](examples/day_planner.png) | ![Next Action](examples/next_action.png)
| ![Project Overview](examples/project_overview.png) | ![Project](examples/project.png) | ![Project Actions](examples/project_actions.png) |

## Installation
The code has been tested using the following setup:

- Ubuntu 18.04
- Python 3.8.0
- pdflatex

Besides from running the code natively on your computer, this project also comes with a slim `Dockerfile` which allows you to create and upload the reMarkable templates on any operating system which [has docker installed](https://docs.docker.com/get-docker/). See usage below.

### LaTeX
A LaTeX compiler for generating the pdf containing the templates. Sevaral LaTeX packages are required, which can be found in the `gtd.tex` file.

### Converting
For converting the pdf to separate png and svg files three linux command line tools are used:
- `pdfseparate` (standard available on Ubuntu)
- `pdf2svg` (standard available on Ubuntu)
- `rsvg-convert` (can be installed using `sudo apt-get install librsvg2-bin`)

### Uploading
The files can be uploaded automatically to the Remarkable over SSH. The python script has two requirements which can be installed by running `python -m pip install -r requirements.txt`.

## Usage
The tex filename and template names have to specified in the  `names.txt` file. The first line is the name of the tex file (e.g., `gtd`), each following line specifies a template name. This means the number of lines in the `names.txt` file has to equal to the number of pages + 1 of the pdf file.

The generated pdf can be converted using the `convert.py` script. The png/svg files and a templates.json file will be placed in the files directory. The templates can automatically be uploaded using the `upload.py` script or can be manually copied onto your remarkable.

Commands:
- `make pdf` generates pdf using `pdflatex`.
- `make convert` converts pdf to png and svg using (`pdfseparate`, `pdf2svg` and `rsvg-convert`).
- `make upload` uploads templates to remarkable and updates the `templates.json` file.
- `make clean` deletes latex build files and files directory.
- `make` runs `pdf`, `convert` and `upload` in sequence.

### Using Docker

You can also use `docker` to run all above commands without having the required dependencies installed on your computer.

Commands:
- `docker build -t gtd .` creates the docker image
- `docker run --network host -it gtd` executes the `make` command as documented above
- `docker run --network host -it gtd make pdf` to run a specific make command

## Notes
### Page Sizes
`pdf2svg` uses a dpi of 90.0

- Width: 1404 pixels = 15.6in
- Height: 1872 pixels = 20.8in
- Left: 120 pixels = 1.33in
- Top: 20 pixels = 0.22in
- Right: 20 pixels = 0.22in
- Bottom: 20 pixels = 0.22in


text:
![Try it now in CWS](https://raw.github.com/GoogleChrome/chrome-app-samples/master/tryitnowbutton.png "Click here to install this sample from the Chrome Web Store")

# Push Sample App

Sample that shows how to use the [Push Messaging
API](http://developer.chrome.com/apps/pushMessaging.html) in an app.

How to install on your local machine:

You can either install this from the Chrome Web Store at https://chrome.google.com/webstore/detail/push-messaging-sample-cli/bafimiidcfafikaonocgmmcpbbhfjjik
or put this into a directory on your machine, and go to chrome://extensions,
click on the "Load unpacked extension..." button, and choose the directory where
you downloaded this sample.

That will install the sample app, you can launch it from the new tab page.
Choose the apps view at the bottom if it is not already selected, and click on
the Push Messaging Sample app.  It will launch an app which registers for and
receives push messages.  Now you can use this to test recieving messages from
the push messaging server you write.  You can also test it with a curl script
which sends push messages.

Most of the relevant code for this sample is in background.js.  We've commented
it heavily, to explain what is going on and what you need to do to write your
client code.

Here is a sample curl script to send a push message - you will need to replace
the Access token with the one you get by following the
[instructions](https://developer.chrome.com/apps/cloudMessagingV1#checklist),
and replace the channel ID with the channelID shown in the UI once you launch
the sample app.

    curl https://accounts.google.com/o/oauth2/token \
    -H "Authorization: Bearer <insert accessToken>" \
    -H "Content-Type: application/json" \
    -d "{'channelId': '<insert channelId>', 'subchannelId': '0', 'payload': 'Hello'}"

## APIs

* [Push Messaging API](http://developer.chrome.com/apps/pushMessaging.html)
* [Google Cloud Messaging for Chrome V1](https://developer.chrome.com/apps/cloudMessagingV1)

## Screenshot
![screenshot](/samples/push-sample-app/assets/screenshot_1280_800.png)


text:
# About

QA is the node.js application, which allow user implementing Q&A functionality into their website.
Application is Node.js based using MongoDB as the data store.

## Prerequisites:

- Node.js and npm installed
- an existing Node.js app (QA app)
- a free Heroku account ([sing-up for Heroku account](https://signup.heroku.com/))
- the Heroku CL ([download Heroku CLI](https://devcenter.heroku.com/categories/command-line))
- git installd on the local machine

## Pre-installation:
Before deploying application to the private or public server, its necessary to provide the information necessary for the deployment.

- your database address, hash and limit result (pagination) should be set in .env file
- when pushing application to Heroku remove node_modules, Heroku will install all necessary modules on your package.JSON file

## Installation (on Heroku):
Installation can be done on any public or private server. Bellow given a guidance for Heroku deployment, which is the free-to-use deployment.
Additional info can be found directly at [Heroku website](https://devcenter.heroku.com/articles/deploying-nodejs).

1. Declare dependencies.
```bash
cd your-directory
npm init
```
2. Declare node version in package.json file. Whitht it, Heroku wouldn't know which version is supporting your application.
```bash
"engines": {
    "node": "10.x"
  },
```
3. Initiate the git project. Remember to do it in your project folder.
```bash
git init
```
4. Deploy your application to Heroku. Heroku will ask you to pass the login criteria.
```
git add .
git commit -m "Added a Procfile."
heroku login
heroku create
git push heroku master
```

## Usage

You app can be accessed for the public address provided by Heroku during implementation.

## Contributing
Application may be subject to any changes.

## License
[Unlicense](https://choosealicense.com/licenses/unlicense/)

license: Unlicense

repository: jotkapc/QA

repo_name: jotkapc/QA


text:
chip8-win-console
=================

For science!

![Screenshot of the implementation playing PONG](screenshot.png)

Running
-------

1. Build the source
2. Run the program
3. Type in a path to a CHIP-8 game (relative to the exe)
4. Press Enter to play!

(This project relies on P/Invoke to interact with the native Windows API, and
thus only Windows Desktop platforms are supported at the moment)

Keyboard Input
--------------

A CHIP-8 / COSMAC-VIP keyboard is made up of 16 keys and is laid out like this:

    1 2 3 C
    4 5 6 D
    7 8 9 E
    A 0 B F

These are mapped to the following keys on a typical QWERTY keyboard:

    1 2 3 4
    Q W E R
    A S D F
    Z X C V

If you have a non-QWERTY keyboard that has the same mechanical layout, the keys
should map across to your setup equally well. For example, the keys for a
Russian ЙЦУКЕН keyboard *should* be mapped like so:

    1 2 3 4
    Й Ц У К
    Ф Ы В А
    Я Ч С М

TODOs / Up For Grabs
--------------------

* Implement a less flickery method of drawing to the console
  - Collision detection is done by inverting pixels on the screen, and it's
    quite evident...
* Less abrupt audio cut off
  - Sound is implemented by looping a dynamically-generated WAV file until a
    timer hits 0
  - Stopping the sound sometimes results in a little pop noise that's caused by
    the waveform dropping to 0 very suddenly, instead of smoothing out
* Configurable keyboard layout
* Get rid of some magic numbers / constants
* Support exiting / changing / resetting programs


text:
# Alfonso Tool Suite

The accompanying tool suite for rapidly creating Moka Modules. Alfonso is a
command line environment that automates many of the tasks that are otherwise
incredibly tedious. It also includes the Moka Module Manager and Colada
documentation generator.

## Installing

Currently Alfonso is installed via NPM, although a standalone executable is in
the works.

```
npm install -g alfonso
```

## Usage

Use the `alf` command in a terminal or command prompt to enter the Alfonso prelude.
This mode provides access to general commands that can get information about
or create new modules, but will not interact much with files outside of generating
new ones. It also provides access to other modes of the environment.

Any prelude commands can be executed without entering the Alfonso environment
by using the `alf [command] [options] [arguments]` variant command. This allows
users to create a new module in the current directory by simply typing `alf new`
instead of having to do this through the full environment.

### Basic File System Commands

These commands are available in all modes that do not deal directly with a single
file.

* `pwd` - Display the present directory
* `cd [path]` - Change the present directory
* `ls [-a]` - List files and folders in present directory. `-a` flag displays
hidden files and folders as well
* `list [lex|parse|interp]` - List Module files of the given types in the current
module. Multiple types can be specified, and if none are specified then all are assumed.

### Prelude Commands

* `new [-f]` - Enter the new module wizard. `-f` flag forces wizard if present
directory is not empty

repository: AffogatoLang/Alfonso

repo_name: AffogatoLang/Alfonso


text:
# S.js

S.js is a small library for performing **simple, clean, fast reactive programming** in Javascript.  It aims for a simple mental model, a clean and expressive syntax, and fast execution.

In plain terms, S helps you **keep things up-to-date** in your program.  S programs work like a spreadsheet: when data changes, S automatically updates downstream computations.

Here's a tiny example:
```javascript
var a = S.data(1),                   //       a() |   1     3     3     5
    b = S.data(2),                   //       b() |   2     2     4     6
    c = S(() => a() + b()),          //       c() |   3     5     7    11
    d = S(() => c() * a()); // t0    //       d() |   3    15    21    55
a(3);                       // t1    //           +------------------------>
b(4);                       // t2    //              t0    t1    t2    t3
S.freeze(() => {                     //
    a(5);                            //
    b(6);                            //
});                         // t3    //
```
The timeline on the right shows how the values evolve at each instant.  Initially (time t0), `c()` and `d()` are 3, but when `a()` changes to 3 (t1), they become 5 and 15.  Ditto for t2 and t3.  Every time `a()` or `b()` changes, S re-evaluates `c()` and `d()` to make sure they stay consistent.

To achieve this behavior, static data and computations must be converted to *signals*, which is a reactive term for a value that changes over time.  S data signals are constructed by `S.data(<value>)` and computations by `S(() => <code>)`.  Both return closures: call a signal to read its current value; pass a data signal a new value to change it.

When an S computation runs, S records what signals it references, thereby creating a live dependency graph of running code.  When data changes, S uses that graph to figure out what needs to be updated and in what order.

S has a small API.  The example above shows `S.freeze()`, which aggregates multiple changes into a single step (t3).  The full API is listed below.

## S Features

S maintains a few useful behaviors while it runs.  These features are designed to make it easier to reason about reactive programming:

> **Automatic Dependencies** - No manual (un)subscription to change events.  Dependencies in S are automatic and exact.
>
> **Guaranteed Currency** - No need to worry about how change propagates through the system.  S insures that signals always return current and updated values.
>
> **Exact Updates** - No missed or redundant updates.  Computations run exactly once per upstream change event.
>
> **A Unified Global Timeline** - No confusing nested or overlapping mutations from different sections of code. S apps advance through a series of discrete "instants" during which state is immutable.
>
> **Self-Extensible** - Computations can extend the system by creating new "child" computations.
>
> **Automatic Disposals** - No manual disposal of stale computations.  "Child" computations are disposed automatically when their "parent" updates.

For advanced cases, S provides capabilities for dealing with self-mutating code:

> **Multi-Step Updates** - Computations can set data signals during their execution.  These changes don't take effect until the current "instant" finishes, resulting in a multi-step update.
>
> **Partitionable Time** - Multi-step updates can run on a 'subclock,' meaning that surrounding code will only respond to final, at-rest values, not intermediate ones.

## An Example: TodoMVC in S (plus friends)
What else, right?  S is just a core library for dealing with change; it takes more to build an application.  This example uses Surplus.js, aka "S plus" a few companion libraries.  Most notably, it uses Surplus' JSX preprocessor for embedded DOM construction.
```jsx
var Todo = t => ({               // our Todo constructor
       title: S.data(t.title),   // properties are data signals
       done: S.data(t.done)
    }),
    todos = SArray([]),          // our array of todos
    newTitle = S.data(""),       // title for new todos
    addTodo = () => {            // push new title onto list
       todos.push(Todo({ title: newTitle(), done: false }));
       newTitle("");             // clear new title
    },
    view = S.root(() =>          // declarative main view
       <div>
          <h2>Minimalist ToDos in Surplus</h2>
          <input type="text" fn={data(newTitle)}/>
          <a onClick={addTodo}> + </a>
          {todos.map(todo =>     // insert todo views
             <div>
                <input type="checkbox" fn={data(todo.done)}/>
                <input type="text" fn={data(todo.title)}/>
                <a onClick={() => todos.remove(todo)}>×</a>
             </div>)}
       </div>);

document.body.appendChild(view); // add view to document
```
Run on [CodePen](https://codepen.io/adamhaile/pen/ppvdGa?editors=0010).

Some things to note:

- There's no code to handle updating the application.  Other than a liberal sprinkling of `()'s`, this could be static code.  In the lingo, S enables declarative programming, where we focus on defining how things should be and S handles updating the app from one state to the next as our data changes.

- The Surplus library leverages S computations to construct the dynamic parts of the view (the '{ ... }' expressions).  Whenever our data changes, S updates the affected parts of the DOM automatically.

- S handles updates in as efficient a manner as possible: Surplus apps generally place at or near the top of the various web framework benchmarks (ToDoMVC, dbmonster, js-framework-benchmark, etc).

Reactive programs also have the benefit of an open structure that enables extensibility.  For instance, we can add localStorage persistence with no changes to the code above and only a handful of new lines:

```javascript
if (localStorage.todos) // load stored todos on start
    todos(JSON.parse(localStorage.todos).map(Todo));
S(() =>                 // store todos whenever they change
    localStorage.todos = JSON.stringify(todos().map(t =>
        ({ title: t.title(), done: t.done() })));
```

## API

### Constructors

### `S.root(dispose => <code>)`
Computations created by `<code>` live until `dispose` is called.  S will log an error if you try to construct a computation that is not under a root or parent computation.

### `S.data(<value>)`
Construct a data signal whose initial value is `<value>`.

### `S(() => <code>)`
Construct a computation whose value is the result of the given `<code>`.

### `S(val => <code>, <seed>)`
Construct a reducing computation, whose new value is derived from the last one, staring with `<seed>`.

### `S.on(<signal>, val => <code>, <seed>, <onchanges>)`
Statically declare a computation's dependencies, rather than relying on S's automatic dependency detection.

`<seed>` is optional, with default `undefined`.

`<onchanges>` is optional and defaults to `false`.  If `<onchanges>` is true, then the initial run is skipped (i.e. computation starts with value `<seed>` and doesn't run `<code>` until a change occurs).

`<signal>` may be an array, in which case dependencies are created for each signal in the array.

### Behavior

### `S.freeze(() => <code>)`
Run `<code>`, but hold any data changes it produces in a pending state until it completes, at which point they all run as a single update.  If called within a computation, the system is already frozen, so `freeze` is inert.  Returns value of `<code>`.

### `S.sample(<signal>)`
Sample the current value of `<signal>` but don't create a dependency on it.

### `S.cleanup(final => <code>)`
Run the given function just before the enclosing computation updates or is disposed.  The function receives a boolean parameter indicating whether this is the "final" cleanup, with `true` meaning the computation is being disposed, `false` it is being updated.

S.cleanup() is used to free external resources which a computation may have claimed, like DOM event subscriptions.  Computations can register as many cleanup handlers as needed, usually adjacent to where the resources are claimed.

### `S.subclock(() => <code>)`
Run computations and data signals created by `<code>` on a subclock, meaning that they don't just run but run *to completion* before surrounding code reads them.

© 2017 Adam Haile<EMAIL_ADDRESS> MIT License.

repository: cbforks/S

repo_name: cbforks/S


text:
Demonstration of "Collusion Resistant Broadcast Encryption With
Short Ciphertexts and Private Keys" [BGW05](https://eprint.iacr.org/2005/018.pdf)

# install
this code depends on [mcl-wasm](https://github.com/herumi/mcl-wasm) and other modules. Install them with:
```
npm i
```

# test
```
node src/bgw.js
```
Demonstrate the special case:
* setup a system of `n` users, run time and public key size linear with `n` (64 bytes, 2.4 ms per user.)
* create a random set `S` of users that will be allowed to decrypt.
* create a random encryption key `K` and encrypt it. Run time linear with `|S|` (12usec per user)
* select `ntrial` random users and check that only users in `S` can decrypt and retrieve `K`. Run time linear with `|S|` (4usec per user)

The general construction is achieved by splitting the users into shards of size `n` and splitting `S` accordingly. You can use the same public key in each shard except for a different `gamma`in each shard. So now all sizes are proportional to the shard size.


text:
# auto-correction

### About

This is the code repository for the article at https://medium.com/@ehioroboevans/building-a-simple-auto-correction-tool-97d77d458742.

This tool allows for auto-correction of spelling errors and was built with HTML, CSS and JavaScript. See more about it in the Medium article above.

### Usage

- Clone or download this repository.
- Open the main.html file inside the auto-correction folder in your browser.

Alternatively, you can just extract the JavaScript code and use it in a larger project.

The functions provided are:

- *getBigram(word)*: returns the bigram of the word. Read about bigrams here: https://en.wikipedia.org/wiki/Bigram.

- *getSimilarity(word1, word2)*: calculates the similarity of the bigrams of the two words.

- *autoCorrect(word, knownWords, similarityThreshold)*: given an array of known or expected words, this function finds the most similar word in the array to the word passed in and, if the similarity is higher than the given threshold (a decimal value between 0 and 1), returns the matched word.

repository: eshiofune/auto-correction

repo_name: eshiofune/auto-correction


text:
### This Repository is NOT a supported MongoDB product

Note: Code samples in this repository are entirely for development & evaluation only. Note that all examples that use local key files are intended only for illustration - for production purposes, the integrated Key Management Service (KMS) option is strongly recommended.

## Information

This Docker file uses by default the 3.6.2 version of [MongoDB NodeJS driver](https://docs.mongodb.com/drivers/node/)
See [MongoDB NodeJS driver QuickStart](https://docs.mongodb.com/drivers/node/quick-start) for more examples.
Alternatively, you can select a specific MongoDB NodeJS driver version by leveraging the `--build-arg` option when building the image.

Note that the given code example has been tested against the default MongoDB Node driver version. There is no guarantee that the code sample with work for all possible versions of the driver.

## Build Steps

1. Build Docker image with a tag name. Within this directory execute:
   * For using the latest driver version:
     ```
     docker build . -t mdb-csfle-example
     ```
   This will build a Docker image with a tag name `mdb-csfle-example`.

2. Run the Docker image by executing:
   ```
   docker run -tih csfle mdb-csfle-example
   ```
   The command above will run a Docker image with tag `mdb-csfle-example` and provide it with `csfle` as its hostname.

## Execution Steps

Once you're inside the Docker container, you could follow below steps to run the NodeJS code example.

1. `export MONGODB_URL="mongodb+srv://USER:PWD@EXAMPLE.mongodb.net/dbname?retryWrites=true&w=majority"`
2. `node ./example.js`

If you're connecting to MongoDB Atlas please make sure to [Configure Whitelist Entries](https://docs.atlas.mongodb.com/security-whitelist/)


text:
---
comments: true
date: 2012-09-20 07:28:08
layout: post
slug: whitespace-issues-in-cfscript-based-functions
title: Whitespace issues in cfscript based functions
wordpress_id: 1179
categories:
- ColdFusion
---

Ok now we all know that ColdFusion is kind of lame when it comes to whitespace management, unless you specifically have "whitespace management" turned on for your server.

I have a function that is used to build the _href_ value of a hyperlink. Nothing special there. However when I viewed the source of the page I was a little surprised to see a mountain of whitespace coming back from the function.

All I do is return a string from the function, I don't output any text from within the function.

Here it is:

``` javascript
public string function getFullPageURI(required string pagename)
{
  var pages = new lib.services.pages();
  var page = pages.getPageByNavURL(arguments.pagename, getId());
  return page.getPageURI();
}
```

And the link source:

![](/images/uploads/2012/09/Screen-shot-2012-09-20-at-5.24.32-PM.png)

Hmm, could that suck any more? Now what happens if I add output="false" (not particularly intuitive) to the end of the function, like this:

``` javascript
public string function getFullPageURI(required string pagename) output="false"
{
  var pages = new lib.services.pages();
  var page = pages.getPageByNavURL(arguments.pagename, getId());
  return page.getPageURI();
}
```

Now I get:

![](/images/uploads/2012/09/Screen-shot-2012-09-20-at-5.25.54-PM.png)

Sorry but that's just insane. cfscript should behave like cfsilent all the time unless you specify a writeOutput();

Hope this helps any other people out there. The lesson learned is that you can specify output="false" in a cfscript based function, but ONLY AFTER THE METHOD SIGNATAURE!

So if you did this:

``` javascript
public string output="false" function getFullPageURI(required string pagename)
```

If would fail. It needs to occur after the parens.

extension: markdown


text:
# JavaScript Bundling for Rails

Use [esbuild](https://esbuild.github.io), [rollup.js](https://rollupjs.org), or [Webpack](https://webpack.js.org) to bundle your JavaScript, then deliver it via the asset pipeline in Rails. This gem provides installers to get you going with the bundler of your choice in a new Rails application, and a convention to use `app/assets/builds` to hold your bundled output as artifacts that are not checked into source control (the installer adds this directory to `.gitignore` by default).

You develop using this approach by running the bundler in watch mode in a terminal with `yarn build --watch` (and your Rails server in another, if you're not using something like [puma-dev](https://github.com/puma/puma-dev)). You can also use `./bin/dev`, which will start both the Rails server and the JS build watcher (along with a CSS build watcher, if you're also using `cssbundling-rails`).

Whenever the bundler detects changes to any of the JavaScript files in your project, it'll bundle `app/javascript/application.js` into `app/assets/builds/application.js` (and all other entry points configured). You can refer to the build output in your layout using the standard asset pipeline approach with `<%= javascript_include_tag "application", defer: true %>`.

When you deploy your application to production, the `javascript:build` task attaches to the `assets:precompile` task to ensure that all your package dependencies from `package.json` have been installed via yarn, and then runs `yarn build` to process all the entry points, as it would in development. The latter files are then picked up by the asset pipeline, digested, and copied into public/assets, as any other asset pipeline file.

This also happens in testing where the bundler attaches to the `test:prepare` task to ensure the JavaScript has been bundled before testing commences. (Note that this currently only applies to rails `test:*` tasks (like `test:all` or `test:controllers`), not "rails test", as that doesn't load `test:prepare`).

If your testing library of choice does not define a `test:prepare` Rake task, ensure that your test suite runs `javascript:build` to bundle JavaScript before testing commences.

That's it!

You can configure your bundler options in the `build` script in `package.json` or via the installer-generated `rollup.config.js` for rollup.js or `webpack.config.json` for Webpack (esbuild does not have a default configuration format, and we don't intend to use esbuild as an API in order to hack around it).

If you're already using [`webpacker`](https://github.com/rails/webpacker) and you're wondering if you should migrate to `jsbundling-rails`, have a look at [the high-level comparison](./docs/comparison_with_webpacker.md). If you're looking to migrate from webpacker, see the [migration guide](https://github.com/rails/jsbundling-rails/blob/main/docs/switch_from_webpacker.md).

If you want to use webpack features like [code splitting](https://webpack.js.org/guides/code-splitting/) and [hot module reloading](https://webpack.js.org/concepts/hot-module-replacement/), consider using the official fork of `webpacker`, [`shakapacker`](https://github.com/shakacode/shakapacker).

## Installation

You must already have node and yarn installed on your system. You will also need npx version 7.1.0 or later. Then:

1. Run `./bin/bundle add jsbundling-rails`
2. Run `./bin/rails javascript:install:[esbuild|rollup|webpack]`

Or, in Rails 7+, you can preconfigure your new application to use a specific bundler with `rails new myapp -j [esbuild|rollup|webpack]`.

## FAQ

### Is there a work-around for lack of glob syntax on Windows?

The default build script for esbuild relies on the `app/javascript/*.*` glob pattern to compile multiple entrypoints automatically. This glob pattern is not available by default on Windows, so you need to change the build script in `package.json` to manually list the entrypoints you wish to compile.

### Why does esbuild overwrite my application.css?

If you [import CSS](https://esbuild.github.io/content-types/#css-from-js) in your application.js while using esbuild, you'll be creating both an `app/assets/builds/application.js` _and_ `app/assets/builds/application.css` file when bundling. The latter can conflict with the `app/assets/builds/application.css` produced by [cssbundling-rails](https://github.com/rails/cssbundling-rails). The solution is to either change the output file for esbuild (and the references for that) or for cssbundling. Both are specified in `package.json`.

### How can I reference static assets in JavaScript code?

Suppose you have an image `app/javascript/images/example.png` that you need to reference in frontend code built with esbuild.

1. Create the image at `app/javascript/images/example.png`.
1. In `package.json`, under `"scripts"` and `"build"`, add the option `--loader:.png=file` to the esbuild script, which instructs esbuild to copy png files to the build directory.
1. When esbuild runs, it will copy the png file to something like `app/assets/builds/example-5SRKKTLZ.png`.
1. In frontend code, the image is available for import by its original name: `import Example from "../images/example.png"`.
1. The image itself can now be referenced by its imported name, e.g. in React, `<img src={Example} />`.
1. The path of the image resolves to `/assets/example-5SRKKTLZ.png`, which is served by the asset pipeline.

## License

JavaScript Bundling for Rails is released under the [MIT License](https://opensource.org/licenses/MIT).

repository: Konradzet/flutterpl

repo_name: Konradzet/flutterpl


text:
---
id: 554d3c62-29da-4c86-9d16-f910e36ad7b1
title: Dendron Agent
desc: ''
updated:<PHONE_NUMBER>305
created:<PHONE_NUMBER>560
---

## Summary

The API server is a local express server that runs on the users machine. It can be initialized by the [[Dendron CLI|pkg.dendron-cli]] or the [[Dendron Plugin|pkg.plugin-core]].

It is a wrapper around the [[Dendron Engine|pkg.dendron-engine]].

It is located at `$ROOT/packages/api-server``

It is also called the Dendron Agent.

repository: bdefore/dendron-site

repo_name: bdefore/dendron-site


text:
Fibtastic

Simple and easy to use tools to work with the Fibonacci sequence.

  [![NPM version](https://img.shields.io/npm/v/fibtastic.svg?style=flat)](https://www.npmjs.com/package/fibtastic)
  [![Known Vulnerabilities](https://snyk.io/test/github/robertcorponoi/fibtastic/badge.svg)](https://snyk.io/test/github/robertcorponoi/fibtastic)
  ![npm](https://img.shields.io/npm/dt/fibtastic)
  [![NPM downloads](https://img.shields.io/npm/dm/fibtastic.svg?style=flat)](https://www.npmjs.com/package/fibtastic)

  [![Gitter](https://badges.gitter.im/gitterHQ/gitter.svg)](https://gitter.im/robertcorponoi)

## **Installation**

To install this module through npm, simply use the following command:

```
$ npm install --save fibtastic
```

and then require it in your project like so:

```js
// Node
const fibtastic = require('fibtastic');

// Webpack
import * as fibtastic from 'fibtastic';

// Browser
import * as fibtastic from '/path/to/fibtastic.js';
```

## **Basic Example**

Using fibtastic is short and simple. Calculating the fibonacci sequence from the 10th to the 15th number is shown below:

```js
const fibonacci = require("fibtastic");

const sequence = fibonacci.sequence(10, 15);

console.log(sequence);
// => [55, 89, 144, 233, 377, 610]
```

## **API**

There are currently three methods that make up fibtastic with the above sequence included.

### **sequence**

Sequence takes an object with an optional start time and a required end time and returns the fibonacci sequence from the specified start point to the end point with the start and end points included.

| Type   | Option | Description | Default |
| ------ | ------ | ----------- | ------- |
| number | start  | Location in the fibonacci sequence to start | 0
| number | end    | Location in the fibonacci sequence to stop  | none (required)

Example:

```js
const sequence = fibonacci.sequence(10, 15);

console.log(sequence);
// => [55, 89, 144, 233, 377, 610]
// => [55, 89, 144, 233, 377, 610]
```

---

### **value**

Value is used to find the fibonacci number at a specific point in the sequence.

| Type   | Option    | Description | Default |
| ------ | --------- | ----------- | ------- |
| number | location  | The location in the fibonacci sequence to retrieve the value from | none (required)

Example:

```js
const value = fibonacci.value(20);

console.log(value);
// => 6765
```

---

### **isValue**

IsValue takes a value and check to see if that value is a part of the fibonacci sequence. If it is, it returns the location in the sequence where the value is and if it is not part of the fibonacci sequence it returns false.

_**Note:**_ If the value is less than 2 but greater than 0, `isValue` will just return true because the value 1 occurs in two locations in the fibonacci sequence and it is not possible to deduce which location is desired.

| Type   | Option | Description | Default |
| ------ | ------ | ----------- | ------- |
| number | value  | The value to use to search the fibonacci sequence and find the location | none (required)

Examples:

```js
const isValue = fibonacci.isValue(6765);

console.log(isValue);
// => 20
```

```js
const isValue = fibonacci.isValue(6770);

console.log(isvalue);
// => false
```

```js
const isValue = fibonacci.isValue(1);

console.log(isValue);
// => true
```

## **Running Tests**

To run the tests, use:

```
npm run test
```

## **License**

MIT

repository: robertcorponoi/fibtastic

repo_name: robertcorponoi/fibtastic


text:
---
layout: default
---

# 1996-09-02 - Re: It is good that anon.penet.fi has been closed!

## Header Data

From: Damaged Justice<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: cebd237e2330e0f6e80666a5de511248b9f6c4a6bc79fc575b925e7168b7eb16

Message ID<EMAIL_ADDRESS>Reply To: \<Pine.LNX.3.95.960901161500.520A-100000@gak\>

UTC Datetime: 1996-09-02 05:36:10 UTC

Raw Date: Mon, 2 Sep 1996 13:36:10 +0800

## Raw message

```
{% raw  %}From: Damaged Justice<EMAIL_ADDRESS>Date: Mon, 2 Sep 1996 13:36:10 +0800
To<EMAIL_ADDRESS>Subject: Re: It is good that anon.penet.fi has been closed!
In-Reply-To: <Pine.LNX.3.95.960901161500.520A-100000@gak>
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text

> headers.  Many people just don't want to deal with cpunk remailers.  OTOH, I
> agree that this might actually force many people with Penet addresses to learn
> about more secure remailers.  In this way, the closing of anon.penet.fi could
> be looked upon as a Good Thing.  However, as long as there is no easy way for
> Windoze and Mac users to use secure remailers, users will sooner resort to
> fake-mailing then learning how to use cpunk remailers.  People that need a
> pseudonym address to use on various support groups can get them from other,
> equally insecure, remailers.

I've put up a list of remailer front ends, sorted by platform, at

http://yakko.cs.wmich.edu/~frogfarm/free/crypt.html#private

I welcome all additions. Right now, I have links to Private Idaho (Windows),
Yet Another NewsWatcher (Mac), and PGPMR/2 for OS/2 (requires MailReader/2).

Nym servers and cpunk remailers are poised to take off, if those who wish to
use them are capable of learning. The rest of us can either try to teach 'em
in a non-condescending manner, or continue to work on front end utilities.

--
http://yakko.cs.wmich.edu/~frogfarm ...for the best in unapproved information
"We think people like seeing somebody in a uniform on the porch."  -US Postal
spokeswoman, quoted in AP 1/27/96. I don't know about you, but the only folks
I know who'd enjoy seeing someone in uniform on their porch are leathermen...

{% endraw %}
```

## Thread

+ Return to [September 1996](/archive/1996/09)

+ Return to "[Damaged Justice <frogfarm@yakko.cs.wmich.edu>](/authors/damaged_justice_frogfarm_at_yakko_cs_wmich_edu_)"
+ Return to<EMAIL_ADDRESS>(Igor Chudov @ home)](/authors/ichudov_at_algebra_com_igor_chudov__at__home_)"
+ Return to "["Mark M." <markm@voicenet.com>](/authors/mark_m__markm_at_voicenet_com_)"
+ Return to<EMAIL_ADDRESS>(Dave Harman OBC)](/authors/qut_at_netcom_com_dave_harman_obc_)"

+ 1996-09-01 (Mon, 2 Sep 1996 03:22:56 +0800) - [It is good that anon.penet.fi has been closed!](/archive/1996/09/df3216fdc2663e24eb3faae58991e04c7d798ad3cac9fd22ef4c4032f423b187) -<EMAIL_ADDRESS>(Igor Chudov @ home)_
  + 1996-09-01 (Mon, 2 Sep 1996 06:26:49 +0800) - [Re: It is good that anon.penet.fi has been closed!](/archive/1996/09/0216905bea612afe1b62ae8d0d31eb4dcb4115ff58195d35d92cc698a5378825) - _"Mark M."<EMAIL_ADDRESS>    + 1996-09-02 (Mon, 2 Sep 1996 08:11:15 +0800) - [Re: It is good that anon.penet.fi has been closed!](/archive/1996/09/24c642758d3d7c6aad74d4ffcc91bea89e9256c4bd222aca68cc6f3e87ac7dbf) -<EMAIL_ADDRESS>(Igor Chudov @ home)_
      + 1996-09-02 (Mon, 2 Sep 1996 13:32:32 +0800) - [Re: It is good that anon.penet.fi has been closed!](/archive/1996/09/44c38f053f1f36ce96e0f2e4fc2c4c812cc9aeb69df8119c13c99cef97edbfe1) - _"Mark M."<EMAIL_ADDRESS>    + 1996-09-02 (Mon, 2 Sep 1996 13:36:10 +0800) - Re: It is good that anon.penet.fi has been closed! - _Damaged Justice<EMAIL_ADDRESS>  + 1996-09-01 (Mon, 2 Sep 1996 07:42:13 +0800) - [Re: It is good that anon.penet.fi has been closed!](/archive/1996/09/570cafb61db49eec6e069c71fcf9abcfd634b615a1331d9ea2ff3ad2ef0f995b) -<EMAIL_ADDRESS>(Dave Harman OBC)_


text:
Skeleton Cookbook
=================

This is a testable skeleton cookbook designed for you or your organization to
fork and modify appropriately. The cookbook comes with everything you need to
develop infrastructure code with Chef and feel confident about it. See file
`TESTING.md` to learn more.

(While you're encouraged to customize everything in this cookbook to fit your
needs, I recommend keeping the `TESTING.md` file as-is.)

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

### Platform:

*List supported platforms here*

### Cookbooks:

*List cookbook dependencies here*

Attributes
----------

*List attributes here*

Recipes
-------

### skeleton::default

*Explain what the recipe does here*

Testing
-------

Everything you need to know about testing this cookbook is explained in
`TESTING.md`.

[![Build Status](https://travis-ci.org/mlafeldt/skeleton-cookbook.png?branch=master)](https://travis-ci.org/mlafeldt/skeleton-cookbook)

License and Author
------------------

Author:: Mathias Lafeldt<EMAIL_ADDRESS>
Copyright:: 2013, Mathias Lafeldt

Licensed 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.

Contributing
------------

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

repository: jjasghar/skeleton-cookbook

repo_name: jjasghar/skeleton-cookbook


text:
# SwiftGame

A framework for creating cross-platform games written in Swift.
Inspired by MonoGame/XNA it will initially be structured very similarly, but is expected to diverge and become more idiomatic Swift as it progresses.

## Supported Platforms

Initial support is for Apple platforms, with support for Linux and Windows to be added after the initial implementation is functional.

* Desktop Operating Systems
  * Mac OS X
* Mobile Devices
  * iPhone/iPad
* Other
  * tvOS

repository: SwiftGameLib/SwiftGame

gha_language: Swift

repo_name: SwiftGameLib/SwiftGame


text:
# Cloud App Labs at OpenStack Summit Barcelona 2016

![Cloud App Labs at the OpenStack Summit in Barcelona Spain](https://pbs.twimg.com/media/CuN700EWEAAo4xK.jpg:large)

Welcome to the OpenStack Summit.  The following 'Cloud App Labs' are part of the 'OpenStack Academy' and will be located in the Summit Marketplace (aka Expo Hall). This repository contains a series of 'Cloud App Labs' to help you get self-started with becoming a _cloud application engineer_ - the future of apps development.

TL;DR = Learn the skills to become a 'Cloud Application Engineer' - ask Q's anytime by sending a tweet which includes [#CloudApp](https://twitter.com/hashtag/cloudapp) + your question which one of our [Cloud App Pros](https://docs.google.com/presentation/d/1RBtAOjxmUh97fXrJlowvqVNmq2-8FxvBIHx2Dts1Jh8/pub?start=true&loop=true&delayms=2000) will answer.

Overall Learning Objectives (_by completing these labs you will know how to..._)
 - [x] ...work as part of the growing cloud app community, to understand the significance of working as part of a multi-factor cloud application team (NetEng, SysAdmin, DevOpps, AppDev, UX, etc).
 - [x] ...be inspired to build cloud apps which are 'cross-cloud' (hybrid apps which can work across multiple datacenters worldwide).
 - [x] ...make cloud apps which are simple at the start: constrain their state so they can be further configured as they evolve (to become stateless micro-services aka 'cloud native').
 - [x] ...know where to go to for further learning resources and community ideas for building the cloud apps of the future.

The _overall aim_ of the cloud apps lab lounge is to connect you with likeminded cloud application community members who are evolving the thinking on how to engineer cloud apps which will work interoperably across open cloud infrastructures.

Depending on your skill level, each lab will take anywhere from five to forty-five minutes (faster for those who know how to _ask for help_).
Labs are designed to start easy and get more difficult, so as to keep you _playfully challenged_.

You can get help on each lab by simply hanging out in the "Lab Lounge" and asking for help at the info-desk; or you can ask one of our [app pros](https://docs.google.com/presentation/d/1RBtAOjxmUh97fXrJlowvqVNmq2-8FxvBIHx2Dts1Jh8/pub?start=true&loop=true&delayms=1000) who will be on-hand to help.  Also, get help by tweeting your question by using the [#cloudapp](https://twitter.com/hashtag/cloudapp) hashtag via twitter/irc (we'll continually monitor #OpenStack channels).

**Best of all, win points by completing labs which will earn you Stacker swag!**
![Win Stacker Swag by completing these Cloud App Labs](https://pbs.twimg.com/media/CuNYDXsWIAARjHb.jpg:large)

The process for completing labs and earning Stacker points is simple:
 1. select a lab (below) to complete;
 2. get help to complete the lab;
 3. show your lab result to the community to get points;
 4. use your points to claim Stacker swag at the 'App Labs' lounge.
 5. Repeat by completing more labs (see step 1)

To get you started you'll need to have the following pre-requisites:

 * a laptop with wifi access whose SSH ports are open.
 * very basic Python scripting skills
 * an account on one of the many OpenStack public clouds: if you don't have one, we have one for you:
   * [Setup your laptop to work with an OpenStack powered datacenter](/prereq.md)
 * an SSH key and basic understanding for how to apt-get/curl applications onto the cloud (only very basic).
 * an understanding for the basics for making URL based (ReSTful) code calls to a datacenter's API endpoints.
 * willingness to ask questions, ask for help and get involved in the community conversation!

# List of Cloud Application Laboratories
![Let's get started, pick a lab:](https://media.giphy.com/media/epRoTgGfkLpxS/giphy.gif)

### Cloud App Lab no.0 - StackLogin: if you don't have an account on a cloud you'll need to get one.

 - Please see [this list of OpenStack-powered Clouds to get your FREE account](/prereq.md).  The OVH cloud is the official sponsor of the OpenStack Academy.

## Cloud App Lab no.1 - [StackTour: an overview of OpenStack projects as per the buttons they relate to on the Web dashboard.](/StackTour.md)

About this lab (complete in ~5min):
 - [x] _Skills you'll learn_ = which buttons on the OpenStack dashboard (Horizon) connect with the other core OpenStack projects (Nova, Neutron, Cinder, Swift, Glance, etc).
 - [x] _Community you'll meet_ = people who are actively getting their users to launch their own applications using the dashboard and basic scripting skills.
 - [x] _Point's you'll score_ = up to +10 points for completing this lab. [What can I win with 10 StackerPoints?!](/StackerPoints.md)

## Cloud App Lab no.2 - [StackEntrance: having your own personal entrance to all OpenStack public clouds worldwide](/StackEntrance.md)

About this lab (complete in ~10min):
 - [x] _What you'll learn_ = how to configure your laptop to control a datacenter, so that you don't have to use a Web-based dashboard; instead, use simple python scripts to get access to datacenters (powered by OpenStack worldwide). Yes that's right, one simple file is all you need to access hundreds of clouds (i.e. clouds.yaml via os-cloud-config.py)
 - [x] _Community you'll meet_ = people who are helping engineers shift their skills to be able to: a.) authenticate via command line, b.) use of YAML as a simple structured document for storing login details, and c.) basic (beginner) control of a datacentre via command line API calls.
 - [x] _Points you'll score_ = +10 points for completing this lab. [What can I win with my StackerPoints?!](/StackerPoints.md)

## Cloud App Lab no.3 - [StackControl: how to use the basic features of simple multi-cloud dev-kit for controlling your app on the cloud](/StackControl.md)

About this lab (complete in ~15min):
 - [x] _What you'll learn_ = the basic features of a simple python dev-kit for controlling a datacentre including containers, baremetal and VMs (called 'Shade' SDK).
 - [x] _Community you'll meet_ = DevOpps and OpenStack Core Contributors who use Shade as a way to test interoperability between the different clouds.
 - [x] _Points you'll score_ = up to +10 points for completing this lab. [What can I win with my StackerPoints?!](/StackerPoints.md)

## Cloud App Lab no.4 - [StackCreate: how to upload and manually control a simple application at multiple OpenStack-powered datacenters around the planet](/StackCreate.md)

About this lab (complete in ~15min):
 - [x] _What you'll learn_ = how to upload an application at 1 (or more) datacenters using simple command line python code (called 'Shade').
 - [x] _Community you'll meet_ = people who understand how to enable application developers to use basic cloud skills for: a.) controlling a datacentre via command line API calls, and b.) those who actively use a simple python library (shade).
 - [x] _Points you'll score_ = +10 points for completing this lab. [What can I win with my StackerPoints?!](/StackerPoints.md)

## Cloud App Lab no.5 - [StackScale: installing an application which is multi-factor (stateless) at different datacenter locations around the world.](/StackScale.md)

About this lab (complete in ~15min):
 - [x] _What you'll learn_ = install an application whose data (state) needs to be maintained separate from the stateless jobs of the application workers.
 - [x] _Community you'll meet_ = advanced application engineers who are experimenting with how to best build applications which are stateless in their design.
 - [x] _Points you'll score_ = +20 points for completing this lab. [What can I win with my StackerPoints?!](/StackerPoints.md)

## Cloud App Lab no.6 - [StackData: attaching storage to your multi-factor app, understanding state/less app architectures.](/StackData.md)

About this lab (complete in 20min):
 - [x] _What you'll learn_ = Building on Lab no.4 you'll start to utilise the block (volume) storage of OpenStack so your application can share it's data with other application in your enterprise.
 - [x] _Community you'll meet_ = engineers who manage application and operational systems whose data is required to be available for the long term business of the enterprise.
 - [x] _Points you'll score_ = +25 points [What can I win with my StackerPoints?!](/StackerPoints.md)

# Future Cloud App Labs coming soon!
Stay tuned for these future cloud app labs...

## Cloud App Lab no.7 - StackHeal: start to create self-healing workers to monitor and rebuild different parts of your cloud application in situ.

About this lab:
 - [x] _What you'll learn_ =
 - [x] _Community you'll meet_ = advanced, understanding of application architectures and orchestration frameworks...
 - [x] _Points you'll score_ = +15 points for completing this lab. [What can I win with my StackerPoints?!](/StackerPoints.md)

## Cloud App Lab no.8 - StackContainers: start splitting out the state of your app workers to be more agile (self healing) as containers which can dynamically shift across datacentres worldwide.
About this lab:
 - [x] _What you'll learn_ =
 - [x] _Community you'll meet_ =
 - [x] _Points you'll score_ =

## Cloud App Lab no.9 - StackDock: launch Docker on OpenStack then launch a cloud app within Docker
About this lab:
 - [x] _What you'll learn_ =
 - [x] _Community you'll meet_ =
 - [x] _Points you'll score_ =

## Cloud App Lab no.10 - StackPod: launch Kubernetes on OpenStack and get a cloud app working within K8S

About this lab:
 - [x] _What you'll learn_ =
 - [x] _Community you'll meet_ =
 - [x] _Points you'll score_ =

# Cloud App Lab no.Z - StackFoo: do you have an idea for a self-paced cloud app lab, click the branch button now ;0)
Go on, just 'fork/pull' now :)

repository: DFFlanders/cloud-app-labs

repo_name: DFFlanders/cloud-app-labs


text:
_**Clippy —** Access system clipboard in Dart (Server & Browser)_

[![Pub](https://img.shields.io/pub/v/clippy.svg?style=flat-square)](https://pub.dartlang.org/packages/clippy)
[![Build Status](https://travis-ci.org/andresaraujo/clippy.svg?branch=master)](https://travis-ci.org/andresaraujo/clippy)
[![Build status](https://ci.appveyor.com/api/projects/status/ufiu8o0wvugr149b?svg=true)](https://ci.appveyor.com/project/andresaraujo/clippy)

A library to access the clipboard (copy/paste) for server and browser

### Install

Add `clippy` to dependencies/dev_dependencies in in your pubspec.yaml

### Usage

#### Server
In the server Clippy supports writing and reading from the clipboard. It uses system tools for this:
- On linux uses `xsel` (Install if needed)
- On Mac uses `pbcopy`/`pbpaste`
- On windows it embeds a copy/paste tool [win-clipboard](https://github.com/sindresorhus/win-clipboard)

```dart
import 'package:clippy/server.dart' as clippy;

main() async {
  // Write to clipboard
  await clippy.write('https://github.com/andresaraujo/clippy');

  // Read from clipboard
  final clipboard = await clippy.read();
}
```

See [example/server](/example/server)

#### Browser

In the browser Clippy supports writing and listening to paste events.

```dart
import 'package:clippy/browser.dart' as clippy;

main() async {

  // Write a string to clipboard
  await clippy.write('https://github.com/andresaraujo/clippy');

  // Write text from an element to clipboard
  await clippy.write(element);

  // Write current selection to clipboard
  await clippy.write();

  // Listen to paste event
  clippy.onPaste.listen((text) => print('OnPaste: $text'));

}
```

See [example/web](/example/web)

repository: andresaraujo/clippy

gha_language: Dart

repo_name: andresaraujo/clippy


text:
# Puppet PR Triage Notes 2015-02-18.md

Recording: https://www.youtube.com/watch?v=10r3m1-PPLg

### Attending

* **Scott Garman (ScottGarman)**
* **Kylo Ginsberg (kylog)**
* **Geoffery Gardella**
* **Justin May (dankreek)**
* **Felix Frank (ffrank)**

### Summary

During the previous week, We [closed 2 PRs](https://github.com/pulls?q=repo%3Apuppetlabs%2Fpuppet+repo%3Apuppetlabs%2Ffacter+repo%3Apuppetlabs%2Fhiera+is%3Apr+label%3ATriaged+closed%3A%222015-02-11+..+2015-02-18%22++-label%3APL), of which [1 was merged](https://github.com/pulls?q=repo%3Apuppetlabs%2Fpuppet+repo%3Apuppetlabs%2Ffacter+repo%3Apuppetlabs%2Fhiera+is%3Apr+label%3ATriaged+merged%3A%222015-02-11+..+2015-02-18%22+-label%3APL)

At the start of the triage:

* Puppet
  - [12 new](https://github.com/puppetlabs/puppet/pulls?q=is%3Apr+created%3A%222015-02-11+..+2015-02-18%22+-label%3APL+) from community
  - 14 currently open, 4 from community
* Facter
  - [3 new](https://github.com/puppetlabs/facter/pulls?q=is%3Apr+created%3A%222015-02-11+..+2015-02-18%22+-label%3APL) from community
  - 2 currently open, 2 from community
* Hiera
  - [3 new](https://github.com/puppetlabs/hiera/pulls?q=is%3Apr+created%3A%222015-02-11+..+2015-02-18%22+-label%3APL) from community
  - 1 currently open, 0 from community

View each individual pull request for detailed notes.

## Reviewed and Updated this Week

### Puppet

Due to the current PR merge freeze while Puppet 4.0.0 is being released, PRs without new actions will remain on hold until the merge freeze is over. PRs tagged with "Merge After Unfreeze" should be ready for merge as-is and don't require further review.

* PUP-735
  - PR-1854
  - Waiting on test fixes from contributor
  - Kylo assigned the JIRA ticket to himself as a reminder to follow-up
* PUP-3116
  - PR-3043
  - Last week: Kylo created ticket PUP-4002 to track the general facility, and made it a blocker for PUP-3116
  - Nothing new to report
* PUP-3127
  - PR-3045
  - Contributor is unable to continue work on this, needs finishing by PL
  - Last week: **Action: Scott to follow up on this**
* PUP-3094
  - PR-3061
  - Last week: Waiting on contributor
  - **Action: Scott to see if we can get this working with a rebase - and now we can ignore Ruby 1.8.7**
* PUP-3319
  - PR-3107
  - Last week: Kylo noted that this PR blocks on the resolution of PUP-3905
* PUP-3332
  - PR-3113
  - Last week: **Action: Kylo to review**
* PUP-1253
  - PR-3141:
  - New feedback from RelEng supports the contributor's approach
  - **Action: Scott and Kylo to discuss further and comment.**
* PUP-3618
  - PR-3276
  - New feedback from Eric S. favors the PR as-is
  - Kylo commented to make sure this isn't dependent on facter PR-843
* PUP-3341
  - PR-3321
  - Still awaing feedback from Josh
* PUP-3706
  - PR-3348
  - Waiting on contributor (get well soon, Erik!)
  - **Action: Scott to update the spec test and rebase**
* PUP-1072
  - PR-3372
  - This is targeted for post-4.0.0
* PUP-1085
  - PR-3399
  - Marked with Merge After Unfreeze tag
* PUP-3939
  - PR-3510: Scott is working with this contributor, in-progress.
  - We can accept it if it passes specs
  - Last week: **Action: Scott to follow up on this and assist with spec test**
* PUP-3908
  - PR-3518
  - Waiting on contributor
* PUP-3166
  - PR-3531
  - Marked with Merge After Unfreeze tag
* PUP-3968
  - PR-3578
  - Last week: Kylo added feedback on design, requested spec test
  - Scott pinged Adrian, who followed-up immediately with some code suggestions
* PUP-1635
  - PR-3586
  - Kylo assigned the JIRA ticket to himself as a reminder
  - Last week: **Action: Kylo to review**
* PUP-3930
  - PR-3591
  - **Action: Kylo to review**
* PUP-3986
  - PR-3597
  - Looks to need review from the server team
  - **Action: Justin to review**
* PUP-1291
  - PR-3610
  - PR was closed by contributor with plans to create a new PR
* PUP-4014
  - PR-3614
  - In-progress
* PR-3615
  - Needs a JIRA ticket
  - Kylo commented and pinged Rob Reynolds.

### Facter

**Note:** Kylo is preparing to discuss the state of incoming facter PRs on puppet-dev this week. Existing PRs will remain on hold for now.

* FACT-824
  - PR-850
* PR-849
* PR-847
* FACT-805
  - PR-845
* PUP-3618
  - PR-843
  - PR is waiting on Puppet PR-3276

### Hiera

* HI-282
  - PR-239
  - In-progress discussion w/ Henrik

## PRs Closed This Week

### Puppet

* PUP-1291
  - PR-3610: Closed by contributor with plans to create a new PR

### Facter

* FACT-596
  - PR-844: Closed in favor of PR-848
  - PR-848: Merged

### Hiera

None

## Actions

### Scott Garman

In need of further review/action:

* PUP-3127
* PUP-3094
* PUP-1253
* PUP-3706
* PUP-3939

### Kylo Ginsberg

In need of further review/action:

* PUP-3332
* PUP-1253
* PUP-1635
* PUP-3930

### Josh Cooper

* PUP-3341

### Justin May

In need of further review/action:

* PUP-3986

repository: voxpupuli/community-triage

repo_name: voxpupuli/community-triage


text:
This is the main page of your UDOO IoT Cloud account.

Here it's possible to see an overview of your gateways (the [setting up of the gateway](!Client_Registration/Register_the_Client_into_the_UDOO_IoT_Cloud_Server) is required), a report on the actual situation of the net and container(s) and widget(s) you decided to view.

<img src="../img/14_iot_dashboard_complete.png" alt="iot_dashboard_complete" class="img-responsive" >

repository: UDOOboard/IoT-Docs

repo_name: UDOOboard/IoT-Docs


text:
# Square Brackets: Single vs Double

- `[` is a program
- `[[` is bash syntax. `[[` is better.
- Using the `[[...]]`  rather than `[...]` can prevent many logic errors in scripts. For example, the `&&`, `||`, `<`, and `>` operators work within a `[...]` test, despite giving an error within a `[...]` construct.

[filename](../../examples/operators/single_brackets.sh ':include :type=code bash')

[filename](../../examples/operators/double_brackets.sh ':include :type=code bash')

#### Demo
```
which '['
```

```
which '[['
echo $?
```

```
bash ./examples/operators/single_brackets.sh 1 2 3
```

```
bash ./examples/operators/double_brackets.sh 1 2 3
```

### References
- https://jvns.ca/blog/2017/03/26/bash-quirks/

repository: Mavrikant/bash-lingua-non-grata

repo_name: Mavrikant/bash-lingua-non-grata


text:
# Deploy an Edgemicro proxy to Apigee Edge

You must export the following environment variables:
```
export ae_password=apigeepassword
export ae_username=apigeeusername
export ae_org=apigeeorg
```

### edge.json
The edge.json file contains the configuration (KVMs, Caches, Target Servers, products, developers apps, etc.) for deploying the proxy to Edge.

## Helpful to Know
You don't have to review these links, since I list all the commands to deploy the proxy.  But if you are interested in learning more about the config and deploy plugins, then you should read them.
* [apigee-config-maven-plugin](https://github.com/apigee/apigee-config-maven-plugin)
* [apigee-maven-deploy-plugin](https://github.com/apigee/apigee-deploy-maven-plugin)

# Apigee Edge

## You must update the following

* Update the jmeter/edgemicro_test.csv with the IP/hostname of the edgemicro kubernetes load balancer server IP

Update the following if you want to run the Jmeter tests
* Update the config.json file with the IP/hostname of the target server

## Deploy
Follow the steps below to deploy the proxy, and create the developer, product and app in Apigee Edge.

### Proxy
This will deploy:
* a proxy
* a developer
* a developer app
* an API product

### Deploy the proxy
Run this command to deploy the proxy.

```
cd edgemicroproxy/microproxy
mvn install -Ptest -Dusername=$ae_username -Dpassword=$ae_password \
                    -Dorg=$ae_org -Dauthtype=oauth -Dapigee.config.options=create
```