text:
# IItemDefinition

An IItemDefinition object is the direct reference to an item.
It is different from an [IItemStack](IItemStack) as this only refers to the item, it does not include any meta-information or NBT-values!

## Importing the package
It might be required for you to import the package if you encounter any issues (like casting an [Array](/AdvancedFunctions/Arrays_and_Loops)), so better be safe than sorry and add the import.
`import crafttweaker.item.IItemDefinition;`

## How to get one
The easiest way is from an [IItemStack](IItemStack), but you can also get a list of all registered IItemDefinitions in the game and do something with that.

```
//IItemStack Zengetter "definition" -> single IItemDefinition
val itemDefinition = <minecraft:stone>.definition;

//IGame zengetter "items" -> LIST!
val itemDefinitionList = game.items;
```

## What to do with it

### ZenGetters

| ZenGetter | What does it do                                                                                | Return Type                             | Usage      |
|-----------|------------------------------------------------------------------------------------------------------|-----------------------------------------|------------|
| id        | Returns the item ID                                                                                | String                                  | `def.id`   |
| name      | Returns the unlocalized item Name                                                                    | String                                  | `def.name` |
| ores      | Returns all ore entries containing this item. Can also contain ore entries that refer to a sub-item. | List<[IOreDictEntry](/Vanilla/OreDict)> | `def.ores` |

### ZenMethods

`def.makeStack(meta);` Creates an [IItemStack](IItemStack) with the given metadata. Metadata is an int and OPTIONAL.

repository: dalapo/CraftTweaker-Documentation

repo_name: dalapo/CraftTweaker-Documentation


text:
# Timed

