text:
RadioDNS.uk
===========

This is the code repository that powers the [radiodns.uk] website. The website is a directory
listing of all the radio stations in the United Kingdom which have [RadioDNS] Hybrid Radio
services available. Transmitter and DAB multiple information comes from [Ofcom].

The website written in [Ruby] and uses the [Sequel] and [Roda] gems.

The steps to build the site are:

1. Load the list of TV Anytime genre files into the database
2. Load the [Transmitter Parameters] spreadsheet from Ofcom into the database
3. For each service on FM and DAB, lookup the Authoritative FQDN using radiodns.org
4. For each Authoritative FQDN, attempt to load the Service Information (SI.xml) file

## Data Model

<img src="https://github.com/njh/radiodns-uk/blob/master/docs/data-model.png?raw=true" width="533" height="388" alt="Data Model Diagram" />

## Project Structure

These are the key files and directories that make up the project:

* `Gemfile` Used by [Bundler] to list all the dependencies for this project
* `Rakefile` parent [rake] file, describing build tasks. Run `rake -T` to list all the tasks
* `ansible` contains an [Ansible] playbook, used to deploy the application to the live server
* `app.rb` the main web server application and top level router
* `bin` various ruby scripts, used to generate the site
* `db.rb` this is used to initialise [Sequel] and sets the `DB` constant
* `genres` collection of JSON files, mapping [TV Anytime] genre IDs to genre names
* `helpers.rb` view helpers - methods to generate HTML to make the view code simpler
* `migrate` [Sequel] database migration files that create/update the database schema
* `models` directory containing the [Sequel] database models
* `models.rb` require this file to setup [Sequel] and load all the database models
* `public` static files served directly by the HTTP server
* `si_files` the various `SI.xml` files are downloaded to this directory
* `routes` directory containing route files (controllers) for main part of application
* `spec` Rspec files to run tests against the application and model code
* `tasks` directory containing [Rake] task files
* `views` [Erubi] templates for the the HTML and XML pages

## Development

You may need to install a recent version of [Ruby] on your computer before you can run the scripts.

To perform the geographic calculations on the transmitter locations, you also need Python 2.7 and the GDAL library.

To install GDAL on a Mac run:

    $ brew install gdal

To install GDAL on Debian/Ubuntu run:

    $ apt-get install python-gdal

Then make sure you have ruby [Bundler] installed:

    $ gem install bundler

And install all the dependencies:

    $ bundle install

To initialise the database run:

    $ bundle exec rake db:migrate

Then fill it up with data using:

    $ bundle exec rake load:all

Run `rake -T` to see a list of the individual tasks:

    $ bundle exec rake -T
    rake clean             # Deleted all the generated files (based on .gitignore)
    rake db:annotate       # Annotate Sequel models
    rake db:migrate        # Migrate database to latest version
    rake load:all          # Load all data into the database
    rake load:authorities  # Load authority information for each bearer from ra...
    rake load:genres       # Load TVA genre data into the database
    rake load:ofcom        # Load Ofcom data into the database
    rake load:si           # Load SI files into the database
    rake publish           # Publish the local SQLite database to the web server
    rake spec              # Run RSpec code examples

You can then run a local webserver using:

    $ bundle exec shotgun

Shotgun will reload the application after every request, which makes development much easier.

