text:
# Overview

Use this package to install the Tellor User Contracts and integrate Tellor into your contracts.

Once installed this will allow your contracts to inherit the functions from UsingTellor.

#### How to Use
Just inherit the UsingTellor contract, passing the Tellor address as a constructor argument:

Here's an example
```solidity
import "usingtellor/contracts/UsingTellor.sol";

contract PriceContract is UsingTellor {

  uint256 public btcPrice;

  // This contract now has access to all functions in UsingTellor
  constructor(address payable _tellorAddress) UsingTellor(_tellorAddress) public {}

  function setBtcPrice() public {
      bytes memory _b = abi.encode("SpotPrice", abi.encode("btc", "usd"));
      bytes32 _btcQueryId = keccak256(_b);

      uint256 _timestamp;
      bytes memory _value;

      (_value, _timestamp) = getDataBefore(_btcQueryId, block.timestamp - 1 hours);
      btcPrice = abi.decode(_value,(uint256));
  }
}
```
##### Addresses:

Find Tellor contract addresses [here](https://docs.tellor.io/tellor/the-basics/contracts-reference).

#### Available Tellor functions:

Children contracts have access to the following functions:

```solidity
/**
 * @dev Retrieves the next value for the queryId after the specified timestamp
 * @param _queryId is the queryId to look up the value for
 * @param _timestamp after which to search for next value
 * @return _value the value retrieved
 * @return _timestampRetrieved the value's timestamp
 */
function getDataAfter(bytes32 _queryId, uint256 _timestamp)
    public
    view
    returns (bytes memory _value, uint256 _timestampRetrieved);

/**
  * @dev Retrieves the latest value for the queryId before the specified timestamp
  * @param _queryId is the queryId to look up the value for
  * @param _timestamp before which to search for latest value
  * @return _value the value retrieved
  * @return _timestampRetrieved the value's timestamp
  */
function getDataBefore(bytes32 _queryId, uint256 _timestamp)
    public
    view
    returns (bytes memory _value, uint256 _timestampRetrieved);

/**
 * @dev Retrieves next array index of data after the specified timestamp for the queryId
 * @param _queryId is the queryId to look up the index for
 * @param _timestamp is the timestamp after which to search for the next index
 * @return _found whether the index was found
 * @return _index the next index found after the specified timestamp
 */
function getIndexForDataAfter(bytes32 _queryId, uint256 _timestamp)
    public
    view
    returns (bool _found, uint256 _index);

/**
 * @dev Retrieves latest array index of data before the specified timestamp for the queryId
 * @param _queryId is the queryId to look up the index for
 * @param _timestamp is the timestamp before which to search for the latest index
 * @return _found whether the index was found
 * @return _index the latest index found before the specified timestamp
 */
function getIndexForDataBefore(bytes32 _queryId, uint256 _timestamp)
    public
    view
    returns (bool _found, uint256 _index);

/**
 * @dev Retrieves multiple uint256 values before the specified timestamp
 * @param _queryId the unique id of the data query
 * @param _timestamp the timestamp before which to search for values
 * @param _maxAge the maximum number of seconds before the _timestamp to search for values
 * @param _maxCount the maximum number of values to return
 * @return _values the values retrieved, ordered from oldest to newest
 * @return _timestamps the timestamps of the values retrieved
 */
function getMultipleValuesBefore(
  bytes32 _queryId,
  uint256 _timestamp,
  uint256 _maxAge,
  uint256 _maxCount
)
  public
  view
  returns (bytes[] memory _values, uint256[] memory _timestamps);

/**
 * @dev Counts the number of values that have been submitted for the queryId
 * @param _queryId the id to look up
 * @return uint256 count of the number of values received for the queryId
 */
function getNewValueCountbyQueryId(bytes32 _queryId)
  public
  view
  returns (uint256);

/**
 * @dev Returns the address of the reporter who submitted a value for a data ID at a specific time
 * @param _queryId is ID of the specific data feed
 * @param _timestamp is the timestamp to find a corresponding reporter for
 * @return address of the reporter who reported the value for the data ID at the given timestamp
 */
function getReporterByTimestamp(bytes32 _queryId, uint256 _timestamp)
  public
  view
  returns (address);

/**
 * @dev Gets the timestamp for the value based on their index
 * @param _queryId is the id to look up
 * @param _index is the value index to look up
 * @return uint256 timestamp
 */
function getTimestampbyQueryIdandIndex(bytes32 _queryId, uint256 _index)
  public
  view
  returns (uint256);

/**
 * @dev Determines whether a value with a given queryId and timestamp has been disputed
 * @param _queryId is the value id to look up
 * @param _timestamp is the timestamp of the value to look up
 * @return bool true if queryId/timestamp is under dispute
 */
function isInDispute(bytes32 _queryId, uint256 _timestamp)
  public
  view
  returns (bool);

/**
 * @dev Retrieve value from oracle based on queryId/timestamp
 * @param _queryId being requested
 * @param _timestamp to retrieve data/value from
 * @return bytes value for query/timestamp submitted
 */
function retrieveData(bytes32 _queryId, uint256 _timestamp)
  public
  view
  returns (bytes memory);
```

#### Tellor Playground:

For ease of use, the  `UsingTellor`  repo comes with a version of [Tellor Playground](https://github.com/tellor-io/TellorPlayground) for easier integration. This version contains a few helper functions:

```solidity
/**
 * @dev A mock function to submit a value to be read without miners needed
 * @param _queryId The tellorId to associate the value to
 * @param _value the value for the queryId
 * @param _nonce the current value count for the query id
 * @param _queryData the data used by reporters to fulfill the data query
 */
function submitValue(bytes32 _queryId, bytes calldata _value, uint256 _nonce, bytes memory _queryData) external;

/**
 * @dev A mock function to create a dispute
 * @param _queryId The tellorId to be disputed
 * @param _timestamp the timestamp of the value to be disputed
 */
function beginDispute(bytes32 _queryId, uint256 _timestamp) external;
```

# Test
Open a git bash terminal and run this code:

```bash
git clone https://github.com/tellor-io/usingtellor.git
cd usingtellor
npm i
npm test
```

# Implementing using Tellor
See our documentation for implementing usingTellor [here.](https://docs.tellor.io/tellor/getting-data/introduction)

# Keywords

Decentralized oracle, price oracle, oracle, Tellor, TRB, Tributes, price data, smart contracts.

repository: tellor-io/usingtellor

repo_name: tellor-io/usingtellor


text:
# Changelog

## 1.1.1 (in development)

* Fix an edge case for exclusively empty views/clones fragments ([issue #15](https://github.com/jgehrcke/github-repo-stats/issues/15)).

## 1.1.0 (2021-04-14)

Job robustness:

* Consolidate data branch writing so that multiple jobs operating concurrently on the same branch are less likely to fail ([issue #9](https://github.com/jgehrcke/github-repo-stats/issues/9)). Thanks to Henry Bley-Vroman and Dmytro Chasovskyi for the feedback.
* Fix an edge case for missing path/referrer data ([issue #8](https://github.com/jgehrcke/github-repo-stats/issues/8)).
* Attempt to fix an edge case for missing views/clones data ([issue #11](https://github.com/jgehrcke/github-repo-stats/issues/11)).
* Log output: work towards less interleaved stdout/err in the GH Actions log viewer.

Data handling:

* Fix a rare view / clone count data loss condition ([issue #4](https://github.com/jgehrcke/github-repo-stats/issues/4)). Thanks to Davis J. McGregor.
* Write stargazer and fork time series to data repository as CSV files, with at most one data point per day (resampled).

Plot improvements:

* Synchronize the time window shown for stargazer and fork time series.
* Decrease marker size in the referrer / paths plots.

Report generation:

* Tweak CSS for mobile view / narrow screens.
* Link to stats repository in HTML report.

## 1.0.0 (2021-01-14)

Initial release.

repository: fboemer/github-repo-stats

branch_name: refs/heads/main

extension: md

license_type: permissive

repo_name: fboemer/github-repo-stats


text:
## React DispHatcher
#### _Epicodus Capstone Project, 5/3/19_

#### Slater Smith

### Description

Application built for React routing and state management practice using Redux. The application is meant to act as a worker dispatcher for organizations that need to manage large numbers of contract workers in realtime. Specifically, this app is being built with trade unions in mind, but could be applicable to any industry that needs to efficiently manage, track, and dispatch contract workers or employees (examples: dental professionals, medical, government workers, police dispatch, temp agencies, etc.). Project in progress, view live at: https://slaterjamessmith.github.io/disp-hatcher/#/

### Component Tree

![Component Tree](./src/assets/images/disphatcher-tree.png)

### Features
The user can currently add and remove new workers in the 'profiles' view, create and remove new job calls in the 'job builder' view, and see those job calls and members with job specific data appear in the 'dispatcher view.' This app is still under construction, as errors occur when the user makes updates in the 'dispatcher' view. See 'Current Bugs' section in this README for more information.

### Roadmap & Stretch Goals
MVP:
- Fully build out Job Builder & Profile Editor components using mock data and mock job lists.
- Deploy to firebase.

Stretch goals:
- Build out Edit Jobs component, and have each job automatically archive after timeout (job call ends).
- In 'Profile Editor' component, add 'search by name' option, and a 'view all' option to choose from
- Add option for user to create new job-types (Rigger, Electricial, Lead Rigger) and sort by them.
- Add preset job-types for different industries (Stagehands Union, Electricians Union, etc.)
- Add ability to upload excel sheet list of workers, then delete mock data
- Add functionality to send emails

#### Database/Sort-items map:

Master list data:
- First name
- Last name
- Email
- Proficiencies / Skills
- Notes / General
- Exclusions
- Hire Date / Seniority
- List Number / Seniority

Data / job specific:
- Notes / This Job
- Job assignment
- Availability (warning pops up if assigned to conflicting job)
- Offer sent
- Confirmation

### Technologies and Resources Used

* React
* npm & Node
* Redux (to be implemented)
* Jest (to be implemented)

### Setup Instructions

1. Clone this repository to your desktop at https://github.com/SlaterJamesSmith/disp-hatcher
2. Use a terminal of your choice to access the webpage and its files by inputting: "git clone {the above clone link}"
3. If homebrew is not yet installed on your Mac, install it by running the following command in your terminal: "$ /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
4. If you are not using a Mac, and homebrew is not yet installed, go to the node website and follow appropriate installer for your operating system at https://nodejs.org/en/download/
5. Navigate into your new directory and run '$ npm i' and then 'npm run start'
6. In your preferred web browser, navigate to url 'localhost:8080'

### Current Bugs
This project is still in progress. While it does successfully implement Redux, errors occur in the 'dispatcher' view when an edit is made to the status of a particular worker on a particular job. Instead of updating a single instance of that worker, the application updates the information accross all jobs. The issue may be that state is being mutated, or possibly the way information about a particular list is being accessed.

This project will meet MVP when this issue is addressed.

### License

*This software is licensed under the MIT license*
Copyright (c) 2019 **_Slater Smith_**

license: MIT

repository: SlaterJamesSmith/disp-hatcher

branch_name: refs/heads/master

gha_language: JavaScript

repo_name: SlaterJamesSmith/disp-hatcher


text:
![Open Source Love](https://firstcontributions.github.io/open-source-badges/badges/open-source-v1/open-source.svg)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)

# first-bit

It's hard. It's always hard the first time you do something. Especially when you are collaborating, making mistakes isn't a comfortable thing. We at [BitByte - The Programming Club](https://github.com/BitByte-TPC) wanted to simplify the way new open-source contributors learn & contribute for the first time.

Reading articles & watching tutorials can help, but what's better than actually doing the stuff in a practice environment? So, to provide guidance and simplify the way beginners make their first contribution, we've created this amazing project.

If you are a beginner and wants to get your hands dirty in Open Source, you've hopped on to the right place. This project is made just for you.

## About first-bit

This project is developed and maintained by [BitByte - The Programming Club](https://github.com/BitByte-TPC) to help young developers kickstart their journey to the world of Open Source. This is a very basic project where you can easily make your first contribution and learn the complete workflow of using Git and Github along the way.

So, let's start with the first and the most basic step, installing **Git**.

## Install Git

If you don't have git on your machine, [install it](https://git-scm.com/downloads).

## Configure Git

So by now you must have successfully downloaded and installed Git on your system. Congrats! :tada: You have completed your first and the most basic step into Open Source.

Now, it's time to let Git know who you really are, i.e., provide your Name and Email Address to Git. This step is important because Git attaches your identity with every commit (we'll talk about that later) you make; so that if someone comes around asking, *Hey! Who made these changes?* or *Hey! Who wrote this beautiful code?*, Git can instantly say, oh it was this guy or that lady.

To set your *username* and *email* in Git, open your Terminal (on Linux, press `Ctrl + Alt + t`) or Command Prompt (on Windows, press `Windows + r` to open Run box, type `cmd` there and hit `Enter`) and type the following comands:

```
git config --global user.name "your-full-name"
git config --global user.email<EMAIL_ADDRESS>```

replacing `your-full-name` with your Full Name and<EMAIL_ADDRESS>with your email address (associated with your GitHub Account).

Done that? Well congrats again!! :tada: Now, you're all set to start using Git on your system and make wonderful Open Source contributions. :raised_hand:

## Fork this repository

So, you've come this far.  Amazing! :heart_eyes:

So, let's start by forking this repository. But, what exactly is *forking*, you'd ask! Well, as you don't own this repository, you cannot make any changes directly into it. Anyways, it would cause a disaster if anyone could make any changes into it, wouldn't it? Like assume, some notorious person comes and deletes this whole repository! Well what would we do then. restore the repository you'd say but why should we go through all this trouble? :information_desk_person:

So, how would you make changes to this repository then? Well, that's where forking comes in. Forking this repository will create an exact copy of this repository in your account. And guess what, you can make any changes in that copy and send a Pull Request (we'll talk about that later) to us when you're done with making changes asking us to merge those changes into our main repository. Isn't that amazing? :grinning:

So, what are your waiting for? Go ahead and Fork this repository by clicking on the fork button on the top of this page.

## Clone the repository

Now clone the forked repository to your machine. Go to your GitHub account, open the forked repository, click on the clone button and then click the *copy to clipboard* icon.

 See the previous steps to obtain the url.

For example:
```
git clone https://github.com/this-is-you/first-bit.git
```
where `this-is-you` is your GitHub username. Here you're copying the contents of the first-bit repository on GitHub to your computer.

## Create a branch

Change to the repository directory on your computer (if you are not already there):

```
cd first-bit
```
Now create a branch using the `git checkout` command:
```
git checkout -b <add-your-new-branch-name>
```

For example:
```
git checkout -b add-alonzo-church
```
(The name of the branch does not need to have the word *add* in it, but it's a reasonable thing to include because the purpose of this branch is to add your name to a list.)

## Make necessary changes

### Using Terminal

Change to `public/directory` directory/folder inside your repository where you need to add a new file.

```
cd public/directory
```

Create a new file in your current directory (`first-bit/public/directory`) with name `this-is-you.json` where `this-is-you` is your GitHub username.

#### For Windows Users

* On cmd, type `notepad this-is-you.json` which will search for a file with name `this-is-you.json` in your current directory.
* If a file with the same name exists in your current directory (which will not be the case unless you create one), it will be opened using notepad.
* If not (which is our case :wink:), Windows will display a prompt saying `Do you want to create a new file?`.
* On clicking `Yes`, a file with name `this-is-you.json` will be created in your current directory :tada: and opened using notepad.
* Now copy the follwing text and paste it in your newly created file:
  ```
    {
        "githubId": "this-is-you",
        "name": "your-name",
        "bio": "Something about yourself using not more than 64 characters."
    }
  ```
  replacing `this-is-you` with your GitHub ID, `your-name` with your Full Name and updating the text in bio.

  **For example:**
  ```
    {
        "githubId": "sdhiman99",
        "name": "Shivansh Dhiman",
        "bio": "Searching new horizons.."
    }
  ```
* Save the file pressing `Ctrl + s` and close the notepad.

#### For Linux Users

- Copy the template

  ```bash
  cp public/directory/name.json.example public/directory/<this-is-you>.json
  ```

  Replace `<this-is-you>` with your GitHub username.

- Open  `public/directory/<this-is-you>.json`.

  ```bash
  gedit public/directory/<this-is-you>.json
  ```

- In the file you just opened, replace `this-is-you` with your GitHub ID, `your-name` with your Full Name and update the text in bio.
- Save the file by pressing `Ctrl + s` and close the editor.

### Using GUI

- Open the cloned repository on your pc using your File Manager.
  (You can check the address where you cloned the repository by typing `pwd` in your terminal).
- Go to `public/directory` from there.
- Create a new file with name `<this-is-you>.json` where `this-is-you` is your GitHub username and `json` is the file extension.
- Open `name.json.example` file using your favourite text editor and copy its content.
- Open the newly created file using your favourite text editor and paste the content you just copied.
- Replace `this-is-you` with your GitHub ID, `your-name` with your Full Name and update the text in bio in your newly created file.
- Save the file by pressing `Ctrl + s` and close the text editor.

## Commit those changes

If you go to the project directory and execute the command `git status`, you'll see there are changes.

Add those changes to the branch you just created using the `git add` command:

```
git add public/directory/<yout-github-id>.json
```

Now commit those changes using the `git commit` command:
```
git commit -m "Add <your-github-id> to Contributors list"
```

## Push changes to GitHub

Push your changes using the command `git push`:
```
git push origin <add-your-branch-name>
```
replacing `<add-your-branch-name>` with the name of the branch you created earlier.

## Submit your changes for review

If you go to your repository on GitHub, you'll see a  `Compare & pull request` button. Click on that button.

Now submit the pull request.

Soon I'll be merging all your changes into the master branch of this project. You will get a notification email once the changes have been merged.

## Where to go from here?

Congrats!  You just completed the standard _fork -> clone -> edit -> PR_ workflow that you'll encounter often as a contributor!

Celebrate your contribution and share it with your friends and followers by going to [web app](https://firstcontributions.github.io/#social-share).

You could join our slack team in case you need any help or have any questions. [Join slack team](https://join.slack.com/t/firstcontributors/shared_invite/enQtNjkxNzQwNzA2MTMwLTVhMWJjNjg2ODRlNWZhNjIzYjgwNDIyZWYwZjhjYTQ4OTBjMWM0MmFhZDUxNzBiYzczMGNiYzcxNjkzZDZlMDM).

Now let's get you started with contributing to other projects. We've compiled a list of projects with easy issues you can get started on. Check out [the list of projects in the web app](https://firstcontributions.github.io/#project-list).

repository: dynamoh/first-bit

repo_name: dynamoh/first-bit


text:
---
layout: default
---

# 1997-11-23 - Re: The Subliminal Algebra-Seinfield Conspiracy

## Header Data

From<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)

To<EMAIL_ADDRESS>Message Hash: 157839e4873b91682b8817be63af200a8892b6a02a07a0fbe6972f31957354a7

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1997-11-23 20:39:42 UTC

Raw Date: Mon, 24 Nov 1997 04:39:42 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)
Date: Mon, 24 Nov 1997 04:39:42 +0800
To<EMAIL_ADDRESS>Subject: Re: The Subliminal Algebra-Seinfield Conspiracy
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

John Young<EMAIL_ADDRESS>writes:

> Dimitri confessed:
>
> >Above Tom's restaurant, on 112th and Broadway.  I worked for 7 years upstair
> >from that restaurant in a very secret organization.  I'm socked they even
> >show that building on TV. :-)
>
> You bet, that secret org is well-known among CU pick-up artists as
> a swell place to pick up socks ...  well, more than that and sudden
> death's your next shock.

Columbia University's campus map shows it as the 'Armstrong Building'.

---

Dr.Dimitri Vulis KOTM
Brighton Beach Boardwalk BBS, Forest Hills, N.Y.: +1-718-261-2013, 14.4Kbps

{% endraw %}
```

## Thread

+ Return to [November 1997](/archive/1997/11)

+ Return to<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)](/authors/dlv_at_bwalk_dm_com_dr_dimitri_vulis_kotm_)"
+ Return to "[John Young <jya@pipeline.com>](/authors/john_young_jya_at_pipeline_com_)"

+ 1997-11-22 (Sun, 23 Nov 1997 02:13:48 +0800) - [Re: The Subliminal Algebra-Seinfield Conspiracy](/archive/1997/11/4ce93ef5798e7e3224c772ea5ab1682464e1865801df83e5f6566e775a75ea19) - _John Young<EMAIL_ADDRESS>  + 1997-11-23 (Mon, 24 Nov 1997 04:39:42 +0800) - Re: The Subliminal Algebra-Seinfield Conspiracy -<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)_

gha_license_id: MIT


text:
---
external help file: ScheduleTask_Test-IsOnBattery-help.xml
Module Name: ScheduleTask_Test-IsOnBattery
online version: https://github.com/jfishe/battery/blob/master/docs/Test-IsOnBattery.md
schema: 2.0.0
---

# Test-IsOnBattery

## SYNOPSIS
Test-IsOnBattery sends a Toast notification when battery charging/discharging
is outside the optimum range for battery lifetime.

## SYNTAX

```
Test-IsOnBattery [[-computer] <String>] [[-sleep] <Int32>] [<CommonParameters>]
```

## DESCRIPTION
Test-IsOnBattery sends a Toast notification when battery charging/discharging
is outside the optimum range for battery lifetime.

A Toast notification is sent when:

* The battery is unplugged below 50%
* The battery is plugged-in above 75%.

Toast notifications stop if the battery is plugged-in and fully charged.

## EXAMPLES

### Example 1
```Powershell
PS C:\> Test-IsOnBattery -sleep 10
```

Issue Toast notification every 10 seconds. Default is 600 seconds.

## PARAMETERS

### -computer
Only tested with `localhost`. For other computers, credentials are likely required.

```yaml
Type: String
Parameter Sets: (All)
Aliases:

Required: False
Position: 1
Default value: Localhost
Accept pipeline input: False
Accept wildcard characters: False
```

### -sleep
How long to wait, in seconds, before checking whether batter is plugged,
unplugged or fully charged.

```yaml
Type: Int32
Parameter Sets: (All)
Aliases:

Required: False
Position: 2
Default value: 600
Accept pipeline input: False
Accept wildcard characters: False
```

### CommonParameters
This cmdlet supports the common parameters: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutVariable, -OutBuffer, -PipelineVariable, -Verbose, -WarningAction, and -WarningVariable. For more information, see about_CommonParameters (http://go.microsoft.com/fwlink/?LinkID=113216).

## INPUTS

## OUTPUTS

## NOTES

## RELATED LINKS

repository: jfishe/battery

repo_name: jfishe/battery


text:
# Change Log

## [0.2.7](https://github.com/jamztang/CSStickyHeaderFlowLayout/tree/0.2.7) (2015-06-05)

[Full Changelog](https://github.com/jamztang/CSStickyHeaderFlowLayout/compare/0.2.6...0.2.7)

**Closed issues:**

- Horizontal scroll [\#75](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/75)

## [0.2.6](https://github.com/jamztang/CSStickyHeaderFlowLayout/tree/0.2.6) (2015-06-04)

[Full Changelog](https://github.com/jamztang/CSStickyHeaderFlowLayout/compare/0.2.5...0.2.6)

**Closed issues:**

- Header not sticking properly to the top with more then one cell on the section. [\#74](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/74)

- Explanation [\#70](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/70)

- Section header go behind cell when insert via performBatchUpdates [\#68](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/68)

- A crash when parallaxHeaderReferenceSize is changed [\#65](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/65)

- Unable to compile CSStickyHeaderFlowLayoutAttributes \(v0.2.4\) [\#57](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/57)

## [0.2.5](https://github.com/jamztang/CSStickyHeaderFlowLayout/tree/0.2.5) (2015-04-15)

[Full Changelog](https://github.com/jamztang/CSStickyHeaderFlowLayout/compare/0.2.4...0.2.5)

**Closed issues:**

- How to create "Spotify" example programmatically? [\#63](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/63)

- Support device rotation [\#61](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/61)

- Height of header when minimized [\#60](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/60)

- EXC\_BAD\_ACCESS on \[super collectionViewContentSize\]; [\#43](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/43)

**Merged pull requests:**

- fix issue \#43 [\#62](https://github.com/jamztang/CSStickyHeaderFlowLayout/pull/62) ([marciomeschini](https://github.com/marciomeschini))

## [0.2.4](https://github.com/jamztang/CSStickyHeaderFlowLayout/tree/0.2.4) (2015-03-02)

[Full Changelog](https://github.com/jamztang/CSStickyHeaderFlowLayout/compare/0.2.3...0.2.4)

**Closed issues:**

- No `Podfile' found in the project directory. [\#53](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/53)

- How to collapse CSAlwaysOnTopHeader [\#51](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/51)

- ContentOffset on bottom causes flickering to occur when scrolling down [\#50](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/50)

- Section Header can't receive touches [\#49](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/49)

- NSInternalInconsistencyException crash in logs [\#46](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/46)

- Where does the "header" reuseIdentifier come from? [\#42](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/42)

- pod install fails [\#39](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/39)

- Crash on iOS 8.1 [\#38](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/38)

- Layout not working on iOS7.1 [\#37](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/37)

- ParallaxHeader crash if contain a UILabel [\#36](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/36)

- MapView inside header not working [\#35](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/35)

- Creating constraint programmatically for the Parallax Header [\#34](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/34)

- It doesn't seem to work with Swift [\#32](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/32)

- Parallax header doesn't show when there are 0 sections [\#22](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/22)

- NSInternalInconsistencyException when scrolling to the bottom [\#18](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/18)

- "Snapshotting a view that has not been rendered results in an empty snapshot." [\#12](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/12)

**Merged pull requests:**

- CSStickyHeaderFlowLayoutAttributes confirms NSCopying protocol [\#56](https://github.com/jamztang/CSStickyHeaderFlowLayout/pull/56) ([i3th](https://github.com/i3th))

## [0.2.3](https://github.com/jamztang/CSStickyHeaderFlowLayout/tree/0.2.3) (2014-10-16)

[Full Changelog](https://github.com/jamztang/CSStickyHeaderFlowLayout/compare/0.2.2...0.2.3)

**Closed issues:**

- iPhone 6 & Plus Sizes [\#31](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/31)

- Sticky header not resizing in iOS 7.1 5s simulator, Xcode 6 [\#29](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/29)

- SHUFFLE PLAY button is not tappable sometimes [\#28](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/28)

- grow header does not work on iOS 7 \(Xcode 6.0.1\) [\#27](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/27)

- Autolayout Error [\#26](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/26)

- xcode 6 gm seed breaks always on top scrolling [\#25](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/25)

- Content over scroll indicator [\#24](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/24)

- Header overlaps content when scrollToItemAtIndexPath: is used [\#11](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/11)

**Merged pull requests:**

- Show parallax header even if there are 0 sections [\#23](https://github.com/jamztang/CSStickyHeaderFlowLayout/pull/23) ([Xyand](https://github.com/Xyand))

## [0.2.2](https://github.com/jamztang/CSStickyHeaderFlowLayout/tree/0.2.2) (2014-09-01)

[Full Changelog](https://github.com/jamztang/CSStickyHeaderFlowLayout/compare/0.2.1...0.2.2)

**Closed issues:**

- Permit cell height to be zero [\#19](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/19)

**Merged pull requests:**

- Fix CollectionView zIndex issue when cells travel between sections [\#20](https://github.com/jamztang/CSStickyHeaderFlowLayout/pull/20) ([Xyand](https://github.com/Xyand))

- Fix 1px header under navigation bar [\#7](https://github.com/jamztang/CSStickyHeaderFlowLayout/pull/7) ([m1entus](https://github.com/m1entus))

## [0.2.1](https://github.com/jamztang/CSStickyHeaderFlowLayout/tree/0.2.1) (2014-07-31)

[Full Changelog](https://github.com/jamztang/CSStickyHeaderFlowLayout/compare/0.2...0.2.1)

**Closed issues:**

- Sticky Header programmatically [\#16](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/16)

- Crash on reloadData in collection view when header is offscreen [\#15](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/15)

- Support for landscape mode [\#14](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/14)

- Is it possible to use CSStickyHeaderFlowLayout only from code? [\#10](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/10)

- support 6.0 [\#9](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/9)

- Layout assertion failure [\#6](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/6)

**Merged pull requests:**

- fix issue \#15 [\#17](https://github.com/jamztang/CSStickyHeaderFlowLayout/pull/17) ([jessesquires](https://github.com/jessesquires))

- fixed typo in README.md [\#8](https://github.com/jamztang/CSStickyHeaderFlowLayout/pull/8) ([dannyshmueli](https://github.com/dannyshmueli))

## [0.2](https://github.com/jamztang/CSStickyHeaderFlowLayout/tree/0.2) (2014-05-02)

[Full Changelog](https://github.com/jamztang/CSStickyHeaderFlowLayout/compare/0.1.1...0.2)

**Closed issues:**

- Demo Fails [\#5](https://github.com/jamztang/CSStickyHeaderFlowLayout/issues/5)

## [0.1.1](https://github.com/jamztang/CSStickyHeaderFlowLayout/tree/0.1.1) (2014-03-24)

[Full Changelog](https://github.com/jamztang/CSStickyHeaderFlowLayout/compare/0.1.0...0.1.1)

**Merged pull requests:**

- Add default to numberOfSectionsInCollectionView: method [\#3](https://github.com/jamztang/CSStickyHeaderFlowLayout/pull/3) ([miwillhite](https://github.com/miwillhite))

- Add a Bitdeli Badge to README [\#2](https://github.com/jamztang/CSStickyHeaderFlowLayout/pull/2) ([bitdeli-chef](https://github.com/bitdeli-chef))

## [0.1.0](https://github.com/jamztang/CSStickyHeaderFlowLayout/tree/0.1.0) (2014-02-21)

**Merged pull requests:**

- Fixed autolayout issues [\#1](https://github.com/jamztang/CSStickyHeaderFlowLayout/pull/1) ([andreamazz](https://github.com/andreamazz))

\* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*


text:
# Leica Scanstation ROS

This package is created to control in PC, throught ROS interface, the Leica Scanstation C5.
Tested on ROS Melodic for Windows 10.

Due to Leica's libraries dependencies, the source code development is done under Windows 10.

Once the program is released, it could be executed in either Windows or Linux (with tools such us Wine).

# Dependencies #

- [ROS](http://wiki.ros.org/Installation/Windows)

Recomended: `ros-melodic-desktop_full`

- Leica HXI SDK.

Note: To get your HXI SDK contact your local Leica supplier.

# Set up #
0. Mandatory: Windows 10
1. Create a workspace e.g: *catkin_ws*

        mkdir catkin_ws\src && cd catkin_ws\src

2. Clone repo on your workspace

        git clone https://github.com/fada-catec/leica_scanstation.git

3. Place HXI SDK files on a reachable path. Recommended: create a directory on `c:/opt/hxi_scanner` and copy the content of your HXI SDK into the directory

4. Set path to SDK files

        setx HXI_SCANNER_INCLUDE_PATH c:/opt/hxi_scanner/Include
        setx HXI_SCANNER_BINARY_PATH c:/opt/hxi_scanner/Release

5. Compile your workspace.

        cd catkin_ws
        catkin_make
        devel\setup.bat

# Usage #

        roslaunch leica_scanstation_ros start.launch

Use ROS services to control, move and start scanning on the Scanstation. E.g: Try to move your pan and tilt

        rosservice call /leica/move 3.141 0.785

# Export program #
The ROS node created for this package can be executed in a Linux distribution, using tools such as [Wine](https://www.winehq.org/). If you plan to do this, it will be necessary to have the related libraries to run the program. Compile the program setting export option. Move the executable file (.exe) and the libraries to your linux system.

        setx LEICA_EXPORT_PROGRAM ON
        catkin_make

Files will be exported on your package folder: `catkin_ws\...\leica_scanstation_ros\export`

# Code API #

Read documentation `leica_scanstation_ros/doc/html/index.html`


text:
## Entity structure data provider

Namespace: `Oro\Bundle\EntityBundle\Provider\EntityStructureDataProvider`

Provides data of all configurable entities. Collects the following data (see `Oro\Bundle\EntityBundle\Model\EntityStructure`):
- Entity aliases
- Entity labels (translated)
- Entity fields (see `Oro\Bundle\EntityBundle\Model\EntityFieldStructure`)
- Entity options (for example `auditable`)
- Entity routes.

For every field, the following information is provided:
- name
- type
- label (translated)
- type of relation (`oneToMany`, `manyToMany` and so on)
- options (for example `[configurable: true, auditable: false]`).

This data can be returned by API.

This data can be extended or modified using event (see [Entity Structure Options Event](./events.md#entity-structure-options-event)).

repository: successmarket/oroinc-platform

gha_license_id: NOASSERTION

repo_name: successmarket/oroinc-platform


text:
# bass_boost

#### A flutter plugin to increase bass in any audio.

## Initialize the object of BassBoost class like this
```
 BassBoost bassBoost = new BassBoost( id );
 // id here is the audioSessionId for the playing audio.
 ```
## Enable it by calling the function setEnabled(bool b) using the same object initialized above

`bassBoost.setEnabled(true);`

## Change the strength of bass by calling the function setStrength(int strength) on the object initialized above

```
bassBoost.setStrength(i);
//i = intger value ranging from 0 to 1000 including the extremes ([0,1000]) .
//All values less than 0 and greater than 1000 will be neglected
```

## Check whether the bass is already enabled or not by calling the function getEnabled() using the same object initialized above

`bool b = await bassBoost.getEnabled();//b will get a boolean value in return.`

## Get current strength of the bass by calling getStrength() using the same object initialized above

`int strength = await bassBoost.getStrength();//strength will get an integer value in return.`

repository: Aman-Malhotra/Bass-Boost-Flutter

repo_name: Aman-Malhotra/Bass-Boost-Flutter


text:
## `zdesk organizations list`

/organizations

### Synopsis

    zdesk organizations list [ ... ]

### REST endpoint

    GET https://{HOSTNAME}/api/v2/organizations

### Description

https://developer.zendesk.com/api-reference/ticketing/organizations#list-organizations

repository: fprimex/zdesk-cli

repo_name: fprimex/zdesk-cli


text:
# **Learn Hindi Bhasha App**

Learn Hindi Bhasha application is a learning app that makes learning the Hindi language easy, fast, and fun. Users can smoothly nagivate between different categories and with the help of images and audio the user can visualize while learning the correct pronunciations. The built in search functionality allows users to instantly search for a specific word within a category. The apps clean UI gives users a wonderful user experience while learning the Hindi language.

## **Pre-requisites**
Install Android Studio.

* [Android Studio](https://developer.android.com/studio) version 4.1.1 and higher.

## **Getting Started**
To build this project:

1. Clone or download the repository.
    ```bash
    git clone https://github.com/dhanvinpatel/Learn-Hindi-Bhasha.git
    ```
2. Open Android Studio and select `Import Project` and navigate to the root directory of the project.

3. Click 'OK' to open the project in Android Studio.

4. Wait for the Gradle sync to finish.

## **Running the Application**
(The app was tested on Pixel 4 API 27.)

Setup a virtual device using the AVD Manager in Android Studio or connect an Android device to your development machine.

To run the application:
1. Select the deive you wish to run the app on.
2. From the menu bar select `Run -> Run 'app'` to launch the app.

## **Screenshots**

repository: dhanvinpatel/Learn-Hindi-Bhasha-App

repo_name: dhanvinpatel/Learn-Hindi-Bhasha-App


text:
# Vault Elastic Load Balancer

This folder contains a [Terraform](https://www.terraform.io/) module that can be used to deploy an [Elastic Load
Balancer (ELB)](https://aws.amazon.com/elasticloadbalancing/classicloadbalancer/) in front of the Vault cluster
from the [vault-cluster module](https://github.com/hashicorp/terraform-aws-vault/tree/refine/modules/vault-cluster). This is useful if you need to access Vault from the public
Internet. Note that for most users, we recommend NOT making Vault accessible from the public Internet and using
DNS to access your Vault cluster instead (see the [install-dnsmasq
module](https://github.com/hashicorp/terraform-aws-consul/tree/master/modules/install-dnsmasq) for details).

## How do you use this module?

This folder defines a [Terraform module](https://www.terraform.io/docs/modules/usage.html), which you can use in your
code by adding a `module` configuration and setting its `source` parameter to URL of this folder:

```hcl
module "vault_elb" {
  # TODO: update this to the final URL
  # Use version v0.0.1 of the vault-elb module
  source = "github.com/hashicorp/terraform-aws-vault//modules/vault-elb?ref=v0.0.1"

  # ... See vars.tf for the other parameters you must define for the vault-cluster module
}

# Configure the Vault cluster to use the ELB
module "vault_cluster" {
  # TODO: update this to the final URL
  # Use version v0.0.1 of the vault-elb module
  source = "github.com/hashicorp/terraform-aws-vault//modules/vault-cluster?ref=v0.0.1"

  load_balancers = ["${module.vault_elb.load_balancer_name}"]

  # ... (other params omitted) ...
}
```

Note the following parameters:

* `source`: Use this parameter to specify the URL of the vault-elb module. The double slash (`//`) is intentional
  and required. Terraform uses it to specify subfolders within a Git repo (see [module
  sources](https://www.terraform.io/docs/modules/sources.html)). The `ref` parameter specifies a specific Git tag in
  this repo. That way, instead of using the latest version of this module from the `master` branch, which
  will change every time you run Terraform, you're using a fixed version of the repo.

* `load_balancers`: Setting this parameter in the [vault-cluster module](https://github.com/hashicorp/terraform-aws-vault/tree/refine/modules/vault-cluster) tells it to register
  each server with the ELB when it is booting.

You can find the other parameters in [vars.tf](vars.tf).

Check out the [vault-cluster-public example](https://github.com/hashicorp/terraform-aws-vault/tree/refine/examples/vault-cluster-public) for working sample code.

## How is the ELB configured?

The ELB in this module is configured as follows:

1. **TCP Passthrough**: The ELB does NOT attempt to terminate SSL, as your Vault servers should do that themselves.
   This ensures that all Vault information is encrypted end-to-end, with no middle man (including AWS) able to read
   the contents. It also allows your Vault servers to do [mutual TLS
   authentication](https://en.wikipedia.org/wiki/Mutual_authentication) so that Vault clients verify the server's
   certificate and the Vault server verifies the client's certificate.

1. **Listeners**: The ELB only listens on one port (default: 443) and forwards the requests to Vault's API port
   (default: 8200).

1. **Health Check**: The ELB uses the [/sys/health endpoint](https://www.vaultproject.io/api/system/health.html) on
   your Vault servers, with the `standbyok` flag set to `true`, as a health check endpoint. This way, the ELB will see
   any primary or standby Vault node that is unsealed as healthy and route traffic to it.

1. **DNS**: If you set the `create_dns_entry` variable to `true`, this module will create a DNS A Record in [Route
   53](https://aws.amazon.com/route53/) that points your specified `domain_name` at the ELB. This allows you to use
   this domain name to access the ELB. Note that the TLS certificate you use with Vault should be configured with this
   same domain name!

repository: Ghost---Shadow/terraform-board

repo_name: Ghost---Shadow/terraform-board


text:
cyberlinux-aur
[![build-badge](https://travis-ci.com/phR0ze/cyberlinux-aur.svg?branch=master)](https://travis-ci.com/phR0ze/cyberlinux-aur)
[![license-badge](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
====================================================================================================

cyberlinux-aur provides a home for all the updated and custom Arch Linux package related files
being maintained for the cyberlinux project.

### Disclaimer
***cyberlinux-aur*** comes with absolutely no guarantees or support of any kind. It is to be used at
your own risk.  Any damages, issues, losses or problems caused by the use of ***cyberlinux-aur*** are
strictly the responsiblity of the user and not the developer/creator of ***cyberlinux-aur***.

### Git-Hook Version Increment
Enable the githooks to have automatic version increments

```bash
cd ~/Projects/cyberlinux-aur
git config core.hooksPath .githooks
```

## License
Licensed under either of:
 * MIT license [LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT
 * Apache License, Version 2.0 [LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0


text:
## JavaFX: Editable TextField
This is a very simple and straight-forward JavaFx-based application that allows you to add and edit TextFields objects as a labels using CSS.

### Disclaimer

This repository contains a sample code intended to demonstrate the capabilities of the JavaFx StackPane and TextField objects. The current version is not intended to be used as-is in applications as a library dependency, and will not be maintained as such. Bug fix contributions are welcome, but issues and feature requests will not be addressed.

### Pre-requisites

- Java 8
- JavaFX
- Maven 3

### Code Samples

- Editable TextField
- Editable Draggable TextField

## Credits

This project was based on **JavaFxPlayVideoAndAudio**.

- [Another JavaFX example: The editable label][1]
- [How do I create an editable Label in javafx 2.2][2]

## License

The code supplied here is covered under the MIT Open Source License..

[1]: http://chaoticjava.com/posts/another-javafx-example-the-editable-label/
[2]: https://stackoverflow.com/questions/25572398

repository: teocci/Editable-TextField

repo_name: teocci/Editable-TextField


text:
pyginx
======

A very simple web server written in Python. Run it locally like so:

    python server.py

then head to [http://localhost:1337/test.html](http://localhost:1337/test.html) and sit back and admire.

repository: jamesrwhite/pyginx

repo_name: jamesrwhite/pyginx


text:
---
layout: page
title: Lab Members
subtitle: Welcome to the J. Yang Lab
css: "/css/people.css"
googlefonts: ["Monoton", "Lobster"]
bigimg:
  - "https://i.imgur.com/rC2GEi7.jpg?1" : "Plant Sciences Hall 2018"
  - "https://i.imgur.com/eGQ5UBE.png" : "Maize Meeting in St. Louis 2019"
---

{% include module.html
image_path="https://i.imgur.com/uf8nsvN.png"
name="Gen Xu"
title="__Postdoctoral Scholar__"
contact="University of Nebraska-Lincoln, \\
  361 Keim Hall, \\
  1825 N 38th St, \\
  Lincoln, NE 68583-0915"
email="gxu6 at unl dot edu \\
[Google Scholar](https://scholar.google.com/citations?user=EQUPblkAAAAJ&hl)"
%}

### Research Interests:

I'm interested in integrating different Omics data to dissect the genetic mechanisms of quantitative traits, especially nitrogen-responsive traits.

### Education:

- Ph.D. in Crop Genetics and Breeding, China Agricultural University, Beijing, China
- B.S. in Agronomy, Yangzhou University, Jiangsu, China


text:
SoC specs
===========

vga
-----

* 320x240, 3 bits per pixel
* Output as 640x480x72hz/32.5 mhz pixel clock

cpu
-----

* Target 32.5mhz (vga clock)
* 16 bit registers
* 16 registers
* 16 bit address bus
* dedicated vga bus
* 8K ram x16 bits

[opcode spec details](cpu/opcodes.md)

Sound
-------

* Todo
* Will communicate via mmio

vga
-----
* Todo
* Will use a special bus (can't fit into the 16 bit address space)

Input
-------
* Todo
* via mmio

CPU BUS
---------

NAME | address space | used size | start  |  end
---  | ------------- | --------- | ------ | -----
RAM/ROM  |      32K      |     8K    | 0x0000 | 0x7FFF
MMIO |      32K      |     ??    | 0x8000 | 0xFFFF

VGA BUS
---------
* x, y, color


text:
! https://raw.githubusercontent.com/twilson63/gwo-2016-angular2/master/ng2-view.jpg

---

### Hello, I am Tom

* @twilson63
* Jack Russell Software/Tabula Rasa Healthcare
* Developer/Instructor
* <3 JavaScript <3 NodeJS <3 CouchDB

---

### About you

* How many use Angular?
* How many use other JS Frameworks?

---

! https://raw.githubusercontent.com/twilson63/gwo-2016-angular2/master/Angular2.png

---

### Agenda

* What is Angular 2?
* Why Angular 2?
* Component Model Architecture
* Events
* Services/Injectables
* ngFor
* Inputs
* ngClass
* ngModel

---

### What is Angular 2?

One Framework for Mobile and Desktop

---

### Why Angular 2?

The framework is faster, more scalable, and more modern. Chances are that organizations that found value in Angular 1.x will find more value in Angular 2.

---

### Component Model Architecture

```
<TodoApp>
  <TodoInput></TodoInput>
  <TodoList>
    <TodoItem></TodoItem>
  </TodoList>
</TodoApp>
```

---

### Angular 2 Component

```
import {Component} from 'angular2/core'

@Component({
  selector: 'my-component',
  template: '<h1>Component</h1>'
})
export class MyComponent {

}
```

---

### A Todo App

```
<TodoApp>
  <TodoInput></TodoInput>
  <TodoList>
    <TodoItem></TodoItem>
  </TodoList>
</TodoApp>
```

---

### Component and Template

In angular2 the template can be included within the component annotation or can be a html file path using the `templateUrl` node.

---

### Event Handlers

Using the property name you want to handle assigned to an expression. The '()' indicates event handler.

```
<button (click)="onClick()">Click Me!</button>
```

---

### References

Using the '#' symbol plus an unique name, creates a reference to the HTML Element
within the component.

```
<input type="text" #myInput>
<button (click)="onClick(myInput.value)">Click Me!</button>
```

---

### Pipes

A new name for filters and work very similar:

```
{{todos | json}}
```

date, json, currency, uppercase, limitTo, lowercase, decimal, percent, async

Async Pipes are supported.
---

### ngFor

Then new ng-repeat - or structural directive

```
<ul>
  <li *ngFor="#todo of todos">{{todo}}</li>
</ul>
```

---

### Services and Providers

A service is just a class or function with Injectable decorator

```
@Injectable()
export class TodoService {

}
```

---

### ngModel

ngModel established two-way data-binding using both the '[]' and '()'

```
<form (submit)="onSubmit($event)">
  <input type="text" [(ngModel)]="todo.title">
</form>
```

---

### Models

You can define and implement models easier with ES6 and TypeScript

```
export class TodoModel {

}
```

---

### Inputs

You can create inputs that enable values to be passed down from parent
components via '[]' properties.

```
<todo-item [todo]="todo"></todo-item>
```

---

### ngClass directive

With ngClass you can modify the presentation with expressions

```
<style>
  .completed {
    text-decoration: line-through;
  }
</style>
<span [ngClass]="todo.status">{{todo.title}}</span>
```

---

### TodoInput

```
this.todoService.todos.push(this.todo)
this.todo = new TodoModel('')
```

---

### Custom events with EventEmitter

```
<todo-item (update)="update(todo)"></todo-item>
...
export class TodoItem {
  @Output() update = new EventEmitter()
  onUpdate() {
    update.emit('event')
  }
}
```

---

### Http Provider

The Http provider returns Rx Observables.

```
http.get('/foo.json')
  .subscribe(res => {
    const body = res.json()
  })
```

---

### Router

The router is another provider and set of directives to create linkable components.

```
@Component({
	selector: 'my-app',
	providers: [ROUTER_PROVIDERS],
	directives: [ROUTER_DIRECTIVES],
	template: `
	  <h1>My First Angular 2 App</h1>
	  <a [routerLink]="['Home']">Home</a>
	  <a [routerLink]="['About']">About</a>
	  <router-outlet></router-outlet>
	`
})
```

---

# Questions

---

### Thank You

http://gwo-2016.jsplay.space/

https://github.com/twilson63/gwo-2016-angular2

---


text:
Advanced User and Developer Tutorials
======================================

This page contains links to some useful tutorials intended for advanced users and developers. As new documentation is created it will be added here.

## Advanced usage
- [Sending Counterparty assets in bulk](send_assets_in_bulk.md)
- [Using multisig with `counterparty-server`](multisig_counterparty-server.md)

## Development-related
- [Integrating XCP and assets into an exchange](exchange_integration.md)
- [Counterwallet Enhanced Asset Info](enhanced_asset_info.md)
- [Counterwallet Enhanced Feed Info](enhanced_feed_info.md)
- [Counterwallet failover mechanics and misc notes](counterwallet_notes.md)
- Additional tutorials are available at the [Counterparty Community Forum](https://counterpartytalk.org)
 - How to Encode & Decode Counterparty Transactions
 - How to use `counterparty-client` with the Counterparty Distributed Exchange (DEx)
 - Counterparty API Tutorials: `create_send`, `create_dividend`

repository: CounterpartyXCP/Documentation

repo_name: CounterpartyXCP/Documentation


text:
---
layout: writeup
title: "The Leprechauns of Software Engineering"
full_title: "The Leprechauns of Software Engineering: How folklore turns into fact and what to do about it"
author: Laurent Bossavit
book_link: https://leanpub.com/leprechauns
image: leprechauns.png
categories:
- writeup
favorite: true
---

**What's the point?**
Citing research studies can be a powerful argument. But it can also be a fallacy if we blindly place trust in research without evaluating both the methods of experimentation, as well as the actual findings.

This book aims to show readers how to evaluate academic research (specifically in the context of software engineering) by going beyond the abstract, comparing the experimental setup to their own context, and vetting cited sources.

**How was it?**
The authors provides examples of how some "common wisdom" that is often cited as iron-clad and definitive is much more shaky than it is presented.

Take one example: the [cost of change curve][coc]. Traditional, this is presented as a graph that plots the "cost of change" over the stages of a project (requirements, design, coding, production, etc). The graph depicts a smoothly-sloping, exponential relationship — intended to highlight that the further along the development process, the more costly a change will be to make.

![]({{site.url}}/static/cost-of-change-graph.gif)

This graph looks very scientific and official. It is cited in early and well-known Agile software literature. But once you dig deeper, there are numerous problems with taking this graph at face value.

Over time and across authors, the Y-axis morphs from measuring the cost to fix software (a bug) to the cost to change (a bug or new features?). The X-axis implies an equal time transition through the project phases (not realistic). The origin paper (Boehm 1976) is not clear on how data was collected or if measurement was consistent across all subjects.

Other topics that are also critically examined: the 10x productivity developer, the cone of uncertainty, and the "terrible" software process of Waterfall.

It is prudent to point out that the book is not saying that these ideas are incorrect, but rather that the "research" and "data" that is so often attached to these concepts is rather flimsy. The author calls on the software community to improve the bar for software research, not just throw it all away.

**Who should read it?**
This book had been on my radar for a while, but I was compelled to read it after a series of process-related discussions had ended with "there are many research studies that prove this is right".

I think this book is a great resource for people interested in software team process — if for nothing else other than to remind people that nearly every project and team exists in it's own context and must be considered as such.

As an aside, I was glad to have read this book recently when I came across some less-than-satisfactory (to me) research which empirically claimed that ["refactoring does not improve code quality"][bogus]. A more detailed critic of this paper is left as an exercise to future readers.

[coc]: http://www.agilemodeling.com/essays/costOfChange.htm
[bogus]: http://www.itworld.com/article/2891140/study-finds-that-refactoring-doesn-t-improve-code-quality.html


text:
---
layout: home
title: Sum Up Numbers
#permalink: index.html # in case of we remove the index.md file, this doc will be the index page
---

## Description
------

CodeMaster has just returned from shopping. He scanned the check of the items he bought and gave the resulting string to Ratiorg to figure out the total number of purchased items. Since Ratiorg is a bot he is definitely going to automate it, so he needs a program that sums up all the numbers which appear in the given input.

Help Ratiorg by writing a function that returns the sum of numbers that appear in the given inputString.

**Example**

For inputString = "2 apples, 12 oranges", the output should be
sumUpNumbers(inputString) = 14.

**Input/Output**

* **[execution time limit] 4 seconds (js)**

* **[input] string inputString**

*Guaranteed constraints*:
6 ≤ inputString.length ≤ 60.

* **[output] integer**

**[JavaScript (ES6)] Syntax Tips**

{% highlight javascript linenos=table %}
// Prints help message to the console
// Returns a string
function helloWorld(name) {
    console.log("This prints to the console when you Run Tests");
    return "Hello, " + name;
}
{% endhighlight %}

## Solution
------

{% highlight javascript linenos=table %}

{% include_relative solution.js %}

{% endhighlight %}

repository: Gregiss/codefights-arcade-intro

repo_name: Gregiss/codefights-arcade-intro


text:
# dwmbar

dwmbar is a simple status bar for the [dwm](https://dwm.suckless.org/) tiling window manager.

![](images/example.png)

## Installation

Configure by editing the source code in `dwmbar.c` then install:
```bash
sudo make install
```

The program sets the name of the root windows to a text formatted for the [status2d](https://dwm.suckless.org/patches/status2d/) patch of dwm.

## Description

I was not satisfied with existing status bar for dwm so I wrote my own. In particular I didn't want to call shell scripts to fetch basic informations and preferred using a more efficient polling technique than just calling a function every second.

To get into more detail, standard status bars use a single thread and sleep for a pre-determined number of seconds before updating all the informations. I used this technique with great success in a previous application but it suffers from a major drawback: the smaller the update interval the snappier the bar, but also the more it draws resources. This becomes a problem for me when I was changing the sound of my computer. I wanted quick feedback but updating the status every tenth of a second seemed ridiculous. I looked for other alternatives, such as sending a signal to the status bar every time the "volume script" changes its value but in the ends I chose to monitor files for changes using [inotify](https://en.wikipedia.org/wiki/Inotify).

## Features

The status bar can display several values:

* current keyboard layout
* cpu temperature
* fan speed
* ram used
* percentage of remaining battery
* power consumption
* brightness level
* sound level
* a clock

## Technical details

Each value is contained in a `Block`. A `Block` has an icon, a color and a text content. For each block a `listener` and a `callback` are defined. The `listener` calls the `callback` whenever the content of the block should be updated.

The application is multi-threaded, and each block runs in its own thread. Thus they can update themselve independently of each other. When a block's listener fires the associated callback, the content of the block changes and a global `pthread_cond_t` condition variable is unblocked. The main function can then loop over all the blocks, see which one has changed, and then set the output text accordingly.

Three types of listeners are implemented:

* `time_listener`: the simplest one, simply sleep for a given interval then launch the callback.
* `aligned_time_listener`: a variant of the first listener, update a block every n seconds but align the interval on an unix timestamp. For example, the clock should be updated every 60 seconds, but I want it to change instantaneously when the minute changes. For that, we align the update interval on the timestamp `1592384460`, which is exactly 09:01:00 GMT.
* `file_listener`: update the block every time the content of a file changes. It uses the `inotify` linux kernel library to monitor the specified files.

The aligned time listener is only used for the clock.

The file listener is used for all the values changed via a custom script, which writes the new value in a file every time it is called, namely the volume, the brightness and the current keyboard layout.

Unfortunately for the rest of the values the time listener is used. It is simply not possible to react to events such as a change in the cpu temperature or a drop of the battery level. Still, I use a different update interval, based on how often I want some informations to be updated.

repository: ThomasChevalier/dwmbar

repo_name: ThomasChevalier/dwmbar


text:
# atom-react-instyle package

## Most likely you want an alternative
This plugin **is not meant to be of  interest to all users**, but if you find a use in it, by all means use it.

### Alternative
For a more generic implementation please use [TOP-Chao](https://github.com/TOP-Chao)'s implementation of [atom-react-native-css](https://github.com/TOP-Chao/atom-react-native-css)

## Purpose
This plugin allows conversion of CSS/SCSS/SASS to React Native compatible StyleSheet objects or javascript plain objects for usage with React.

![A screenshot of your package](https://f.cloud.github.com/assets/69169/2290250/c35d867a-a017-11e3-86be-cd7c5bf3ff9b.gif)

repository: ghepesdoru/atom-react-instyle

repo_name: ghepesdoru/atom-react-instyle


text:
# lex-chatbot

This is a very unuseful chatbot that ingests data from the HERE REST API. The chatbot is built with Amazon Lex and an AWS Lambda function. You can ask the chatbot to retrieve place names based on latitude and longitude data.

repository: trevorstam/lex-chatbot

repo_name: trevorstam/lex-chatbot


text:
**This folder contains notebooks to reproduce / extend the results in the paper.**

The [text notebook](text_fig2.ipynb) contains code to load a pretrained model on the SST dataset. Then, you can give it different sentences and observe the hierarchical interpretations it produces.

![](figs/fig_2.png)

# mnist

The [mnist notebook](mnist_figs3,s4.ipynb) contains code for analyzing the mnist dataset with ACD. Running this notebook will download the MNIST dataset, if you do not already have it.

- note: adversarial attacks require the `foolbox` and `randomgen` python packages (installable via pip)
  - 'boundary attack' is currently commented out as a result of an error in the `randomgen` package

![](figs/fig_s3.png)

# imagenet
The [imagenet notebook](imagenet_fig3,s1,s2.ipynb) contains code for using CD on CNN models. It comes with a pickle file containing a few imagenet images for testing out.

- note: redoing the imagenet results will be very slow if using cpu instead of gpu

![](figs/fig_s2.png)


text:
# Misc

## Referrer Receiver

Add the Broadcast Receiver in `AndroidManifest.xml`

```xml title="AndroidManifest.xml"
<receiver
    android:name=".ReferrerReceiver"
    android:exported="true">
    <intent-filter>
        <action android:name="com.android.vending.INSTALL_REFERRER" />
    </intent-filter>
</receiver>
```

And in the Receiver's `onReceive()` method, you can get the referrer value

```kotlin title="ReferrerReceiver.kt"
class ReferrerReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        val referrer: String? = referrer = intent.extras.getString("referrer")
    }
}
```

## Deeplinking

You can get the deeplink `Uri` in your `Activity`'s `onCreate()` method as well as the corresponding properties:

```kotlin title="MainActivity.kt"
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    val deeplink = intent.data
    if (deeplink != null) {
        val host = deeplink.host
        val path = deeplink.path
        val query = deeplink.query
        val fragment = deeplink.fragment
    }
}
```

## Deferred deeplink

When using [Play Store url](play-store-url.md) or [Market scheme](market-scheme.md) or [Firebase Dynamic Links](firebase-dynamic-links.md) methods, the regular Play Store **Open** button will be replaced by a **Continue** button.
Furthermore, a notification will be displayed with **Tap to continue** content.
These two actions are essential to the Deferred deeplink method as they provide the initial data to the app.

| Regular Deeplink | Deferred Deeplink |
|---|---|
| ![](assets/store_deeplink_notification.png) | ![](assets/store_deferred_deeplink_notification.png) |
| ![](assets/store_deeplink_button.png) | ![](assets/store_deferred_deeplink_button.png) |

## Url redirections

- HTML regular `href` link
  ```html
  <a href="${link}">Click here</a>
  ```
- Javascript manual redirect
  ```javascript
  window.location = "${link}";
  ```
- Javascript automatic redirect
  ```javascript
  window.onload = function() {
    window.location.replace("${link}");
  };
  ```
- Server 3XX redirection (php, nginx, etc.)
  ```php
  header("Location: ${link}");
  ```

## Adb Activity Manager

To try links with adb, use the Activity Manager (am) command:

```shell
$ adb shell 'am start "link://smarquis.fr/action?key=value#data"'
```

## Alternatives

- [Branch](https://branch.io/)
- [HOKO](https://hokolinks.com)
- [Yozio](http://www.yozio.com)
- [Tapstream](https://tapstream.com/onboarding-links)

repository: SimonMarquis/Android-App-Linking

repo_name: SimonMarquis/Android-App-Linking


text:
# distconf
[![CircleCI](https://circleci.com/gh/cep21/distconf.svg)](https://circleci.com/gh/cep21/distconf)
[![GoDoc](https://godoc.org/github.com/cep21/distconf?status.svg)](https://godoc.org/github.com/cep21/distconf)
[![codecov](https://codecov.io/gh/cep21/distconf/branch/master/graph/badge.svg)](https://codecov.io/gh/cep21/distconf)

distconf is a distributed configuration framework for Go.

All applications need to load configuration somehow.  Configuration can be loaded
in many different ways

* Environment variables
* Command line parameters
* ZooKeeper or consul

How configuration is loaded should ideally be abstracted from the need for configuration.

An additional complication is that configuration can change while an application is live.  It is sometimes
useful to allow applications to update their configuration without having to restart.  Unfortunately,
systems like zookeeper can be slow so your application also needs to atomically cache configuration, while
also monitoring for changes.

Distconf does all that

* Abstract the need for configuration from the source of configuration
* Fast, atomic loading of configuration
* Monitoring of configuration updates

# Usage

The correct way to use distconf is to get a configuration value once from it, then either pass that value into your
application code or register a watch to update your application when the value changes.  For example, for type Float
call `distconf.Float` once, then call `Get` on that value while your application is live.

## Normal example with for loop
```go
    func ExampleFloat_Get_inloop() {
        ctx := context.Background()
        m := distconf.Mem{}
        if err := m.Write(ctx, "value", []byte("2.0")); err != nil {
            panic("never happens")
        }
        d := distconf.Distconf{
            Readers: []distconf.Reader{&m},
        }
        x := d.Float(ctx, "value", 1.0)
        sum := 0.0
        for i := 0 ;i < 1000; i++ {
            sum += x.Get()
        }
        fmt.Println(sum)
        // Output: 2000
    }
```

## Getting a float value from distconf

```go
    func ExampleDistconf_Float() {
        ctx := context.Background()
        m := distconf.Mem{}
        if err := m.Write(ctx, "value", []byte("3.2")); err != nil {
            panic("never happens")
        }
        d := distconf.Distconf{
            Readers: []distconf.Reader{&m},
        }
        x := d.Float(ctx, "value", 1.0)
        fmt.Println(x.Get())
        // Output: 3.2
    }
```

## Getting the default value from distconf

```go
    func ExampleDistconf_defaults() {
        ctx := context.Background()
        d := distconf.Distconf{}
        x := d.Float(ctx, "value", 1.1)
        fmt.Println(x.Get())
        // Output: 1.1
    }
```

## Watching for updates for values

```go
    func ExampleFloat_Watch() {
        ctx := context.Background()
        m := distconf.Mem{}
        d := distconf.Distconf{
            Readers: []distconf.Reader{&m},
        }
        x := d.Float(ctx, "value", 1.0)
        x.Watch(func(f *distconf.Float, oldValue float64) {
            fmt.Println("Change from", oldValue, "to", f.Get())
        })
        fmt.Println("first", x.Get())
        if err := m.Write(ctx, "value", []byte("2.1")); err != nil {
            panic("never happens")
        }
        fmt.Println("second", x.Get())
        // Output: first 1
        // Change from 1 to 2.1
        // second 2.1
    }
```

# Design Rational

The primary design goals of distconf are:

* Obey best practices around lack of globals or reflection
* Have small core interfaces with very few functions
* Allow fast, atomic fetches of values, allowing them to be used in tight loops
* Allow registered updates of values as they change
* Minimal external dependencies

The core component of distconf is an interface with only one method.

```go
    // Reader can get a []byte value for a config key
    type Reader interface {
        // Read should lookup a key inside the configuration source.  This function should
        // be thread safe, but is allowed to be slow or block.  That block will only happen
        // on application startup.  An error will skip this source and fall back to another
        // source in the chain.
        Read(ctx context.Context, key string) ([]byte, error)
    }
```

From this simple interface, we can derive the rest of distconf.  Readers are used by Distconf to fetch configuration
information.  Some readers, such as zookeeper, allow you to watch for specific keys and get notifications live when they
change.  To support this, readers can also optionally implement the Watcher interface.

```go
    // A Watcher config can change what it thinks a value is over time.
    type Watcher interface {
        // Watch a key for a change in value.  When the value for that key changes,
        // execute 'callback'.  It is ok to execute callback more times than needed.
        // Each call to callback will probably trigger future calls to Get().
        // Watch may be called multiple times for a single key.  Only the latest callback needs to be executed.
        // It is possible callback may itself call watch.  Be careful with locking.
        // If callback is nil, then we are trying to remove a previously registered callback.
        Watch(ctx context.Context, key string, callback func()) error
    }
```

Any Reader that implements Watcher will get a Watch() function call whenever a key should be watched for changes.  That
Watcher should then forever notify Distconf whenever that key's value changes by executing callback.  When you're done
with distconf, call `Shutdown` to deregister watches.  It will try to exit early if context is terminated.

# Contributing

Contributions welcome!  Submit a pull request on github and make sure your code passes `make lint test`.  For
large changes, I strongly recommend [creating an issue](https://github.com/cep21/distconf/issues) on GitHub first to
confirm your change will be accepted before writing a lot of code.  GitHub issues are also recommended, at your discretion,
for smaller changes or questions.

# License

This library is licensed under the Apache 2.0 License, forked from https://github.com/signalfx/golib
under the Apache 2.0 License.


text:
# Sourdough Bread

## Basic recipe from Jason Gloor, adapted by Greg Gloor with help from Tartine Bread

One of the best presents I've received is when Jason taught me how to make bread. My grandmother used to make bread and I recall the wonderful aroma that filled the mobile home she lived in on the farm.

There are a few keys to making good sourdough.

- good flour

- an active starter culture

- a long rise and proof

## The flour

Every type of flour will behave differently. I have tried Robin Hood flour bread flour available at any grocery store, and artisanal flour from the Arva Flour Mill. I prefer the Arva Flour Mill flour.

 I keep my starter in a plastic container. I find Farm Boy soup containers to be ideal. I have kept the same starter alive for manu years by following this simple protocol.

1) Fri am Remove almost all the starter from the container and add 1/2 cup whole wheat flour, 1/2 cup white flour, and 1 cup of tap water.

2) Fri pm. At the end of the day, usually 5:30 or 6, I make bread with the starter. The remainder I store by adding 2 TB white flour, 2 TB whole wheat flour, and about 2 TB water. Mix, well and store in the fridge. Keeps for up to 2 weeks, although weekly is best.

If it does not smell fruity when you use it, do a couple of feedings starting on Wed using the protocol for Fri PM, but keep it on the counter.

#### Note: if the starter is very active, the maintenance and feeding can be done starting on Thurs or even Fri AM. This appears to be seasonal and a little unpredictable.

## The Bread recipe

I use the Tartine Bread Recipe modified as follows:

Add the starter mix that has sat for 6-8 hours (It should be nice and fluffy) to 2 1/2 cups of tap water, and 1/4 tsp or less of dry yeast (not bread yeast). Mix well (I use a stand mixer).

1 slightly heaping cup of whole wheat flour and 6 slightly above level cups of hard white flour to the above (I use Arva Flour Mills flour). You will have to experiment with the actual amounts of flour and water a bit. I notice that less water is needed in the summer (when it is humid) than in the middle of winter (when the air is dry) Work into a mass. At the end it should be a well formed ball. Work those forearms. Again I use a mixer with a dough-hook.

Let sit 30 min - 1 hour covered with a damp tea towel

Add 1 1/2 Tb salt and about 2 Tbsp hot water. The Tartine book is a great resource for how to do this. With wet hands, I take one side of the mass and fold it over the top of the mass, stretch it as much as you can. I do this 4 times, rotating 90 degrees each time

let sit 30 min, and mix with wet hands every 30 min thereafter until it is a nicely cohesive mass. The last 2 -3 mixes I do as long pulls that I wrap around my hand, repeating with a 90 degree turn. When it is tough to mix it is done (Usually 3-5 mixes)

let sit at least a half an hour or up to about an hour or so, covered. it should be somewhat inflated

cut in half, and form each mass into a nice ball by rotating as a ball on the counter by squeezing your hands together as you turn. Do not use flour!. The goal here is to get a ball that when rotated turns back a little. There is lots of tension on the gluten in the flour when this happens

let sit half an hour, covered

put into wicker proofing pans and place covered in the fridge (6-8 degrees C) for 8-12 hours. If your fridge is cold let it sit longer, or take it out for a while until you cook it. covered. you can also use a casserole dish or bread pan that has been oiled to proof the bread.

Transfer to a flour-covered pizza stone, or to a flour-covered pyrex bread pan. Score the top with a sharp knife about 1/3 of the way deep.

Bake at 450 degrees (covered by a bigger pan) for 20 min, and 450 degrees uncovered.  Alternatively, if you don't have a pan to cover, you can put a roasting tray in the oven and add 1 to 1.5 cups of water at the same time as you put the  bread in. this creates steam for the first 15-20 minutes of cooking.

you will need to experiment with the timing a bit for your oven and your pans. I use a rectangular pizza stone, cover the bread with a metal pan for the first 20, and uncover for the second 20. Tartine suggests a dutch oven. In this case you might try 15 and 15 since metal is a better conductor than the pizza ceramic

Let sit for about half an hour. Can be frozen in tinfoil and plastic if needed. To re-thaw bake 450 for 20 min and then let sit for 30.

Keeps for 5-7 days or so (first 2 are great, toast and grilled cheese the last three is amazing).

repository: ggloor/recipes

repo_name: ggloor/recipes


text:
# Security Policy

## Supported Versions

Only the latest version of our project is supported with security updates. We highly recommend updating to the latest version to ensure the best possible security for your system.

## Reporting a Vulnerability

If you discover a security vulnerability, please report it to us immediately at<EMAIL_ADDRESS>Please do not disclose the vulnerability publicly or through GitHub issues until we have had an opportunity to investigate and provide a fix.

When reporting a vulnerability, please include a detailed description of the issue, along with any steps necessary to reproduce it. We will make every effort to investigate and provide a fix as quickly as possible.

You can expect to receive an initial response from us within 24 hours of submitting your report. Depending on the complexity of the issue, it may take us longer to investigate and provide a fix. We will keep you informed of our progress and provide updates on a regular basis.

If we accept the vulnerability, we will work with you to coordinate the release of a fix. If we decline the vulnerability, we will provide a detailed explanation of our reasoning.

Thank you for helping to keep our project secure!

repository: alphaolomi/actions-africastalking

gha_language: TypeScript

repo_name: alphaolomi/actions-africastalking


text:
# Changelog

## ✨ **0.4.3** _(2021-04-01)_

#### Changelog

- #### ⚡ Features

  - Support `'-'` in attribute names. This makes the following syntax valid:
    ```rust
    template! {
        button(aria-hidden="true")
    }
    ```
    [[@lukechu10], [#79](https://github.com/sycamore-rs/sycamore/pull/79)]

- #### 🛠 Fixes

  - Delete removed nodes in `Keyed` first before adding new nodes and moving existing nodes [[@lukechu10], [#77](https://github.com/sycamore-rs/sycamore/pull/77)]

## ✨ **0.4.2** _(2021-03-31)_

#### Changelog

- #### 🛠 Fixes

  - Fix `Keyed` iteration (hopefully for the last time) when moving nodes already inserted [[@lukechu10], [#75](https://github.com/sycamore-rs/sycamore/pull/75)]

## ✨ **0.4.1** _(2021-03-31)_

#### Changelog

- #### 🛠 Fixes

  - Fix `Keyed` iteration (swapping and inserting not at the end) [[@lukechu10], [#73](https://github.com/sycamore-rs/sycamore/pull/73)]

- #### 📃 Documentation Fixes

  - Fix typo in `README.md` [[@iwburns], [#64](https://github.com/sycamore-rs/sycamore/pull/64)]]
  - Add discord server link to issue template [[@lukechu10], [#68](https://github.com/sycamore-rs/sycamore/pull/68)]

- #### 🎁 Example Fixes

  - Fix filter links in TodoMVC example [[@lukechu10], [#65](https://github.com/sycamore-rs/sycamore/pull/65)]

## ✨ **0.4.0** _(2021-03-25)_

#### Changelog

- #### ⚡ Features

  - Iteration using `SignalVec`. This is more of an experiment and there are some bugs. This will most likely be removed in a future version [[@lukechu10], [#49](https://github.com/sycamore-rs/sycamore/pull/49)]
  - Keyed iteration using `Keyed` and non-keyed iteration using `Indexed` which can iterate over a `Signal<Vec>`. This is the recommended way to iterate over a list of values [[@lukechu10], [#51](https://github.com/sycamore-rs/sycamore/pull/51), [#53](https://github.com/sycamore-rs/sycamore/pull/53) and [#54](https://github.com/sycamore-rs/sycamore/pull/54)]
  - Node references. Use the `ref` attribute to bind an HTML element to a `NodeRef` [[@lukechu10], [#57](https://github.com/sycamore-rs/sycamore/pull/57)]

- #### 🛠 Fixes

  - Fix debug assertions in `Keyed` [[@lukechu10], [#53](https://github.com/sycamore-rs/sycamore/pull/53)]

- #### 🛠 Internal Fixes and Improvements

  - Setup integration tests [[@lukechu10], [#51](https://github.com/sycamore-rs/sycamore/pull/51)]

- #### 🎁 Examples

  - Complete spec conforming TodoMVC implementation [[@lukechu10], [#60](https://github.com/sycamore-rs/sycamore/pull/60)]

## ✨ **0.3.1** _(2021-03-16)_

#### Changelog

- #### ⚡ Features

  - More types in `template!` macro. `template!` can now be nested [[@lukechu10], [#45](https://github.com/sycamore-rs/sycamore/pull/45)]
  - Component lifecycle using `on_cleanup` [[@lukechu10], [#24](https://github.com/sycamore-rs/sycamore/pull/24)]

- #### 🛠 Fixes

  - Add some badges to `README.md` [[@lukechu10], [#44](https://github.com/sycamore-rs/sycamore/pull/44) and [#48](https://github.com/sycamore-rs/sycamore/pull/48)]

## ✨ **0.3.0** _(2021-03-13)_

#### Changelog

- #### ⚡ Features

  - Nested effects. Inner effects are destroyed and recreated when outer effects re-run [[@lukechu10], [#29](https://github.com/sycamore-rs/sycamore/pull/29)]
  - `cloned!` macro for making it easier to clone items into a new scope [[@lukechu10], [#34](https://github.com/sycamore-rs/sycamore/pull/34)]
  - Effects are created inside a reactivity root (using `create_root`). When the root `Owner` is dropped, all effects are also destroyed [[@lukechu10], [37](https://github.com/sycamore-rs/sycamore/pull/37)]
  - Nested templates. Using this, it is also possible to build simple `if`/`else` control flow although there will be a more polished version [[@lukechu10], [#41](https://github.com/sycamore-rs/sycamore/pull/41)]

- #### 🛠 Fixes

  - Parse html root as an `HtmlTree` [[@lukechu10], [#25](https://github.com/sycamore-rs/sycamore/pull/25)]
  - Recreate effect dependencies on each re-run [[@lukechu10], [#29](https://github.com/sycamore-rs/sycamore/pull/29)]

- #### 🛠 Internal Fixes and Improvements

  - Remove double boxing of `Computation` [[@Kestrer], [#31](https://github.com/sycamore-rs/sycamore/pull/31)]
  - Create `CODE_OF_CONDUCT.md` [[@lukechu10], [#33](https://github.com/sycamore-rs/sycamore/pull/33)]
  - Add some preliminary benchmarks for signals and effects [[@lukechu10], [#35](https://github.com/sycamore-rs/sycamore/pull/35)]
  - Add clippy to CI workflow [[@Kestrer], [#42](https://github.com/sycamore-rs/sycamore/pull/42)]

- #### ⚠ **BREAKING CHANGES**

  - Replaced `create_signal` with `Signal::new(...)` and return `Signal` instead of getter/setter functions for increased type safety [[@Kestrer], [#20](https://github.com/sycamore-rs/sycamore/pull/20)]

- #### 📢 Announcements

  - New documentation website: https://sycamore-rs.netlify.app/ [[@lukechu10], [#26](https://github.com/sycamore-rs/sycamore/pull/26) and [#40](https://github.com/sycamore-rs/sycamore/pull/40)]

## ✨ **0.2.0** _(2021-03-07)_

#### Changelog

- #### ⚡ Features

  - Components! In `sycamore` they are simply plain old functions that take their props via their parameters [[#9](https://github.com/sycamore-rs/sycamore/pull/9)]
  - Event listeners now have access to the `Event` object [[#16](https://github.com/sycamore-rs/sycamore/pull/16)]

- #### 🛠 Changes

  - The `template!` macro now returns a `TemplateResult` instead of raw DOM nodes for increased type safety [[#10](https://github.com/sycamore-rs/sycamore/pull/10)]

## ✨ **0.1.1** _(2021-03-07)_

#### Changelog

- #### ⚡ Features

  - New `untracked` utility for explicitly opting out of automatic dependency detection in reactive contexts [[#8](https://github.com/sycamore-rs/sycamore/pull/8)]

- #### 🛠 Fixes
  - Only subscribe to a dependency once in an effect, even if it is called multiple times [[#7](https://github.com/sycamore-rs/sycamore/pull/7)]

## ✨ **0.1.0** _(2021-03-06)_

#### Changelog

- #### ⚡ Features

  - Initial release!
  - Added `template!` macro.
  - Added reactivity primitives.

[@iwburns]: https://github.com/iwburns
[@Kestrer]: https://github.com/Kestrer
[@lukechu10]: https://github.com/lukechu10

repository: parker-codes/sycamore

repo_name: parker-codes/sycamore


text:
The document is about the exploratory analysis of the NOAA Storm Database. The dataset has been taken from this [link](https://d396qusza40orc.cloudfront.net/repdata%2Fdata%2FStormData.csv.bz2). The dataset defines the enviornmental events, like typhoon, thunderstorms, floods, flash floods etc. which have occured since 1950 till 2011. The dataset also describes the economical loss that each of the events have caused to the country. Count for the number of injuries and fatalities that have occured due to each event has been defined too. The project is aimed at deriving the relationships and insights from the dataset about the injuries, property damage and the determining which event is the most dangerous event.

Following are the observations from the analysis:

1. Thunderstorm and hail are the most frequent type of events across the country.
2. Flood and Hurricane are the events which cause the most property damage.
3. Tornado tops the list for the number of injuries and fatalities caused due to an
   event.
4. Heat which was not even in the top 10 events of the country, comes second to
   tornado as the event with most number of fatalities.
5. Statewise analysis highlights the states with the most number of events. Texas,
   Kansas, Oklahoma, Missouri, Indiana and Nebraska have the most number of
   incidents.
6. California which had relatively less count for number of events, tops the list
   for the property damage at more than $120 billion.
7. The number of events has seen a rising trend since the dataset has been
   maintained.

path: /R/NOAA Analysis/Readme.md

gha_language: Jupyter Notebook


text:
# PyTorch Examples with tensorboard

A repository showcasing examples of using [PyTorch](https://github.com/pytorch/pytorch) with tensorboard(https://github.com/lanpa/tensorboardX)

- [X] MNIST Convnets
- [ ] Word level Language Modeling using LSTM RNNs
- [X] Training Imagenet Classifiers with Residual Networks
- [X] Generative Adversarial Networks (DCGAN)
- [ ] Variational Auto-Encoders
- [X] Superresolution using an efficient sub-pixel convolutional neural network
- [ ] Hogwild training of shared ConvNets across multiple processes on MNIST
- [ ] Training a CartPole to balance in OpenAI Gym with actor-critic
- [ ] Natural Language Inference (SNLI) with GloVe vectors, LSTMs, and torchtext
- [ ] Time sequence prediction - create an LSTM to learn Sine waves

Additionally, a list of good examples hosted in their own repositories:

- [Neural Machine Translation using sequence-to-sequence RNN with attention (OpenNMT)](https://github.com/OpenNMT/OpenNMT-py)


text:
[PostageApp](http://postageapp.com) for Node.JS
===================================================

This is a module for Node.JS that allows you to send emails with PostageApp service.
Personalized transactional email sending can be offloaded to PostageApp via the JSON based API.

### [API Documentation](http://help.postageapp.com/faqs/api) • [PostageApp FAQs](http://help.postageapp.com/faqs) • [PostageApp Help Portal](http://help.postageapp.com)

Installation
------------

_Node Package Manager_

In your app directory type
`npm install postageapp`

_Manual_

- Download this: https://github.com/postageapp/postageapp-nodejs/tarball/master
- Unzip that download.
- Copy the resulting folder to `node_modules`
- Rename the folder you just copied to `postageapp`

_GIT Submodule_

In your app directory type:

git submodule add git@github.com:postageapp/postageapp-nodejs.git plugins/postage
git submodule init
git submodule update

_GIT Clone_

In your `node_modules` directory type

git clone git@github.com:postageapp/postageapp-nodejs.git postageapp

Sending a Message
-----
When you require the library, make sure to specify your API key:

    var postageapp = require('postageapp')('YOUR API KEY HERE');

After that, you should be good to go. Load the module in your app and call the `sendMessage` function. Here is a sample of how to use it:

    var postageapp = require('postageapp')('YOUR API KEY HERE');
    postageapp.sendMessage(options);

**NOTE:** The function has been renamed to `sendMessage()` so that this plugin will be more flexible going forward, for when we expand the API.

The `options` parameter on the `sendMessage()` function is a hash that contains all of the arguments that you will be using in your API call. Here is an example API call:

	var options = {
		recipients<EMAIL_ADDRESS>
		subject: "Subject Line",
		from<EMAIL_ADDRESS>
		content: {
			'text/html': 'Sample bold content.',
			'text/plain': 'Plain text goes here'
		}
	}

You can use any of the arguments available to [send_message.json](http://help.postageapp.com/kb/api/send_message) when creating this hash.

Recipients can be passed along as a single string or as an array.

    recipients<EMAIL_ADDRESS>    recipients<EMAIL_ADDRESS><EMAIL_ADDRESS>
If you wish to set Message Variables for each individual recipient, you just have to pass an array for each recipient.

    recipients: {
<EMAIL_ADDRESS>{
		    'variable': 'Value'
	    },
<EMAIL_ADDRESS>{
		    'variable': 'Another Value'
	    }
    };

Content will accept an array for HTML and plain text content.

    content: {
    	'text/html': 'Sample bold content.',
    	'text/plain': 'Plain text goes here'
    };

Subject and from can be simple strings.

    subject: 'Subject Line';
    from<EMAIL_ADDRESS>
Templates can be called by using the template slug from your PostageApp Projects.

	template: 'sample_template';

Message Variables needs to have an array passed into it with the global variable names and values.

    variables: {
    	'variable': 'Variable value',
    	'variable2': 'Another variable'
    };

For more information about formatting of recipients, templates and variables please see the [PostageApp documentation](http://help.postageapp.com/kb/api/send_message).

repository: stefankendall/postageapp-nodejs

repo_name: stefankendall/postageapp-nodejs


text:
# A Brat to Conll converter

This is due to Ji-Ung Lee. A similar script has been used to convert the original Student Essay corpus into CONLL (tab separated) format. (**NB** This does not work for relations. If you want to also transform the relations into CONLL format, you have to adapt the script, or else use DKpro.)

From Ji-Ung's description:

It's a python script, you can execute it with:

``python3 convert_brat_conll.py [path-to-folder-containing-annotation-folders]``

In my use case, I had subfolders with several annotation files inside folders, so I iterate over a list of subfolders and over each file inside the subfolder.
The annotations always consisted of an `.ann` file and a `.txt` file and had the following format:

``<ID> \t <label> \t <start-offset end-offset;start-offset end-offset;...> \t text``

The script writes the text file with the annotations into a `.conll` file of the same name inside the subfolder.
Annotations are converted to IOB tags, so unannotated text is tagged with O.
The text is tokenized using the `nltk TweetTokenizer`.

Note that the script does not handle overlapping annotations, it just writes the first annotation it finds to a given text chunk.
Depending on your use case, you may want to change that.

I also added a python script for merging all conll files produced with the first script. It also writes token indices into the first column.
You can call it with:

``python3 merge_conll.py [path-to-folder-containing-annotation-folders] [output.file]``


text:
---
layout: post
title: "Coldfusion, CAC Cards, and File Uploads over 48k Oh My!"
date: 2010-03-11
comments: false
categories:
 - coldfusion
 - cac-cards
 - iis
 - form-processing
---
Yesterday I was working on a deployment to a UAT server at a US government
building. The govt uses CAC (Common Access Cards) cards (yes, I know it's
redundant) as a security device on all of their pc's and laptops. All of the
websites I deal with there also are using SSL (which may be a requirement with
the CAC card I'm not sure).

Well, it turns out that, by default, on IIS 6 over SSL with a CAC card you
can't upload via a webform a payload over 48k. Thus, my form, which contained
a few fields and a file field, wouldn't upload any form data if I selected a
file of 48k or larger. The cfdump of the form scope just showed nothing. It
was quite a surprise and it took me a while to realize it was the payload size
and not some other issue when my form processing didn't work.

Anyway a few google searches later brought me to [this
page](http://blogs.msdn.com/jiruss/archive/2007/04/13/http-413-request-entity-
too-large-can-t-upload-large-files-using-iis6.aspx) which explained I had to
update a setting in the IIS metabase using the following command:

```vbnet
cscript adsutil.vbs set w3svc/1/uploadreadaheadsize 204800

```

The number at the end is in bytes so that command roughly increases the upload
size to 200k. Note that you should be careful when using this since it is
technically possible to open yourself up to a DOS attack; but since, in my
case, it is an internal and protected site I feel ok moving forward.

You have to run that command from the cmd prompt but if it isn't in your path
you'll need to go to your ISS admin scripts directory
(C:\inetpub\adminscripts) to execute it as explained in this
[article](http://blogs.technet.com/benw/archive/2007/05/03/exchange-2003-isa-
and-attachment-size.aspx).

UPDATE:
If you want to see what your setting is currently at go into your
c:\inetpub\adminscripts directory and call this:

```vbnet
Cscript adsutil.vbs get w3svc/1/uploadreadaheadsize

```

extension: markdown

gha_language: CSS


text:
# Changelog

All Notable changes to `Object` will be documented in this file

## v1.0.0 (released 2015-06-09)

* Initial Release

## v1.1.0

* Changed class name to SuperObject because Object is a reserved word on latest PHP versions

repository: MASNathan/Object

repo_name: MASNathan/Object


text:
The dwl-rviz-plugin
==============================================

DEPRECATED -- please use the following repor: https://github.com/loco-3d/whole_body_state_rviz_plugin
This project will be archived soon.

##  Introduction

The *Dynamic Whole-body Locomotion* library (DWL) describes a set of core functions targeted to developed, design, and deploy locomotion algorithms, i.e. planning, control, etc. DWL is core library used in many projects of the Dynamic Legged Systems Lab of Istituto Italiano di Tecnologia (for more details about the project see http://www.iit.it/en/advr-labs/dynamic-legged-systems.html). For more details about DWL software infrastructure please visit https://github.com/robot-locomotion/dwl.

The dwl_rviz_plugin contains a set of tools and plugins for visualization of: the whole-body state of the robot (dwl_rviz_plugin::WholeBodyStateDisplay), the whole-body trajectory (dwl_rviz_plugin::WholeBodyTrajectoryDisplay), the terrain map (dwl_rviz_plugin::TerrainMapDisplay), the footstep regions (dwl_rviz_plugin::FootstepRegionDisplay), etc. These plugins subscribe to the standarized dwl messages (for more information see https://github.com/robot-locomotion/dwl-msgs).

You can also have tools that allows us to create our custom plugin such as: points (dwl_rviz_plugin::PointVisual), lines (dwl_rviz_plugin::LineVisual), polygons (dwl_rviz_plugin::PolygonVisual), arrows (dwl_rviz_plugin::ArrowVisual), etc.

| [![](https://i.imgur.com/oiBL7Be.gif)](https://www.youtube.com/watch?v=MOhJRMqBWQk&feature=youtu.be) | [![](https://i.imgur.com/4kKhryj.gif)](https://www.youtube.com/watch?v=KI9x1GZWRwE)
|:-------------------------:|:-------------------------:|
| [![](https://i.imgur.com/TUrgkzO.gif)](https://www.youtube.com/watch?v=MOhJRMqBWQk&feature=youtu.be) | [![](https://i.imgur.com/RKe3sNo.gif)](https://www.youtube.com/watch?v=KI9x1GZWRwE)
|||

The source code is released under a [BSD 3-Clause license](LICENSE).

**Author: Carlos Mastalli<EMAIL_ADDRESS>/>
With support from the Dynamic Legged Systems lab at Istituto Italiano di Tecnologia
**

##  Dependencies

The algorithms are built primarily in C++. The library uses a number of the local dependencies, which some of them are optionals.

The dwl-rviz-plugin is a ROS packages with the following required dependencies:
* [Boost](http://www.boost.org) (version 1.5.4 or higher)
* [Rviz](http://www.cmake.org)
* [dwl](https://github.com/robot-locomotion/dwl)
* [dwl-msgs](https://github.com/robot-locomotion/dwl-msgs)

The following dependencies are optional:
* [Doxygen](http://www.doxygen.org)

##  Building

Before building the dwl_rviz_plugin, you need to install the dependencies of DWL. Additionally you have to build dwl and dwl_msgs with catkin.

The dwl_rviz_plugin is a catkin project which can be built as:

	cd your_ros_ws/
	catkin_make

repository: robot-locomotion/dwl-rviz-plugin

repo_name: robot-locomotion/dwl-rviz-plugin


text:
# Starcraft risk

Starcraft risk is a browser boardgame made with HTML, CSS and Javascript. It's basicly the game risk but in a differnt enviorment. If you're not familiar with the game risk you can read about it here http://en.wikipedia.org/wiki/Risk_%28game%29.

# How to play
This section describes how to play the game.

## Setup
### Number of players
First choose the number of players
![Number of players](https://github.com/whey86/starcraft/blob/master/screens/1.png?raw=true)
### Enter player names and race
Diffrent races has diffrent achivements
![Race and name](https://github.com/whey86/starcraft/blob/master/screens/2.png?raw=true)
## The game
The game is turnbased game and each player will do diffrent actions on each phase. All the phases can be divided into two blocks, prephases and gamephases.

### Prephases
In the start of the game you place your starting units etc which will be explained below.

1. Place your base

![Base](https://github.com/whey86/starcraft/blob/master/screens/3.png?raw=true)

The circle represents your base which gives +1 unit
2.

### GamePhases
The gamephases will be repeted until someone has won the game.

1. Deploy reinforcement
2. Attack
![Attack](https://github.com/whey86/starcraft/blob/master/screens/4.png?raw=true)

First line displays the number of units the attacker and defender has left
Second line the dices rolled

The bottom part you choose how many units attacks(max 3, min 1)
Click end to end the battle

3. Achivement
4. Movement
![Movement](https://github.com/whey86/starcraft/blob/master/screens/5.png?raw=true)
Choose number of units to transfer

## Finish phase

Click the done button to finish your deploy, attack, achivement or movementphase.

![Movement](https://github.com/whey86/starcraft/blob/master/screens/6.png?raw=true)


text:
The FlowStacks Sample Workflow
------
Version 1.0:
Alpha - Release

How to Use the Sample FlowStacks Project
------
1. Clone the Repo
2. Refer to the Alpha documentation here: https://flowstacks.com/

repository: jay-johnson/social-workflow

repo_name: jay-johnson/social-workflow