![Go](https://github.com/corka149/timed/workflows/Go/badge.svg)

Manages my working times.

## Usage
```
The timed cli helps to managing working times.
          _________
         /   12    \
        |     |     |
        |9    |    3|
        |      \    |
        |           |
         \____6____/

Usage:
  timed [flags]
  timed [command]

Available Commands:
  delete      Delete by the provided DATE
  help        Help about any command
  list        List working days
  version     Prints version of timed and quit

Flags:
  -b, --break int      Takes the duration of the break in minutes. (default 0min) (default -1)
  -d, --date string    Takes the date that should be used. Format: "yyyy-mm-dd" -> E.g. 2019-03-28. (default: today)
  -e, --end string     Parameter for end time. Format "hh:mm" -> E.g. "08:00". (default: now)
  -h, --help           help for timed
  -n, --note string    Takes a note and add it to an entry. Default: ''
  -s, --start string   Takes the start time. Format "hh:mm" -> E.g. "08:00". (default: now)

Use "timed [command] --help" for more information about a command.

```

## Data
"$HOME/.timed.db" stores the timed data.

## Build `timed`

_Requirements:_

- git
- Go ([see here](https://go.dev/))

Only for cross-compilation:

- make
- Docker

_Build it:_

```sh
git clone -b v3.1.0 --single-branch git@github.com:corka149/timed.git

# Only for current machine
go build

# Cross compilation
make
```

Enjoy your `timed` binary at the project directory.

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: Elixir

license_type: permissive


text:
# WWDTM

## Note

This version of the Wait Wait Stats Library has been superceded by version 2.
The repository for the new version of the Stats Page is available at
[wwdtm](https://github.com/questionlp/wwdtm).

No further development or bugfixes will be made to this project and the
repository has been marked as read-only.

## Overview

Data Access Library to provide show, host, scoreekeeper, panelist and guest
details from an instance of the
[Wait Wait... Don't Tell Me! Stats Page](http://wwdt.me) database.

## Requirements

- Python 3.6 or newer (Python 2.x is not supported)
- MySQL or MariaDB database containing data from the Wait Wait... Don't Tell
  Me! Stats Page database

### Notes

Even though the library is currently being developed and tested against Python
3.6, the code makes explicit use of `collections.OrderedDict()` to preserve key
insertion order into specific dictionaries. This was done as the code was
originally developed on systems with earlier versions of Python 3 that not
preserve key insertion order for `dict()`.

That behavior has since changed with Python 3.6 and key insertion order for
standard `dict()` is now part of the language's specifications moving forward.

That said, all development and testing has already been migrated to Python 3.6
and there is no guarantee that the library will be 100% functional in any older
versions.

## Installation

A packaged version of the library is available for download and install via
`pip` by adding <https://wheels.wwdt.me/> to your Python index list at install
time:

```bash
pip3 install --extra-index-url https://wheels.wwdt.me/ wwdtm
```

`pip` will also install packages that are required to use the library,
including:

- mysql-connector
- numpy
- python-dateutil
- python-slugify

## How to Use

```python
from wwdtm import guest, host, location, panelist, scorekeeper, show

guest.info.retrieve_by_id(id: int, database_connect: mysql.connector.connect)

host.info.retrieve_by_id(id: int, database_connect: mysql.connector.connect)

location.info.retrieve_by_id(id: int, database_connect: mysql.connector.connect)

panelist.info.retrieve_by_id(id: int, database_connect: mysql.connector.connect)

scorekeeper.info.retrieve_by_id(id: int, database_connect: mysql.connector.connect)

show.info.retrieve_by_id(id: int, database_connect: mysql.connector.connect)
```

## Running Tests

1. Set up a venv in the current directory by running: `python3 -m venv venv`
2. Create a copy of `config.dist.json` and name it `config.json`
3. Edit `config.json` and fill in the `local` section with the appropriate
   MySQL/MariaDB connection information
4. Activate the venv by running: `source ${venv}/bin/activate`
5. Install any required packages via `pip`: `pip3 install -r requirements.txt`
6. Run the test script: `python3 test.py`

## Packaging

```bash
python3 setup.py bdist_wheel
```

## Contributing

If you would like contribute to this project, please make sure to review both
the [Code of Conduct](CODE_OF_CONDUCT.md) and the
[Contributing](CONTRIBUTING.md) documents in this repository.

## License

This library is licensed under the terms of the
[Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0).

repository: questionlp/libwwdtm

branch_name: refs/heads/main

gha_language: Python

repo_name: questionlp/libwwdtm


text:
# ἐμ-πίπρημι

<!-- Status: S2=NeedsEdits -->
<!-- Lexica used for edits:   -->

## Word data

* Strongs: G17140

* Alternate spellings:

,

* Principle Parts:

* Part of speech:

* Instances in Scripture: 1

* All Scriptures cited: Yes

## Etymology:

* LXX/Hebrew glosses:

[ἐμπρήθω]() (for the form, v.s. [ἐμπίπλημι](), and cf. Veitch, s.v. [πίμπρημι]()),

* Time Period/Ancient Authors:

* Related words:

* Antonyms for all senses

* Synonyms for all senses:

## Senses

### Sense  1.0:

#### Definition:

#### Glosses:

to set on fire;

#### Explanation:

 to become inflamed;

#### Citations:

to set on fire: [πόλιν](), [Mt 22:7](Mat 22:7); pass., of the body, to become inflamed: [Ac 28:6](Act 28:6) (T; [πίμπρημι]() WH, q.v.).†

repository: mandolyte/uw-obsidian

repo_name: mandolyte/uw-obsidian


text:
# Laravel CodeIgniter Database Integration

[![Build Status](https://travis-ci.org/expressodev/laravel-codeigniter-db.png?branch=master)](https://travis-ci.org/expressodev/laravel-codeigniter-db)
[![Latest Stable Version](https://poser.pugx.org/expressodev/laravel-codeigniter-db/version.png)](https://packagist.org/packages/expressodev/laravel-codeigniter-db)

This package allows you to use the excellent Laravel database library
([illuminate/database](https://github.com/illuminate/database)) inside your
CodeIgniter applications.

Laravel normally uses [PDO](http://www.php.net/manual/en/intro.pdo.php) to
make database connections. CodeIgniter establishes its own connection to the database.

If you are only using the Laravel database components, then this will not be a problem -
you can simply disable the CodeIgniter database connection and use Laravel's instead.
However, if your application is using a mixture of CodeIgniter and Laravel database
libraries, this is the package for you.

This integration layer takes all requests made to the Laravel database library, converts
them to raw SQL, then passes them through to the underlying CodeIgniter database driver.
This means that you will not need to establish two separate connections to the database,
and it also means that CodeIgniter database profiling functions will continue to
work correctly.

## Usage

In your `composer.json` file:

```json
{
    "require": {
        "expressodev/laravel-codeigniter-db": "~1.0"
    }
}
```

In your application:

```php
// use our mock PDO class if PDO is not enabled on this server
if (!class_exists('PDO')) {
    class_alias('Illuminate\CodeIgniter\FakePDO', 'PDO');
}

// pass all Laravel database queries through to CodeIgniter
$ci = get_instance();
$resolver = new Illuminate\CodeIgniter\CodeIgniterConnectionResolver($ci);
Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver);
```

## License

[MIT License](https://github.com/expressodev/laravel-codeigniter-db/blob/master/LICENSE)

repository: expresso-store/laravel-codeigniter-db

gha_language: PHP

gha_license_id: MIT

repo_name: expresso-store/laravel-codeigniter-db


text:
# Tic-Tac-Toe-Game
Tic Tac Toe is a basic game.

This game is played by two players, denoted by either "O" or "X".
A winner is declared once he/she fills a row, column, or main diagonal with his/her symbol.
The game can either result in a win/loss or a tie.

Language: Html, CSS & JavaScript(for logic)

View Demo:- Click Here

repository: abhinandanraj/Tic-Tac-Toe-Game

repo_name: abhinandanraj/Tic-Tac-Toe-Game


text:
---
layout: default
---

# 1995-12-09 - Re: More FUD from First Virtual

## Header Data

From: Adam Shostack<EMAIL_ADDRESS>To<EMAIL_ADDRESS>(jim bell)

Message Hash: 14309cbb87f9a65e49ec9857bbaa7b60f39c6075c61fb02a4afce344914aa304

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1995-12-09 21:48:12 UTC

Raw Date: Sat, 9 Dec 95 13:48:12 PST

## Raw message

```
{% raw  %}From: Adam Shostack<EMAIL_ADDRESS>Date: Sat, 9 Dec 95 13:48:12 PST
To<EMAIL_ADDRESS>(jim bell)
Subject: Re: More FUD from First Virtual
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text

jim bell wrote:

[Good points about cost of transactions deleted]

| The answer, I think, it that there would be no problem finding people to
| take that risk in exchange for the return, ESPECIALLY if they have some
| input into the design (level of security) of the system.  They might insist
| on 2048-bit RSA keys, instead of 1024-bit, for example.

	(I know its only an example, but...)

	Key length is not what is needed for better security; more
solid code and better interfaces are needed.  (I might also argue for
hardware keys that are more difficult to steal..)

	Cryptosystems fail because of bad storage of keys, coding
mistakes, accidentally writing passphrases to disk during a swap, etc.
Moving to 2048 bit keys is no help if you lose the key to a
non-cryptanalytic attack.  Moving to keys with a week or day lifetimes
might be better.

	You need to figure how the system might fail, and design to
protect yourself from those failures.  Keys with a thousand bits
aren't lost to factoring very often.

Adam

--
"It is seldom that liberty of any kind is lost all at once."
					               -Hume

{% endraw %}
```

## Thread

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

+ Return to "[Adam Shostack <adam@homeport.org>](/authors/adam_shostack_adam_at_homeport_org_)"
+ Return to "[jim bell <jimbell@pacifier.com>](/authors/jim_bell_jimbell_at_pacifier_com_)"
+ Return to "[Nathaniel Borenstein <nsb@nsb.fv.com>](/authors/nathaniel_borenstein_nsb_at_nsb_fv_com_)"

+ 1995-12-09 (Sat, 9 Dec 95 12:07:32 PST) - [Re: More FUD from First Virtual](/archive/1995/12/0043c5bdcc0c9cc2d6d4f86071d8db33fd67c8fa9ca4749992646c78cf5e5447) - _jim bell<EMAIL_ADDRESS>  + 1995-12-09 (Sat, 9 Dec 95 13:48:12 PST) - Re: More FUD from First Virtual - _Adam Shostack<EMAIL_ADDRESS>  + 1995-12-10 (Sun, 10 Dec 95 05:58:01 PST) - [Re: More FUD from First Virtual](/archive/1995/12/aeb7b316cd634e41ebd1bbaecf602760e376b0d9d29fe05d076ea407a697fffe) - _Nathaniel Borenstein<EMAIL_ADDRESS>


text:
### Branching
No workflow engine would be complete without a way to _branch_ from one workflow to another. And since `asynchro` aims to supply a simple, yet versatile workflow engine, this feature is essential for handling logic routes based upon any number of conditions.

As we seen when [verifying](tutorial-3-verification.html) queued `async` tasks, the results/errors can be altered after execution has taken place. One aspect that was not dicussed though was the ability to either __stop__ the queue from continuting execution or __tranfer/branch__ to another queue altogether.

Stoping the queue from continuting execution is fairly easy. Simply return `false` from [Asynchro.verify](Asynchro.html#verify). Let's examine the subsequent example.
```js
// sample data and async function
const delay = 10, a = 1, b = 2, c = 3, d = 4, e = 5;
function multiply(a, b, c) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve({ m1: 10 * (a || 0), m2: 20 * (b || 0), m3: 30 * (c || 0) });
    }, delay);
  });
}

const ax = new Asynchro({});
ax.series('one', multiply, a, b, c);
ax.verify('one', async it => {
  it.result = 999; // optionally override result value
  return false; // stop the queue from continuing to process/run
});
// two is never ran
ax.series('two', multiply, d, e);
const rslt = await ax.run();
// { one: { m1: 999, m2: 40, m3: 90 } }
console.log(rslt);
```

Tranferring from one `Asynchro` instance/queue to another is very similar to stopping one. The difference is that a new `Asynchro` instance is returned from [Asynchro.verify](Asynchro.html#verify) rather than returning `false`.
```js
const resultObject = {};
const ax = new Asynchro(resultObject);
ax.parallel('one', multiply, a, b, c); // multiply/a/b/c from previous example
ax.verify('one', async it => {
  // execute when parallel function is first called (called 2x)
  // 1. when function is called and a promise is returned
  // 2. after await on the promise
  if (it.isPending) { // pending so transfer happens before "two" is executed
    // we can either use the same result object from the original queue
    // or use a new one (values from the original will be merged into the new one)
    const axt = new Asynchro(resultObject);
    axt.series('x', multiply, 1, 1, 1); // multiply from previous example
    axt.parallel('y', multiply, 2, 2);
    // stop the queue from continuing to process/run and transfer/run the new one
    return axt;
  } else {
    // optionally override result value (once it's set- i.e. isPending = false)
    it.result = 999;
  }
});
// two is never ran
ax.series('two', multiply, d, e); // multiply/d/e from previous example
const rslt = await ax.run();
// {
//   one: { m1: 999, m2: 40, m3: 90 },
//   x: { m1: 10, m2: 20, m3: 30 },
//   y: { m1: 20, m2: 40, m3: 60 }
// }
console.log(rslt);
```

#### Multiple Branches
Branching can occur at any given point during queue execution via the return value from [Asynchro.verify](Asynchro.html#verify). There is no _hard_ limit to the number of branches from one `Asynchro` instance to another. This leads to a simple, yet flexible logic route for defining how workflows interact between one another.
```js
// Multiple Branching Example:
// Asynchro instances instantiated/queued all at one time for illustrative purposes,
// but could be instantiated/queued at verification time instead
const ax = new Asynchro({}), valueOverride = 'Override value from axt branch "three" verify';
const axt = new Asynchro(ax.result);
const axt2 = new Asynchro(ax.result);

ax.background('one', multiply, 1, 2, 3);
ax.series('two', multiply, 4, 5, 6);
ax.parallel('three', multiply, 7, 8, 9);
// branch/transfer from "ax" to "axt" after "three" has been invoked, but not yet awaited
ax.verify('three', async it => it.isPending ? axt : !(it.result = valueOverride));
ax.parallel('four', multiply, 10, 11, 12); // never invoked

axt.background('five', multiply, 13, 14, 15);
axt.series('six', multiply, 16, 17, 18);
// branch/transfer from "axt" to "axt2" after "six" has been invoked/awaited
axt.verify('six', async it => it.error ? axt2 : null);
axt.parallel('seven', multiply, 19, 20, 21); // never invoked

axt2.series('eight', multiply, 22, 23, 24);
axt2.background('nine', multiply, 25, 26, 27);
axt2.series('ten', multiply, 28, 29, 30);

await ax.run();
```

#### Background Tasks & Branching
As noted in the [background tasks section](tutorial-2-background.html), caught [Asynchro.errors](Asynchro.html#errors) and [Asynchro.result](Asynchro.html#result)s may continue to accumulate __after__ [Asynchro.run](Asynchro.html#run) is `await`ed for. Likewise, branching from one [Asynchro](Asynchro.html) instance to another will also have the same impact. Results are of course dependent upon the result object passed into the constructor of each [Asynchro](Asynchro.html) instance in the branch (or the optional background object that is passed into [Asynchro.backgroundWaiter](Asynchro.html#backgroundWaiter), when used).
```js
const ax = new Asynchro({});
ax.parallel('one', multiply, a, b, c); // multiply/a/b/c from previous example
ax.verify('one', async it => {
  if (it.isPending) {
    const axt = new Asynchro(ax.result);
    axt.series('x', multiply, 1, 1, 1); // multiply from previous example
    axt.parallel('y', multiply, 2, 2);
    axt.background('z', multiply, 4, 4, 4);
    // stop the queue from continuing to process/run and transfer/run the new one
    return axt;
  } else {
    it.result = 999;
  }
});
// two is never ran
ax.series('two', multiply, d, e); // multiply/d/e from previous example
await ax.run();
// {
//   one: { m1: 999, m2: 40, m3: 90 },
//   x: { m1: 10, m2: 20, m3: 30 },
//   y: { m1: 20, m2: 40, m3: 60 }
// }
console.log(ax.result);
// if we don't want to set results on the same result object as "ax"
// we can pass another object as the 1st argument
const abx = await ax.backgroundWaiter();
// {
//   one: { m1: 999, m2: 40, m3: 90 },
//   x: { m1: 10, m2: 20, m3: 30 },
//   y: { m1: 20, m2: 40, m3: 60 },
//   z: { m1: 40, m2: 80, m3: 120 }
// }
console.log(abx.result);
// true
console.log(ax.result === abx.result);
```

#### [Conversions >>](tutorial-5-conversion.html)

repository: ugate/asynchro

gha_language: JavaScript

repo_name: ugate/asynchro


text:
# `classes`

```javascript
  <div className=${classes('className', condition && 'anotherClass'/*, ...*/)} />
```

`classes` returns a function whose `toString()` method has been overloaded to
return a valid, deduplicated className string.  Calling the function directly will
return another function, decorated the same way, with the arguments passed
appended to the list. Any falsy values in the list are ignored, which makes
`classes` a good way to build out a list of conditional classes.

`.and(...)` is equivalent to directly calling the function, and is nicer,
semantically, e.g., `classes('className').and(condition && 'anotherClass').

`classes` is used by the CSS-in-JS template function, [`css`](./css.md) for
its slugs, so if you're using `css`, you probably won't need `classes`.

license: ISC

repository: Fordi/buildless

gha_license_id: ISC

repo_name: Fordi/buildless


text:
# Sample Points from a Curve

`Algebra` `Arrays` `Math`

[View on Edabit](https://edabit.com/challenge/9se2zfxxSrLPKpyH9)

Create a function that given a type of `curve` will generate an array containing a `samples` amount of numbers calculated from said `curve`.

It's easier to see with a visual representation:

![Graph of the 3 curves](img/graph-example.png)

If `samples = 3` and `curve = "pow"`, we would sample 3 points along the **x axis** `[0, 0.5, 1]` and figure out the value of `y`, in the case of the `pow` curve the values are `[0, 0.25, 1]`.

### Examples

```js
samplesFromCurve(3, "linear") ➞ [0, 0.5, 1]

samplesFromCurve(3, "pow") ➞ [0, 0.25, 1]

samplesFromCurve(3, "sqrt") ➞ [0, 0.71, 1]

samplesFromCurve(5, "linear") ➞ [0, 0.25, 0.5, 0.75, 1]
```

### Notes

- The available curves are `linear`, `pow`, `sqrt` as shown in the picture.
- All values returned must have a **maximum of 2 decimals** to avoid floating point problems in the tests.
- All values returned must be between `0` and `1` (inclusive).
- The `samples` parameter will always be ≥ `2`.
- The samples are **evenly distributed** along the **x axis**.

url: https://raw.githubusercontent.com/Pustur/edabit-js-challenges/8e65b4fa19de274b57518bdfbb2361209728145a/src/Sample Points from a Curve/README.md

repository: Pustur/edabit-js-challenges

repo_name: Pustur/edabit-js-challenges


text:
[![Build status](https://ci.appveyor.com/api/projects/status/7ucks5y2hqo7mphg?svg=true)](https://ci.appveyor.com/project/mmaitre314/IpCamera)
[![NuGet package](http://mmaitre314.github.io/images/nuget.png)](https://www.nuget.org/packages/MMaitre.IpCamera/)
[![Symbols](http://mmaitre314.github.io/images/Symbols.png)](http://mmaitre314.github.io/2015/05/24/personal-pdb-symbol-server.html)

IP Camera
=========

An API to stream video from cameras on Windows and Windows Phone devices (and probably to any HTTP MJPEG video player).

![IpCamera](http://mmaitre314.github.io/images/IpCamera.jpg)

`CameraServer` starts an HTTP server and streams the video from a camera on the local machine over a network in MJPEG format.
```c#
// Start the camera and open an HTTP listener on port 31415
var server = await CameraServer.CreateAsync(31415);
```

The server supports multiple clients connected at the same time.

Using the [MediaCaptureReader](http://www.nuget.org/packages/MMaitre.MediaCaptureReader/) NuGet package client apps can display the video by creating an `HttpMjpegCaptureSource` and connecting it to `MediaElement`.

```xml
<MediaElement Name="Preview" AutoPlay="True" RealTimePlayback="True"/>
```
```c#
// Start an HTTP client, connect to port 31415, and display the video
var client = await HttpMjpegCaptureSource.CreateFromUriAsync("http://localhost:31415/");

// Start playback
Preview.SetMediaStreamSource(client.Source);
```


text:
How to install everything required to run the code in this repo.  Note that if you have **any issues** please join the [ProfitView Discord](https://discord.gg/34Jy8STJRg).

## BitMEX

You need an account with [BitMEX](https://www.bitmex.com/).  This is not available for residents of the United States or Hong Kong yet, unfortunately.

Signing up to BitMEX requires authentication.  You will need to enable your microphone and webcam (temporarily) as part of this process - they ask you to repeat some numbers and to obey some simple instructions.  You will need to send a photograph of a government issued id - driver's license or passport e.g.
This may take a few hours - or perhaps a day if there is some complication.

**Please note** that you must complete this authentication prior to using your BitMEX API key both to trade **and** in ProfitView.  Otherwise your trades will fail with REST errors - and ProfitView will fail - we'll see it in the logs, but it won't be clear to you.

You need some Bitcoin to transfer to your BitMEX wallet.  I buy from [CoinBase](https://www.coinbase.com/), however you may have a preferred vendor.  Once you have bought Bitcoin you transfer it to the BitMEX wallet - click the [Deposit](https://www.bitmex.com/app/wallet) button and copy the wallet id to provide when you send from the vendor.

You need to generate **2** [API key pairs](https://www.bitmex.com/app/apiKeys), one with Key Permissions blank (-) which means **Read Only**, for ProfitView and one with Key Permissions "Order" for your algo so that it can trade.  Copy both these to a safe place (you won't be able to see the API Secret again unless you make a copy).  Make sure you distinguish which is which.

See [Crypto Trading From Scratch](https://profitview.net/blog/crypto-trading-from-scratch) for some more information and detail.

## ProfitView

You need a [ProfitView](https://profitview.net/) account (the free tier is adequate) - [Sign-up](https://profitview.net/register) and go to your email to confirm.  It will prompt you to enter your BitMEX API key/secret pair.  Make sure you enter the **Read Only** key here.

Go to the ProfitView "Settings" tab.  This is where you find your generated ProfitView API Key.  You will need this to retrieve real-time market data.

See [ProfitView for Dummies](https://profitview.net/blog/profitview-for-dummies) for more detail.

## Install Steps

On all platforms, you will need `git`, a JDK, `gradle` and Kotlin itself.  It's probably best to have [Jetbrains IDEA](https://www.jetbrains.com/idea/) too.

 Step 	  Windows 	  Linux 	  MacOS

     Preparation

There are various security settings that are typically defaulted to in a Windows installation.  You may need to turn some of these off, for example any restriction on downloading files.  It is possible to do this on a domain-by-domain basis, and this is encouraged.
If you wish to generally allow file downloads, you can do it (on Windows Server 2019) by:
1. Click the lower left corner "Window" symbol "Start" menu.
2. Choose "Settings" and search for "Change Security Settings"
3. Choose the "Security" tab and select the zone "Internet"
4. Un-check the "Enable Protected Mode"
5. Choose "Custom" and scroll down to "Downloads"
6. On "File download" choose "Enable"
7. Click "Okay" boxes to exit

Since both operating systems are derived from Unix, the installations are similar for Linux and MacOS.

 Git

Go to https://git-scm.com/download/win and click the appropriate download button.  Click to run the downloaded install file.
In the options generally choose the defaults.  Make sure you choose to enable **Git Bash**

Open a terminal window and use your package manager to install `git`. On Debian derivatives including Ubuntu e.g. run
```shell
sudo apt install git
```

Open Terminal and do
```shell
brew install git
```

For many of the steps below, where it says to open a Terminal window, on Windows, this means the Git Bash window.

 Clone this Repo

Open a Terminal window, create a directory in which you wish to place this `kotlinalgotrading` repo, `cd` to it and do:
```shell
git clone git@github.com:profitviews/kotlinalgotrading.git
```
This will clone this repo into your chosen directory.

Java

Go to [OpenJDK](https://adoptopenjdk.net/releases.html?variant=openjdk15&jvmVariant=hotspot) and install JDK version 8 or greater.

If you choose the [.msi](https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/download/jdk-15.0.1%2B9/OpenJDK15U-jdk_x64_windows_hotspot_15.0.1_9.msi), after download you need only to click it to install.  During installation choose to have it set `JDK_HOME` and the Registry variables.

Kotlin

Go to [this](https://kotlinlang.org/docs/tutorials/command-line.html) webpage and under "Downloading the compiler" click "GitHub Releases".  Go down to "Assets" and choose the latest `kotlin-compiler-x.y.z.zip` (not the `native` versions) and download.  Unzip to a directory of your choice.

1. Go to "Windows" Start->Control Panel
2. System and Security->System->Advanced System Settings
3. "Environment Variables". Under "System variables" scroll down to "Path"
4. Click that line and then click "Edit...".
5. Click "New" and add the full path of the `kotlinc\bin` directory in the unzipped folder.
6. Click "Okay" repeatedly to exit.
This will set the Kotlin executables as available to be run in other contexts.

```shell
sudo apt install curl # or similar
curl -s https://get.sdkman.io | bash
sdk install kotlin
```

```shell
brew update
brew install kotlin
```

Gradle

In https://gradle.org/install/ go to [Installing manually](https://gradle.org/install/#manually) and follow the instructions for "Microsoft Windows users"

Assuming `sdk` was installed with Kotlin above
(otherwise follow those steps first)
```shell
sdk install gradle
```

```shell
brew update
brew install gradle
```

# Initializing Gradle Build

Open a Terminal window and `cd` to the directory where you cloned `kotlinalgotrading` and run `./gradlew tasks`.  This will download Gradle (if necessary) and the required libraries.

Then `./gradlew build` will build the system.

If you check [build.gradle.kts](https://github.com/profitviews/kotlinalgotrading/blob/main/build.gradle.kts) you will see it is configured to run the first example from the webinar - though you must first set your BitMEX API key and secret with
```shell
export bitmex_api_key=YourApiKey
export bitmex_secret=YourSecretString
```
If you're using Jetbrains IDEA, you can set these environment variable in a Run Configuration: Run menu -> Edit configuations... -> Environment variables.  Click the icon on the right of the text box to enter multiple variables.

Then you can run `./gradlew run` which will buy $10 worth of Bitcoin equivalent for you!

To run the other examples, edit [build.gradle.kts](https://github.com/profitviews/kotlinalgotrading/blob/main/build.gradle.kts) in your cloned `kotlinalgotrading` directory, and change
```kotlin
application {
    mainClass.set("example1.ExecuteExampleKt")
}
```
to
```kotlin
application {
    mainClass.set("example2.MarketDataExampleKt")
}
```
or similar with `example3.SimpleKt` or `example4.MeanReversionKt`.

Then execute `./gradlew run` again.

**NOTE**: to run `example2.MarketDataExampleKt`, `example3.SimpleKt` and `example4.MeanReversionKt` - or any algo - you will need your ProfitView API Key from above and write it to the `profitview_api` environment variable with:
```shell
export profitview_api_key=YourProfitViewAPIKey
```
or put it in your IDEA Run Configuration.

# Jetbrains IntelliJ IDEA

[Jetbrains](http://jetbrains.com/) created Kotlin and continue to manage its development.  Therefore you can count on their IDE being well adapted to the language.  We recommend you use [IntelliJ IDEA](https://www.jetbrains.com/idea/).  The installation is straightforward on all the platforms.

repository: seanahmad/kotlinalgotrading

repo_name: seanahmad/kotlinalgotrading


text:
# Render templates

**Registering engines**

Engines are registered using the [.engine](/api/engines#engine) method.  and the name you choose for the engine is used by assemble

```js
// render handlebars templates in `.hbs` files
app.engine('hbs', require('engine-handlebars'));
```

Note that the name you use when registering the engine will be used by assemble for automatically matching the file extensions of files to render.

```js
var assemble = require('assemble');

app.task('default', function () {
  app.src('templates/*.hbs')
    .pipe(app.dest('dist'));
});
```

Run `assemble` from the command line to run the `default` task in your `assemblefile.js`.

repository: klokie/assemble

repo_name: klokie/assemble


text:
# Binary BPS Sampler

C++ implementation and MATLAB wrapper for the sampling algorithm introduced in
["Binary Bouncy Particle Sampler"](https://arxiv.org/pdf/1711.00922.pdf),
presented at the NIPS 2017 Workshop Advances in Approximate Bayesian Inference.

This implementation targets the binary Markov Random Fields used in the paper.

See comments in the file binary_demo.m for instructions.

### Prerequisites

MATLAB and g++-4.9

## Author

* **Ari Pakman**

## License

This project is licensed under the MIT License.


text:
ClosedCube Arduino Library for
ClosedCube OPT3002 Light to Digital Sensor Breakout
=====================================================================================================

This is breakout board for [Texas Instruments OPT3002](http://www.ti.com/product/OPT3002) Light to Digital Sensor

[![](https://github.com/closedcube/ClosedCube_OPT3002_Arduino/blob/master/images/B061_OPT3002_Pic1.jpg)](https://www.tindie.com/stores/closedcube/)
[![](https://github.com/closedcube/ClosedCube_OPT3002_Arduino/blob/master/images/B061_OPT3002_Pic2.jpg)](https://www.tindie.com/stores/closedcube/)

### Where to Buy?


text:
![BlitzMax Logo](../media/blitzmax_title.svg)

# Code Formatter

A code formatter is an external application that helps keep your layout, indentation and capitalization consistent across all of your projects.\
Right click the BlitzMax document you're editing and select "Format Document".\
You can also select the specific text you want formatted.

![Format Document](../media/format.png)

VS Code has many optional settings for automatic formatting, including "Format On Type" and "Format On Save".

The code formatter needs to be installed manually and the "formatter path" needs be set in your [BlitzMax extension settings](command:blitzmax.settings).\
Search for BlitzMax code formatters on [GitHub](https://github.com/search?q=topic%3ABlitzMax+topic%3Aformatter).

# Language Server Protocol (LSP)

A LSP is an external application that provides diagnostics, document symbols _(outliner)_, better auto-complete, code fixes and suggestions among many other things.\
The LSP starts automatically and keeps track of your code changes in the background.

The LSP needs to be installed manually and the "LSP path" needs be set in your [BlitzMax extension settings](command:blitzmax.settings).\
Search for BlitzMax BlitzMax LSPs [GitHub](https://github.com/search?q=topic%3ABlitzMax+topic%3Alsp).

repository: Hezkore/vscode-blitzmax-support

gha_language: TypeScript

repo_name: Hezkore/vscode-blitzmax-support


text:
[![Join the chat at https://gitter.im/Rabrennie/anything.css](https://badges.gitter.im/Rabrennie/anything.css.svg)](https://gitter.im/Rabrennie/anything.css?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [![Build Status](https://travis-ci.org/Rabrennie/anything.css.svg?branch=master)](https://travis-ci.org/Rabrennie/anything.css)

Δ.CSS is a CSS Framework that accepts almost any pull request (as long as it follows the rules).

## Temporary Playground
Use [this codepen](https://codepen.io/TheBITLINK/pen/JKNgxN?editors=1000) to test Δ.css, it always uses the latest version on the master branch.

When we get a site set up (if we do), a proper playground will be set up (like the one in [anythingjs.io](http://anythingjs.io/playground.html)).

# Rules
1. Nothing that'll crash a web page.
1. Can't violate GitHub terms of service.
1.
  1. Nothing malicious.
  1. Deleting stuff that doesn't need to be.

# Contributing
1. Fork ( https://github.com/Rabrennie/anything.css/fork )
1. Clone ( git clone https://github.com/YourUsername/anything.css.git )
1. Branch ( git checkout -b your-feature )
2. Make a new file in ./src/styles with a relevant name. ( name.scss )
  1. if you're making a new mixin etc. put it in ./src/constants with a relevant name (name.scss)
1. Edit ( Type! Type! Type! )
1. Push ( git push -u origin your-feature )
1. Pull Request ( https://help.github.com/articles/using-pull-requests/ )
1. Fire up another branch and add yourself to the [contributors list](CONTRIBUTORS.md), to congratulate yourself for your work :).

![Tag](http://i.imgur.com/etWLNKJ.gif) ![Tag](http://i.imgur.com/c4J95hH.gif) ![Tag](http://i.imgur.com/Sl7UbNI.gif) ![Tag](http://i.imgur.com/xaoeuKp.gif)

gha_language: CSS


text:
# Install and run
```
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
python main.py
```

this will generate the `helpradar.db` sqlite file. No sqlite3? Don't worry, you can upload the database to https://sqliteonline.com/ and view it there!

Read [bronnen](bronnen.md) for our roadmap of platforms to scrape

repository: koaben/helpradar

repo_name: koaben/helpradar


text:
Digital Permission QR Code
==========================

This is a spike project to test how feasible it would be to encode a Digital Permission as a QR
code for offline use, and be able to detect forgery.

1. `pip install pyqrcode zbar pypng scikit-image`
2. `python -m unittest`
3. `python -m permission`

repository: UKHomeOffice/qrpermission

repo_name: UKHomeOffice/qrpermission


text:
### Description

This exmaple runs [Office.cxx](/Cxx/VisualizationAlgoriths) as follows:

```
  ./OfficeA office.binary.vtk 0 -E 50)
```

repository: lassoan/VTKExamples

repo_name: lassoan/VTKExamples


text:
#### :zap: Write `config.yml` file
> This library uses the language resource name pattern used by PMMP
> Therefore, need to name the language resource file according to the established rules
> ```php
> Rules:
> /resources/config/{$locale}.yml
> ```
> - **$locale** is the code of the language according to the [`ISO_639-3`](https://en.wikipedia.org/wiki/ISO_639-3) standard
> ```php
> Examples:
> /resources/config/eng.yml
> /resources/config/kor.yml
> /resources/config/chz.yml
> /resources/config/ind.yml
> /resources/config/jpn.yml
> ```

#### :sparkles: Support multilingual in `config.yml` file
> Just use `MultilingualConfigTrait` provided by this library
> ```php
> Examples:
> //Roughly, example source that  example source that save default config file
> class Main extends PluginBase{
>     use MultilingualConfigTrait;
>
>     public function onLoad() : void{
>         $this->saveDefaultConfig();
>     }
> }
> ```


text:
```
Usage: cut OPTION... [FILE]...
Print selected parts of lines from each FILE to standard output.

Mandatory arguments to long options are mandatory for short options too.
  -b, --bytes=LIST        select only these bytes
  -c, --characters=LIST   select only these characters
  -d, --delimiter=DELIM   use DELIM instead of TAB for field delimiter
  -f, --fields=LIST       select only these fields;  also print any line
                            that contains no delimiter character, unless
                            the -s option is specified
  -n                      with -b: don't split multibyte characters
      --complement        complement the set of selected bytes, characters
                            or fields
  -s, --only-delimited    do not print lines not containing delimiters
      --output-delimiter=STRING  use STRING as the output delimiter
                            the default is to use the input delimiter
      --help     display this help and exit
      --version  output version information and exit

Use one, and only one of -b, -c or -f.  Each LIST is made up of one
range, or many ranges separated by commas.  Selected input is written
in the same order that it is read, and is written exactly once.
Each range is one of:

  N     N'th byte, character or field, counted from 1
  N-    from N'th byte, character or field, to end of line
  N-M   from N'th to M'th (included) byte, character or field
  -M    from first to M'th (included) byte, character or field

With no FILE, or when FILE is -, read standard input.

GNU coreutils online help: <http://www.gnu.org/software/coreutils/>
For complete documentation, run: info coreutils 'cut invocation'

```

repository: sltzwfy/java-reader

repo_name: sltzwfy/java-reader


text:
+++
title = "Search by destination"
pagetitle = "Search by destination"
description = "Enables search query to request per destinations by converting destination codes to hotel codes"
icon = "fa-globe"
weight = 4
alwaysopen = false
+++

Search by destination is a feature to search by destinations codes in the Search query. To use it, codes must be sent in 'CriteriaSearch'. Destination codes will be converted to hotel codes, then merged with the hotel codes sent in criteria if any, and finally the request will be sent to the supplier. In order to achieve the destination to hotel conversion, a source must be specified in a plugin.

## Plugin

The conversion must be done at the 'REQUEST' step, either in type 'PRE_STEP' or 'POST_STEP'. The parameter with key "accessID" is mandatory and is the access used to convert destinations to hotel from its hotel list, which means that the hotel codes obtained are in the same context as the access.

```
{
    "plugins": {
        "step": "REQUEST",
        "pluginsType": [
            {
                "type": "POST_STEP",
                "name": "search_by_destination",
                "parameters": [
                    {
                        "key": "accessID",
                        "value": "x"
                    }
                ]
            }
        ]
    }
}
```

repository: Globix/documentation-site

repo_name: Globix/documentation-site


text:
Algorithms In A Nutshell
========================

### What is this?

This is my own personal implementation/interpretations of the algorithms
outlined in the book: Algorithms in a Nutshell(Heineman, Pollice, Selkow). None
of the code will be verbatim, but I will try to follow pretty close to the
pseudo-code implementations outlined in the book.

I'm starting somewhere in the middle, since I felt like I was glossing over the
details and really needed to write some code if I wanted it to sink in. I may
come back to the earlier chapters later.

I'm starting in JavaScript (node.js) for now, but I may experiment with
some other languages down the road.

repository: andyvanee/algorithms-in-a-nutshell

repo_name: andyvanee/algorithms-in-a-nutshell


text:
---
layout: default
---

# 1996-01-25 - Re: NSA advanced knowledge

## Header Data

From<EMAIL_ADDRESS>(Timothy C. May)

To<EMAIL_ADDRESS>Message Hash: 978a84ebefbbaf22a53abc18ab2e5e5d4f8cf70b149c88ca28913b1f0ba30182

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-01-25 06:31:30 UTC

Raw Date: Thu, 25 Jan 1996 14:31:30 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Timothy C. May)
Date: Thu, 25 Jan 1996 14:31:30 +0800
To<EMAIL_ADDRESS>Subject: Re: NSA advanced knowledge
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

At 12:34 AM 1/25/96, Rich Salz wrote:
>Is there any indication that the NSA knew about public-key before
>it entered the open literature?

I've asked Whit Diffie about this issue more than once. He, too, is very
interested in the real answer to this.

In the Gus Simmons book, there are cryptic (sorry) references to what the
NSA may have known. And certainly Don Coppersmith was no slouch, having
been a Putnam winner in the early 70s (I was invited to take the Putnam
about that time, and was so overwhelmed and unprepared--especially being
that I was studying physics then--that I just gave up and left the room!).

On the other hand, the comments are sufficiently elliptical that it may
just be the NSA putting the best face on an embarrassing development.

At Crypto '88, I put this question to NSA cryptographer Brian Snow. He just
played the Cheshire cat. Which told me nothing.

A friend of mine who was an active amateur cryptographer in the 1970s
pointed out to me--much later--that there were NSA boxes used on ships and
similar remote outposts which appeared to have no provision for providing
keying material, suggesting a sealed-box public-key system. He was just
speculating, of course.

Here's to hoping the Bamford-Madsen 2nd edition sheds more light on this
subject. I can't say I'll be surprised to learn that NSA was as surprised
as the rest of us.

--Tim

Boycott espionage-enabled software!
We got computers, we're tapping phone lines, we know that that ain't allowed.
---------:---------:---------:---------:---------:---------:---------:----
Timothy C. May              | Crypto Anarchy: encryption, digital money,
<EMAIL_ADDRESS>408-728-0152 | anonymous networks, digital pseudonyms, zero
W.A.S.T.E.: Corralitos, CA  | knowledge, reputations, information markets,
Higher Power: 2^756839 - 1  | black markets, collapse of governments.
"National borders aren't even speed bumps on the information superhighway."

{% endraw %}
```

## Thread

+ Return to [January 1996](/archive/1996/01)

+ Return to<EMAIL_ADDRESS>(Timothy C. May)](/authors/tcmay_at_got_net_timothy_c_may_)"

+ 1996-01-25 (Thu, 25 Jan 1996 14:31:30 +0800) - Re: NSA advanced knowledge -<EMAIL_ADDRESS>(Timothy C. May)_


text:
 Forma 36 - The Contentful Design System

![build status](https://travis-ci.com/contentful/forma-36.svg?token=9ZgfZHVDFAy8E7oFpbGM&branch=master)
[![lerna](https://img.shields.io/badge/maintained%20with-lerna-cc00ff.svg)](https://lernajs.io/)

This is the monorepo for the Forma 36 design system by [Contentful](https://www.contentful.com).

- [Packages](#packages)
  - [Forma 36 React Components](./packages/forma-36-react-components/README.md)
  - [Forma 36 FCSS](./packages/forma-36-fcss/README.md)
  - [Forma 36 Tokens](./packages/forma-36-tokens/README.md)
  - [Forma 36 Website (WIP)](./packages/forma-36-website/README.md)
- [Adding packages](#adding-packages)
- [Development](#development)
- [Commits & releases](#commits--releases)
- [Testing changes locally](#testing-changes-locally)
- [Get Involved](#get-involved)
- [Reach out to us](#reach-out-to-us)
- [License](#license)
- [Code of conduct](#code-of-conduct)

## Packages

Forma 36 is a monorepo maintained using Lerna. Get started with Lerna by following this link: https://github.com/lerna/lerna

The monorepo is currently structured into the following packages:

- [`forma-36-website`](https://github.com/contentful/forma-36/tree/master/packages/forma-36-website)
  - This package includes the design system documentation which offers guidelines, best practices and examples.
    See the README [here](./packages/forma-36-website/README.md)
- [`forma-36-react-components`](https://github.com/contentful/forma-36/tree/master/packages/forma-36-react-components)
  - A React component library built with Storybook. See the README [here](./packages/forma-36-react-components/README.md)
- [`forma-36-fcss`](https://github.com/contentful/forma-36/tree/master/packages/forma-36-fcss)
  - CSS utility classes for spacing, typography, colors and transitions. See the README [here](./packages/forma-36-fcss/README.md)
- [`forma-36-tokens`](https://github.com/contentful/forma-36/tree/master/packages/forma-36-tokens)
  - Forma 36 design tokens. See the README [here](./packages/forma-36-tokens/README.md)

### Adding packages

To add another package create a new directory in the packages folder. Make sure that the package name is prefixed with forma-36 (e.g. forma-36-css-utilities). Since we are using Lerna all package scripts are available from the root by running lerna run {script_name}

## Development

For local development run `yarn` from the root of this repo to install all dependencies and build all packages.

## Commits & releases

Use `yarn commit`. This uses the [Commitzen](https://github.com/commitizen/cz-cli) CLI to create a conventional commit message based on your changes. CI is setup to release all new commits on the master branch.

## Testing changes locally

You can test changes to a package of this monorepo in your own project locally by taking the following steps:

1. Run `yarn build` in the desired package's directory to ensure your latest changes have been built
2. Run `yarn link` in the desired package's directory
3. Change to your local project's directory and run `yarn link NAME_OF_PACKAGE` to link to the local version of the package (e.g. `yarn link @contentful/forma-36-react-components`)

## Get involved

[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?maxAge=31557600)](http://makeapullrequest.com)

We appreciate any help on our repositories. For more details about how to
contribute to a package, see the README of the corresponding package.

## Reach out to us

You can reach out to us using the [Contentful community Slack](https://www.contentful.com/slack/). We've setup a channel [#forma36](https://contentful-community.slack.com/messages/CFXGTMB98) in which we announce latest changes and updates.

### Maintainers

- [Johannes Bugiel](https://github.com/wichniowski)
- [Mike Mitchell](https://github.com/m10l)

### You found a bug or want to propose a feature?

- File an issue here on GitHub: [![File an issue](https://img.shields.io/badge/-Create%20Issue-6cc644.svg?logo=github&maxAge=31557600)](https://github.com/contentful/forma-36/issues/new). Make sure to remove any credential from your code before sharing it.

## License

This repository is published under the [MIT](LICENSE.md) license.

## Code of Conduct

We want to provide a safe, inclusive, welcoming, and harassment-free space and experience for all participants, regardless of gender identity and expression, sexual orientation, disability, physical appearance, socioeconomic status, body size, ethnicity, nationality, level of experience, age, religion (or lack thereof), or other identity markers.

[Read our full Code of Conduct](https://github.com/contentful-developer-relations/community-code-of-conduct).


text:
# Travel and Expense Policy

## General
* Keep PopPays best interests in mind.
* Plan ahead to find balance between convenience and cost.
* We'll need a receipt for each item you'll be expensing. Take photos of receipts to attach to your reports in Expensify. If you have an email receipt, please take a screenshot of it and attach it to your Expensify report.
* Clearly mark what the expense is for in Expensify - e.g. client lunch, Lyft to airport. Bonus points for writing it on the receipt itself before taking a picutre of it as well. This is most important for expenses involving clients or job candidates, which are categorized differently for tax purposes.
* Submit your expenses within 60 days of being incurred. Our Accounting team needs to close the books on months/quarters/years, so getting expenses that are older than 60 days can create a good amount of extra work.

## Accommodations and Per Diem Guidance
Note:
* Our per diem guidance is based on the General Services Administration’s (GSA) reimbursement guidelines for governmental employees. We’ve included these values for your reference.
* Travel to and from the airport/meetings and meals involving clients do not count against your per diem, but as always, please keep PopPays’ best interest in mind (sensing a theme here..).

#### Chicago:
* Hotel Option 1: Hampton Inn Chicago Downtown West Loop Hotel (116 N Jefferson); use the corporate code<PHONE_NUMBER> to get the "Good Neighbor Rate." Book here: https://goo.gl/q2fj7t
* Hotel Option 2: Crowne Plaza West Loop; use this link to book for 10% discount: https://goo.gl/2uEj6i
* If you choose to stay elsewhere, you are eligible to be reimbursed up to the Hampton Inn rate plus $20
* Meals and incidentals per diem: $74 is the GSA recommended amount
* First/last day of travel: aim for $50 or lower

#### NYC:
* Hotel Option 1: Hotel 50 Bowery; use promo code "bowery on their website or book via this link: https://goo.gl/TH7SA4
* Hotel Option 2: Arlo, mention Popular Pays corporate rate when booking
* If staying elsewhere, you are eligible to be reimbursed up to the Arlo rate
* Meals and incidentals per diem: $74 is the GSA recommended amount
* First/last day of travel: aim for $50 or lower

#### Los Angeles
* Hotel: target $175 per night (GSA max: $158)
* Meals and incidentals per diem: $74 is the GSA recommended amount
* First/last day of travel: aim for $50 or lower

#### San Francisco
* Hotel: target $285 per night (GSA max: $267)
* Meals and incidentals per diem: $64 is the GSA recommended amount
* First/last day of travel: Aim for $50 or lower

#### Additional Things to keep in mind:
* It may make sense to book a hotel closer to a meeting/airport. If this puts you over the $$ amount for accommodations, reach out to the Expenses Team<EMAIL_ADDRESS>before booking and we can provide guidance on a case by case basis.
* If traveling to a market not listed above, send a note to the Expenses Team as soon as you think the trip is likely, so we can provide guidance on reimbursable amounts for accommodations and meals and incidentals.
* If you're having issues finding accommodations at or under the rates listed above (e.g. due to a conference in town), check in with the Expenses Team before booking, and we'll help you figure things out.

## Flights
* Use sites like Kayak, Expedia, or Google Flights to find flights that are both affordable and convenient
* If booking on your preferred airline to get points or status, please keep PopPays’ best interest in mind. If this causes your rate to be higher than other reasonable flight options, please check with the Expenses Team first. If it's a significant difference, we may ask that you cover the difference.
* If traveling with other teammates, try to fly out/in at similar times so travel expenses to/from airports can be minimized.

## :(
* Uber Black instead of UberX
* Flying business class instead of economy
* Really expensive client dinners - keep PopPays best interest in mind
* $200 unofficial team happy hours
* $20 coffee in room
* $30 for water, soap, shampoo

repository: aankitroy/handbook

path: /Operations Documents/Expense Policy.md

filename: Expense Policy.md

repo_name: aankitroy/handbook


text:
# How to contribute to Home Operating System

Love to get your contribution to the Anorak. In case you have a contribution, create a pull request and I will review it.

## General guideline

- Do not create major changes accross the whole HOS repo without agreement with the owner of the repo!
- A typical pull change would be a spesific feature or a new REST enpoint.
- Test to ensure there are no breaking changes in your contribution. In case there is, consult the owner of the repo before the pull request
- Add a detailed descripion of what you changed and why

## Did you write a patch that fixes a bug?
- Open a new GitHub pull request with the patch.

- Ensure the PR description clearly describes the problem and solution. Include the relevant issue number if applicable.

## Do you intend to add a new feature or change an existing one?
- Suggest your change in the HOS mailing list and start writing code.

- Do not open an issue on GitHub until you have collected positive feedback about the change. GitHub issues are primarily intended for bug reports and fixes.

Thanks

/brede

repository: BredeBorhaug/anorak

repo_name: BredeBorhaug/anorak


text:
---
layout: course
courseid: s18 410/510
desc: Project
permalink: /teaching/s18_4510_qc/project/
title: (Spring 2018) CS 410/510 - Intro to Quantum Computing
subtitle: Course Project
modified: 2018-05-16
---

## Instructions
2-3 people group projects. You may choose to do a _literature review_
project or (more exciting) _mini original research_. For literature review,
you'd read a few papers around a topic, understand the connection of
this topic to the general field of quantum computing as well as the of
various works under this topic. The final outcome would be a _survey_
paper including interesting open problems. For research project,
identify clearly a problem (e.g., designing/improving an algorithm for
a specific task) and let your _creativity_ guide you while maintaining
reasonable _precision_! You are not requried to completely solve a
problem (big congrats if you do!).

### Specs
*  **Proposal**: 1-2 pages consisting of 1) the topic, background,
   context, motivation; 2) brief summary of the relevant works and
   core papers to be studied; and 3) a goal you intend to achieve and
   a plan.
*  **Mid-term report**: ~5 pages. After more reading and group discussion, your mid-term report should have a polished and expanded version of your proposal. You also need to demonstrate the progress you've made since the proposal.
*  **Oral presentation**: Each group will have about 20mins to present your project followed by 5-minute Q&A. Your presentation should demonstrate both _breath_ and _depth_: you should aim for a clear introdution of your topic with sufficient background and motivation that would  **interest** the audience; and then you may choose to explain 1-2 techincal ideas in a little detail. Every group member needs to participate, and your group will be graded by other fellow students. You may give your the presentaion on board or with slides.
*  **Final report**: ~10 pages. This should resemble a real research
   paper: 1) a short abstract; 2) an introduction that motivates the
   topic/problem and gives an overview of the entire report; 3) details
   including proper preliminary materials (e.g., notations &
   defintions), explaning some main technical results; and finally 4)
   further discussion and open questions.
*  **Report format**: you are recommended to typeset your reports in **LaTeX**, and manage your bibliography using BibTeX. The [resource page]({{base}}/teaching/s18_4510_qc/resource/) has links to materials to pick up LaTeX. You should use single-column, single-space (between lines) format on letter-size papers. Here is a barebone [[TeX]({{base}}/teaching/s17_4510_qc/sample-quantum.tex){:target="_blank"} [PDF]({{base}}/teaching/s17_4510_qc/sample-quantum.pdf){:target="_blank"}] template. You may also follow a suitable [ACM Article Template](https://www.acm.org/publications/proceedings-template){:target="_blank"} (e.g., _ACM Small_ format). Many LaTeX templates are availabe there. There are online TeX editors available if you don't want to install a local engine, e.g., [Overleaf](https://www.overleaf.com/){:target="_blank"}.

### Timeline (Tentative)
*  **Week 1 & 2**: forming groups.
*  **Week 3 & 4**: meeting and discussing project ideas.
*  **April 27**: proposal due.
*  **May 14**: mid-term report due.
*  **Week 10**: in-class presentations.
*  **June 13**: final report due, 11:59pm any time zone.

------

## Suggested Topics

<!--Also available in ([PDF]({{base}}/teaching/s18_4510_qc/project.pdf){:target="_blank"}). --> Feel free to pursue a project not on this list. I'm happy to meet with your group and discuss about your ideas.

A few venues to look for inspirations:

*  [QIP](https://qipconference.org/)
*  [Qcrypt](http://2016.qcrypt.net/previous-conferences/)
*  General TCS conferences (e.g., [STOC](http://acm-stoc.org/), [FOCS](http://ieee-focs.org/), [SODA](http://www.siam.org/meetings/archives.php#SODA), [Crypto](http://www.iacr.org/meetings/crypto/)).

### Quantum algorithms for algebraic problems

Shor's quantum factorization problems is a notable example of solving algebraic problems faster, sometimes with exponential speedup, on a quantum computer than best known classical algorithms.

*  **General survey** [[CvD10](https://arxiv.org/abs/0812.0380)]
   _Quantum algorithms for algebraic problems_ by Andrew M. Childs,
   Wim van Dam.
* [[W01](http://arxiv.org/abs/quant-ph/0011023)]
_Quantum algorithms for solvable groups_ by J. Watrous.
*  **(Generalized) hidden shift problem**
    * [[vDHI02](http://arxiv.org/abs/quant-ph/0211140)] _Quantum
     Algorithms for some Hidden Shift Problems_ by W. van Dam,
     S. Hallgren, and L. Ip. A. Childs and W. van Dam, “Quantum
     algorithm for a generalized hidden shift problem”.
    * [[CvD05](http://arxiv.org/abs/quant-ph/0507190)] _Quantum
      algorithm for a generalized hidden shift problem_ by A. Childs
      and W. van Dam.
*  **Non-abelian** hidden subgroup problem
    * [[EK04](http://arxiv.org/abs/quant-ph/0401083)] _The quantum
      query complexity of the hidden subgroup problem is polynomial_
      by M. Ettinger, P. Høyer, E. Knill.
    * [[K03](http://arxiv.org/abs/quant-ph/0302112)] _A
     subexponential-time quantum algorithm for the dihedral hidden
     subgroup problem_ by G. Kuperberg.

### Quantum random walk

An extension of classical random walk to the quantum setting. It has become a framework for quantum algorithm design that usually achieves polynomial speedup. Grover's quantum search algorithm can be viewed as a special case of quantum random walk.

*  Survey papers
    *  [[K03](http://arxiv.org/abs/quant-ph/0303081)] _Quantum random walks – an introductory overview_ by J. Kempe.
    *  [[A04](http://arxiv.org/abs/quant-ph/0403120)] _Quantum walks and their algorithmic applications_ by A. Ambainis.
*  **Amplitute amplification**: simple generalization of Grover's search algorithm.
    *  [[BHMT02](https://arxiv.org/abs/quant-ph/0005055)] _Quantum Amplitude Amplification and Estimation_ by Gilles Brassard, Peter Hoyer, Michele Mosca, Alain Tapp.
	*  **Oblivious** amplitute amplification. [BCC+14] _Exponential improvement in precision for simulating sparse Hamiltonians_ by D. W. Berry, A. M. Childs, R. Cleve, R. Kothari, R. D. Somma.
*   [[MNRS06](http://arxiv.org/abs/quant-ph/0608026)] _Search
          via Quantum Walk_ by F. Magniez, A. Nayak, J. Roland, and
          M. Santha.
*  [[HK16](https://arxiv.org/abs/1612.08958)] _Efficient quantum
      walk on the grid with multiple marked elements_ by Peter Hoyer,
      Mojtaba Komeili.
*  **Continuous-time** quantum walk. [[C08](http://arxiv.org/abs/0806.1972)] _Universal computation by quantum walk_ by A. M. Childs.

### Quantum simulation related algorithms

Original motivation of quantum computers proposed by
R. Feynman. Closely related to quantum algorithms for linear
systems. They might already be meaningful on near-term quantum
processors (~100 noisy qubits). Machine learning is a potential
application.

*  [[HHL09](https://arxiv.org/abs/0811.3171)] _Quantum algorithm for solving linear systems of equations_ by Aram W. Harrow, Avinatan Hassidim, Seth Lloyd.
*  [[CKS16](http://arxiv.org/abs/1511.02306)] _Quantum linear systems
      algorithm with exponentially improved dependence on precision_
      by Andrew M. Childs, Robin Kothari, and Rolando D. Somma.
*  [[BCK15](http://arxiv.org/abs/1501.01715)] _Hamiltonian simulation
   with nearly optimal dependence on all parameters_ by Dominic
   W. Berry, Andrew M. Childs, and Robin Kothari.
*  Application in quantum **machine learning**. ML, of course... but be critical about what you see.
    * A survey. [[AW17](https://arxiv.org/abs/1701.06806)] _A Survey of Quantum
     Learning Theory_ by S. Arunachalam, R. de Wolf.
    * [[LMR14](https://arxiv.org/abs/1307.0401)] _Quantum principal component analysis_ by Seth Lloyd, Masoud Mohseni, Patrick Rebentrost.

### Quantum Information Theory

*  **Quantum error correcting** and **fault-tolerence**. We only scratch the surface of this topic in class. Quantum information is prone to noise, and to transmit quantum information reliably and build a robust quantum computer, we need to correct errors and further make all computation fault-tolerant. These techniques have also found critical in quantum cryptography.
    *  [[FMMC12](https://arxiv.org/abs/1208.0928)] _Surface codes:
      Towards practical large-scale quantum computation_ by Austin
      G. Fowler, Matteo Mariantoni, John M. Martinis, Andrew
      N. Cleland.
    * [[ABO99](http://arxiv.org/abs/quant-ph/9906129)] _Fault-Tolerant
     Quantum Computation with Constant Error Rate_ by D. Aharonov and
     M. Ben-Or.
	* [[CR17a](https://arxiv.org/abs/1705.02329)] _Quantum error correction with only two extra qubits_ by Rui Chao, Ben W. Reichardt.
    * [[CR17b](https://arxiv.org/abs/1705.05365)] _Fault-tolerant quantum computation with few qubits_ by Rui Chao, Ben W. Reichardt.
*  **Quantum Shannon Theory** Quantum information shows distinct features than what Shannon's theory about classical information describes.
    * [[HOW05](http://arxiv.org/abs/quant-ph/0505062)] _Quantum
     information can be negative_ by M. Horodecki, J. Oppenheim,
     A. Winter.
    * [[SY08](http://arxiv.org/abs/0807.4935)] _Quantum Communication
     With Zero-Capacity Channels_ by G. Smith, J. Yard.
*  Quantum information and **black holes**. There is some fancinating connection to the theory of black holes.
    *  [[A16 Chapter 6](http://www.scottaaronson.com/barbados-2016.pdf)]
      _From quantum money to balck holes_ by S. Aaronson.

### Quantum Computational Complexity

There is a large body of research that explores abstractly the strengths and the limits of quantum computing.

*  **General survey** [[W09](http://arxiv.org/abs/0804.3401)] _Quantum Computational Complexity_ by J. Watrous.
*  Quantum **interactive proofs** What problems can you compute by interacting with a ``powerful'' guru?
    * A comprehensive survey. [[VW16](https://arxiv.org/abs/1610.01664)] _Quantum
     Proofs_ by Thomas Vidick, John Watrous.
    * [[JJUW09](https://arxiv.org/abs/0907.4737)] _QIP = PSPACE_ by
      Rahul Jain, Zhengfeng Ji, Sarvagya Upadhyay, John Watrous
* Can you verify a quantum computer by a classical computer? Someone claims a quantum computer at hand, can you trust him/her?
    *  [[M18](https://arxiv.org/abs/1804.01082)] _Classical Verification of Quantum Computations_
by Urmila Mahadev.
*  **Hamiltonian Complexity** How difficult is it to determin the ground energy of a physical system?
    * [[AN02](https://arxiv.org/abs/quant-ph/0210077)] _Quantum NP - A
     Survey_ by Dorit Aharonov, Tomer Naveh.

### Quantum Query & Communication Complexity

*  [[MW13](https://arxiv.org/abs/1310.2035)] _A Survey of Quantum Property Testing_ by Ashley Montanaro, Ronald de Wolf.
*  [[G01](https://arxiv.org/abs/quant-ph/0101005)] _Quantum
   Communication Complexity (A Survey)_ by Gilles Brassard.
*  Separations of classical/quantum complexity
    *  [[ABDK16](https://arxiv.org/abs/1511.01937)] _Separations in
      query complexity using cheat sheets_ by Scott Aaronson, Shalev
      Ben-David, and Robin Kothari.
    *  [[ABBD+16](http://arxiv.org/abs/1605.01142)] _Separations in
      communication complexity using cheat sheets and information
      complexity_ by Anurag Anshu et al.
*  [[ATYY16](https://arxiv.org/abs/1611.08946)] _Exponential
      Separation of Quantum Communication and Classical Information_
      by Anurag Anshu, Dave Touchette, Penghui Yao, Nengkun Yu.

### Quantum and crypto
*  **Post-quantum crypto** cope with quantum _codebreakers_
    *  [[Z12](http://eprint.iacr.org/2012/182)] _How to Construct
      Quantum Random Functions_ by Mark Zhandry.
    *  [[Z13](http://eprint.iacr.org/2012/606)] _Quantum-Secure Message
      Authentication Codes_ by Dan Boneh and Mark Zhandry.
    * [[S14](https://arxiv.org/abs/1409.2187)] _A Note on Quantum
     Security for Post-Quantum Cryptography_ by F. Song.
    * [[BDF+11](https://arxiv.org/abs/1008.0931)] _Random Oracles in a
     Quantum World_, by Dan Boneh et al.
    *  [[KLLNP16](https://arxiv.org/abs/1602.05973)] _Breaking
      Symmetric Cryptosystems using Quantum Period Finding_ by Marc
      Kaplan, Gaëtan Leurent, Anthony Leverrier, María Naya-Plasencia.
	*  [[SY17](https://eprint.iacr.org/2017/509)] _Quantum Security of NMAC and Related Constructions_ by F. Song and A. Yun. A positive message, proving several security constructions, in regard to the above attack.
*  **Quantum cryptograpy** equip _codemakers_ with quantum information
   processing
    * **Survey**. [[BS15](https://arxiv.org/abs/1510.06120)] _Quantum
     Cryptography Beyond Quantum Key Distribution_ by Anne Broadbent,
     Christian Schaffner.
    * Quantum key exchange a la
     **Merkle** [[BHK+11](http://arxiv.org/abs/1108.2316)] _Merkle
     Puzzles in a Quantum World_ by G. Brassard, P. Hoyer, K. Kalach,
     M. Kaplan, S. Laplante, L. Salvail.
    * **Quantum Money** [[AC12](https://arxiv.org/abs/1203.4740)]
     _Quantum Money from Hidden Subspaces_ by Scott Aaronson, Paul
     Christiano. [[A16 Chapter 8,9](http://www.scottaaronson.com/barbados-2016.pdf)]
      _From quantum money to balck holes_ by S. Aaronson.
    * **Quantum homomorphic encryption** [[DSS16](https://arxiv.org/abs/1603.09717)] _Quantum
     homomorphic encryption for polynomial-sized circuits_ by Yfke
     Dulek, Christian Schaffner, Florian Speelman.
*  **Device-independence, randomness amplification** What if your
   devices for cryptography cannot be trusted (recall
   what [NSA](https://en.wikipedia.org/wiki/Dual_EC_DRBG) did)?
   Quantum non-locality enables certified security.
    * [[BCMVV18](https://arxiv.org/abs/1804.00640)] _Certifiable Randomness from a Single Quantum Device_ by Z. Brakerski, P. Christiano, U. Mahadev, U. Vazirani, T. Vidick.

### Other models of quantum computation

*  **Adiabetic quantum computation** [[AvDK+04](https://arxiv.org/abs/quant-ph/0405098)] _Adiabatic Quantum Computation is Equivalent to Standard Quantum Computation_ by D. Aharonov et al.
*  **Measurement-based** [[Jozsa05](http://arxiv.org/abs/quant-ph/0508124)] _An introduction to measurement based quantum computation_ by R. Jozsa.
*  **Topological quantum computation**: Microsoft is pursing this direction. A beautiful idea that would make noises much easier to deal with. [[K97](https://arxiv.org/abs/quant-ph/9707021)] _Fault-tolerant quantum computation by anyons_ by A. Yu. Kitaev.
*  A **non-univeral** model concerning **bonson
   sampling**, which is also a promising approach to demonstrate **quantum supremacy**.
    *  [[AA11](https://arxiv.org/abs/1011.3245)] _The
   Computational Complexity of Linear Optics_ by S. Aaronson and
   A. Arkhipov.
    *  [BFNV18] _Quantum Supremacy and the Complexity of Random Circuit Sampling_ by A. Bouland, B. Fefferman, C. Nirkhe, U. Vazirani.
*  Qubit is precious, be
   conservative. [[KL98](https://arxiv.org/abs/quant-ph/9802037)] _On
   the Power of One Bit of Quantum Information_ by E. Knill,
   R. Laflamme.

### Quantum software and logic

*  **Universal quantum gates**. Quantum computer is digital! How come one can implement a continuous space of unitary operations by a constant-size gate set?
    * Survey. [[DN05](https://arxiv.org/abs/quant-ph/0505030)]_The
   Solovay-Kitaev algorithm_ by Christopher M. Dawson, Michael
   A. Nielsen.
    * [[S03](https://arxiv.org/abs/quant-ph/0205115)] _Both Toffoli
     and Controlled-NOT need little help to do universal quantum
     computation_ by Y. Shi.
*  **Quantum software (and hardware) platforms**. Project idea: survey some popular platforms, and write quantum programs to simulate selected quantum algorithms on some backends (classical simulator or actual quantum processor).
    *  [[IBM18](https://www.research.ibm.com/ibm-q/)] IBM Q Experience and Quantum information software Kit [QISKit](https://nbviewer.jupyter.org/github/QISKit/qiskit-tutorial/blob/stable/index.ipynb).
    *  [[SHT16](https://arxiv.org/abs/1612.08091)] _ProjectQ: An Open
   Source Software Framework for Quantum Computing_ by Damian
   S. Steiger, Thomas Häner, Matthias Troyer. More info. on their
   project [website](https://projectq.ch/){:target="_blank"}.
    *  [MS18](https://www.microsoft.com/en-us/quantum/development-kit) _Microsoft Quantum Development Kit_ by QuArC @ Microsoft.
    *  [[GLRSV13](https://arxiv.org/abs/1304.3390)] _Quipper: A Scalable
   Quantum Programming Language_ by A. S. Green et al. [Project website](http://www.mathstat.dal.ca/~selinger/quipper/).
*  Thoery of quantum programing. [[LY18](https://popl18.sigplan.org/event/popl-2018-papers-algorithmic-analysis-of-termination-problems-for-quantum-programs)] _Algorithmic Analysis of Termination Problems for Quantum Programs
_ by Y. Li, M. Ying.

gha_language: TeX


text:
# jsonrpcserver

Process [JSON-RPC](http://www.jsonrpc.org/) requests in Python.

![PyPI](https://img.shields.io/pypi/v/jsonrpcserver.svg)
![Downloads](https://pepy.tech/badge/jsonrpcserver)
![Coverage Status](https://coveralls.io/repos/github/bcb/jsonrpcserver/badge.svg?branch=master)

```python
from jsonrpcserver import method, serve

@method
def ping():
    return "pong"

if __name__ == "__main__":
    serve()
```

Full documentation is at [jsonrpcserver.readthedocs.io](https://jsonrpcserver.readthedocs.io/).

See also: [jsonrpcclient](https://github.com/bcb/jsonrpcclient)

repository: vasechko-sergey/jsonrpcserver

repo_name: vasechko-sergey/jsonrpcserver


text:
# Python cheat sheet

## Pad a number with zeros on the left

From [StackOverflow](http://stackoverflow.com/questions/339007/nicest-way-to-pad-zeroes-to-string)

Strings:

```python
>>> n = '4'
>>> print n.zfill(3)
>>> '004'
```

And for numbers:

```python
>>> n = 4
>>> print '%03d' % n
>>> 004
>>> print format(4, '03') # python >= 2.6
>>> 004
>>> print '{0:03d}'.format(4)  # python >= 2.6
>>> 004
>>> print('{0:03d}'.format(4))  # python 3
>>> 004
```
## Turn off warnings

Turn them off for a specific function:

```python
import warnings

def fxn():
    warnings.warn("deprecated", DeprecationWarning)

with warnings.catch_warnings():
    warnings.simplefilter("ignore")
    fxn()
```

Turn them off for everything (not condonded):

```python
import warnings
warnings.filterwarnings("ignore")
```

repository: shayanhoss/cheatsheets

repo_name: shayanhoss/cheatsheets


text:
---
title: Full Screen Mode
page_title: Full Screen Mode - RadEditor
description: Check our Web Forms article about Full Screen Mode.
slug: editor/functionality/editor-views-and-modes/full-screen-mode
tags: full,screen,mode
published: True
position: 3
---

# Full Screen Mode

As the name implies, the Full Screen Mode feature of RadEditor for ASP.NET AJAX allows you to view the editor as you would in a normal fullscreen window.

![](images/editor-fullscreenmode.png)

If you would like to open the editor in full screen mode when the page is loaded, you can use the editor's Fire client-side method to fire the ToggleScreenMode command as shown below:

````ASP.NET
<script type="text/javascript">
	function OnClientLoad(editor, args)
	{
		editor.fire("ToggleScreenMode");
	}
</script>
<telerik:RadEditor RenderMode="Lightweight" runat="server" ID="RadEditor1" OnClientLoad="OnClientLoad">
	<Content>Full Screen Mode on Load</Content>
</telerik:RadEditor>
````

repository: telerik/ajax-docs

gha_language: C#

repo_name: telerik/ajax-docs


text:
---
title: "porter installations output"
slug: porter_installations_output
url: /cli/porter_installations_output/
---
## porter installations output

Output commands

### Options

```
  -h, --help   help for output
```

### Options inherited from parent commands

```
      --experimental strings   Comma separated list of experimental features to enable. See https://getporter.org/configuration/#experimental-feature-flags for available feature flags.
      --verbosity string       Threshold for printing messages to the console. Available values are: debug, info, warning, error. (default "info")
```

### SEE ALSO

* [porter installations](/cli/porter_installations/)	 - Installation commands
* [porter installations output list](/cli/porter_installations_output_list/)	 - List installation outputs
* [porter installations output show](/cli/porter_installations_output_show/)	 - Show the output of an installation

repository: getporter/porter

gha_language: Go

repo_name: getporter/porter


text:
# randomjsongenerator
Simple bash script that relies on `/usr/share/dict/words` to generate documents like:

```
cat 2.json
{
  "title" : "ringleaders cuckoos supplementary clipping stabilizers " ,
  "category" : "Krishnamurti" ,
  "date" : "2019-03-27" ,
  "author" :
  {
    "first_name": "Mesmer" ,
    "last_name": "Libreville"
  }
}
```

## Usage
Run `docGen.sh <num of docs>` by default it tries to create 20 documetns.


text:
# AWS API client for AWS Batch

**Warning: This is a generated library, some operations may not work.**

*About the service:*
AWS Batch enables you to run batch computing workloads on the AWS Cloud.
Batch computing is a common way for developers, scientists, and engineers to
access large amounts of compute resources, and AWS Batch removes the
undifferentiated heavy lifting of configuring and managing the required
infrastructure. AWS Batch will be familiar to users of traditional batch
computing software. This service can efficiently provision resources in
response to jobs submitted in order to eliminate capacity constraints,
reduce compute costs, and deliver results quickly.

As a fully managed service, AWS Batch enables developers, scientists, and
engineers to run batch computing workloads of any scale. AWS Batch
automatically provisions compute resources and optimizes the workload
distribution based on the quantity and scale of the workloads. With AWS
Batch, there is no need to install or manage batch computing software, which
allows you to focus on analyzing results and solving problems. AWS Batch
reduces operational complexities, saves time, and reduces costs, which makes
it easy for developers, scientists, and engineers to run their batch jobs in
the AWS Cloud.

## Links

- [Other AWS libraries](https://github.com/agilord/aws_client/tree/master/generated).
- [Issue tracker](https://github.com/agilord/aws_client/issues).
- [AWS API definitions](https://github.com/aws/aws-sdk-js/tree/master/apis).

## Contributors

- [Jonathan Böcker](https://github.com/Schwusch)
- [Istvan Soós](https://github.com/isoos)


text:
# UD513_Intro_to_DS_and_Algo
Note and reference material to UD 513 Intro to Data structure and Algorithm

Course website:
https://www.udacity.com/course/data-structures-and-algorithms-in-python--ud513

Table of content:

## Lesson 1: Introduction and efficiency

  Concept of time and space complexity

  Big O notation

  Evaluate complexity of an algorithm

## Lesson 2: List based collection

  Concept of container

  Python built-in type - list

  Python class usage

  Abstract Data Type - Stack, and implementation

  Abstract Data Type - Queue, and implementation

  Abstract Data Type - Linked List, and implementation

## Lesson 3: Searching and Sorting

  Concept of efficienct algorithm

  Binary Search implementation

  Concept of sorting

  Concept of divide-and-conquer

  Concept of recursion

  Entry level sorting - Bubble sort

  Advanced sorting - Merge sort, and tracing

  Advanced sorting - Quick sort, and implementation

  Recursion example - Fibonacci sequence

## Lesson 4: Maps and Hashing

  Concept of key-value pair

  Python built-in type - dictionary

  Nested dictionary, and implementation

  Concept of Hashing

  Concept of load factor and collision

  Abstract Data Type - Hash, and implementation

## Lesson 5: Trees

  Concept of tree, and terminology

  Definition of tree traversal -
    pre-order, in-order, post-order

  Tree traversal with recursion, and implementation

  Concept of Binary Tree

  Concept of Binary Search Tree, and implementation

  Concept of Balanced Search Tree

  Concept of Red-black Tree

## Lesson 6: Graph

  Concept of grpah, and terminology

  Definition of graph traversal -
    Topological, Depth First Search (DFS), Breadth First Search (BFS)

  Abstract of graph presentation -
    Adjacency List, Adjacency Matrix, Edge List

  Implementation of DFS as well as BFS

  Implementation of graph presentation


text:
xsdwalker
=========

Traverse a set of XML Schema documents (.xsd) building up a list of
all dependencies/imports.  This list then printed out as an 'uber xsd'
file, suitable for processing by the Java 'xjc' JAXB tool (or its
Ant/Maven equivalent).  Build is via Maven.

Example, using a recent (as of May 2014) release of Mitre's STIX
schema file set (https://stix.mitre.org/language/version1.1.1/stix_v1.1.1.zip):

% xsdwalker.sh [-v] /path/to/stix_v1.1.1/

which produces ./stix_v1.1.1.uber.xsd (and a report file
./stix_v1.1.1.txt).  The verbose flag '-v' prints progress to stdout. Then

% xjc stix_v1.1.1.uber.xsd

To exclude subsets of .xsd files from the uber xsd file, use the -e
option (can be used 2+ times).  An example, relating again to the STIX
.xsd bundle:

% xsdwalker.sh [-v] /path/to/stix_v1.1.1/ -e /path/to/stix_v1.1.1/extensions

For the STIX schema set above, we likely have to exclude the
'extensions' .xsd files, else xjc complain about a myriad of issues.

The XSDWalker utility takes the guess work out of deciding which .xsd
files to offer to xjc and which ones to not offer (since they will
produce duplication and xjc complaints).

repository: uw-dims/xsdwalker

repo_name: uw-dims/xsdwalker


text:
# SBTUITestTunnelClient

Library for IPC.

It was copy-pasted from <https://github.com/Subito-it/SBTUITestTunnel>. See top-level README.md for explanation.

## Author

[Subito-it](https://github.com/Subito-it)

## Licenses

All source code is licensed under the [Apache License, Version 2.0](LICENSE).

repository: avito-tech/Mixbox

gha_language: Swift

repo_name: avito-tech/Mixbox


text:
# Fake Hanging Chains
Fake, fast chains for Unity3D that can be animated ingame with false simple physics.
If the chain is not going to move ingame you can merge all the generated links to have only one mesh
instead of multiple copies to save drawcalls

![Preview](https://github.com/forestrf/Fake-hanging-chains/blob/master/Readme/chain.gif)

[MIT LICENSE](https://github.com/forestrf/Fake-hanging-chains/blob/master/LICENSE)


text:
---
layout: post
title: "A Book Review: The Meaning of It All by Richard Feynman"
date: 2013-06-17
status: publish
comments: true
share: true
categories:
- Book Reviews
- Science
- Society
tags: []
image:
  feature: main-banner-2.jpg
---

ISBN-13:<PHONE_NUMBER>943

I was really excited about this book when I first saw it. Feynman was a brilliant physicist and his other writings I have read are excellent (Feynman Lectures, for example). He was a master at explaining ideas and I thought this book would reflect that. I was excited about seeing how he would bring together different ideas that were outside his area of expertise.

This book, however, has fallen short. I have to be completely honest here, I did not finish the book. I couldn't. I got half way through the book and it was a struggle getting that far (the book is only about 120 pages)! I found myself having to re-read almost every page two and three times. Feynman is usually very eloquent when he speaks but in this lecture series... not so much. It is almost like there wasn't any proofing when this book was transcribed from his lectures.

I also did not like the content of the lectures very much. Feynman is all over the place in these lectures and he sometimes side-hands the historically "soft" sciences that deal with things like society. I do not agree with this sentiment and it annoys me when I read it from him.

I will eventually give this book another try and re-read it but I just can't get through it at this point in time. Feynman himself didn't want these lectures published apparently and I can see why...


text:
# Spring MVC Security Example

Sample [Spring MVC][spring-mvc] project with web security.

Handles user authentication, and access restrictions.

## Features

* Login form handling
* Encrypted passwords
* Roles and privileges model
* User status (enabled/expired/locked)
* CSRF token
* Remember-me support
* Security annotations
* OAuth authentication

## Views

Thymeleaf is used for the views.

[spring-mvc]: https://spring.io

### Users

| User     | Password | Permissions    |
|----------|----------|----------------|
| admin    | 1234     | all            |
| noroles  | 1111     | none           |
| locked   | 1111     | all            |
| expired  | 1111     | all            |
| disabled | 1111     | all            |
| expcreds | 1111     | all            |
| noread   | 1111     | all minus read |

repository: Bernardo-MG/spring-mvc-security-example

gha_language: Java

repo_name: Bernardo-MG/spring-mvc-security-example


text:
# Cytodiplospora elymina Davis, 1919 SPECIES

#### Status
SYNONYM

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

#### Published in
Trans. Wis. Acad. Sci. Arts Lett. 19(2): 701 (1919)

#### Original name
Cytodiplospora elymina Davis, 1919

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Davisiella/Davisiella elymina/ Syn. Cytodiplospora elymina/README.md

repo_name: mdoering/backbone


text:
# `@thorgate/spa-components`

> Common components used with [Thorgate project template SPA variant](https://gitlab.com/thorgate-public/django-project-template/tree/spa)

## Usage

```
import<EMAIL_ADDRESS>
import { PageError, Status } from '@thorgate/spa-components';

// Somewhere in the dom tree to render permission denied.
<PageError statusCode={403}>
    Very bad, you should not have come. Meow.
</PageError>

// Or use Status to create custom error component
<Status code={404}>
    Terribly sorry, I have lost what you are looking for.
</Status>
```

repository: thorgate/tg-spa-utils

gha_license_id: NOASSERTION

repo_name: thorgate/tg-spa-utils


text:
---
layout: engineering-education
status: publish
published: true
url: /how-to-use-modular-patterns-in-nodejs/
title: How to Use Modular Patterns in Node.js
description: This article will go through the basics of modularizing codes in Node.js. This tutorial will focus on creating modules, exporting and importing them to different files using Node.js.
author: edwin-wachira
date: 2021-05-24T00:00:00-11:30
topics: [Node.js]
excerpt_separator: <!--more-->
images:

  - url: /engineering-education/how-to-use-modular-patterns-in-nodejs/hero.jpg
    alt: Modular patterns image example
---
In this article, we will learn in-detail what modularization of code is, and how to do it. We will also learn to modularize code in Node.js. When building applications, you don’t write all your code in one file. As this would be very difficult to manage.
<!--more-->
If it's a large application, it would be hard for a developer to come back to this code, refactor, or extend the application functionalities.

However, you can break down this complex application into smaller reusable parts.

### Prerequisites
To follow this article along it will be useful to have the following:
- [Node.js installed](https://nodejs.org/en/download/).
- A background knowledge of using [Node.js](https://nodejs.dev/learn).

### Introduction
Typically, developers code is divided into several logical files. Each file has a different bit of code with certain functionality. This way, it is easier to maintain your codebase, because each file has less code to accomplish a specific task.

It is easier to debug and share the code with other developers, this makes it easier for application contributions and maintenance.

This concept is common in most programming languages. The concept is called modularity (Modular patterns). In this case, every single file is a module.

Let's say, for example, you are creating a calculator application. In this case, you can have a file that handles addition, and another file handling subtraction functionality. So, we have each file performing a specific arithmetical task.

### Scope and namespace
This is a huge advantage for Node.js. When you use JavaScript without frameworks such as Node.js, there is no concept of public and private scope.

JavaScript offers local scope, which means the content of a function or an object is private, unless specifically exposed to any external module.

This might pollute the global namespace when executing this JavaScript code in the browser. Thus, you need to wrap the functions method in a function scope to enhance privacy and avoid populating the global namespace in the browser.

Node.js does not implement the global namespace. In Node.js, modular systems are implemented natively, based on the common JavaScript specifications.

This way, you implement a local namespace within every module. It contains variables, and properties that are private to a module until explicitly exposed/exported to other modules.

This breaks down the application complexity into manageable units and separating concerns.

### Modularization
A modular system provides a scalable framework when building complicated apps.

These patterns can be implemented in several ways, but that depends on the modular programming paradigm of the host programming language.

In Node.js, the concept of Modular patterns has additional features that go beyond the regular module (file) pattern.

The Node.js modular functionality can be used to import functions, classes, objects, external files, core Node.js modules, and NPM modules.

A Node.js can be stateless or stateful:
- Stateless expose stateless entities such as class, objects, and methods.
- Stateful exposes a stateful instance of an object such as a database connection, and an instance of third-party API service.

This tutorial will focus on creating modules, exporting and importing them to different files using Node.js.

Let's create some Node.js modules.

### Creating and importing a function module
To start with, create a project folder and include the `app.js` and `main.js` files respectively, as shown below:

```js
// app.js
const sum = (num1,num2) => {
    return 'The sum is '+ (num1 + num2);
}
```

```js
// main.js
const result = sum(10,14)
console.log(result);
```

It is clear that `app.js` wants to access function `sum()` from `main.js`.

When you run `node main.js`, it shows `undefined`. This is because `sum` is private to `main.js`. And cannot be accessible outside this module unless exposed publically to other modules.

This is how modules are made available when required by other modules.

```js
// app.js
const sum = (num1, num2) => {
    return 'The sum is '+ (num1 + num2);
}

module.exports = sum
```

```js
// main.js
// search app.js in present directory
const sum = require('./app.js')

const result = sum(10, 14)
console.log(result);
```

Here, we have a function `sum()` containing `module.exports`, which makes this function accessible outside of the module wherever we require that module.

The object `module` uses the property `exports` to expose the function `sum` natively. The function is now explicitly accessible and can now be invoked in other modules such as `main.js`.

To use this module, you need to import it to another module using `require()`. Here, we import the module `app.js` to module `main.js`.

> Note: The require() function is synchronous. `require()` caches the value of `module.exports` and returns that same value for all future `require()` calls. If the module should return different value, you should export a function that can be called afterward to return a new value.

When you run `node main.js`, you'll get the results as expected.

What if you have different functions and export them to `main.js`.

This is how you would use the module system:

```js
// app.js
const sum = (num1, num2) => {
    return 'The sum is '+ (num1 + num2);
}

const count = (anims) => {
    return 'The number of animals is '+ anims.length;
};

const greet = () => {
    console.log("Hello world");
}

module.exports = {
    sum:sum,
    count:count,
    greet:greet
}
```

```js
// main.js
// search app.js in present directory
const myModule = require('./app.js')

const result = myModule.sum(10,14)
console.log(result);

const animals = myModule.count(['Sheep','Horse','Tiger','Pigeon'])
console.log(animals);

myModule.greet();
```

In this case, `module.exports` is set to an object with a set of functions as properties you want to export.

The above patterns are called **Revealing Module Pattern**.

This is because you are only exposing the things you want to be public to other modules. It only exposes the final results when the `require()` is run on the other module.

### Exporting and importing a class
```js
// person.js
// constructor function for the Person class
function Person(name) {
    this.age = 21;
    this.name = name;
}

// export the class, so other modules can access Persion objects
module.exports = {
    Person: Person
}
```

This is a class `Person` containing objects name and age. `Person` is exposed as a property of `module.exports`. We can access the class `Person` by importing the `person.js` module to main.js, as shown below.

```js
// main.js
// import the Person module
let persons = require('./person.js');
let Person = persons.Person;

// creates a Persion
let persons1 = new Person("John");

// find the names and ages persons1 in the class Persion
console.log(persons1.name + " is " + persons1.age + " old." );
```

In this case, we create an instance of class `Person` inside `main.js` using the `new` keyword.

Run `node main.js` to log the results in the console.

### Exports
`exports` is a shorthand for `module.exports`.

`exports` helps you expose objects and methods.

Check this example to better understand:

```js
//circle.js
// constant value
const pi = Math.PI

// using the the value to diggrent elements and exposing them to other modules
exports.areaOfaCircle = radiusOfaCircle => (radiusOfaCircle ** 2) * pi
exports.circumferenceOfaCircle = radiusOfaCircle => 2 * radiusOfaCircle * pi
```

The module circle exposes functions `circumferenceOfaCircle` and `areaOfaCircle` using alias `exports`.

To find the area and circumference of a circle you need a `const PI`. `Math.PI` provides this mathematical functionality.

In this case, `const pi` is private to `circle.js`. It's only accessible to this module.

We need a way to consume `PI` within this module and then expose its elements using `exports`.

Let's consume these elements as shown here:

```js
//app.js
const circle = require('./app.js')

const r = 21
const area = circle.areaOfaCircle(r)
const circumference = circle.circumferenceOfaCircle(r)

console.log(`Area of the circle is: ${area}`)
console.log(`Circumference of the circle is: ${circumference}`)
```

Run `node app.js` to get the results.

### module.exports vs exports
`exports` is just an alias variable used for the convenience of writing less code. `exports` behaves as if there is an implicit line of code that assigns it to `module.exports` i.e.:

```js
const exports = module.exports = {};
```

This assignment occurs behind the scenes whenever you use  `exports`.

Variable `exports` is only a pointer to the `module.exports`'s initial value.

This is how you should use `exports`.

```js
exports.areaOfaCircle = radiusOfaCircle => (radiusOfaCircle ** 2) * pi
```

#### Usecase
- `module.exports` is commonly used to expose elements such as functions, objects, and classes at the root level.

For example:

```js
module.exports = sum
```

- If you'd rather have a single object that reveals multiple assignments, use the `module.exports` method.

For example:

```js
module.exports = {
    sum:sum,
    count:count,
    greet:greet
}
```

> Assigning more than one object to `exports` won't work

- `exports` is great when directly exposing named functions such as `exports.areaOfaCircle`.

### Using Node.js core modules
Node.js is bundled with a couple of modules such as HTTP [file system](https://nodejs.org/api/fs.html) (fs)

To use these modules in your project, you use the `require()` function to access an instance of modules.

For example, using [Node.js HTTP module](https://nodejs.org/api/http.html) to create a simple server.

### Node.js NPM modules
Npm provides open sources packages that you can use within your project.

When you install an `npm` package, dependencies are saved in a `node_modules` folder. For these modules to work, you need to import them using `require()`.

To work with NPM modules, you have to run `npm init -y` to generate a `package.json` file.

Run `npm install <package name>` to make a package available for your project.

For example, `Moment` is an NPM module used when trying to display and format Node.js dates. Here is how you would use Moment.

Run `npm install moment` to install `Moment` dependencies for your project.

Using [Moment](/engineering-education/nodejs-date-and-time-objects-with-moment/) to display today date.

```js
//app.js
const moment = require('moment');
const todayDate = moment();

console.log(
    "The date today is " +
    todayDate.format('dddd, MMMM Do YYYY, h:mm:ss a')
);
```

Run `node app.js`, and we would get the output as shown below:

```bash
The date today is Saturday, May 1st 2021, 4:11:26 pm
```

### Conclusion
Module patterns help you implement the art of building Node.js projects at scale by dividing them into reusable parts.

Happy coding.

### Further reading
- [RESTful Web API in Node.js using PostgresSQL and Express](/engineering-education/restful-web-api-using-nodejs-postgressql-and-express/)
- [Logging with Winston and Node.js](/engineering-education/logging-with-winston/)
- [Documenting a Node.js REST API using Swagger](/engineering-education/documenting-node-js-rest-api-using-swagger/)
- [Uploading Files Using Multer in a Node.js](/engineering-education/uploading-files-using-multer-nodejs/)

---
Peer Review Contributions by: [Srishilesh P S](/engineering-education/authors/srishilesh-p-s/)

repository: mbuguac/engineering-education

gha_language: SCSS

repo_name: mbuguac/engineering-education