And then open the following URL in your browser: [http://localhost:9393/]

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/njh/radiodns-uk.
This project is intended to be a safe and welcoming space for collaboration. Contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

## License

The gem is available as open source under the terms of the [MIT License].

[Ansible]:                   http://www.ansible.com/
[Bundler]:                   http://bundler.io/
[Erubi]:                     https://github.com/jeremyevans/erubi
[http://localhost:9393/]:    http://localhost:9393/
[MIT License]:               http://opensource.org/licenses/MIT
[Ofcom]:                     https://www.ofcom.org.uk/
[radiodns.uk]:               http://www.radiodns.uk/
[RadioDNS]:                  http://www.radiodns.org/
[Rake]:                      https://github.com/ruby/rake
[Roda]:                      http://roda.jeremyevans.net/
[Ruby]:                      http://ruby-lang.org/
[Sequel]:                    http://sequel.jeremyevans.net/
[Transmitter Parameters]:    https://www.ofcom.org.uk/spectrum/information/radio-tech-parameters
[TV Anytime]:                http://www.tv-anytime.org/

repository: njh/radiodns-uk

branch_name: refs/heads/main

gha_language: Ruby

repo_name: njh/radiodns-uk


text:
intelliseats
============

Demo app for the SLC hackathon in Denver, CO.

Credits
============

Big thanks to the following.
[Blog on getting node running on Azure](http://seroter.wordpress.com/2012/08/09/combining-clouds-accessing-azure-storage-from-node-js-application-in-cloud-foundry/) - since apparently I forgot how to do this.

repository: KevalMahendra/intelliseats

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: KevalMahendra/intelliseats


text:
# Advanced Shiny [Video]
This is the code repository for [Advanced Shiny [Video]](https://www.packtpub.com/big-data-and-business-intelligence/advanced-shiny-video?utm_source=github&utm_medium=repository&utm_campaign=9781788471688), published by [Packt](https://www.packtpub.com/?utm_source=github). It contains all the supporting project files necessary to work through the video course from start to finish.
## About the Video Course
Shiny combines the computational power of R with the interactivity of the modern web. Along with hosting standalone apps on a webpage or embedding them in R Markdown, you can also extend your Shiny apps with CSS themes, htmlwidgets, and JavaScript actions.

At first, we begin by covering new Shiny functions, allowing you to save and restore the state of a Shiny application. Here you will learn to create a fully-featured application by exploring and analyzing the data with the use of an example. Moving on, this application will be used to demonstrate their use and function. Bookmarking and reading URLs, reading client information from browsers as well as passwords, and the use of functions and modules will all be added to the application. Next, you will learn about using JavaScript within Shiny applications. From a simple script to improve the appearance of an application to a more advanced application. An interactive map will be added using the htmlwidgets package as well as using shinyjs to perform common JavaScript tasks without writing any JavaScript also learning graphic using the Google Charts API.

Finally, you will learn the tips and tricks to share your applications. There are several ways to share Shiny applications: Gist, .zip, GitHub, and Shiny Server (cloud- and self-hosted), some of which require more work on your users’ part and some on your part. Get to explore the different methods with its advantages and disadvantages. By the end of this course, you will have all the information you will need on Shiny’s advanced techniques.

What You Will Learn

At the end of this course, you will be able to understand what the Webservices are, a and their functionality,

You will learn How to test Webservices and REST API using SoapUI

You will understand the importance of automating services

You will learn new language called groovy to automate Webservices

You will be able to develop robust automation Testcases and manual Testcases for Webservices and API's

You will understand the importance and procedure of Mocking the Webservices

You will learn basic sql concepts and procedure for database testing using SoapUI

Will get clear picture on Security Testing using SoapUI

You will understand how to generate neat reports for execution results

## Instructions and Navigation
### Assumed Knowledge
To fully benefit from the coverage included in this course, you will need:

Basic Shiny skills

Basic JavaScript knowledge

### Technical Requirements
This course has the following software requirements:

R studio

System capabale of running R studio

## Related Products
* [Advanced Applied SQL for Business Intelligence and Analytics [Video]](https://www.packtpub.com/application-development/advanced-applied-sql-business-intelligence-and-analytics-video?utm_source=github&utm_medium=repository&utm_campaign=9781788470803)

* [UI Development with Shiny [Video]](https://www.packtpub.com/big-data-and-business-intelligence/ui-development-shiny-video?utm_source=github&utm_medium=repository&utm_campaign=9781788470780)

* [WebServices/REST API Testing with SoapUI+ Real Time Projects [Video]](https://www.packtpub.com/application-development/webservicesrest-api-testing-soapui-real-time-projects?utm_source=github&utm_medium=repository&utm_campaign=9781789134926)

license: MIT

repository: PacktPublishing/advanced-shiny-video

repo_name: PacktPublishing/advanced-shiny-video


text:
---
layout: post
title: Research Intern Booklet
category: academics
image: research_intern_booklet.png
tags: [wona]
---

Watch Out! IIT Roorkee brings to you the 'Research Intern Booklet.' An extensive guide for various Research Internship programs available across the globe. The associated details like the eligibility criteria, application procedure, corresponding timelines, necessary documents, Stipend, etc., have been mentioned for each of these programs.

Disclaimer: Despite several hours of work by multiple members, we cannot claim this document to be error-free. The timelines, dates, and other details are for reference sake only. They may vary, primarily due to the pandemic. Please refer to the official websites of the relevant programs to get the updated information.

<button type="button" class="btn btn-primary btn-block btn-lg">Download the Booklet Here!</button>

**Design Credits**:- Janani

gha_language: SCSS

gha_license_id: MIT


text:
# Agency Calculator by Yan Qin
## Enviorment Requirement
Please have [node.js](https://nodejs.org/en/download/)  installed, the project was tested under 8.11.4 LTS
## Build Project
Please build the project by issuing command
`npm install`
## Running Project
The project is run through unit-test for testing runability, to run the unit-test, simply issue the following command after the project built successfully.
`npm test`


text:
# The predefined variables

Some variables are predefined and they can be used into `.ffizer.yaml` into the `ignores` section or `default_value` via handlebars expression.

- `ffizer_dst_folder` contains the value from cli arg `--destination`
- `ffizer_src_rev` contains the value from cli arg `--rev`
- `ffizer_src_uri` contains the value from cli arg `--source`

The following sample combine a helper function `file_name` with `ffizer_dst_folder`.

```yaml
variables:
  - name: project_name
    default_value: "{{ file_name ffizer_dst_folder }}"
```

repository: darlaam/ffizer

gha_license_id: NOASSERTION

repo_name: darlaam/ffizer


text:
Random Factorio Things (RFT for short) extends vanilla (base) game, adding new assembling machines, new buildings tiers and new modules.

RandomFactorioThings development is stopped. There will be no content updates. Minor bug fixes and updates for new Factorio versions will still come out.

### Main features:

- New tiers of common machines, such as furnaces or mining drills.
- New "Nuclear" tier for assemblling machines, inserters and transport belts.
- Level 4-6 modules.
- Merged modules up to 4 levels. Merged modules combine characteristics of two modules, but take only one module slot.
- Ability to combine wood and coal to get more effective fuel. ~~By the way, not really a main feature.~~

Join my [Discord server](https://discord.gg/PJXWT2e) to get latest news about my mods and just to talk with each other. I'll wait for you there!
You can support me on [Patreon](https://www.patreon.com/JohnTheCoolingFan). Your support is very important for me!

### Available languages:

*   English (en) by [JohnTheCF](https://mods.factorio.com/user/john_thecf)
*   Russian / Русский (ru) by [JohnTheCF](https://mods.factorio.com/user/john_thecf)
*   Ukrainian / Українська (uk) by [IgorLutiy](https://github.com/IgorLutiy)
*   Polish / Polski (pl) by Guru [TSM]#8528
*   German / Deutsch (de) by PanCave

### Other my mods:

*   [Plutonium Energy](https://mods.factorio.com/mod/PlutoniumEnergy) (RFT has integration with Plutonium Energy)
*   [No Artillery Map Reveal](https://mods.factorio.com/mods/John_TheCF/NoArtilleryMapReveal)
*   [Placeable-off-grid](https://mods.factorio.com/mod/PlaceableOffGrid)

# Support

If you would like to support me, you can donate me using BTC, BCH or SLP (images are too large, so it's just a link):
[Bitcoin Cash (BCH)](https://imgur.com/tBASbzf.png= 50x)
[Bitcoint (BTC)](https://imgur.com/NwaMwIX.png =50x)
[SLP](https://imgur.com/0Kga1Ee.png =50x)

You can also contact me on discord, if you would like to dontae some other way.

repository: JohnTheCoolingFan/RandomFactorioThings

gha_language: Lua

repo_name: JohnTheCoolingFan/RandomFactorioThings


text:
# sourcemap

A tool for generating sourcemaps based on input/output files in linear time.

# Example

File `foo.js`:
```javascript
/**
 * @return {string}
 */
function foo() {
    return "foo";
}
```
File `bar.js`:
```javascript
console.log(foo());
```

Say you have a build procedure which concatenates these files and removes comments and spaces, producing `script.js`:
```javascript
function foo(){return "foo";}console.log(foo());
```

The tool will will generate [sourcemap v3](https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit):
```bash
lushnikov:~/prog/sourcemap(master)$ python gensm.py foo.js bar.js script.js > script.js.map
lushnikov:~/prog/sourcemap(master)$ cat script.js.map
{"mappings": "AAGA,SAAS,MACL,QAAQ,MCJZ,QAAQ,IAAI", "sourceRoot": "http://localhost:8090", "sources": ["foo.js", "bar.js"], "version": 3, "names": [], "file": "script.js"}

```

**Notes**:
- `sourceRoot` is set to localhost; change it to whatever you want.
- order of input files is crucial. If the script fails to match inputs with output, it fails with exception `Exception: Failed to match generated and source files`
- Algorithm has linear complexity, though the current implementation is not quite fast and produces ~100k of sourcemapping in a second.

repository: aslushnikov/generate-sourcemap

repo_name: aslushnikov/generate-sourcemap


text:
# Random Last.fm Artist Picker

## Requirements

 * Docker
 * Docker Compose
 * Last.fm API key ([from here](http://www.last.fm/api/account/create))
 * Spotify API key ([from here](https://developer.spotify.com/my-applications/))

## Usage

```bash
$ composer install
$ cp config/autoload/local.php.dist config/autoload/local.php
$ docker-compose build
$ docker-compose up --abort-on-container-exit --force-recreate
```

Configure `local.php` with your username and API keys.

Head to [http://localhost:8080](http://localhost:8080). Refresh for a new artist.

### Limitations

 * No tests. deal-with-it.gif
 * Limited to first 1,000 of your top artists.
 * Slow first request
 * Manual cache clearing (delete `./cache/*.json`)

repository: asgrim/random-lastfm-artist

repo_name: asgrim/random-lastfm-artist


text:
# SwitchDex

[![Chat with us on Discord](https://img.shields.io/badge/chat-Discord-blueViolet.svg)](https://discord.gg/JqheZms)
[![CircleCI](https://circleci.com/gh/0xProject/0x-launch-kit-frontend.svg?style=svg)](https://circleci.com/gh/0xProject/0x-launch-kit-frontend)
[![dependencies Status](https://david-dm.org/verisafe/veridex/status.svg)](https://david-dm.org/verisafe/veridex)
[![devDependencies Status](https://david-dm.org/verisafe/veridex/dev-status.svg)](https://david-dm.org/verisafe/veridex?type=dev)
[![Coverage Status](https://coveralls.io/repos/github/VeriSafe/VeriDex/badge.svg?branch=development)](https://coveralls.io/github/VeriSafe/VeriDex?branch=development)

This project is forked from [veridex](https://github/verisafe/veridex) and it have a goal to be the most complete open-source 0x based dex out there.

This repo ships with both an ERC-20 token trading interface and an ERC-721 marketplace interface.

To use this fork the following actions are required:

-   Add ESH, SDEX, DESH and 0x as pairs
-   Lets us know you are using this fork
-   Add a Powered by 0x and Switch
-   Don't use another pool associated with this code besides the one on: [Veridex Pool](https://0x.org/zrx/staking/pool/16). If you are market maker you can join Veridex market pool at [Join as Maker](https://dex.verisafe.io/#/erc20/join-as-maker)

## Dex Wizard

Please follow these instructions if you plan to use your own domain: [DEX on your domain](ADD_DEX_BY_DOMAIN.md)

## Adding token

Please follow all the instructions here: [ADD TOKEN](ADD_TOKEN.md)

## Adding token to launchpad

Please follow all the instructions here: [ADD TOKEN LAUNCHPAD](ADD_TOKEN_LAUNCHPAD.md)

## Deployed DEX's

List of deployed dex's using forks of this source code:

-   [VeriDex](https://dex.verisafe.io)
-   [0xChange](https://0xchange.verisafe.io)
-   [Belifex](https://dex-belifex.com)

If you are using the source code of this fork, please let me know! Help the project adding ESH as a pair on your fork!

If you have the URL of an existing relayer, you can use this frontend against it. After installing the dependencies, start the application with this command, replacing `RELAYER_URL` and `RELAYER_WS_URL` with the proper value:

```
REACT_APP_RELAYER_URL='https://RELAYER_URL/' REACT_APP_RELAYER_WS_URL='wss://RELAYER_URL/' yarn start
```

## Usage

Clone this repository and install its dependencies:

You can optionally pass in any relayer endpoint that complies with the [0x Standard Relayer API](https://github.com/0xProject/standard-relayer-api). For example, if you want to show liquidity from 0x API:

```
REACT_APP_RELAYER_URL='https://api.0x.org/sra' REACT_APP_RELAYER_WS_URL='wss://api.0x.org/sra' REACT_APP_NETWORK_ID=1 REACT_APP_CHAIN_ID=1 yarn start
```

### Creating a relayer for development

If you don't have a relayer, you can start one locally for development. First create a `docker-compose.yml` file like this:

```yml
version: '3'
services:
    ganache:
        image: 0xorg/ganache-cli
        ports:
            - '8545:8545'
    backend:
        image: 0xorg/launch-kit-backend:latest
        environment:
            HTTP_PORT: '3000'
            NETWORK_ID: '50'
            CHAIN_ID: '1337'
            WHITELIST_ALL_TOKENS: 'true'
            FEE_RECIPIENT: '0x0000000000000000000000000000000000000001'
            MAKER_FEE_UNIT_AMOUNT: '0'
            TAKER_FEE_UNIT_AMOUNT: '0'
            MESH_ENDPOINT: 'ws://mesh:60557'
        ports:
            - '3000:3000'
    mesh:
        image: 0xorg/mesh:7.2.1-beta-0xv3
        environment:
            ETHEREUM_RPC_URL: 'http://ganache:8545'
            ETHEREUM_CHAIN_ID: 1337
            VERBOSITY: 3
            RPC_ADDR: 'mesh:60557'
            # You can decrease the BLOCK_POLLING_INTERVAL for test networks to
            # improve performance. See https://0x-org.gitbook.io/mesh/ for more
            # Documentation about Mesh and its environment variables.
            BLOCK_POLLING_INTERVAL: '5s'
        ports:
            - '60557:60557'
            - '60558:60558'
            - '60559:60559'
```

and then run `docker-compose up`. This will create three containers: one has a ganache with the 0x contracts deployed and some test tokens, another one has an instance of the [launch kit](https://github.com/0xProject/0x-launch-kit) implementation of a relayer that connects to that ganache and finally a container for [0x-mesh](https://github.com/0xProject/0x-mesh) for order sharing and discovery on a p2p network.

After starting those containers, you can run the following in another terminal. A browser tab will open in the `http://localhost:3001` address. You'll need to connect MetaMask to `localhost:8545`.

```
REACT_APP_RELAYER_URL='http://localhost:3000/v3' REACT_APP_RELAYER_WS_URL='ws://localhost:3000' yarn start
```

```
git clone git@github.com:SwitchOS/veridex.git
cd Veridex
yarn
```

## TODO

This is a detailed list of planned features to add to this DEX (includes Switch backend) on long term:

-   [x] List Dex Trades
-   [x] Add troll box using ChatBro
-   [x] Fully configuration of orderbook and sell and buy cards
-   [x] Support multiple wallets, like Portis, Torus etc please see list of planned wallets below,
-   [x] Add mobile support
-   [x] Support to transfer tokens
-   [x] Display prices and total holdings on wallet
-   [x] Display median price
-   [x] Add notifications
-   [x] List descriptions for each project
-   [x] List Market Trades
-   [x] List Markets stats
-   [x] List last prices for each token
-   [x] Add Fiat on Ramp
-   [x] Add 0x Instant to easy buy of assets
-   [x] Adding graphs like Trading View
-   [x] Support for mobile dapp browswers like Enjin and Coinbase
-   [x] Mobile friendly
-   [x] Connect to 0x mesh
-   [x] Adding Account market stats
-   [ ] Click on buy and sell button to auto-fill
-   [ ] Create a costumized front page
-   [x] Order Matching on the Frontend when doing limit orders
-   [x] Page for trading competitions
-   [x] Add instant as standalone
-   [x] Code splitting
-   [ ] Report data to the most known crypto data aggregators (In progress)
-   [x] Theme switcher
-   [x] Dex Wizard
-   [x] Upgrade 0x v3
-   [ ] [i18n](https://github.com/i18next/react-i18next)
-   [x] Add [tour](https://github.com/elrumordelaluz/reactour)
-   [ ] Add crypto price calculator
-   [x] Add Swap interface

## IDEAS FOR COMMUNITY DEVELOPERS

This is some ideas that community devs could work to add value to this dex on long term.

-   [] Create simple swap interface with support for meta transactions Eg [Meta](https://0x.org/docs/guides/unlocking-meta-transaction-swaps)
-   [] Add Token factory
-   [] Wizard for Marketplace

## Planned Wallets Support

-   [x] [Metamask](https://metamask.io/)
-   [ ] [Torus](https://docs.tor.us/developers/getting-started)
-   [x] [Portis](https://developers.portis.io/)
-   [x] [Fortmatic](https://developers.fortmatic.com/)
-   [x] [WalletConnect](https://docs.walletconnect.org/)
-   [x] [EnjinWallet](https://enjin.io/products/wallet)
-   [x] [CoinbaseWallet](https://wallet.coinbase.com/)
-   [x] [TrustWallet](https://trustwallet.com)
-   [x] [CipherBrowser](https://www.cipherbrowser.com/)

### Using Switch relayer

```

REACT_APP_RELAYER_URL='https://dex-backend.verisafe.io/v3' yarn start

```

[Switch OPEN API SPEC](https://switchos.github.io/veridex-api-spec/)

This relayer has additional endpoints to enable market view data with stats and candles. We will be adding as an opt-in option use these features in your frontend. That way you can use a Standard Relayer without any issues.

## Environment variables

You can create a `.env` file to set environment variables and configure the behavior of the dApp. Start by copying the example file (`cp .env.example .env`) and modify the ones you want. Some things you can configure are:

-   `REACT_APP_RELAYER_URL`: The URL of the relayer used by the dApp. Defaults to `http://localhost:3000/v3`
-   `REACT_APP_RELAYER_WS_URL`: The Websocket URL of the relayer used by the dApp. Defaults to `http://localhost:3000/`
-   `REACT_APP_FEE_PERCENTAGE`: The fee percentage amount charged on 0x orders filled via the Forwarder. Note this is limited to `*/WETH` orders for the taker.
-   `REACT_APP_FEE_RECIPIENT`: The address which receives the fees from the Forwarder.
-   `REACT_APP_NETWORK_ID`: The network id to build the front end for. E.g `42` for Kovan, `50` for Ganache
-   `REACT_APP_CHAIN_ID`: The chain id to build the front end for. E.g `42` for Kovan, `1337` for Ganache
-   `REACT_APP_DEFAULT_ORDER_EXPIRY_SECONDS`: The expiration time for an order. Defaults to 1 day.

Check `.env.example` for the full list.

### Using custom themes

If you want to add your own theme for the app, please read the [THEMES.md](THEMES.md) file

### Using custom Config on the DEX

If you want to config the app and markets, please read the [CONFIG.md](CONFIG.md) file

```

```

repository: SwitchOS/switchdex

branch_name: refs/heads/development

gha_language: TypeScript

repo_name: SwitchOS/switchdex


text:
# The Buendia Tree
The Buendia Tree is the implementation of extended Kinship domain problem using **First Order Logic**. Kinship domain problem is a task to find out relationship or kinship between family members. In this repository, the relationship between members of the Buendia family has been described using First Order Logic. It is inspired from the book *One Hundred Years of Solitude* and the family has seven generations. It is not like a normal family and sometimes has pretty messed up relationships (You'd know if you read the book). The family tree looks like this:

![Buendia Family Tree](/oyos_characters_tree_420.jpg)

## First Order Logic
In formal terms, First Order Logic is defined as a set of logical rules which are explicitly defined to describe a problem. Every problem is operated under some set of rules which are an intrinsic part of the problem. It is the way to exploit those rules and define objects and individuals, as well as their properties and the relationships between them. Sounds Confusing? Let's take an example in kinship domain.

In a family, there are many relationships and all of them are operated under a set of rules. For Instance "Your **grandfather** is a **male** who is also **parent** of your **father**". In this case, an individual is your grandfather if it is **male** **parent** of your **father**. Now you can derive your grandfather if you know your father and his parents and can find the male one from them. Formally you can write it :
**grandfather(X, Y) => father(Z, Y) & parent(W, Z) & gender(W, "male")**
The above rule states that X is the grandfather of Y if  Z is the father of Y and W is the parent of Z and gender of W is male.
This is how rules are described in **First Order Logic**.

### Syntax And Semantics
Logic in first order is made of following entities:

1. **Functions**
A function takes multiple arguments as input and returns a single object.
For Example : **mul(x,y)**
2. **Predicates**
A predicate takes a single argument and returns binary value.
For Example : **even(x)**
3. **Relations**
A relation takes multiple arguments and returns binary value.
For Example : **divides(x,y)**
4. **Quantifiers**
What makes first-order logic powerful is that it allows us to make general assertions using quantifiers. The universal quantifier ∀ followed by a variable x is meant to represent the phrase "for every x."

Dual to the universal quantifier is the existential quantifier, ∃, which is used to express assertions such as "some number is even," or, "between any two even numbers there is an odd number."
5. **Connectives**
Symbols which connect the clauses.
For Example : not (~), and (^), or (v), implies (=>), if and only if (<=>)

## Inference
Inferences are made when a person (or machine) goes beyond available evidence to form a conclusion. With a deductive inference, this conclusion always follows the stated premises. In other words, if the premises are true, then the conclusion is valid. First Order Logic in deductive inference involves conditional reasoning problems which follow the "if A, then B" format i.e. the process of deriving new relation using a set of logical rules is known as inference.
The Inference can be derived by following processes:
### Unification
Unification in logic is a kind of logical substitution. For instance, it is given that **Knows(John, Jane)** and we have to find **Knows(John,x)** i.e. people who know John. We can unify both of them and say that Jane is a subset of x. It is a basic building block of Inference model.
Formally Unification procedure can be defined as:
*Unify(P, Q)* takes two atomic(i.e. single predicates) sentences P and Q and returns a substitution that makes P and Q identical.

### Forward Chaining
Forward chaining starts with the available data and uses inference rules to extract more data (from an end user, for example) until a goal is reached. An inference engine using forward chaining searches the inference rules until it finds one where the antecedent (If clause) is known to be true. When such a rule is found, the engine can conclude, or infer, the consequent (Then clause), resulting in the addition of new information to its data. To understand it better let us take a classical example:
Given that:*The law says that it is a crime for an American to sell weapons to hostile nations. The country Nono, an enemy of America, has some missiles, and all of its missiles were sold to it by Colonel West, who is American.*.

Step 1: West is an American(Given) |  Nono owns missiles(Given) | Nono is an enemy of America(Given)

Step 2: Missile is a Weapon (Given) | West sold missiles to Nono(Since Nono owns missiles) | Nono is  hostile(Since Nono is an enemy of America)

Step 3: West is a criminal(Since West is american who sold weapon to hostile country)

![Forward Chaining](/forward_chaining_example.png)

But this method would take exponential time in a well defined world. There are many advanced inference algorithms are available such as *Backward Chaining*, *Resolution Refutation Procedure* and  *lifted inference*. You can read  about them [here](http://pages.cs.wisc.edu/~dyer/cs540/notes/fopc.html)

## Application of First Order Logic
First order logic is a deterministic model and that is why alone it has very few advantages. Since the uprising of AI, It became an intrinsic part of it. AI usually works on a system and that system has to follow some rules, therefore, First Order  Logic became the most expressive as well as the simplest way to represent those rules.
Alongside this, It is also a basic block of Markov Logic Networks which has a potential to revolutionalize artificial intelligence.
## The Buendia Domain
Let's come to Buendia tree again. Now as we know First order logic is dependent on two entities data and Logic.
### Data
In this domain, the only input data used is marriage between two individuals, the parent-child relationship and gender of the individuals. Everything else is derived using logical rules.
### Logic
You can checkout all the logical rules [here](/logic.py)
### Test
To run test file
```bash
python3 -m unittest test.py
```

## References
1. [First Order Logic](https://leanprover.github.io/logic_and_proof/first_order_logic.html)
2. [Inference](http://www.cs.cornell.edu/courses/cs4700/2011fa/lectures/16_FirstOrderLogic.pdf)
3.  [AI and First Order Logic](https://ipvs.informatik.uni-stuttgart.de/mlr/marc/teaching/15-ArtificialIntelligence/10-firstOrderLogic.pdf)
4. [First Order Logic with Examples](https://formal.iti.kit.edu/~beckert/teaching/Einfuehrung-KI-WS0304/08FirstOrderLogic.pdf)

repository: Hsankesara/The-Buendia-Tree

repo_name: Hsankesara/The-Buendia-Tree


text:
# UPSILoN Extract
UPSILoN Extract is a Python script for extracting information from (time, magnitude, error) light curve data. It was created from the functionality built into the [UPSILoN](https://github.com/dwkim78/py3-UPSILoN) periodic variable star classifier ([Kim & Bailer-Jones 2015](https://arxiv.org/abs/1512.01611)).

All of the extraction functionality is directly from the UPSILoN classifier. UPSILoN Extract includes only the needed modules so that users do not have to download the Random Forest classifier included in the UPSILoN library. Additionally, UPSILoN Extract gives a command line tool `upsilon-extract` for batch processing light curve data files.

## Installation
To install UPSILoN Extract from the GitHub repository, run the following commands:

```
$ git clone https://github.com/ExcaliburZero/upsilon-extract.git
$ cd upsilon-extract
$ python setup.py install
```

## Usage
UPSILoN Extract should be given information on how to find each of the data files that you want to process. The results will be sent to `stdout`, and the processed file number will be sent to `stderr` to allow the user to see the progress of the program as the results are redirected into an output file.

```
$ upsilon-extract ~/Documents/smc/OGLE-SMC-RRLYR- ".dat" 4 1 2 > output.dat
0001
0002
$ cat output.dat
0001	0.222105266231	0.168940812264	2.35350124662	0.711495042227	-0.706604217476	654	0.558817465271<PHONE_NUMBER>09	-72.6342860101	9.37487384865e-05	0.344141984626	0.430623638191	1.06856914681	2.28453779004	0.3225	0.456557492082	0.309140970985	0.984962463379	-0.149973531529	-0.0599727535122	0.0421956525987	0.773791293693	19.0023237696	0.205908079655
0002	0.137918745451	0.134565757297	2.3456030004	0.935545830991	-0.455123603177	645	0.594781360714<PHONE_NUMBER>35	-64.2267065839	0.000106218547561	0.24627817273	0.683383802924	1.1766264556	-0.159475344256	0.215	0.474068384018	0.344516869683	0.990370690823	0.188820654255	-0.0653176913294	0.0570889600839	0.803583677383	19.0047431589	0.137336005957
```

### Command Structure
```
upsilon-extract FILE_PREFIX FILE_SUFFIX DIGIT_PADDING START END
```

| Command Part    | Description
|-----------------|-------------
| `FILE_PREFIX`   | The part of the path of the data files in front of the id number. Ex. `~/Documents/smc/OGLE-SMC-RRLYR-`
| `FILE_SUFFIX`   | The part of the path of the data files after the id number. Ex. `.dat`
| `DIGIT_PADDING` | The number of digits to pad the id numbers to. Ex. `4` will give id numbers like `0001`.
| `START`         | The id number of the first file to process. Ex. `1`
| `END`           | The id number of the last file to process. Ex. `2000`

It is also reccomended to redirect the results of the program into an output file. This can be done using a shell output redirection.

```
upsilon-extract FILE_PREFIX FILE_SUFFIX DIGIT_PADDING START END > OUTPUT_FILE
```

### Input File Structure
The input data files should give only the time, magnitude, and error data. Each (time, mag, err) data point should be given each on their own lines, in chronological order, and seperated by spaces.

```
TIME_1 MAG_1 ERR_1
TIME_2 MAG_2 ERR_2
...
```

The data points should use the following units:

| Data Type | Units | Description
|-----------|-------|-------------
| Time      | days  | Heliocentric Julian Day - 2450000
| Magnitude | mag   |
| Error     | mag   | Uncertainty of magnitude

### Output Structure
UPSLILoN Extract gives the following pieces of information through `stdout` for each processed input file. The data for each input file are seperated by newlines, and each attribute is tab separated.

The order given here is the order that the atrtibutes are given in the program output.

* id
* amplitude
* cusum
* eta
* hl_amp_ratio
* kurtosis
* n_points
* period
* period_SNR
* period_log10FAP
* period_uncertainty
* phase_cusum
* phase_eta
* phi21
* phi31
* quartile31
* r21
* r31
* shapiro_w
* skewness
* slope_per10
* slope_per90
* stetson_k
* weighted_mean
* weighted_std

## Licensing
All of the code in the `extract_features` folder is from the UPSILoN library, licensed under the MIT License by Dae-Won Kim. See the [UPSILoN library history](https://github.com/dwkim78/py3-upsilon/commits/2c3e1da134014bf75fd672044f03f3b650045b10) for more attribution information.

The remainer of UPSILoN is also licensed under the MIT License.

repository: ExcaliburZero/upsilon-extract

repo_name: ExcaliburZero/upsilon-extract


text:
# Minitest::RedGreen

Adds red/green colors to standard minitest output

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'minitest-red_green'
```

Or your gem's gemspec:

```ruby
spec.add_development_dependency 'minitest'
spec.add_development_dependency 'minitest-red_green'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install minitest-red_green

## Usage

Once you add this gem to your `Gemfile`, minitest should start printing out red and green colors. If you wish to disable this for some reason,

```ruby
Minitest::RedGreen.disabled = true
```

Although, it's probably much simpler to simply remove this gem from your `Gemfile` in the first place :)

## Why not minitest-reporters

There is another gem, [minitest-reporters](https://github.com/kern/minitest-reporters/), that also adds red/green progress output. However, often this is overkill for gems or small applications.

## Contributing

1. Fork it ( https://github.com/[my-github-username]/minitest-red_green/fork )
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create a new Pull Request


text:
Cloudinary Java/Spring MVC Sample Project on Google AppEngine
=============================================================

A simple web application that allows you to uploads photos, maintain a database with references to them, list them with their metadata, and display them using various cloud-based transformations.

## Installation

Run the following commands from your shell.

Clone the Cloudinary Java project:

    git clone git://github.com/cloudinary/cloudinary_java.git

This sample relies on a version of the Cloudinary client not yet published so we need to install it locally:

    cd cloudinary_java
    mvn install

Go to the sample project folder:

    cd samples/photo_album_gae

## Configuration

Next you need to pass your Cloudinary account's Cloud Name, API Key, and API Secret. This sample application assumes these values exists in the form
of a `CLOUDINARY_URL`. The `CLOUDINARY_URL` value is available in the [dashboard of your Cloudinary account](https://cloudinary.com/console).
If you don't have a Cloudinary account yet, [click here](https://cloudinary.com/users/register/free) to create one for free.

    cp src/main/webapp/WEB-INF/appengine-web.xml.sample src/main/webapp/WEB-INF/appengine-web.xml

Edit the new `appengine-web.xml` file and set `CLOUDINARY_URL` to the value matching your account.
*Note*: you can also change the application ID to match a remote project ID you might have started.

## Running

Running the application locally first clean and compile to make sure everything is working as it should:

    mvn clean compile

Then start the application:

    mvn appengine:devserver_start

and point your browser to [http://localhost:8080/](http://localhost:8080/).

This sample configures the Cloudinary client with `GAEConnectionManager` from [here](http://esxx.blogspot.co.il/2009/06/using-apaches-httpclient-on-google-app.html).
You can use any other connection manager or leave the default if you have the sockets enabled for your application. In the development environment it should work with either.
Also, the way the `GAEConnectionManager` is instantiated and managed in this sample is not pretty. You should change it when building a real application.

gha_language: Java


text:
# SFND Radar Target Generation and Detection

### Project Layout
This project has the following tasks:
- Configure the FMCW waveform based on the system requirements.
- Define the range and velocity of target and simulate its displacement.
- For the same simulation loop process the transmit and receive signal to determine the beat signal
- Perform Range FFT on the received signal to determine the Range
- Towards the end, perform the CFAR processing on the output of 2nd FFT to display the target.

![image](https://github.com/Ohara124c41/SFND-RADAR-Target_Generation-n-Detection/blob/master/images/project_tasks.png?raw=true)
## Radar System Requirements

|Parameter|Value|
|-|-|
|Frequency  |77GHz   |
|Range Resolution   |1m   |
|Max Range   |200m   |
|Max Velocity   |70m/s   |
|Velocity Resolution   |3m/s   |

#### Initial Range and Velocity of the Target (Constraints)
You will provide the initial range and velocity of the target. Range cannot exceed the max value of 200m and velocity can be any value in the range of -70 to + 70 m/s.

## Dependencies for Running Locally
* Matlab 2018B or higher.

## Basic Build Instructions

1. Clone this repo.
2. Open Matlab Script in $Path.
3. Run `radar_target_generation_and_detection.mlx`.

## Tasks
- [x] FR.0 Implement Matlab Style Guide
- [x] FR.1 FMCW Waveform Design
- [x] FR.2 Simulation Loop
- [x] FR.3 Range FFT (1st FFT)
- [x] FR.4 2D CFAR

### FR.0 Implement Matlab Style Guide
The initial variables and constants were renamed to match the Matlab styling guide, along with other formatting principles.

### FR.1 FMCW Waveform Design
> Task: Using the given system requirements, design a FMCW waveform. Find its Bandwidth (B), chirp time (Tchirp) and slope of the chirp.
>
> Criteria: For given system requirements the calculated slope should be around 2e13

```c
sweepBW = LIGHT_SPEED / (2 * resolutionRange);
sweepTF = 5.5;
Tchirp  = sweepTF * (2 * maxRange / LIGHT_SPEED);
slope   = sweepBW / Tchirp;
```

##### Result: `slope = 2.0455e+13`

### FR.2 Simulation Loop
> Task: Simulate Target movement and calculate the beat or mixed signal for every timestamp.
>
> Criteria: A beat signal should be generated such that once range FFT implemented, it gives the correct range i.e the initial position of target assigned with an error margin of +/- 10 meters.

```c
% Operating carrier frequency of Radar
carrierFrequency = 77e9;

%{
The number of chirps in one sequence. Its ideal to have 2^ value for the ease of
running the FFT for Doppler Estimation.
%}
nCells = 64; % #of doppler cells OR #of sent periods % number of chirps

% The number of samples on each chirp.
nRange = 512; %for length of time OR # of range cells

% Timestamp for running the displacement scenario for every sample on each chirp
t = linspace(0, nCells * Tchirp, nRange * nCells); %total time for samples

% Creating the vectors for Tx, Rx and Mix based on the total samples input.
Tx  = zeros(1, length(t)); % transmitted signal
Rx  = zeros(1, length(t)); % received signal
Mix = zeros(1, length(t)); % beat signal

% Similar vectors for range_covered and time delay.
r_t = zeros(1, length(t));
td  = zeros(1, length(t));

%% Signal generation and Moving Target simulation

% Running the radar scenario over the time.
for i=1:length(t)

    % For each time stamp update the Range of the Target for constant velocity.
    r_t(i) = (targetVelocity * t(i)) + targetPosition;
    td(i)  = (2 * r_t(i)) / LIGHT_SPEED;

    % For each time sample we need update the transmitted and received signal.
    Tx(i) = cos(2 * pi * (carrierFrequency * t(i) + (slope * t(i) ^ 2) / 2.0));
    Rx(i) = cos(2 * pi * (carrierFrequency * (t(i) - td(i)) + (slope * (t(i) - td(i)) ^ 2) / 2.0));

    %{
    Now by mixing the Transmit and Receive generate the beat signal
    This is done by element wise matrix multiplication of Transmit anCells
    %}

    %Receiver Signal
    Mix(i) = Tx(i).*Rx(i);

end
```

### FR.3 Range FFT (1st FFT)
> Task: Implement the Range FFT on the Beat or Mixed Signal and plot the result.
>
> Criteria: A correct implementation should generate a peak at the correct range, i.e., the initial position of target assigned with an error margin of +/- 10 meters.

#### Tasks

Tasks:
- Implement the 1D FFT on the Mixed Signal
- Reshape the vector into Nr*Nd array.
- Run the FFT on the beat signal along the range bins dimension (Nr)
- Normalize the FFT output.
- Take the absolute value of that output.
- Keep one half of the signal
- Plot the output
- There should be a peak at the initial position of the target

```c
%{
Reshape the vector into Nr*Nd array. Nr and Nd here would also define the
size of Range and Doppler FFT respectively.
%}
Mix = reshape(Mix, [nRange, nCells]);

%Run the FFT on the beat signal along the range bins dimension (Nr) and normalize.
signalFFT = fft(Mix, nRange);
signalFFT = signalFFT / nRange;

% Take the absolute value of FFT output
signalFFT = abs(signalFFT);

%{
Output of FFT is double sided signal, but we are interested in only one side
of the spectrum. Hence we throw out half of the samples.
%}
signalFFT = signalFFT(1:nRange / 2);

% Plotting the range
figure ('Name','Range from First FFT')
subplot(2,1,1)

% Plot FFT output
plot(signalFFT);

axis ([0 200 0 1]); %[range, resolution]

```
##### Result:

![image](https://github.com/Ohara124c41/SFND-RADAR-Target_Generation-n-Detection/blob/master/images/fft.PNG?raw=true)

### FR.4 2D CFAR
> Task: Implement the 2D CFAR process on the output of 2D FFT operation, i.e., the Range Doppler Map.
>
> Criteria: The 2D CFAR processing should be able to suppress the noise and separate the target signal. The output should match the image shared in walkthrough.

#### Steps

Tasks:
- Determine the number of Training cells for each dimension. Similarly, pick the number of guard cells.
- Slide the cell under test across the complete matrix. Make sure the CUT has margin for Training and Guard cells from the edges.
- For every iteration sum the signal level within all the training cells. To sum convert the value from logarithmic to linear using db2pow function.
- Average the summed values for all of the training cells used. After averaging convert it back to logarithmic using pow2db.
- Further add the offset to it to determine the threshold.
- Next, compare the signal under CUT against this threshold.
- If the CUT level > threshold assign it a value of 1, else equate it to 0.

#### Guard Cell, Training Cell, and Offset Selection
The initial selection was based on the classroom instructions. Adjustments were made by trial-and-error as the program compiles quickly. The offset was initially chosen at lower values (e.g. 1.0) but performed the best at 10 based on the nC and nR values selected.

#### Suppression of Non-Threshed cells
To maintain the map size, two loops were created for the combined contributions of the guard cells and the combined contributions of the training cells, respectively. This was completed over the entire set of ranges and cells (nR and nC).

```c

%Range Doppler Map Generation.
The output of the 2D FFT is an image that has reponse in the range anCells
doppler FFT bins. So, it is important to convert the axis from bin sizes
to range and doppler based on their Max values.
%}
Mix = reshape(Mix, [nRange, nCells]);

% 2D FFT using the FFT size for both dimensions.
signalFFT2 = fft2(Mix, nRange, nCells);

% Taking just one side of signal from Range dimension.
signalFFT2 = signalFFT2(1:nRange / 2, 1:nCells);
signalFFT2 = fftshift (signalFFT2);
RDM = abs(signalFFT2);
RDM = 10 * log10(RDM) ;

%{
Use the surf function to plot the output of 2DFFT anCells to show axis in
both dimensions
%}
doppler_axis = linspace(-100, 100, nCells);
range_axis = linspace(-200, 200, nRange / 2) * ((nRange / 2) / 400);
figure('Name', '2DFFT'), surf(doppler_axis, range_axis, RDM);

%% CFAR implementation

% Slide Window through the complete Range Doppler Map

% Select the number of Training Cells in both the dimensions.

trainingRange = 10;
trainingDoppler = 8;
%{
Select the number of Guard Cells in both dimensions around the Cell under
test (CUT) for accurate estimation
%}
guardRange = 4;
guardDoppler = 4;

% Offset the threshold by SNR value in dB
offset = 10;

% Create a vector to store noise_level for each iteration on training cells
noise_level = zeros(1,1);

%{
Design a loop such that it slides the CUT across range doppler map by
giving margins at the edges for Training and Guard Cells.
For every iteration sum the signal level within all the training
cells. To sum convert the value from logarithmic to linear using db2pow
function. Average the summed values for all of the training
cells used. After averaging convert it back to logarithimic using pow2db.
Further add the offset to it to determine the threshold. Next, compare the
signal under CUT with this threshold. If the CUT level > threshold assign
it a value of 1, else equate it to 0.
%}

[rows_RDM, cols_RDM] = size(RDM);

% Use RDM[x,y] as the matrix from the output of 2D FFT for implementing CFAR
RDM_pow = db2pow(RDM);

for i = trainingRange + guardRange + 1:(nRange/2) - (trainingRange + guardRange)
    for j = trainingDoppler + guardDoppler + 1:nCells - (trainingDoppler + guardDoppler)
        cumulative = zeros(1,1);
        for m = i - (trainingRange + guardRange):i + (trainingRange + guardRange)
            for n = j - (trainingDoppler + guardDoppler):j + (trainingDoppler + guardDoppler)
                 if((abs(i - m) > guardRange) || (abs(j - n) > guardDoppler))
                        cumulative = cumulative + RDM_pow(m, n);
                 end
            end
        end
        avg = cumulative / ((2 * (trainingDoppler + guardDoppler + 1) * 2 * (trainingRange + guardRange + 1) - (guardRange * guardDoppler) - 1));
        threshold = pow2db(avg) + offset;
        CUT = RDM(i, j);
        if(CUT > threshold)
            RDM(i, j) = 1;
        else
            RDM(i, j) = 0;
        end
    end
end

%{
The process above will generate a thresholded block, which is smaller
than the Range Doppler Map as the CUT cannot be located at the edges of
matrix. Hence,few cells will not be thresholded. To keep the map size same
set those values to 0.
%}

for i = 1: trainingRange + guardRange
    RDM(i, :) = 0;
    RDM(nRange / 2 - i - 1:nRange / 2, :) = 0;
end
for i = 1:trainingDoppler + guardDoppler
    RDM(:, i) = 0;
    RDM(:, nCells - i - 1:nCells) = 0;
end

```

##### Result:

![image](https://github.com/Ohara124c41/SFND-RADAR-Target_Generation-n-Detection/blob/master/images/2d-fft.PNG?raw=true)

![image](https://github.com/Ohara124c41/SFND-RADAR-Target_Generation-n-Detection/blob/master/images/2d-cfar.PNG?raw=true)


text:
# Kushi: SSH Client with auto-sync SSH port fowarding settings.

## What is this?

SSH Client + autossh + sync portfowarding settings on `.ssh/config`

## Usage

### 1. Create Kushi configs

```
% emacs ~/.config/kushi/config.yml
```

```yaml
BindingConfigsURL: https://s3-ap-northeast-1.amazonaws.com/path_to_your_binding_list.yaml (required)
CheckInterval: 600 (seconds, optional, default = 600)
SSHConfig:
  HostName: your_ssh_server_hostname (required)
  User: your_ssh_username (required)
  IdentityFile: path_to_your_ssh_identity_key_file (optional, default = $HOME/.ssh/id_ed25519, $HOME/.ssh/id_rsa)
  Port: your_ssh_server_port (optional, default = 22)
  KeepaliveInterval: 3 (seconds, optional, default = 3)
  Timeout: 5 (seconds, optional, default = 5)
```

### 2. Place the portfowarfing bindings list file on your managed server (like S3)

```
https://s3-ap-northeast-1.amazonaws.com/path_to_your_binding_list.yaml
```

```yaml
# WEB
- src: localhost:18080
  dst: your_awesome_server_host:8080

# DB
- src: localhost:13306
  dst: your_awesome_mysql_server_host:3306
```

### 3. Run kushi

```
% kushi --stdout
```

### 4. (Optional) Run as daemon

```
% nohup /Users/cnosuke/dev/bin/kushi 1>/dev/null 2>&1 &
```

All logs are written to `~/.config/kushi/logs/20180128172917.log` .
(Filename is a timestamp of process started time.)

## LICENSE

MIT license

Copyright (C) 2018 Shinnosuke Takeda a.k.a `@cnosuke`


text:
# Dialonectria indigens (Arnold) Cooke, 1884 SPECIES

#### Status
SYNONYM

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

#### Published in
Grevillea 12(no. 64): 110 (1884)

#### Original name
Secoliga indigens Arnold, 1870

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Sordariomycetes/Hypocreales/Bionectriaceae/Nectriopsis/Nectriopsis indigens/ Syn. Dialonectria indigens/README.md

repo_name: mdoering/backbone


text:
---
layout: post
title: "SMART Goals Workshop"
date: 2016-10-20 00:00:00
categories: workshop
author: rian
image: assets/images/blog/smart-goals.png
---

This workshop, presented by Alysia Birkholz from the [Office of Professional Development](https://www.umass.edu/gradschool/office-of-professional-development), focused on how to set goals and how to stick to them.

<!--break-->

# SMART goals

SMART goals is a goal setting framework originally developed in the business field. It says that goals should be **S**pecific,
**M**easurable, **A**ctionable, **R**ealistic, and **T**imely.

1. Specific

Goals should be focused, unambiguous, and defined as much as possible. You should write down exactly what you intend to
accomplish.

2. Measurable

You want to be able to tell for sure that you've completed a goal. The "finished" state should be unambiguous. Write down
concrete criteria for measuring your progress toward attaining each goal.

3. Actionable/Action-oriented

Goals should be actions that you can take. You should also have a strategy to stay accountable for your goals. For example,
telling a friend what you intend to do.

4. Realistic

Your objective should be something that you are both willing and able to accomplish. If you don't *want* to accomplish the
goal, chances are you won't. Each goal should represent substantial progress. You must decide if your goal is attainable given
how difficult it is to achieve and the amount of time you have to achieve it. Keep n mind any conditions that may be required
to reach the goal.

5. Timely

You should write down when you intend to complete the goal. Keep in mind that it will take about 2.5 times longer than you
think it will.

# [9 Factors of Goal Setting](www.umassd.edu/fycm/goalsetting/resources/writtengoals/)

1. Your goals should be something that **you** really **want**, not just something that looks or sounds good.
2. Goals must be consistent with your personal values. If they are inconsistent, you won't accomplish them.
3. Your goals must not contradict your other goals, otherwise you will not accomplish either.
4. You should write all of your goals in a positive sense. This allows you to be more productive in a happier place.
5. Aim high. Goals should be realistic, but challenging.
6. Give details for your goals. This goes back to ensuring goals are specific and actionable.
7. Write down your goals. This allows your brain to work on it in the background, even while you are not focusing on it.
8. Review your goals and change as necessary. Our lives change all the time and our goals must change with them.
9. Have goals in all areas of your life. Not just work and school, but in other areas of your life as well.

# W's of goal setting

- Who is involved
- What is it you are trying to accomplish
- Where (can be a geographic location or a location in time)
- When (i.e. timeframe for completion)
- Which (i.e. requirements or restraints)
- Why (reasons/purpose/benefits of accomplishing)

# Long-term vs. Short-term

Long term goals can be more vague and should be broken up into smaller, more actionable and specific, short-term goals. You
should figure out what needs to happen in the short(er) term in order to reach the long term goal. Short-term goals are more
likely to fit into the SMART framework. For example, a long-term goal could be to build your professional network. Short-term
goals toward accomplishing that could be to conduct two informational interviews by the end of the semester, attend three
conferences this year, and join a professional organization. Each of these short-term goals would involve one or more action
steps and each action step should have a timeframe or deadline associated with it.

# Final Suggestions

Alysia recommends staying accountable by telling your goals and timelines to a friend and telling them that you will share
results with them at a particular time.  She also says that it is okay to reset goals, if need be. We don't always meet our
timelines the first time. When working towards particular jobs, she recommends choosing at least two job options and work
towards each of them at the same time. This translates to other goals as well: sometimes you may want to choose a backup goal
and work contribute to both it and your preferred goal at the same time. For example you may prefer to send your paper to one
conference, but just in case also work toward another conference at the same time, just in case you can't meet the preferred
deadline. You should also manage your goals, expectations, and time. In another workshop, Alysia talks about how to manage
time effectively.

gha_language: HTML


text:
# Dash Redis Demo

This app demonstrates how to:

* Connect to a [Redis](https://redis.io) instance
from [Dash](https://plot.ly/dash).

* Use [Celery](http://docs.celeryproject.org/en/latest/getting-started/introduction.html) for asynchronous (periodic or user-triggered) tasks.

## Redis

It works out of the box with the Redis server built in to
[Dash On Premise](https://plot.ly/products/on-premise/) but could be adapted
to work with other servers such as
[Heroku Redis](https://elements.heroku.com/addons/heroku-redis) or your
local Redis server.

For debugging convenince, we install the
[redis-tools](https://packages.ubuntu.com/trusty/database/redis-tools)
package, which offers the `redis-cli` command. This can be removed
for faster app push times.

To enable Redis in Dash On Premise navigate to the settings page of the Server Manager. Under **Special Options & Customizations** select **Enable Dash Customizations** and then select **Enable Redis Databases for Dash Apps**.

## Celery

This app also includes the Celery task queue and a sample periodic update task. (More information on Celery Periodic Tasks [here](http://docs.celeryproject.org/en/latest/userguide/periodic-tasks.html))

In this sample app, the task `update_data` (in `tasks.py`) creates a dataframe with sample data, then saves it in Redis so that the Dash app, running on a separate process (or a separate container), can have access to it, and read it.

Using the function `setup_periodic_tasks` (also in `tasks.py`), we add the task above, `update_data`, to the list of periodic tasks, with an interval of 15, so this task runs every 15 seconds.

## Deployment

In order to do this, you need to run:

### Locally (MacOS/Linux):

* A Redis instance, a simple way to do this, if you have docker locally, is to run a Redis container:
`docker run --name local-redis -d redis`

Then:
`docker inspect local-redis | grep IPAddress` to get your Redis instance's IP address

If you don't have docker, alternatively, see the Redis documentation: https://redis.io/documentation to download Redis and set up a local instance.

The next commands need to be running from the root of your Dash App (Where the files `app.py` and `tasks.py` are)

* The scheduler:
`REDIS_URL=redis://<your-redis-instance-ip>:6379 celery -A tasks beat --loglevel=DEBUG`

* The worker that will actually run the tasks:
`REDIS_URL=redis://<your-redis-instance-ip>:6379 celery -A tasks worker --loglevel=DEBUG`

The two command above can be shortened into only one command with the `--beat` tag as follows:
`REDIS_URL=redis://<your-redis-instance-ip>:6379 celery -A tasks worker --beat --loglevel=DEBUG`
But please only do this in development, not in a production environment.

* The dash app:
`REDIS_URL=redis://<your-redis-instance-ip>:6379 python app.py`

### Locally (Windows):
Redis is not optimized to work with Windows, but it is possible to use it.

#### Running the Redis-Server
1. Download the Redis MSI installer for Windows from https://github.com/MicrosoftArchive/redis/releases & run the MSI installer.

2. Install Redis Python Client with `pip install redis`.
Note: Originally I had used version `2.10.6` which gave a lot of errors. Upgrading to version `3.2.1` fixed these issues. For more information about the Python client go here: https://redislabs.com/lp/python-redis/

3. Open the cmd and go to the root directory of Redis. Run `redis-server` in cmd. If you get an error check the troubleshooting portion below.

#### Runing the Redis & Celery Instance
**Note: Ensure you're running the below commands in a terminal such as Git Bash or Cygwin**
* The Redis db (run in root of Redis folder or have in Windows ENV variables):
`redis-server`

* The scheduler:
`REDIS_URL=redis://<your-redis-instance-ip>:6379 celery -A tasks beat --loglevel=DEBUG`

* The worker that will actually run the tasks (ensure you have `gevent` -> `pip install gevent`):
`REDIS_URL=redis://<your-redis-instance-ip>:6379 celery -A tasks worker --loglevel=DEBUG info -P gevent`

* The dash app:
`REDIS_URL=redis://<your-redis-instance-ip>:6379 python app.py`

At the end of it you will have four terminals open in total.

#### Troubleshooting (Windows)
If you see the error: `Can't bind TCP listener *:6379 using Redis on Windows`
Follow these steps:
1. `cd` to the bin (Ex: `directory of Redis, and run
2. `redis-cli`
3. `shutdown`
4. `exit`
5. open another cmd window, cd to the root directory of your Redis installation, and run in cmd `redis-server`.
More information on this error here: https://stackoverflow.com/questions/31769097/cant-bind-tcp-listener-6379-using-redis-on-windows

### On your On-Prem server

In order to have this setup when deploying your dash app to your Dash Deployment Server, your `Procfile` has to execute these three processes (`celery worker`, `celery beat` and the dash app)

In order to run Celery tasks On your Dash Deployment Server, your processes workers have to be running and linked to your dash app. To do this, scale up your app's workers processes (Using the names your have in your `Procfile`) - Note that this command is not necessary if you have a `DOKKU_SCALE` file that reflects how many workers are assigned to each process, like in this repository:

```
ssh dokku@YOUR_DASH_SERVER ps:scale APP-NAME worker-default=1 worker-beat=1
```

Just like in the local setup, you need a Redis instance to be running and to be linked to your Dash App:

To create and link a Redis database in Dash On Premise:

```
ssh dokku@YOUR_DASH_SERVER redis:create SERVICE-NAME
ssh dokku@YOUR_DASH_SERVER redis:link SERVICE-NAME APP-NAME
```

If you want to link an existing Redis instance/service, you can simply use the second command, using the SERVICE-NAME of the existing Redis instance.

In the commands above, replace:
* `YOUR_DASH_SERVER` with the name of your Dash server (same as when you run `git remote add`)
* `SERVICE-NAME` with the name you want for your Redis service
* `APP-NAME` with the name of your app (as specified in the Dash App Manager).


text:
[You are now in a GitHub source code view - click this link to view Read Me file as a web page]( https://pushme-pullyou.github.io/tootoo13/#cookbook/mnu-menu/README.md "View file as a web page." )

<input type=button class = "btn btn-secondary btn-sm" onclick=window.location.href="https://github.com/pushme-pullyou/tootoo13/blob/master/cookbook/mnu-menu/README.md"
value="You are now in a GitHub web page view - Click this button to view this read me file as source code" >

# [MNU Menu Test Read Me]( #cookbook/mnu-menu/README.md )

## Full Screen: [MNU Menu Test]( https://pushme-pullyou.github.io/tootoo13/cookbook/mnu-menu/mnu-menu.html )

## Concept

### Mission
* To setup standard menu components with a minimum of fuss
* To provide a user interface that feels normal and natural
* To provide a UI that works well on any device
* To provide templates that may be applied to other apps

### Vision

* You open the app on any device and you immediately know what to do

### mnu-menu.js - Main Menu Functions and their Features

Most of the code here should be fairly easy to read.
Getting the menu sliding process to work in all configurations will be an ongoing process

MNU.description
* Provides boilerplate text to be used here and elsewhere
* Default description that can be used when TooToo is embedded
* Use descriptionTooToo.md in this folder to edit the description in Markdown, then open with TooToo and copy HTML to the source

MNU.getNavHeader
* Creates default menu header menu
* Breadcrumbs provide links to parent folders or repos
* Title is also link to reload the app
* Displays the app description

MNU.getNavFooter
* Creates footer menu content and code
* Variable enables easy linking to local or global files
* Links update location hash only
	* Requires a location hash event monitor to operate

MNU.setPopupShowHide
* Provides code to toggle pop-up window display visibility

MNU.onTouchStart
MNU.onTouchMove
MNU.toggleNavLeft
* Provides code for hamburger sliding menu
	* Enables operation on computer, tablet or phone
	* Supports both pointing device and touch support
	* Resizes both menu and content panels
* Getting all this to work seamlessly is an an ongoing effort

Style.css
* Items are more compressed then you usually see them. So it goes
* Items are sorted by tag, class and ID then in alphabetical order

## To Do / Wish List

* 2019-01-10 ~ Theo ~ Better updates when switching between portrait and landscape mode
* 2019-01-03 ~ Theo ~ popup toggle closes previous opens current with single click
* 2019-01-02 ~ Issues with phone/tablet CSS
* 2019-01-01 ~ Footer links needs homogenizing with tootoo/spider
* 2018-07-24 ~ Theo ~ Move away from tables for building menu items

## Issues

## Things you can do using this script

* Click the three bars( 'hamburger menu icon' ) to slide the menu in and out
* Click the Octocat icon to view or edit the source code on GitHub
* Click on title to reload
* Press Control-U/Command-Option-U to view the source code
* Press Control-Shift-J/Command-Option-J to see if the JavaScript console reports any errors

## Links of Interest

## Change Log

### 2019-01-23 ~ Theo

mnu-menu.js

* Start FPS with button
* Show GH rate limits with button
* Update content

### 2019-01-22 ~ Theo

mnu-menu.js
* Update show results in pop-up with button click

### 2019-01-17 ~ Theo

mnu-menu.js
* Add link to source code in TooToo description

### 2019-01-11 ~ Theo

* Add MNUdetFooter id and set to open in test HTML

### 2019-01-10 ~ Theo

* Add text to read me
* Add index.html to folder

Getter better
* 2019-01-10 ~ Theo ~ Click anywhere to close pop-up

### 2019-01-06 ~ Theo

* First commit

***

#  ❦


text:
# Dashchan Extension: niuchan

Niuchan.org extension for the [**Dashchan**](https://github.com/Mishiranu/Dashchan) imageboard client for Android.<br/>
Code based off of [Dashchan-Extensions-Diochan](https://github.com/Dashchanon/Dashchan-Extensions-Diochan).

## License

Extension is licensed under the [MIT License](LICENSE).

repository: Dashchanon/Dashchan-Extensions-Niuchan

repo_name: Dashchanon/Dashchan-Extensions-Niuchan


text:
## Requirements

- Node 10
- Yarn 1.x or npm
- SQLite3

## Setup

1. Clone the repository
2. Run `yarn` or `npm install` installs all required dependencies.
3. Run `node setup.js` to create the SQLite3 database at `.date/main.db`

## npm scripts

> Equivalent `npm run <script>` should also work

- `yarn dev` will start micro in dev mode using [micro-dev](https://github.com/zeit/micro-dev)
- `yarn start` will start [micro](https://github.com/zeit/micro) in production mode on the port defined by PORT environment variable (default 3000)
  - `prestart` runs `setup.js` which will the SQLite3 events table if it doesn't exist.
- `yarn reset` **DANGER** will remove and re-initialise the SQLite3 database
- `yarn lint` will lint all of the files with [xo](https://github.com/xojs/xo)
- `yarn format` will run lint with `--fix` option on all the examples files (and tests).

## Deploying

### On Glitch

This was designed to run on glitch.com, hence the use of SQLite3.

You can remix it directly from https://glitch.com/~interesting-protocol or deploy from this repository/your fork using Glitch's GitHub import feature.

## LICENSE

Code is licensed under the [MIT License](./LICENSE).

repository: HugoDF/micro-analytics-events

gha_language: JavaScript

repo_name: HugoDF/micro-analytics-events


text:
gulp-task-maker
===============

A small wrapper for gulp, which helps you separate task configuration (objects) and implementation (functions).

Some advantages:

- Creates `watch` tasks automatically.
- Helps you write tasks with sourcemaps, and better logging and system notifications!
- Reuse the same task with different configuration objects, to create multiple builds.

⚠ Requires Node.js 6.5 or later.

## Install

Install `gulp` and `gulp-task-maker` as `devDependencies`:

```bash
npm install --save-dev gulp@4 gulp-task-maker@2
```

## Configure

Then in your `gulpfile.js`, use gulp-task-maker’s `add` method:

```js
const gtm = require('gulp-task-maker')
const test = (config, tools) => {
  console.log(config)
  tools.done()
}

gtm.add(test, {
  src: './src/*.js',
  watch: true,
  dest: './public',
})
```

With this configuration, gulp-task-maker will create four gulp tasks:

- `build` (runs all `build_*` tasks)
- `watch` (runs all `watch_*` tasks)
- `build_test`
- `watch_test`

We can run them on the command line, for example using `npx` (which comes with recent versions of Node and/or `npm`):

```sh
# run the "parent" build task
$ npx gulp build
# run a specific task
$ npx gulp build_test
```

Let’s go back to our `gulpfile.js`. We could also:

- tell `gulp-task-maker` to load the `minifyJS` function from a node script,
- provide an array of config objects, instead of just one,
- and add any arbitrary config values we want on config objects.

Here is an updated example:

```js
gtm.add('./tasks/minifyJS', [
  {
    src: [
      'node_modules/jquery/dist/jquery.js',
      'node_modules/some-other-lib/dist/some-other-lib.js'
    ],
    dest: 'public',
    bundle: 'vendor.js',
    sourcemaps: '.'
  },
  {
    src: 'src/*.js',
    watch: true,
    dest: 'public',
    bundle: 'bundle.js',
    sourcemaps: '.'
  }
])
```

### Writing tasks

With the previous `gulpfile.js`, gulp-task-maker will load the module at `./tasks/minifyJS.js` (or `./tasks/minifyJS/index.js`). This module should export a function (and that function must be named, because we’re using its name for the gulp tasks’ names).

Here is a function that concatenates JS files, minifies the result, and writes it (plus a source map) to a destination folder.

```js
const concat = require('gulp-concat')
const uglify = require('gulp-uglify')

module.exports = function minifyJS(config, tools) {
  return tools.simpleStream(config, [
    concat(config.bundle), // concatenate files
    uglify() // minify JS
  ])
}
```

If you’re used to gulp, you can see that we’re not using `gulp.src` and `gulp.dest`. Instead, we’re using `tools.simpleStream` which does this work for us, supports source maps, and logs file sizes. If we want the same result with gulp only, we have to write:

```js
const gulp = require('gulp')
const concat = require('gulp-concat')
const plumber = require('gulp-plumber')
const sourcemaps = require('gulp-sourcemaps')
const size = require('gulp-size')
const uglify = require('gulp-uglify')

module.exports = function minjs(config, tools) {
  // take some source files
  return gulp.src(config.src)
    // use gulp-plumber to log errors (to console + notifications)
    .pipe(tools.catchErrors())
    // start source maps
    .pipe(sourcemaps.init())
    // concatenate files
    .pipe(concat(config.bundle))
    // minify JS
    .pipe(uglify())
    // log resulting file names and size
    .pipe(size())
    // generate sourcemaps
    .pipe(sourcemaps.write(config.sourcemaps))
    // write resulting files to a directory
    .pipe(gulp.dest(config.dest))
}
```

This is a bit longer, as you can see.

### Running tasks

Finally we can run the gulp command, and get a console output that looks like this:

```sh
$ npx gulp build
[13:37:21] Using gulpfile ~/Code/my-project/gulpfile.js
[13:37:21] Starting 'default'...
[13:37:21] Starting 'build_minifyJS'...
[13:37:22] ./public/ main.js 88.97 kB
[13:37:22] Finished 'build_minifyJS' after 1.12 s
[13:37:22] Finished 'build' after 1.13 s
```

You could also run a specific build task, which can be useful when you have many:

```sh
$ npx gulp build_minifyJS
...
```

Or start the main `watch` task:

```sh
$ npx gulp watch
[13:37:49] Using gulpfile ~/Code/my-project/gulpfile.js
[13:37:49] Starting 'watch'...
[13:37:49] Starting 'watch_minifyJS'...
```

## Full API doc, debugging and more

For a complete guide on using `gulp-task-maker`’s API, see [the API docs](https://github.com/fvsch/gulp-task-maker/blob/v2/API.md).

repository: fvsch/gulp-task-maker

repo_name: fvsch/gulp-task-maker


text:
# Xalan-C++ extension functions

## Introduction

At times, you may want to call your own custom C functions from a
stylesheet.  For these situations, Xalan-C++ supports the creation and
use of extension functions.  Xalan-C++ also provides a
[library of extension functions](extensionslib.md)
for your use.

You can think of extension functions as extending the core library of
functions that XPath provides. Like the XPath functions, an extension
function returns an XObject, which may contain a value of any of the
five XSLT data types: `node-set`, `result-tree-fragment`, `string`,
`boolean` or `number`.

You can send arguments to an extension function in the form of XPath
expressions, literals (for `string`, `boolean`, and `number`), the
values returned by other functions, and XSL variables or parameters set
to any of the preceding.

For an example that implements, installs, and uses three extension
functions, see the [External Functions](samples.md#externalfunctions)
sample.

Note: Xalan-C++ does not support extension elements.

## Implementing an extension function

Like the standard XPath functions, the functions you create derive from
the Function base class. Set up your extension function class as
follows:

1. The body of a function is the `execute()` method. Use the
   appropriate `XObjectFactory` method -- `createNumber()`
   in the example below -- to create an `XObject` corresponding to the
   XSLT data type the function returns.
2. Implement a `clone()` method to enable Xalan to create and maintain
    a copy of the extension function.
3. (Optional) As Xalan does for the XPath functions, you may want to
   prevent the compiler from generating an assignment or equality
   operator for this function.

These features all appear in the following example.

```c++
// Base header file.  Must be first.
#include <xalanc/Include/PlatformDefinitions.hpp>

#include <cmath>
#include <ctime>

#include <xercesc/util/PlatformUtils.hpp>
#include <xalanc/XalanTransformer/XalanTransformer.hpp>
#include <xalanc/XPath/XObjectFactory.hpp>

using namespace xalanc;

// This class defines a function that will return the square root
// of its argument.
class FunctionSquareRoot : public Function
{
public:

  /**
   * Execute an XPath function object.  The function must return a valid
   * XObject.
   *
   * @param executionContext executing context
   * @param context          current context node
   * @param opPos            current op position
   * @param args             vector of pointers to XObject arguments
   * @return                 pointer to the result XObject
   */
  virtual XObjectPtr
  execute(
      XPathExecutionContext& executionContext,
      XalanNode* /* context */,
      const XObjectPtr arg,
     	const Locator*	/* locator */) const
  {
    if (args.size() != 1)
    {
      executionContext.error("The square-root() function takes one argument!",
                              context);
    }
    assert(args[0] != 0);
    // Use the XObjectFactory createNumber() method to create an XObject
    // corresponding to the XSLT number data type.
    return executionContext.getXObjectFactory().createNumber(
                                                        sqrt(args[0]->num()));
  }

  /**
   * Implement clone() so Xalan can copy the square-root function into
   * its own function table.
   *
   * @return pointer to the new object
   */
  virtual FunctionSquareRoot*
  clone() const
  {
    return new FunctionSquareRoot(*this);
  }

private:
  // The assignment and equality operators are not implemented…
  FunctionSquareRoot&
  operator=(const FunctionSquareRoot&);
  bool
  operator==(const FunctionSquareRoot&) const;
}
```

## Installing an extension function

[`XalanTransformer`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html)
provides methods for installing and uninstalling external functions:

* [`installExternalFunction()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a7d932d74897e12629afd62bba2735456)
  makes the function available in the current instance of `XalanTransformer`. Use
  [`uninstallExternalFunction()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a8dbb4538357ab2909925dd16a449dbac)
  to remove the function.
* [`installExternalFunctionGlobal()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a7d4f49b03739feaa01cdbffd5668e736)
  makes the function available globally.
  Use
  [`uninstallExternalFunctionGlobal()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#ab5c8f39bcf0bf84b6bbe0607bbe4afde)
  to remove the function. The global install and uninstall operations
  are not thread-safe.  However, all global functions should be
  thread-safe, because multiple threads could call a particular
  function instance at the same time.

These methods include arguments for the namespace, the function name,
and the function implementation.

When you install an extension function, the function inhabits the
namespace you designate. For information about XML namespaces, see
[Namespaces in XML](http://www.w3.org/TR/REC-xml-names/).

The following code fragment installs locally the square root function
defined above, and binds it to the extension-function name
`square-root` in the namespace
`http://MyExternalFunction.mycompany.org` so it can be accessed from
stylesheets. Keep in mind that the function name does not need to be
the same as the name of the function class, and that a function name
may be used more than once provided that each function with that name
is installed in a different namespace.

```c++
#include <xercesc/util/PlatformUtils.hpp>
#include <xalanc/XalanTransformer/XalanTransformer.hpp>
// You have created a header file for FunctionSquareRoot.
#include <MyFunctions/FunctionSquareRoot.hpp>
// The namespace…
const XalanDOMString
    theNamespace("http://MyExternalFunction.mycompany.org");

theXalanTransformer.installExternalFunction(theNamespace,
                                            XalanDOMString("square-root"),
                                            FunctionSquareRoot());
```

For an example that installs three functions, see the
[External Functions](samples.md#externalfunctions) sample.

## Using an extension function

To use the extension function in a stylesheet, you must do the following:

1. Declare the extension function namespace.

   `xmlns:prefix=URI`

   The `prefix` identifies the namespace, and `URI` matches the
   namespace specified when the function is installed.

   By default, namespace declarations are included in the
   transformation output. To exclude namespaces from the output,
   use

   `exclude-result-prefixes="prefix-1 prefix-2 …"`

   in the stylesheet element or

   `xsl:exclude-result-prefixes="prefix-1 prefix-2 …"`

   in a literal result element or extension element.
2. Call the extension function in the same manner you would call an
   XPath function. The function name you use in the stylesheet is a
   Qualified Name (QName) made up of the prefix you declared in step 1
   and the function name you specified when you installed the function.

   You can use XPath expressions, literals (for `string`, `boolean`,
   and `number`), and values returned by other functions to specify
   function arguments.

Suppose, for example, you are working with XML documents containing
area elements like `<area value="397"/>`, where the value attribute
identifies the area of a square.

The following stylesheet declares the square-root function namespace
(the prefix is up to you), instructs the processor not to copy the
namespace declaration to the result tree, and uses the square-root
function to return the square root of `//area/@value:`

```xml
<?xml version="1.0"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  version="1.0"
	xmlns:external="http://ExternalFunction.xalan-c.xml.apache.org"
  exclude-result-prefixes="external">

    <xsl:template match="//area">
    <out>
      The area of the square is
      <xsl:value-of select="@value"/> square units.
      The length of each side is
      <xsl:value-of select="external:square-root(@value)"/> units
    </out>
    </xsl:template>
</xsl:stylesheet>
```

This stylesheet converts `<area value="397"/>` into the following
output:

```xml
<out>
  The area of the square is
  397 square units.
  The length of each side is
  19.9249 units.
</out>
```

For a slightly more complex variation on this example, see the
[External Functions](samples.md#externalfunctions) sample

### Passing Nodes to a function

Please keep in mind that *all* `LocationPath` expressions return a
`node-set`, even if the expression only returns a single attribute or a
`text` node (`node-set`s with one member). You can use the XSLT
`string()` function to convert a `node-set` value to `string`, and the
`number()` function to convert a `node-set` value to `number` (a
double).

If you pass a `node-set` to an extension function, be sure to set up
the function to process a node-set.

Suppose, for example, you have a `ProcessNodes` function class that
uses

```c++
const NodeRefListBase& theNodeList = args[0]->nodeset();
```

in the `execute()` method to get a reference to the `node-set`.

Assuming you install the function as `ProcessNodes` and use the
`node-ext` prefix in a stylesheet to refer to the `ProcessNodes`
function namespace, any of the following function calls are
syntactically possible:

```xml
<!--Process the current node-->
<xsl:variable name="success" select="node-ext:ProcessNodes(.)"/>

<!--Process all nodes in current context-->
<xsl:variable name="success" select="node-ext:ProcessNodes(*)"/>

<!-- Process all nodes -->
<xsl:variable name="success" select="node-ext:ProcessNodes(/*)"/>

<!--Process the foo/baz nodes in current context -->
<xsl:variable name="success" select="node-ext:ProcessNodes(foo/baz)"/>

<!--Process the/foo/baz and /bar/saz nodes -->
<xsl:variable name="success" select="node-ext:ProcessNodes(/foo/baz | /bar/saz)"/>
```

The `NodeRefListBase` is in fact a list of references into the XML
document, so keep in mind that
[`getNextSibling()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanNode.html#a9b4a7333371ffee9a6fd851203f4c98a),
for example, gets you the next sibling in the document, which may not
be the next `Node` in the `node-set`.

repository: apache/xalan-c

repo_name: apache/xalan-c


text:
# Free-Courses-on-Data-Science

![alt_text](https://github.com/harshitahluwalia7895/Free-Courses-on-Data-Science/blob/master/Free%20courses%20based%20on%20(1).jpg)
##### 1. [A comprehensive Learning Path to become Data Scientist in 2019](https://trainings.analyticsvidhya.com/courses/course-v1:AnalyticsVidhya+LPDS2019+LPDS2019_T1/about?utm_source=linkedinHA&utm_medium=blog)

##### 2. [Experiments with Data](https://trainings.analyticsvidhya.com/courses/course-v1:AnalyticsVidhya+EWD01+2018_EWD_T1/about?utm_source=linkedinHA&utm_medium=blog)

##### 3. [Python for Data Science](https://trainings.analyticsvidhya.com/courses/course-v1:AnalyticsVidhya+BPDS001+2018_T2/about?utm_source=linkedinHA&utm_medium=blog)

##### 4. [Twitter Sentiments Analysis](https://trainings.analyticsvidhya.com/courses/course-v1:AnalyticsVidhya+TSA001+2018_T1/about?utm_source=linkedinHA&utm_medium=blog)

##### 5. [Creating Time Series Forecast with Python](https://trainings.analyticsvidhya.com/courses/course-v1:AnalyticsVidhya+TS_101+TS_term1/about?utm_source=linkedinHA&utm_medium=blog)

##### 6. [A comprehensive path for learning Deep Learning in 2019](https://trainings.analyticsvidhya.com/courses/course-v1:AnalyticsVidhya+Python-Final-Jan-Feb+Python-Session-1/about?utm_source=linkedinHA&utm_medium=blog)

##### 7. [Loan Prediction Practice problem](https://trainings.analyticsvidhya.com/courses/course-v1:AnalyticsVidhya+LP101+2018_T1/about?utm_source=linkedinHA&utm_medium=blog)

##### 8. [Big mart Sales Problem using R](https://trainings.analyticsvidhya.com/courses/course-v1:AnalyticsVidhya+BigMS01+2018_1/about?utm_source=linkedinHA&utm_medium=blog)

repository: sts-sadr/Free-Courses-on-Data-Science

repo_name: sts-sadr/Free-Courses-on-Data-Science


text:
# leftill
A simple way to track how much money is left until your next paycheck.

## Short-term goals:
* (DONE) Configuration of planned/recurring income and expenses
* (DONE) Parsing of recurrences that occur within a date range (pay period until next paycheck)
* (DONE) Parsing of overrides to planned income and expenses
* Figuring out a current cleared balance at a point in time, akin to a "T" account in accounting terms
  * This is based on planned/recurring income and expenses as well as unplanned spending

## Long-term goals:
* Create a configuration UI for recurrences
* Create a UI to log cleared planned/recurring income and expenses
* Create a UI to override recurring/planned income and expenses (when paycheck or bills vary per pay period)
* Create a UI to log current bank account balance

## Recurrence configuration data:
The structure of the recurrence configuration data is:

	configurationID: {			(configuration IDs are unique, integer keys)
		amount: decimal,		(amount of each recurrence)
		description: string,		(description of the recurring transaction)
		type: string,			("Income" or "Expense")
		automatic: boolean,		(Automated income or payment)
		recurrence: string,		(this is the recurrence parser to use)
		recurrenceStart: string,	(short date format: "MM/DD/YYYY" zero padded MM and DD)
		weeksRecurrence: integer	(optional, for weekly parser: default is every 1 week)
	}

## Prerequisites:
* [Node.js](https://nodejs.org/) to be able to use the Node Package Manager (NPM)
* [Git](https://git-scm.com/) distributed version control system

## Getting started:
1. Open a terminal/command prompt
2. `cd` to the path you want to clone this repo into
3. Clone this repo via:
    * HTTPS: `git clone https://github.com/thx2001r/leftill.git`
    * SSH: `git clone git@github.com:thx2001r/leftill.git`
4. `cd leftill`
5. Download and install packages `npm install` or `yarn install`

## NPM Scripts:
They are run in the terminal (PowerShell in Windows) from the repo directory or in your IDE:
*  `npm run watch` watches for changes and runs unit tests stored in the `./__tests__/` directory
*  `npm run test` runs [ESLint](https://eslint.org/) and unit tests once
*  `npm run clean` cleans the `./dist/` directory
*  `npm run minify` minifies and uglifies `./src/js/*.js` and prepends banner into `./dist/leftill.min.js`
*  `npm run build` runs test, clean, and minify scripts


text:
# loom-recruitunit-api-docs
Documentation for the recruitunit content api provided by loom

## Features

Uses the [API Blueprint](https://apiblueprint.org/) [format](https://github.com/danielgtaylor/aglio/blob/master/example.apib) which is converted to html

## Usage

Parse /docs and build /dist/index.html

```npm run build```

repository: leachuk/loom-recruitunit-api-docs

repo_name: leachuk/loom-recruitunit-api-docs


text:
100DaysOfCode Challenge - React App

#DAY 3 -  ReactFire, Firebase for Data Persistence

Day 3 focus was to add data persistence to the app using ReactFire and Firebase which provides a realtime JSON database for storing and syncing your app’s data.

- Added data persistence to the app using ReactFire and Firebase.
- Data was seeded into the realtime JSON database.
- Created a notes list component that renders a bootstrapped list using data binding property.

Read more about it on medium here: https://medium.com/@harinilabs

About me and other interesting projects on my website: http://HariniLabs.com/

url: https://raw.githubusercontent.com/suryansh2020/100DaysOfCode/fd3434d089b70db77587f041903a15a4cdd1b56a/Day 003 - React App with Firebase/README.md


text:
# iMonDisplayApiWrapperSharp

This is a wrapper for [iMonDisplayApiSharp](https://github.com/Sevenanths/imonapi-sharp). I couldn't find any source tree for this library so I created my own repository.
It is very likely that this code is written by [Montellese](https://github.com/Montellese). I only upgraded it to .NET 4.5.

repository: Sevenanths/iMonDisplayApiWrapperSharp

repo_name: Sevenanths/iMonDisplayApiWrapperSharp


text:
+++
title = "Home servers"
weight = 5
description = "Options for hosting with a home server"
tag = "selfhost"
+++

There are a variety of tools that make running Urbit at home straightforward on dedicated hardware.  If your enjoy hardware ownership and full embracing the spirit of decentralization, then these tools are for you.

## Native Planet

[![Native Planet Tellurian](https://storage.googleapis.com/media.urbit.org/site/getting-started/native-planet.jpg)](https://www.nativeplanet.io/hardware)

Purchase a [computer designed to run Urbit](https://www.nativeplanet.io/hardware), out of the box.

## Groundseg & Startram

[![Groundseg UI](https://storage.googleapis.com/media.urbit.org/site/getting-started/groundseg.png)](https://www.nativeplanet.io/software)

Install these [Native Planet software packages](https://www.nativeplanet.io/software) to turn a Linux computer into an urbit that's accessible from anywhere in the world.

## Umbrel

[![Umbrel Screenshot](https://storage.googleapis.com/media.urbit.org/site/getting-started/umbrel.png)](https://umbrel.com/)

Install the [Urbit application](https://subject.network/posts/urbit-apps-umbrel/) on a Raspberry Pi running [Umbrel](https://umbrel.com/).


text:
Ignorance Documentation
=============

Here's the current documentation presented in good 'ol markdown for easy viewing on GitHub. I ain't gonna use GitBook for a simple documentation, sorry to disappoint!

Unless noted, all configuration options presented here are based from Ignorance version 1.4.

Ignorance Transport
------------

The *Ignorance Transport* is a component that attaches to your Mirror NetworkManager. It then bridges code-wise between Mirror itself, Ignorance Core and finally ENet.
For those who are technically inclined, the whole chain is as follows:

```
Mirror Networking (High Level) <-> Ignorance Transport + Core (High to Low Level) <-> ENet-CSharp Managed-To-Native Wrapper <-> ENet (Native, x64/ARM Win/Mac/Linux/Android/iOS/etc)
```

Ignorance Transport Configuration
------------

From top to bottom...

![Image](../master/Documentation/ignorance14options.png?raw=true)

### Essentials

This option... | ...does this.
-------------- | -------------
Port | Specifies the listening port that Ignorance will use when Mirror starts Host or Server Only mode.

### Debugging & Logging

This option... | ...does this.
-------------- | -------------
Log Type | Specifies how verbose Ignorance will be when it's running. Default is **Standard**, which is balanced between being *almost* mute to super verbose.
Debug Display | If you would like a OnGUI debug display that shows some information about the low-level world, enable this. You'll see a debug window in the bottom left of your game window.

### Server Configuration

This option... | ...does this.
-------------- | -------------
Server Binds All | If enabled, ENet will ignore the *Server Bind Address* and bind to all IP addresses. If disabled, it will only bind to the specified bind address. This is useful for multiple instances on the same server. Default is enabled.
Server Bind Address | If *Server Binds All* is disabled, this is the IP address that ENet will attempt to bind to. IPv4 and IPv6 is both supported. If this is invalid, then ENet will likely catch fire.
Server Peer Max Capacity | Also known as maximum CCU. This is best kept to the same number as your Mirror maximum players count.
Server Max Native Time | This is how long the servers' native ENet thread will wait for network events. Higher numbers (3 or 5, for example) can save CPU power, while lower numbers keep ENet running as fast as possible. Default is **1** which is a sane default.

### Client Configuration

This option... | ...does this.
-------------- | -------------
Client Max Native Time | This is how long the client' native ENet thread will wait for network events. Higher numbers (3 or 5, for example) can save CPU power, while lower numbers keep ENet running as fast as possible. Default is **1** which is a sane default.
Client Status Update Interval | If set above 0, this interval will trigger Ignorance to request client information. Since this technically can be expensive if done aggressively as it asks native ENet for the stats, every 3 or 5 seconds is recommended minimum values.

### Channel Configuration

This option... | ...does this.
-------------- | -------------
Channels | Defines the channel array. This allows you to divide up your packets into channels with different packet delivery methods.

### Ring Buffer Tweaking

This option... | ...does this.
-------------- | -------------
Client Data Buffer Size | Defines how many slots in the ring buffer for data packets coming from the server. This may require tweaking if the server is sending a lot of packet data to your client or you have a very fast paced game.
Client Conn Event Buffer Size | Defines how many slots in the ring buffer for connection events. The default is sane enough. Probably overkill for a client, now that I think about it...
Server Data Buffer Size | Defines how many slots in the ring buffer for data packets coming from clients. This will require tweaking depending on how chatty your client network code is. The default should be enough for a majority of projects, but a value like 10000 might be required for others while a turn-based game might be fine with the default or even less. Your mileage may vary.
Server Conn Event Buffer Size | Defines how many slots in the ring buffer for connection events. The default should be sane enough. This is only useful if you have lots of clients connecting/disconnecting at once.

NOTE: A connection event is either a ENet Connect or Disconnect. In other words, when a ENet client connects to the server or disconnects, a event is raised and placed into the queue for processing by Mirror.

### Danger Zone

This option... | ...does this.
-------------- | -------------
Packet Buffer Capacity | Value in bytes. This is used as a temporary scratch pad for incoming packet data. The default is 4 Kilobytes (4096 bytes). If you get errors about packets being too big, it may pay to increase this, or try optimizing your netcode data.
Max Allowed Packet Size | Value in bytes. ENet supports sending a UDP Packet up to 32 Megabytes, but this comes at a cost including reduced performance and stressing out ENet. The default is set to the maximum ENet packet size value. Setting this over 33554432 bytes **will not** have any positive effect, and may even cause ENet to complain.

It is advised to keep your data packets as small as possible. I do not recommend using Ignorance or ENet for real-time video streaming if it's some insane resolution.

*End of configuration options.*

Ignorance Core
------------

Ignorance Core was designed to be able to be used outside of a Unity environment, allowing you to harness the power of Ignorance in your own non-Mirror or non-Unity project. If you remove the Ignorance Transport components, you get Ignorance Standalone.

You'll need to patch the Core to remove `Debug.Log<whatever>` calls, but with a little work you'll be able to do your own IO through Ignorance Core. Use the Ignorance Transport component as a coding reference, how to enqueue packets and dequeue them.

Help improve the documentation!
------------

Confused? Think something can be explained better? Send a issue ticket and tell me what I can elaborate or improve here.

Other than that, thanks again for using Ignorance!

repository: SoftwareGuy/Ignorance

gha_language: C#

repo_name: SoftwareGuy/Ignorance


text:
# Simple HTTP GET & POST Test Server for testing

## Quick Start
To start the server run this following command

```javascript
$ npm start
```

## Generating of a n-Byte payload
To generate a payload for download test or something else run this command
> This command may take sometime to execute

```python
$ python payloadGenerator.py
```

repository: pwmb/SimpleHttpServer

repo_name: pwmb/SimpleHttpServer


text:
---
layout: splash
title: Urban Agriculture
permalink: /docs/urbanag/
excerpt: "Creating digital and methodological tools to optimise the resource use efficiency of urban agriculture"
header:
  image_overlay: /Images/infraredphotooftunnel.PNG
  caption: "Photo credit: [**MJS**](/docs/people/mel)"
tags:
  - urban agriculture
  - digital twin
author: "Melanie"
last_modified_at: 2021-03-09
feature_row:
  - image_path: /Images/uag/sensor_network.png
    alt: "placeholder image 1"
    title: "Co-simulation"
    excerpt: "Quantifying the effect of a hydroponic greenhouse in a building"
    url: "/docs/projects/urbanag/cosim/"
    btn_label: "Read More"
    btn_class: "btn--primary"
  - image_path: /Images/uag/crop_logo.png
    image_caption: "View of CROP"
    alt: "placeholder image 2"
    title: "Digital Twin of Growing Underground"
    excerpt: "Three stages of the development of a prototype digital twin."
    url: "/docs/projects/urbanag/digitaltwin/"
    btn_label: "Read More"
    btn_class: "btn--primary"
  - image_path: /Images/uag/infraredphotooftunnel.PNG
    title: "GES model"
    excerpt: "Functions and structure of the Greenhouse Energy Simulator."
    url: "/docs/projects/urbanag/ges/"
    btn_label: "Read More"
    btn_class: "btn--primary"
---

The urban agriculture project investigates various digital tools to optimise the resource use efficiency of integrating greenhouses in the built environment.

Known as urban-integrated agriculture, vertical farming, controlled environment agriculture, this concept is gaining increasing traction  by investors, start-ups and city planners alike. Integrating a greenhouse in a city can provide multiple benefits: its high yields contribute to local food production, provide local employment with its year-round harvests, increases urban self-sufficiency. However, several issues need to be addressed for its further sustainable development. For instance, high yields come at a high energy cost. The increased resource demand of urban farming may require re-thinking of our food distribution systems, and delivery of water, nutrients and energy to cities.

Digital tools can help answer some of these questions. By better understanding the complicated interdepencies between the built environment and plants, we can predict energy demand, crop yields, and improve day to day operational efficiency. Given the numerous unknowns about these systems, data-centric methods represent an opportunity to learn about these novel systems, and can provide decision-making assistance along the way too.

Click on the link of these three projects to find out more about the tools developed.

{% include feature_row %}

repository: zhuangcq/home

repo_name: zhuangcq/home