text:
# arpping
Discover and search for internet-connected devices (locally) using ping and arp

## Motivation
I was trying to find a quick and reliable way to ping and discover devices connected to my LAN. I tried out:

* [node-nmap](https://www.npmjs.com/package/node-nmap)
* [libnmap](https://www.npmjs.com/package/libnmap)
* [node-arp](https://www.npmjs.com/package/node-arp)

But both node-nmap and libnmap were slow and unreliable, and node-arp only had part of the functionality I needed, so I decided to make my own. This is the result, and it's been pretty helpful so far.

## Installation
Using npm:

```bash
npm install --save arpping
```

## Usage
To include in a project file:

```javascript
const Arpping = require('arpping');
const arpping = new Arpping(options);
```

The module returns the Arpping class. The Arpping constructor accepts an optional object argument with the following parameters:

|Parameter |Default |Description |
|-----------|---------|-------------|
| timeout | 5 | The time, in seconds, ping will try to send packets to a device before returning results |
| includeEndpoints | false | Specify if you'd like to include range endpoints (1, 255) in your scans |
| useCache | true | Specify if you'd like to temporarily cache results for quicker and convenient usage |
| cacheTimeout | 3600 | Specify the cache's TTL (time to live) in seconds |
| interfaceFilters | {} | Filters for specifying which network interface to connect to - valid filters are explained below |
| connectionInterval | 600 | The time interval, in seconds, for testing device's connection |
| onConnect | [] | An array of callback functions to be called when a new connection is established |
| onDisconnect | [] | An array of callback functions to be called when an existing connection is no longer active |
| debug | false | Enable/disable debug logging |

### Interface
Interfaces represent different network types, e.g. Ethernet, WiFi, self-hosted networks (hotspots). Each Arpping instance connects to one (and only one) of these network interfaces and is able to search and discover other devices on that network. Valid filters are arrays that specify valid values for each interface property. They include:

|Filter |Default |Description |
|-----------|---------|-------------|
| interface | `[ 'lo0', 'en0', 'eth0', 'wlan0' ]` | Allowed network interface names |
| internal | `[ false ]` | I think this should only ever be `[ false ]` as I don't believe external devices can connect to internal networks, but I left it as an option just in case |
| family | `[ IPv4 ]` | specify IPv4 and/or IPv6 network protocol |

Note: an empty array means any value is acceptable

### myDevice
An Arpping instance has the property `myDevice`, which lists the interpreted OS of the host machine (`instance.myDevice.os`).

On initialization, the Arpping instance will try to connect to the first network interface that satisfies the provided filters. If a valid connection is found, `myDevice` will also contain the device `type` based on its mac address (if it exists) and `connection` information, including the IP `address`, `mac` address, `netmask`, and IPv4/IPv6 `family`.

### getNetworkInterfaces Static Method
The Arpping class has a static method called `getNetworkInterfaces`, which simply wraps the [os module's](https://nodejs.org/api/os.html#os_os_networkinterfaces) `networkInterfaces` function, returning an object of available interfaces.
```javascript
const Arpping = require('arpping');

Arpping.getNetworkInterfaces();

/* Example output
{
  lo: [
    {
      address: '<IP_ADDRESS>',
      netmask: '<IP_ADDRESS>',
      family: 'IPv4',
      mac: '00:00:00:00:00:00',
      internal: true,
      cidr: '<IP_ADDRESS>/8'
    },
    {
      address: '::1',
      netmask: 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff',
      family: 'IPv6',
      mac: '00:00:00:00:00:00',
      scopeid: 0,
      internal: true,
      cidr: '::1/128'
    }
  ],
  eth0: [
    {
      address: '<IP_ADDRESS>',
      netmask: '<IP_ADDRESS>',
      family: 'IPv4',
      mac: '01:02:03:0a:0b:0c',
      internal: false,
      cidr: '<IP_ADDRESS>/24'
    },
    {
      address: 'fe80::a00:27ff:fe4e:66a1',
      netmask: 'ffff:ffff:ffff:ffff::',
      family: 'IPv6',
      mac: '01:02:03:0a:0b:0c',
      scopeid: 1,
      internal: false,
      cidr: 'fe80::a00:27ff:fe4e:66a1/64'
    }
  ]
}
*/
```

### Methods
Any methods that depend on ping/arp (and therefore an active internet/interface connection) will throw an error if no connection is available.

#### getConnection
This method finds a valid interface connection based on the provided `interfaceFilters`. It sets the `myDevice.connection` property and returns it. It is run on initialization, and on an interval based on the `connectionInterval` parameter. You likely won't need to call this method manually.

Also, depending on the previous and current connection state, the `onConnect` or `onDisconnect` callbacks may fire. The onConnect callbacks will be passed the connection object.
```javascript
const Arpping = require('arpping');
const arpping = new Arpping({
  onConnect: [ connection => console.log(`Connected: ${JSON.stringify(connection, null, 4)}`) ]
});

const connection = arpping.getConnection({
  interface: [ 'en0' ],
  internal: [ false ],
  family: []
});

/* Example output
Connected: {
  name: 'en0',
  address: '<IP_ADDRESS>',
  netmask: '<IP_ADDRESS>',
  family: 'IPv4',
  mac: '01:02:03:0a:0b:0c',
  internal: false,
  cidr: '<IP_ADDRESS>/24'
}
*/
```

#### discover
The discover method returns an array of hosts found on the local network. Each host entry contains the host's name, ip and mac address, and can also be assigned a type based on its mac address VendorID. The host entry that represents the machine running the script will have a `isHostDevice` key set with a value of true.
```javascript
const Arpping = require('arpping');
const arpping = new Arpping(options);

arpping.discover()
  .then(hosts => console.log(JSON.stringify(hosts, null, 4)))
  .catch(err => console.log(err));

/* Example output
[
  {
    "name": "ryans-mbp-2",
    "ip": "<IP_ADDRESS>",
    "mac": "01:01:01:01:01:01",
    "type": null
  },
  {
    "name": "?",
    "ip": "<IP_ADDRESS>",
    "mac": "99:01:99:01:99:01",
    "type": null
  },
  {
    "name": "raspi-43c5",
    "ip": "<IP_ADDRESS>",
    "mac": "01:23:45:67:89:01",
    "type": "RaspberryPi",
    "isYourDevice": true
  }
]
*/
```

#### search
The search functionality is broken up into three methods. For each, you may pass a reference IP address as the second argument to override the default behavior.

###### searchByIpAddress
Searching by ip address runs a discovery scan and filters the result based on an input array of desired ip addresses. The Promise resolves an object with an array of found `hosts` and an array of `missing` ips.
```javascript
const Arpping = require('arpping');
const arpping = new Arpping(options);

const ipArray = [
  "<IP_ADDRESS>",
  "<IP_ADDRESS>",
  "<IP_ADDRESS>"
];
arpping.searchByIpAddress(ipArray)
  .then(({ hosts, missing }) => {
    console.log(`${hosts.length} host(s) found:\n${JSON.stringify(hosts, null, 4)}`);
    console.log(`${missing.length} host(s) missing:\n${missing}`);
  })
  .catch(err => console.log(err));

/* Example output
2 out of 3 host(s) found:
[
  {
    "name": "?",
    "ip": "<IP_ADDRESS>",
    "mac": "01:01:01:01:01:01",
    "type": null
  },
  {
    "name": "?",
    "ip": "<IP_ADDRESS>",
    "mac": "01:01:01:99:99:99",
    "type": null
  }
]
1 out of 3 host(s) not found:
["<IP_ADDRESS>"]
*/
```

###### searchByMacAddress
Searching by mac address functions similarly to the `byIpAddress` method, with the notable additional ability to search by partial mac addresses (i.e. "01:23:45:67:89:10" which only matches one device vs "01:23:45" which may match multiple devices). Each device found will have a `matched` array specifying the corresponding searched mac address(es). Again, the Promise resolves an object with an array of found `hosts` and an array of `missing` search terms.
```javascript
const Arpping = require('arpping');
const arpping = new Arpping(options);

const macArray = [
  "01:01:01",
  "01:01:01:99:99:99",
  "7f:54:12"
];
arpping.searchByMacAddress(macArray)
  .then(({ hosts, missing }) => {
    console.log(`${hosts.length} matching host(s) found:\n${JSON.stringify(hosts, null, 4)}`);
    console.log(`The following search term(s) returned no results:\n${missing}`);
  })
  .catch(err => console.log(err));

/* Example output
2 matching host(s) found:
[
  {
    "name": "?",
    "ip": "<IP_ADDRESS>",
    "mac": "01:01:01:01:01:01",,
    "type": null
    "matched": [
      "01:01:01"
    ]
  },
  {
    "name": "?",
    "ip": "<IP_ADDRESS>",
    "mac": "01:01:01:99:99:99",,
    "type": null
    "matched": [
      "01:01:01",
      "01:01:01:99:99:99"
    ]
  }
]
The following search term(s) returned no results:
["7f:54:12"]
*/
```

###### searchByMacType
Searching by mac type returns all devices that are assigned the specified mac type/vendor (note: my mac address lookup table is painfully sparse)
```javascript
const Arpping = require('arpping');
const arpping = new Arpping(options);

const type = 'RaspberryPi';
arpping.searchByMacType(type)
  .then(hosts => console.log(`${hosts.length} host(s) found with type: ${type}\n${JSON.stringify(hosts, null, 4)}`))
  .catch(err => console.log(err));

/* Example output
1 host(s) found with type: RaspberryPi
[
  {
    "name": "raspi-8008",
    "ip": "<IP_ADDRESS>",
    "mac": "01:23:45:67:89:01",
    "type": "RaspberryPi",
    "isYourDevice": true
  }
]
*/
```

#### ping
The ping method pings a given array of ip addresses (or the full ip range) and returns an array of `hosts` that respond as well as an array of those `missing` hosts that do not
```javascript
const Arpping = require('arpping');
const arpping = new Arpping(options);

const ipArray = null; // set to null to scan the full ip range
arpping.ping(ipArray)
  .then(({ hosts, missing }) => console.log(`${hosts.length} host(s) found:\n${hosts}`))
  .catch(err => console.log(err));

/* Example output
3 host(s) found:
["<IP_ADDRESS>", "<IP_ADDRESS>", "<IP_ADDRESS>"]
*/
```

#### arp
The arp method arps a given array of ip addresses and returns an array of `hosts` that respond as well as an array of `missing` hosts that do not
```javascript
const Arpping = require('arpping');
const arpping = new Arpping(options);

// must specify an array, unlike ping
const ipArray = [
  "<IP_ADDRESS>",
  "<IP_ADDRESS>",
  "<IP_ADDRESS>"
];
arpping.ping(ipArray)
  .then(({ hosts, missing }) => {
    console.log(`${hosts.length} matching host(s) found:\n${JSON.stringify(hosts, null, 4)}`);
    console.log(`The following ip address(es) returned no results:\n${missing}`)
  })
  .catch(err => console.log(err));

/* Example output
2 host(s) found:
[
  {
    "name": "?",
    "ip": "<IP_ADDRESS>",
    "mac": "01:01:01:01:01:01",
    "type": null
  },
  {
    "name": "?",
    "ip": "<IP_ADDRESS>",
    "mac": "01:01:01:99:99:99",
    "type": null
  }
]
The following ip address(es) returned no results:
["<IP_ADDRESS>"]
*/
```

## Updates
1. Build out vendorID lookup table, or find some third-party version to include in project
2. ~~Allow for more customization - custom ip ranges to scan, enable/disable scanning of xxx.xxx.x.1,255, etc.~~
3. ~~Typescript~~
4. Other stuff I haven't thought of yet
5. ???
6. Profit

## Contributing
I made this module on my own. Any help/feedback is appreciated.

repository: haf-decent/arpping

gha_language: TypeScript

repo_name: haf-decent/arpping


text:
# Blog Curator

## Usage
### Requirements
* [NodeJS](http://nodejs.org/) (with [NPM](https://www.npmjs.org/))
* [MongoDB](http://mongodb.com/) - Not currently used, but is on the short-term roadmap
* [Bower](http://bower.io)
* [Gulp](http://gulpjs.com)

### Installation
1. Clone the repository
2. Install the NodeJS dependencies: `sudo npm install`.
3. Install the Bower dependencies: `bower install`.
4. Run the gulp build task: `gulp build`.
5. Run the gulp default task: `gulp`. This will build any changes made automatically, and also run a live reload server on [http://localhost:8888](http://localhost:8888).

Ensure your preferred web server points towards the `dist` directory.

### Development
Continue developing by editing the `src` directory. With the `gulp` command, any file changes made will automatically be compiled into the specific location within the `dist` directory.

license: MIT

repository: phillipcurl/Blog-Curator

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: phillipcurl/Blog-Curator


text:
+++
title        = "Multivariate Gaussian Process Regression for Multiscale Data Assimilation and Uncertainty Reduction"
id           = "barajassolano-2018-multivariate"
eprint       = "1804.06490"
primaryClass = "stat.ME"
year         = "2018"
date         = 2020-01-08T21:56:10-08:00
topics       = ["datadriven", "hydrogeology"]

[[author]]
	given = "D. A."
	family = "Barajas-Solano"

[[author]]
	given = "A. M."
	family = "Tartakovsky"
+++

We present a multivariate Gaussian process regression approach for parameter field reconstruction based on the field's measurements collected at two different scales, the coarse and fine scales. The proposed approach treats the parameter field defined at fine and coarse scales as a bivariate Gaussian process with a parameterized multiscale covariance model. We employ a full bivariate Matérn kernel as multiscale covariance model, with shape and smoothness hyperparameters that account for the coarsening relation between fine and coarse fields. In contrast to similar multiscale kriging approaches that assume a known coarsening relation between scales, the hyperparameters of the multiscale covariance model are estimated directly from data via pseudo-likelihood maximization.
We illustrate the proposed approach with a predictive simulation application for saturated flow in porous media. Multiscale Gaussian process regression is employed to estimate two-dimensional log-saturated hydraulic conductivity distributions from synthetic multiscale measurements. The resulting stochastic model for coarse saturated conductivity is employed to quantify and reduce uncertainty in pressure predictions.

repository: dbarajassolano/site-hugo

repo_name: dbarajassolano/site-hugo


text:
# AsyncAws Iot Client

![](https://github.com/async-aws/iot/workflows/Tests/badge.svg?branch=master)
![](https://github.com/async-aws/iot/workflows/BC%20Check/badge.svg?branch=master)

An API client for Iot.

## Install

```cli
composer require async-aws/iot
```

## Documentation

See https://async-aws.com/clients/iot.html for documentation.

## Contribute

Contributions are welcome and appreciated. Please read https://async-aws.com/contribute/

repository: async-aws/aws

gha_language: PHP

gha_license_id: MIT

repo_name: async-aws/aws


text:
# My 1Blocker Packages

I use [1Blocker](https://1blocker.com/) to block ads, but also have a
few custom packages to clean up websites that annoy me (like Medium),
or to make them easier to take clean screenshots of (Twitter and
GitHub).

Using these packages requires 1Blocker Premium, which costs about £4.99
(each, for both iOS and macOS; they're separate purchases) at the time
of writing.

I'm not sure how editable these (JSON) files really are, because
they're essentially 1Blocker's own internal representation of content
blockers, but I've formatted them so that I can at least diff them when
I update them.


text:
---
layout: post
title: What is a demand deposit?
---

**_v1.0_**

Another measure of money is how much is deposited in banks that can be withdrawn on demand. That is, you don't have to give any notice to the bank in order to withdraw your money.

<iframe src="//fred.stlouisfed.org/graph/graph-landing.php?g=6ve1&width=670&height=475" scrolling="no" frameborder="0" style="overflow:hidden; width:670px; height:525px;" allowTransparency="true"></iframe>

This chart shows the amount of demand deposits (DEMDEPSL) at a specific point in time.


text:
# NameHub

A list of available usernames in GitHub.

No need to think, just choose.

## Lists

- [length of 3](./3)
- [length of 3](./4)

## GitHub Username Rules

- Consists of letters, numbers, strikethrough.
- Border characters are not allowed to be strikethrough.

## Note

- Usernames with lengths of 1 or 2 haves all been taken.
- The results are for information purposes only.
- We will update this list on a daily basis, during which time a username may have been taken by another user.
- Excessively long IDs are not cool, and subject to API rate limits, we will not detect usernames 5 and longer.


text:
# Basics

> To start this exercise, be sure to be in `./packages/novice/basic` folder.
> Be sure you have [installed this repository first](../README.md#install)

## Introduction

This first example is here to help you why Webpack exists and its basic usage.

In this app, we define two CommonJS modules (commonly used [in a NodeJS env](https://nodejs.org/docs/latest/api/modules.html)).
They are both loaded in `index.html`.

If you're not familiar enough with the browser env, it won't be able to load CommonJS bundle.
A browser can't handle NodeJS-like dependencies.

Here is the dependency graph of those modules:

```
title.js
      <- color.js
             <- node_modules/lodash
```

## Old way

If we were few years ago, we would have to load all those files in the browser without the `require` syntax and by keeping the dependency order.
For `lodash` library we would have used a cdn to load it.

This way works perfectly... But for a long time project, it would generate a lot of `<script/>` loading.
Keeping the order would have been humanly difficult.

## Webpack solution

Webpack is a NodeJS package that generate a bundle based on module dependencies graph resolution.
It's very popular in the web community to generate web bundles for web applications.

### Step 1: Setup simple configuration

To configure webpack, you just have to create a CommonJS module with default name `webpack.config.js` at the root of your project.
Coupled with `webpack-cli` dev dependency, you can easily trigger a webpack _build_ on this small app.
This is where all the webpack configuration will be defined

```js
const path = require("path");

module.exports = {
  entry: "./src/title.js", // The source module of our dependency graph
  output: {
    // Configuration of what we tell webpack to generate (here, a ./dist/main.js file)
    filename: "main.js",
    path: path.resolve(__dirname, "dist")
  }
};
```

After launching the command `yarn webpack`, a new file called `main.js` in a `dist` directory should be generated.

### Step 2: Change index.html script target

For now, `index.html` doesn't reference the packaged file, so we must update it to use directly our webpack _output_.
To do so, just change the `<script/>` tag in your `index.html` to reference the file generated by webpack.

```html{10}
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <title>Simple JS file</title>
    <meta name="description" content="Simple JS file" />
  </head>
  <body>
    <h1>This title will change !</h1>
    <script src="dist/main.js"></script>
  </body>
</html>
```

### Step 3: Script the build with webpack-cli

As you can figure out, we will trigger the build a lot! A good practice is to add a new `build` script in `package.json` .

```json{13,14,15}
{
  "name": "@novice/basic",
  "version": "1.0.0",
  "license": "MIT",
  "private": true,
  "dependencies": {
    "lodash": "^4.17.11"
  },
  "devDependencies": {
    "webpack": "^4.28.4",
    "webpack-cli": "^3.2.1"
  },
  "scripts": {
    "build": "webpack"
  }
}
```

Now launch the `build` and open your `index.html` in your browser:

```bash
yarn build
```

Look at the generated _bundle_


text:
# Standard operating procedures for the Analytics platform

## Issues in end to end tests

### Message "Note: integration tests are running localy via docker-compose"

- it means that some environment variable(s) are not set up properly
- make sure that the `F8A_API_URL` is set
- make sure that the `F8A_JOB_API_URL` is set

### Message "Note: integration tests are running against existing deployment"

- all environment variables, including `F8A_API_URL` are set and e2e tests check the remote APIs

### Message "Note: {e} environment variable is specified, but tests are still run locally"

- some of environment variables `F8A_API_URL`, `F8A_JOB_API_URL` or `F8A_GEMINI_API_URL` is setup, but not all
- it might mean that you need to run end to end tests against remote APIs, but in reality tests are run locally
- make sure that the `F8A_API_URL` is set
- make sure that the `F8A_JOB_API_URL` is set

### Message "Warning: the {name} environment variable is not set. Most tests that require authorization will probably fail"

- make sure the `RECOMMENDER_REFRESH_TOKEN` or `RECOMMENDER_API_TOKEN` is set (but no both)
- make sure the `JOB_API_TOKEN` is set in case you need to run jobs API tests (deprecated right now)

## Issues on CI

### CI jobs failure with message "The requested operation failed as no inventory is available"

Full message looks like this:

```
+ true
++ cico node get -f value -c ip_address -c comment
The requested operation failed as no inventory is available.
+ cico_output=
Build step 'Execute shell' marked build as failure
Setting status of afca674a4bf1d03ba432d62f108541130905954c to FAILURE with url https://ci.centos.org/job/devtools-e2e-fabric8-analytics/1348/ and message: 'Build finished. '
Using context: ci.centos.org PR build (fabric8-analytics)
Finished: FAILURE
```

- this is temporary issue caused by insufficient number of nodes on CI
- rerun the job after some time by adding `[test]` message to the pull request

### CI jobs failure with messages "cico node get' failed, trying again in Ns (x/y)"

Typical error message is repeated several times:

```
'cico node get' failed, trying again in 60s (1/15)
+ n=2
+ sleep 60
+ true
++ cico node get -f value -c ip_address -c comment
The requested operation failed as no inventory is available.
```

- this is temporary issue caused by insufficient number of nodes on CI
- rerun the job after some time by adding `[test]` message to the pull request

gha_language: Python


text:
Note: this is work in progress...

## Introduction

Similar to the c preprocessor, the precompiler is a processing tool for generic code. However similar, it has much more capability (including recursive macros) that allow you to create more complex behavior. There are a lot of use cases for this that will be covered in some examples.

#### Features:

- Expandable Python api that can be used in build systems
- Support for custom lexers and virtually any language
- Uses python code in conditional checks and others commands (example `#run print("hello world")`, `#if python_code("some_string") == True: ...`)
- Recursive macros
- Powerful argument capture for macros

#### Dependencies

- ply

#### Documentation

- [Precompiler commands](https://github.com/raxvan/precompiler/blob/master/docs/main.md)
- [Python api](https://github.com/raxvan/precompiler/blob/master/docs/api_doc.md)

### Quick setup

You can use [docker](https://www.docker.com/):
```
git clone https://github.com/raxvan/precompiler.git precompiler
cd precompiler
./_run_tests_docker.sh
```

To get it to work outside docker you need to have python3 and [ply](https://github.com/dabeaz/ply) installed. To be able to `import precompiler` you need to add the precompiler git clone folder to `PYTHONPATH` enviroment variable.

## Quick Example

```
//c++ source file:
#inline "#include <stdio>"
//#def ENABLE_DEBUG_LOG
int main()
{
	#ifdef ENABLE_DEBUG_LOG
		std::cout << "debug mode enabled";
	#else
		std::cout << "release mode";
	#endif

	return 0;
}

//after preprocessing:
#include <stdio>
int main()
{
	std::cout << "release mode enabled";
	return 0;
}
```

```
//glsl source file
#include "metadata.glsl"

varying lowp vec4 v_VertexColor;

#ifdef USE_COLOR
	uniform(lowp,vec4) u_DefaultColor;
	//^ 'uniform' macro can capture identifier 'u_DefaultColor' as argument
#else
	#define u_DefaultColor 1.0
#endif
void main()
{
	gl_FragColor =  v_VertexColor * u_DefaultColor;
}

//glsl after preprocessing with 'USE_COLOR'
varying lowp vec4 v_VertexColor;
uniform lowp vec4 u_DefaultColor;
void main()
{
	gl_FragColor = v_VertexColor * u_DefaultColor;
}
//also a metadata json can be extracted:
{
	"uniforms" : [
		"u_DefaultColor" : ["lowp","vec4"]
	]
}
```

## Alternatives

https://github.com/ned14/pcpp

https://www.boost.org/doc/libs/1_67_0/libs/preprocessor/doc/index.html

https://gcc.gnu.org/onlinedocs/cpp/

https://www.gnu.org/software/m4/m4.html

http://mcpp.sourceforge.net/

http://math.mit.edu/~auroux/software/gpp.html

## Motivation

In c and c++ the #include system is probably one of the most controvertial feature of the proceprcessor. Misusing it can lead to long compilation times and all sort of compile errors and even crashes (combined with miused defines). That being said the c preprocessor enabled a lot of powerfull features in the code that often don't have alternatives in other laguages (python, javascript, etc), here are some of them:

- Efficent removal of debug code and asserts
- Features that can be turned on/off without affecting the final executable or performance.
- Anti piracy protection.
- Custom syntax that makes writing code easier.
- Meta-data and reflection systems inside the code.
- Custom #pragmas were used to generate multi-threaded code.

Having such a tool available to the developer with even more functionality was the main motivation behind the precompiler. Because it's language agnostic can be used in a variaty of languages and many uses-cases:

- Preprocessing glsl shaders allows you to use includes and even metadata directly inside the shader. This is often a problem and developers have all sort of approaches for this (many layers of shader stitching and processing, xml files for metadata, etc).
- Automatic generation of c++ compilation units. Knowing file dependencies can be used to generate optimal compilation units
- Powerfull code generation without macros placed everywhere

## Work in progress

The short term todo list:

- Documentation
- Tests for all errors
- Tests for more complex scenarios
- Proper dependency tree generation
- Examples

repository: raxvan/precompiler

repo_name: raxvan/precompiler


text:
# Boolean type

The `bool` type is a datatype which can be either `true` or `false`. The boolean
type uses one byte of memory. It is used in comparisons and bitwise operations
like `&`, `|`, and `!`.

```rust
fn main() {
    let x = true;
    let y: bool = false; // with the boolean type annotation

    // Use of booleans in conditional expressions
    if x {
        println!("x is true");
    }
}
```

repository: steffahn/reference

repo_name: steffahn/reference


text:
![Kendra Kelly Logo](/kkgithub.png)
# Programming Adventure

#### A website made to help applicants determine which programing language course they should choose to study.

#### By **Kendra Kelly**

## Description

This website uses javascript to guide a visitor through a series of questions that should help them determine which programming language they might be interested in.

## Setup/Installation Requirements

Using Command Line:
1. ``git clone https://github.com/coffeeringsdesign/programming-adventure.git `` to clone the site.
2. ``cd ~`` to navigate to base directory.
3. ``cd Desktop `` to navigate to your desktop.
4. ``cd programming-adventure`` to enter the site folder.
5. ``atom .`` to open site with Atom.
6. I recommend Atom to edit any html, javascript, or sass.

## Objectives

* Code is clean, well-refactored, and easy-to-read. This includes correct indendation, spacing, and including only necessary comments and debugging tools.
* Commits are made regularly with clear messages that finish the phrase "It will…".
* Project README that includes, bare minimum:
  * author name
  * program name
* detailed setup instructions
  * description
  * copyright and license information .
* Site uses branching to return the result.
* jQuery is used to show and hide the result.
* Form gathers input from the user.
* Variable names are descriptive of what they represent.
* Web page is styled using Bootstrap and custom CSS.
* The project is in a presentable, portfolio-quality state.
* Required functionality is in place by the Friday deadline.
* Project demonstrates understanding of concepts covered this week. If prompted, you are able to discuss your code with an instructor using correct terminology.

## Contribution Requirements

1. Clone the repo
1. Make a new branch
1. Commit and push your changes
1. Create a PR

## Technologies Used

* JavaScript
* jQuery 3.3.1
* Bootstrap 4.1.3

## Suuport & Contact Details

Please feel free to get in touch. Reach out to me at<EMAIL_ADDRESS>
## License

This software is licensed under the MIT license.

Copyright (c) 2018 **Kendra Kelly**

## Support and contact details

_Please get in contact if you have any questions. I can be reached at<EMAIL_ADDRESS>
### License

*DMI*

Copyright (c) 2018 **_Kendra Kelly_**

repository: coffeeringsdesign/programming-adventure

repo_name: coffeeringsdesign/programming-adventure


text:
---
title: Using the Robots Meta Tag to Reduce Duplicate Search Engine Data
author: TQuizzle
layout: post
permalink: /archive/using-the-robots-meta-tag-to-reduce-duplicate-search-engine-data/
image:
  -
pdrp_attributionLocation:
  - end
quote-author:
  - Unknown
quote-url:
  - http://
quote-copy:
  - Unknown
audio:
  - http://
link-url:
  - http://
bitly_url:
  - http://bit.ly/10hfR0m
bitly_hash:
  - 10hfR0m
bitly_long_url:
  - http://www.tquizzle.com/archive/using-the-robots-meta-tag-to-reduce-duplicate-search-engine-data/
categories:
  - Normal
tags:
  - functions
  - meta
  - php
  - robots
  - search engine
  - theme
  - Thesis
  - WordPress
---
Chris Pearson is a stud when it comes to all things web, not to mention the guy’s relentless pursuit of wordpress goodness keeps me coming back to his blog again and again.
Yesterday morning, a post from him via DIYThemes.com grabbed my attention. It was all about how to use the Robots Meta Tags option in the very popular theme Thesis. While I dont use Thesis, I still found it extremely interesting and started to investigate its declaration:

> One of the biggest problems with WordPress is that it automatically generates different kinds of archive pages that can be indexed by search engines. From date-based archives (daily, monthly, yearly) to tags to categories, these auto-generated pages all contain duplicate content that doesn't belong in search engines.

Like many times before, he’s exactly right.

Maybe you don’t think its a big deal. Okay, I get that…but think of this:

> The job of search engines is to index your site's pages and determine what your site is about. If you have 100 unique article pages, then ideally, search engines should only have to crawl 100 pages to index your site fully.
>
> However, if you're using categories, tags, and date-based archives (and depending on how overboard you tend to go with categorization and tagging), then you're going to have at least one additional page per category, per tag, per month, etc.
>
> Now, instead of having 100 pages to index, you may have 600 pages. Considering you only have 100 pages of unique content, forcing a search engine to index 600 pages to determine what your site is about just doesnâ€™t make any sense.
>
> Think of it this way: Would you rather read a 100-page book or a 600-page book that tells the same story? Further, which one do you think you'll understand better? Which will hold your focus better?

Wow, now that’s heavy.

### Functions Hack

So since its implemented with Thesis so beautifully, and since I love to hack my functions.php file…I figured, I’d do just that. I’d put together a super-tiny function that fixes this, albeit small, issue for my specific customization.

// META ROBOTS functions.php hack for proper indexing by Search Engines

function tq_meta_robots() {
// If you would like to disable the ODP or Yahoo! Directory
// keep the next two lines.
if( is_home() )
echo '<meta name="robots" content="index,follow,archive,noodp,noydir" />';
if( is_archive() || is_tax() )
echo '<meta name="robots" content="index,nofollow,noarchive" />';
}
add_action('wp_head','tq_meta_robots');

There…that’ll do it.

The first part checks to see if its the home page (since “*noodp*” and “*noydir*” are domain specific settings), then sets the proper search engine robot setting to allow indexing, link following, archiving and prevents search engines from pulling extra information regarding your site from the ODP or DMOZ and the Yahoo! Directory.
The second part checks to see if the page is any archive type page (Category, Tag, Author and Date based pages are all types of Archives), or any taxonomy related pages; and sets the information for those types of pages. This sets the search engine robot setting to allow indexing, tells it that links are to NOT be followed, and to not archive the page.

Done and Done.

      Share this:

          Twitter

          Google

          Facebook

          repost

          More

              LinkedIn

              Reddit

              Digg

              StumbleUpon

              Email

              Print


text:
# dzsal-node-mod-server
Node script for reporting mods to DZSA Launcher. This **does not** run/monitor/manage the dayz server exe.

# Usage (noobs)
- Download exe from [releases](https://github.com/maca134/dzsal-node-mod-server/releases).
- Run `node-mod-server.exe "-port=..." "-mod=..."`, using the same -port and -mod as DayZ server parameters.

# Usage (less noob-ish)
- Install [Node](https://nodejs.org/en/download/current/).
- Clone/download repo.
- Run `npm install` in repo folder.
- Run `node ./node-mod-server.js "-port=..." "-mod=..."`, using the same -port and -mod as DayZ server parameters


text:
# gping.io Server

This is the open-source server software for [gping.io](http://gping.io).

The client (Android app) may be [downloaded at Google Play](https://play.google.com/store/apps/details?id=io.gping).

## Installation

### Docker

If you're interested in running your own dev server we've tried to make setup as
simple as possible by providing a set of containers. These collect all necessary
configuration for local development and should make it trivial to get a
functional production deployment.

For more detailed discussion of our container setup see [docker/README.md][dockerref].
In summary, however, to get a dev environment running:

1. Clone this repo
2. Define `GPINGIO_HOME` to be the cloned directory
   _Recommended_: add `export GPINGIO_HOME='<path>'` to your `~/.profile`, `~/.bash_profile`
   or `~/.bashrc` then log out and back in for changes to take effect.
3. `cd $GPINGIO_HOME`
4. `cp www/config-dist.php www/config.php` and edit.
5. `./docker/build.sh`
6. `./docker/db.sh`
   It may take a few moments for this container to fully spin up as the startup
   process includes bootstraping the DB. You can watch its progress with
   `docker logs -f db`.
   _Note_: the first time you run this command it will produce `Error response
   from daemon`, this is normal.
7. `./docker/www.sh`
8. `docker exec www composer install`
   This instructs [`composer`][composer] to download and install the libraries
   that the GPing service relies on.
9. _Optional_: List the running containers with `docker ps`.
10. _Optional_: Bring up the command line of the `www` container with:
   `docker/shell.sh www`

You should now have an instance of the latest build running on `localhost:8080`.
A brief discussion of the helper scripts used is [here][scriptref]. If you're
interested in running a production instance see [this][prodref] for the changes
that shourd be made.

[dockerref]: docker/README.md#containers
[scriptref]: docker/README.md#conveniences
[prodref]: docs/Production.md
[composer]: https://getcomposer.org/

### Apache

If you already have production Apache server ready to serve PHP files, you can
always deploy the `www/` directly under your htdocs.  Don't forget to `a2enmod
rewrite` in order to enable `mod_rewrite` in Apache and `composer install` to
get PHP library dependencies.

## Participate

Our community guidelines are outlined in the [code of conduct][conduct].

- [Roadmap][roadmap]—Where we see GPing going and the large blocks of
  work that needs attention next.
- [Issues List][issues]—actionable tasks that need to be completed to
  reach some goal on our roadmap. Items marked with `help wanted` should be
  reasonable tasks to get involved with when you're new to the project.
- [Forum][gg]—Ask questions to the community.

We also try to idle in the `#gping.io` IRC channel on [Freenode][fn].

[fn]: http://freenode.net/
[conduct]: conduct.md
[gg]: https://groups.google.com/forum/#!forum/gpingio
[issues]: https://github.com/dustball/gping.io/issues
[roadmap]: docs/Roadmap.md

## Structure

Components of the project live loosely coupled under `$GPING_HOME` with
related code grouped by directory.

* [`db`](db)—DB schema and sample data
* [`docker`](docker)—container definitions and helper scripts around
  running dev setup
* [`docs`](docs)—various documentation; each major topic coordinated
  under `topic.md`
* [`test`](test)—test code; not included in the deployed build but
  mounted in the dev container
* [`www`](www)—website & backend; additional discussion in
  [www docs](docs/www.md)


text:
---
layout: post
title:  "Web Concepts at Craft 2018"
categories: update
---

*Web Concepts* are proud to make an appearance at [Craft 2018](https://craft-conf.com/)! There will be a presentation at the [Craft Conference Special Edition Meetup](https://www.meetup.com/Craft-meetup/events/250410838/) on May 9, 2018. Since the topic will be the same, the [WWW2018](https://www2018.thewebconf.org/) paper still is a useful companion for the presentation, and is linked below as well.

* Presentation: [Erik Wilde, "Surfing the Web: The Path of the Dev", Craft Meetup 2018, Budapest, Hungary, May 9, 2018](http://dret.net/lectures/craft-2018/)
* Paper: [Erik Wilde, "Surfing the API Web: Web Concepts", 27th International World Wide Web Conference (WWW2018), Lyon, France, April 2018](http://dret.net/netdret/docs/wilde-www2018-web-concepts.pdf)

license: Unlicense

repository: dret/webconcepts

branch_name: refs/heads/gh-pages

gha_language: HTML

gha_license_id: Unlicense

repo_name: dret/webconcepts


text:
# `MsgEditPost`
This message allows you to edit the message of a previously published public post.

## Structure
```json
{
  "type": "desmos/MsgEditPost",
  "value": {
    "post_id": "<ID of the post to be edited>",
    "message": "<New post message>",
    "editor": "<Desmos address of the user editing the message>",
    "edit_date": "<RFC3339-formatted date representing the date in which the post has been edited>"
  }
}
```

### Attributes
| Attribute | Type | Description |
| :-------: | :----: | :-------- |
| `post_id` | String | ID of the post to edit |
| `message` | String | New message that should be set as the post message |
| `editor` | String | Desmos address of the user that is editing the post. This must be the same address of the original post creator. |
| `edit_date` | String | Date in RFC3339 format (e.g. `"2006-01-02T15:04:05Z07:00"`) in which the post has been edited. This must be after the original post creation date and cannot be a future date. |

## Example
### With optional data
```json
{
  "type": "desmos/MsgEditPost",
  "value": {
    "post_id": "a4469741bb0c0622627810082a5f2e4e54fbbb888f25a4771a5eebc697d30cfc",
    "message": "Desmos you rock!",
    "editor": "desmos1w3fe8zq5jrxd4nz49hllg75sw7m24qyc7tnaax",
    "edit_date": "2020-02-05T01:00:00"
  }
}
```

## Message action
The action associated to this message is the following:

```
edit_post
```


text:
# Maintainer's Guide

Notes to self and quirks of the project's implementation in case all of the current maintainers get hit by the same bus.

## Why we use Sass

- A lot of the colors are computed with Sass color functions, switching to CSS variables would mean a whole lot more variables.
- Using Sass variables instead of CSS variables gives us more browser compatibility.

## Why we use Sass so strangely

Specifically talking about how most of the components have the following line:

```scss
@use 'node_modules/attractions/_variables';
```

That path doesn't exist for us, library developers, but it does exist for the users who installed this library and are now compiling SCSS. This is done to enable zero-config installation for those users who are not interested in changing Sass variables or using them in their own stylesheets.

So how does it work? Glad you asked.
Sass has several stages of resolution when it comes to imports:

> 1. Loading a file relative to the file in which the `@use` or `@import` appeared.
>
> 2. Each custom importer.
>
> 3. Loading a file relative to the current working directory.
>
> 4. Each load path in `includePaths`
>
> 5. Each load path specified in the `SASS_PATH` environment variable, which should be semicolon-separated on Windows and colon-separated elsewhere.

The trick is to utilize the steps after the second so that the users who want to configure their installation could intercept the resolution chain at step 2.
Particularly, this import uses step 3 (reminding you that the current working directory is the one your terminal is at when running the compilation command, which is probably the same one that holds `rollup.config.js`). Thus, if there are no importers, step 1 fails, step 2 fails, and step 3 resolves.
We too can intercept the chain at step 2 when building the library, so it's okay that the path doesn't exist – our building code will not fail.

Sass mixins, on the other hand, never need to be overridden, so it's okay to import them with step 1 (`@use '../_mixins';`).

repository: RikuVan/attractions

branch_name: refs/heads/main

repo_name: RikuVan/attractions


text:
# BetterMusic 🎧

Your music, your way. A quick and easy way to play your music.

Better Music is highly optimized which means you dont have to worry about slowing down your computer. For convenience, your last played music directory is saved. This allows you to jump right back into the program and immediately start listening to your favorite songs. A dynamic background improves the look of the player and allows the album art to pop.

## Getting Started 🔰

### Easy 🟢
Proceed to [abrahams.dev](https://abrahams.dev) for an executable download.

### Advanced 🟡
Clone the repository, open BetterMusic.csproj in visual studio, build and run.

## Features 📃
* Highly optimized
* Sleek UI
* Dynamic background
* Drag & Drop functionality
* Toast notifications

## Screenshots 📸
![Better Music Screenshot](https://abrahams.dev/images/gallery/BetterMusicMigos.png)
![Better Music Screenshot](https://abrahams.dev/images/gallery/BetterMusicKanye.png)
![Toast Notification Screenshot](https://abrahams.dev/images/gallery/toast.png)

repository: rrajra/MusicPlayer

gha_language: C#

repo_name: rrajra/MusicPlayer


text:
# [andrewmackrodt/docker-python](https://github.com/andrewmackrodt/dockerfiles/tree/master/python)

[![Status](https://jenkins.mackrodt.io/buildStatus/icon?job=dockerfiles%2Fpython)][status]
[![Pulls](https://img.shields.io/docker/pulls/andrewmackrodt/python.svg)][pulls]
[![Dockerfile](https://img.shields.io/github/size/andrewmackrodt/dockerfiles/python/Dockerfile.svg?label=dockerfile)][dockerfile]
[![Size](https://img.shields.io/docker/image-size/andrewmackrodt/python)][size]
[![Version](https://img.shields.io/docker/v/andrewmackrodt/python)][version]

[status]: https://jenkins.mackrodt.io/job/dockerfiles/job/python/
[pulls]: https://hub.docker.com/r/andrewmackrodt/python
[dockerfile]: https://github.com/andrewmackrodt/dockerfiles/blob/master/python/Dockerfile
[size]: https://microbadger.com/images/andrewmackrodt/python
[version]: https://hub.docker.com/r/andrewmackrodt/python/tags

[Python](https://www.python.org/) is an interpreted, object-oriented, high-level
programming language with dynamic semantics. Its high-level built in data
structures, combined with dynamic typing and dynamic binding, make it very
attractive for Rapid Application Development, as well as for use as a scripting
or glue language to connect existing components together.

## Versions

Python `3.10 is tagged as `latest`. Other versions are also provided:

- `andrewmackrodt/python:2.7` (end-of-life: 2020-01-01)
- `andrewmackrodt/python:3.10` (end-of-life: 2025-10-05)

**Update Schedule**

Images are built nightly and images will be updated as new `major.minor.patch-release`
packages of PYTHON are released. It's possible to pull a specific tag, e.g.
`docker pull andrewmackrodt/python:3.9.0-r5`, see [Docker Hub][hub] for a list of
supported tags.

[hub]: https://hub.docker.com/r/andrewmackrodt/python/tags

**Removal Policy**

Old tags are subject to removal periodically without notice.

## Usage

### docker

```
# start interactive mode
docker run --rm -it andrewmackrodt/python

# print version
docker run --rm andrewmackrodt/python --version
```

## Parameters

| Parameter | Function |
| --- | --- |
| `-e PUID=1000` | The user id, recommended: `$(id -u)` |
| `-e PGID=1000` | The group id, recommended: `$(id -g)` |
| `-e SUDO_NOPASSWD=0` | Set to `1` to allow passwordless sudo |

repository: andrewmackrodt/dockerfiles

gha_language: Dockerfile

repo_name: andrewmackrodt/dockerfiles


text:
# generator-react-party
> Generate a prototype app that uses React, Sass, Webpack, ES6, and React Router with Page Transitions

## Installation
> For now, clone the repo, cd into the main folder and run ```npm install```

Then generate your new project:

```bash
yo react-party && webpack
```

And get up and running with:

```bash
npm start
```

## App Structure

```
├── app/                            # The source code of the application
│   ├── components/                 # The react components
|   |   |–– layouts/                # Layouts
|   |   |   |–– app-layout.js       # Main application layout
|   |   |–– pages/                  # Pages
|   │   │   ├── index.js            # The home page
|   │   │   ├── about.js            # The about page
|   │   │   ├── contact.js          # The contact page
|   |   |   |–– no-match.js         # 404
│   ├── css/                        # Styles
|   │   ├── app.scss                # Main stylesheet
|   │   ├── page-transitions.scss   # Page Transitions
│   |── app.js                      # Renders the app and defines the routes
│   |── router.js                   # Contains all the routes
├── dist/                           # Build/processed files
├── node_modules/                   # Libraries/utilities
│–– index.html                      # The root html file
│── package.json                    # Application config and dependencies
│── webpack.config.js               # Build script
```

## License

MIT

repository: kevronosx/generator-react-party

repo_name: kevronosx/generator-react-party


text:
## Spring Web

### Which modules provide Web and MVC support for Spring?
* spring-web
    - Servlet support (SpringServletContainerInitializer)
    - ApplicationContext for Servlets (WebApplicationContext, WebApplicationInitializer)
    - HTTP client, converters, filters, MIME multipart, JSON/JAXB support
    - JAX-WS support
    - JSF support
    - REST Template
    - Annotations for Web, REST, ExceptionHandler, Scopes
* spring-webmvc
    - DispatcherServlet, @EnableWebMVC, WebMvcConfigurerAdapter
    - Template support for JSP, Freemarker, Velocity, Groovy, XML etc.
    - Spring JSP Tag Library and JSP Form Tag Library

### Which are the central classes for the Spring Web Servlet lifecycle?
* DispatcherServlet which acts as a Front Controller and registers
  itself as Servlet in a standard Java Servlet Server like Tomcat.
* ContextLoaderListener

### Which classes can be used to configure the Servlet part of Spring Web?
* Abstract_DispatcherServlet_Initializer
* Abstract_AnnotationConfig_DispatcherServlet_Initializer
* WebMvcConfigurerAdapter (spring-webmvc)
* WebApplicationInitializer (spring-web) as replacement for web.xml

gha_language: Java


text:
# Problem Statement

Write a web crawler using Python that crawls a single domain to scrape all of its internal URLs.

We want you to start by considering the following example domain, where the crawler should crawl the news pages and the comments, but not the links to articles on other domains:

https://news.ycombinator.com

However, the crawler should be capable of working on any domain.

The general rule is to crawl the first page, and all potential sub-pages but not any external URL's on other domains.

# Evaluation

Once execution is complete you should print the links (in any format) from each page on the domain to every other page on the same domain. E.g. if page A links to pages B and C you can print something like:
A -> B

A -> C

Suppose B had a further link to page D you'd also emit:

B -> D

The goal is to make the crawler work as efficiently as possible by using concurrent programming with the Python gevent library.

repository: harutel/WebsiteCrawler

repo_name: harutel/WebsiteCrawler


text:
---
name: Bug report
about: Report a bug to help us improve the project
---

<!--

Have you read the Code of Conduct? By filing an Issue, you are expected to comply with it, including treating everyone with respect:

https://github.com/ministryofjustice/moj-frontend/blob/main/CODE_OF_CONDUCT.md

Do you want to ask a question? Are you looking for support? You can [contact the Design System team](https://design-patterns.service.justice.gov.uk/get-in-touch).

-->

### Prerequisites

- [ ] Put an X between the brackets on this line if you have done all of the following:
  - Reproduced the problem
  - Followed all applicable steps in the debugging guide
  - Checked the FAQs on the message board for common solutions
  - Checked that your issue doesn't exist: https://github.com/ministryofjustice/moj-frontend/issues
  - Checked that there is not already a package that provides the described functionality

### Description

[Description of the issue]

### Steps to Reproduce

1. [First Step]
2. [Second Step]
3. [and so on...]

**Expected behaviour:** [What you expect to happen]

**Actual behaviour:** [What happens]

**Reproduces how often:** [What percentage of the time does it reproduce?]

### Versions

You can get this information from the CHANGELOG. Also, please include details of the browser and OS version you're running.

### Additional Information

Provide any additional information, configuration or data that might be necessary to reproduce the issue.

repository: ministryofjustice/moj-frontend

gha_language: JavaScript

repo_name: ministryofjustice/moj-frontend


text:
---
layout: layout.pug
navigationTitle:  Quick Start
title: Quick Start
menuWeight: 0
excerpt: Launching a pod from the CLI or UI
render: mustache
model: /mesosphere/dcos/2.0/data.yml
enterprise: false
---

### Prerequisites
- DC/OS [installed](/mesosphere/dcos/2.0/installing/)
- DC/OS CLI [installed](/mesosphere/dcos/2.0/cli/install/)

# Launching a pod from the DC/OS CLI

1.  Create a JSON application definition with contents similar to this example. In this example, we will call the file `simple-pod.json`.

    ```json
    {
        "id": "/simplepod",
        "scaling": { "kind": "fixed", "instances": 1 },
        "containers": [
            {
                "name": "sleep1",
                "exec": { "command": { "shell": "sleep 1000" } },
                "resources": { "cpus": 0.1, "mem": 32 }
            }
        ],
        "networks": [ {"mode": "host"} ]
    }
    ```

NOTE: The pod ID (the id parameter in the pod specification above) is used for all interaction with the pod once it is created.

1.  Launch the pod on DC/OS with the following DC/OS CLI command:

    ```bash
    dcos marathon pod add simple-pod.json
    ```

1. Verify the status of your pod.

    ```bash
    dcos marathon pod show simplepod
    ```

# Launching a pod from the DC/OS UI

You can also launch a pod from the [**Services**](/mesosphere/dcos/2.0/gui/) tab of the DC/OS web interface. Select **Services -> Services -> RUN A SERVICE -> Multi-container (Pod)**, then toggle to JSON mode and paste in the application definition supplied above.

If you already have other services running, go to **Services -> Services**, then click the **+** on the upper right hand side.

After you launch your pod, you’ll see your new pod on the **Services** tab of the DC/OS UI. Click the pod to see information about the status of the containers in your pod.

![Pods UI](/mesosphere/dcos/2.0/img/pods-service-dashboard.png)

Figure 1. Services > Pods

repository: mesosphere/dcos-docs-site

gha_language: SCSS

repo_name: mesosphere/dcos-docs-site


text:
# CSEditor
============

CSEditor is a MacOS application. Was implemented for helping to create color shemes for iOS application.

## Implements

## Requirements

- Xcode 4 and later
- MacOS

## Author

Sergey Krotkih http://sergey-krotkih.blogspot.com

## License

CSEditor is available under the MIT license. See the LICENSE file for more info.

## Update

repository: SKrotkih/CSEditor

repo_name: SKrotkih/CSEditor


text:
LiteCloud Core
=====================================

litecloud is a cutting edge cryptocurrency, with many features not available in most other cryptocurrencies.
- Anonymized transactions using coin mixing technology, we call it Obfuscation.
- Fast transactions featuring guaranteed zero confirmation transactions, we call it _FastSend_.
- Decentralized blockchain voting providing for consensus based advancement of the current Masternode
  technology used to secure the network and provide the above features, each Masternode is secured
  with collateral of 10000 LiteCloud

More information at [Litecloudproject.com](http://Litecloudproject.com)

### Coin Specs

Ticker Symbol	ltcl

Algorithm	Quark

Type	PoW - PoS Hybrid*

Block Time	300 Seconds

Difficulty Retargeting	Every Block

Max Coin Supply (PoS)	25Mil ltcl

Premine/Initial Supply	4%

ltcl Created Per block	20 ltcl*

### PoS/PoW Block Details

Proof Of Work Phase	1-25920 Blocks.

Proof of Stake Phase	25921-infinite

### Staking Methods

Masternodes	Yes -10000 ltcl Required

Wallet Staking	Yes - 1 to infinite ltcl

### Staking Reward Details

ltcl Produced	25 ltcl Per Block

Amount Designated for Rewards	100% of ltcl produced goes to Staking Rewards

Rewards Algorithm	Teeter Totter Based Targeting System

Amount of Rewards Per Block	2 Rewards, 1 for Masternodes, 1 for Wallet Staking

Coin Maturity to Stake	150 Blocks

repository: Glasslock/LiteCloud

repo_name: Glasslock/LiteCloud


text:
# GitHub Scraper (beta, active development paused)

GitHub Scraper automatically builds issues and PRs tables in Google Sheets documents, and periodically updates them.
* **Multirepo**: track several repositories within one sheet and several sheets within one spreadsheet
* **Constructible**: tweak table structure, coloring and filling functions
* **Adaptive**: change your preferences and add new repos/sheets without restarting Scraper
* **Ready to go**: avoid tweaking Scraper and just use completely workable [examples](https://github.com/IlyaFaer/GitHub-Scraper/tree/master/scraper/examples)

![image](https://github.com/IlyaFaer/GitHub-Scraper/blob/master/GitHubScraperPreview.png?raw=true)

**Setup**
To build your tables and start tracking repositories you need:
* [Enable Google Sheets API](https://developers.google.com/sheets/api/quickstart/python#step_1_turn_on_the)
* Install required packages with *requirements.txt*
In *scraper* folder:
* Create *config.py* and set your tables configurations with it (see [config_example.py](https://github.com/IlyaFaer/GitHub-Scraper/blob/master/scraper/examples/config_example.py))
* Create *fill_funcs.py* and set your filling functions with it (see [fill_funcs_example.py](https://github.com/IlyaFaer/GitHub-Scraper/blob/master/scraper/examples/fill_funcs_example.py))
* Create and run *main.py* (see [main_example.py](https://github.com/IlyaFaer/GitHub-Scraper/blob/master/scraper/examples/main_example.py))

Scraper will build tables and start tracking specified repositories. First filling can take time, but subsequent updates are faster (~80% faster), as Scraper is processing only recently updated PRs and issues. You can check filling progress in *logs.txt*. If any error occur, its traceback will be shown in *logs.txt* as well.

**Structure, auto and manual filling**
You can tweak table filling in *fill_funcs.py*, leaving some columns for manual-only use (for example "Comment"), setting ignoring and  cleanup rules, sorting, coloring, etc., in any way you like.

Scraper uses *config.py* as a source of preferences. Before update it reloads *config.py* module, so you can change preferences without stoping Scraper - add new sheets, repositories, rules, etc.

**PR autodetection**
To make Scraper detect PRs, use GitHub keywords "Towards", "Closes", "Fixes" to make link from PRs body to the original issue. Scraper will use these links to fill "Public PR" field in the related issues.

**Archive**
By default, Scraper moves issues with `Done` status into Archive sheet and stops tracking them. This feature allows to avoid overwhelming sheets with non-active data. The behavior can be changed by setting `ARCHIVE_SHEET` configurations and `to_be_archived` filling function.

**Credentials**
On a first Scraper launch you'll have to authenticate on Google Sheets API (you'll see appropriate popup-window) and on GitHub (with a console). On subsequent launches Scraper will use previous credentials without asking to enter them once again.

**Beta version disclaimer**
Scraper is in a state of active development yet. Please, use Releases as the most stable versions, and feel free to open an issue in case of any problems.

repository: IlyaFaer/GitHub-Scraper

repo_name: IlyaFaer/GitHub-Scraper


text:
# ConstantProduct AMM Contract

<Zoe-Version/>

##### [View the code on Github](https://github.com/Agoric/agoric-sdk/blob/7d141a47b311363f099f496d4ed9b4d0f28c8fff/packages/inter-protocol/src/vpool-xyk-amm/multipoolMarketMaker.js) (Last updated: Aug 15, 2022)
##### [View contracts on Github](https://github.com/Agoric/agoric-sdk/tree/master/packages/zoe/src/contracts)

The Constant Product AMM is an automated market maker (AMM) that supports multiple
liquidity pools and direct exchanges across pools. It's called the "Constant
Product" AMM because it uses the constant product rule, which is one of a family of
rules that enable a market maker to guarantee to be able to continue to make
trades, regardless of how prices change. (The constant product rule does this by
ensuring that the product of the contents of two pools of assets remains constant
as trading takes place.)

Each liquidity pool maintains a price for exchanges between the central token
and a secondary token. Secondary tokens can be exchanged with each other, but
only through the central token. For example, if BLD and ATM are two token types
and IST is the central currency, a swap giving ATM and wanting BLD would first
use the pool (ATM, IST) then the pool (BLD, IST). There are no direct liquidity
pools between two secondary tokens.

There should only need to be one instance of this contract, so liquidity can be
shared as much as possible. Each secondary currency has a separate pool of liquidity.

When the contract is instantiated, the terms specify the central token.  Invitations
for adding and removing liquidity and for making trades are available by calling
methods on the publicFacet. Other publicFacet operations support querying prices and
the sizes of pools. Create new pools with `addPool()`.

When making trades or requesting prices, the caller must specify that either the
input price (swapIn, getInputPrice) or the output price (swapOut, getOutputPrice) is
fixed. For swaps, the required keywords are `In` for the trader's `give` amount, and
`Out` for the trader's `want` amount.  `getInputPrice()` and `getOutputPrice()` each
take two amounts. When `getInputPrice()` or `swapIn()` is called, the `amountOut`
parameter indicated the desired `amountOut`; if `amountIn` is insufficient to provide
that much, the result indicates that no trade will take place. (The returned amountIn
and amountOut will both be empty amounts.) Similarly, when `swapIn()` or
`getOutputPrice()` is called, `amountIn` is treated as a maximum.  If it would take a
greater amount to get the specified `amountOut`, the result indicates no trade.

When adding and removing liquidity, the keywords are `Central`, `Secondary`, and
`Liquidity`. Adding liquidity uses `Central` and `Secondary` in the `give` section
and `Liquidity` in the `want` section. Removing liquidity reverses the keywords:
`Liquidity` in the `give` section, and `Central` and `Secondary` in the want
section. If the proposal specifies amounts directly taken from a recent quote, and
any trading has intervened, the trade is unlikely to be accepted. You can either
specify limits on how far the price may have moved, or specify limits of zero and
trust the contract to trade fairly.

Transactions that don't require an invitation include `addPool()` and the queries
(`getInputPrice()`, `getOutputPrice()`, `getPoolAllocation()`,
`getLiquidityIssuer()`, and `getLiquiditySupply()`).

## The ConstantProduct API

These examples use IST as the central token. BLD and ATM are secondary currencies.

### Trading with the ConstantProduct AMM

Once trading pools have been set up (see below), a new trader can interact with the
market by asking for the current price, making an invitation, and making an
offer. If Sara has ATM and needs 275 BLD for a deal she has negotiated, she can use
getOutputPrice() to get a quote. (An empty amount indicates no limit on the
amountOut of the result.)

```js
const quote = E(publicFacet).getOutputPrice(
  AmountMath.make(BLDBrand, 275n),
  AmountMath.makeEmpty(ATMBrand),
);
  ```

Let's assume the quote says she needs to provide 216 ATM. Sara believes the
price is somewhat volatile, and she doesn't want to make repeated calls, so she pads
her offer. If the appropriate pools don't exist, she'll get an error (`brands were
not recognized`). If someone sells a lot of ATM into the pool just ahead of
her, the price will increase, and she'll have to decide whether to deposit more
ATM or wait for the price to stabilize. If someone buys a lot of ATM just
ahead of her order, she'll get the 275 BLD for less and will get some ATM
back.

```js
const saraProposal = harden({
  want: { Out: AmountMath.make(BLDBrand, 275n) },
  give: { In: AmountMath.make(atmBrand, 220n) },
});

const swapInvitation = await E(publicFacet).makeSwapOutInvitation();
const atmPayment =
  harden({ In: saraAtmPurse.withdraw(AmountMath.make(atmBrand, 220n)) });

const saraSeat = await E(zoe).offer(swapInvitation, saraProposal, atmPayment);
const saraResult = await saraSeat.getOfferResult();
```

If the result is `Swap successfully completed.`, she got the BLD for 220 ATM
or less (she'll want to deposit any refund). Otherwise the market price moved against
her, and she'll have to check the price again and make another offer.

```js
const BLDProceeds = await E(saraSeat).getPayout('In');
const atmRefund = await E(saraSeat).getPayout('Out');

const BLDProceedsAmount = E(saraBLDPurse).deposit(BLDProceeds);
E(saraAtmPurse).deposit(atmRefund);
```

###  Creating a New Pool

When the contract is first instantiated, there won't be any pools ready for
trading. `addPool()` adds a new currency, which can then be funded.  (All
currencies must be fungible.) When a pool is first funded, there's no other basis
on which to decide how much liquidity to create, so the liquidity amount equals the
amount of the central token in the offer.

```js
const BLDLiquidityIssuer = await E(publicFacet).addPool(BLDIssuer, 'BLD');
```

Alice sees that the current rate in the external market is 2 BLD for each
IST, so she deposits twice as many BLD as IST to fund the market.

```js
const aliceProposal = harden({
  want: { Liquidity: BLDLiquidity(50n) },
  give: {
    Secondary: AmountMath.make(BLDBrand, 100n),
    Central: AmountMath.make(ISTBrand, 50n),
  },
});
const alicePayments = {
  Secondary: aliceBLDPayment,
  Central: aliceISTPayment,
};

const aliceAddLiquidityInvitation = E(publicFacet).makeAddLiquidityInvitation();
const addLiquiditySeat = await E(zoe).offer(
  aliceAddLiquidityInvitation,
  aliceProposal,
  alicePayments,
);
```

### Adding Liquidity to an Existing Pool

When adding or removing liquidity to pools that have already been established, the
amounts deposited must be in proportion to the current balances in the pool. The
calculation is based on the amount of the `Central` asset. The `Secondary` assets
must be added in proportion.  If less `Secondary` is provided than required, the
offer is exited with no trade. If more of the secondary is provided than is required,
the excess is returned.

Bob calls `getPoolAllocation()` to find the relative levels. Let's say the answer is
that the current ratio is 1234 BLD to 1718 IST.

```js
const BLDPoolAlloc = E(publicFacet).getPoolAllocation(BLDBrand);
const ISTValue = BLDPoolAlloc.Central.value;
const BLDValue = BLDPoolAlloc.secondary.value;
```

Now he can add liquidity.  The price ratio changes when anyone trades with the pool,
so he should leave some flexibility in the proposal. The pool calculates the amount
of `secondary` currency required based on the amount of `central` currency provided.
Bob bumps up the amount of BLD he'll contribute by a little. If he was concerned
about how much liquidity this would produce, he would calculate it and specify a rough
figure, but there's no need in this case.

```js
const bobProposal = harden({
  give: {
    Central: AmountMath.make(ISTBrand, 1800n),
    Secondary: AmountMath.make(BLDBrand, 1200n),
  },
  want: { Liquidity: AmountMath.make(liquidityBrand, 0n) },
  exit: { onDemand: null },
});

const bobPayments = {
  Central: bobISTPayment,
  Secondary: bobBLDPayment,
}

const seat = await E(zoe).offer(addLiquidityInvite, bobProposal, bobPayments);
```

## Governance

The ConstantProduct AMM uses governance to manage changes to two parameters: `PoolFee`
and `ProtocolFee`. The current values of the parameters and the history of governance
voting to update their values is visible through the governance APIs.

An instance of the ConstantProduct AMM is managed by a contractGovernor, which
controls the ability to change contract parameters and add new types of collateral.
The contractGovernor adds these four methods to the contract's publicFacet:

* `getSubscription()`: get a [Subscription](/guides/js-programming/notifiers.md) that
    updates when votes are called.
* `getContractGovernor()`: returns the contractGovernor for verification.
* `getGovernedParamsValues()`: returns a structure showing the current values of
    the two parameters.
* `getParamValue('PoolFee')`: gets a description of the current value of
    either parameter. Note the initial capital letter.

repository: Agoric/documentation

repo_name: Agoric/documentation


text:
# Movie Tickets Booking Website [Solo Project]
This project consists of building a responsive website for movie tickets booking. It has three responsive pages- a Homepage, booking page and an About page. All the pages have three responsive breakpoints for small, medium and large screens.
I have used CSS flexbox to make the pages responsive

>Large screens
![screenshot](screenshot.PNG)

>Medium and small screens
![screenshot](screenshot_2.png)

The purpose of this project is to create a responsive website to book movie tickets.

## Built With

- HTML
- CSS
- Stylelint

## Live Demo

[Live Demo Link](https://raw.githack.com/alishabab/HTML-CSS-Capstone/master/index.html)

## Getting Started

To get a local copy up and running follow these simple example steps:

#### Prerequisites

- You should have installed git on your local machine, and a text editor, preferably VS Code.

#### Setup

- Clone the repository into your local machine.
- Open index.html

## Potential Future Features
- It does not have a backend currently, so a backend server can be developed to make the website a fully functional application.

## Authors

👤 **Author**

- Github: [@alishabab](https://github.com/alishabab)
- Twitter: [@shabab_ali](https://twitter.com/shabab_ali)
- Linkedin: [Shabab Ali](https://www.linkedin.com/in/shababali/)

## 🤝 Contributing

Contributions, issues and feature requests are welcome!

Feel free to check the [issues page](issues/).

## Show your support

Give a ⭐ if you like this project!

## Acknowledgments

- Appreciation to my mentor and stand-up team.

## 📝 License

This project is [MIT](lic.url) licensed.

repository: namshadnpt/movie-ticket-booking-website

repo_name: namshadnpt/movie-ticket-booking-website


text:
04/23/19

## Last Week's Accomplishments
> Demo'd feature to better display applied filters and remove filters
> Reviewed PR on new forum bar design
> Had previous PR's merged

## This Week's Plan

> Prepare a plan for the summer for submitty
> Find issues to review for Submitty mini hackathon

## Anything Blocking?

> None at the moment

## Notes

> Check out my work here:
All PRs: https://github.com/Submitty/Submitty/pulls?utf8=%E2%9C%93&q=author%3Ashwehtom89+
Better Filters: https://github.com/Submitty/Submitty/tree/show_filters
Submitty: https://github.com/shwehtom89?org=Submitty&year_list=1


text:
# UniqueSequences
# Language: Python
# Input: FASTA
# Output: TXT
# Tested with: PluMA 1.1, Python 3.6
# Dependency:

PluMA plugin to take an input FASTA file
and produce a TXT file containing unique sequences
in that file.


text:
Testing stacks
==============

See also [dmstr/yii2-yaml-converter-command](https://github.com/dmstr/yii2-yaml-converter-command).

See `build/stacks-gen` for the final stacks, to create the stack flavour from `docker-compose.yml` and `build/stacks-tpl` run

    make app-build-stacks

### Stack merge rules

The process of creating flavours is as follows:

- use `docker-compose.yml` as *base-template*
- look for `*.tpl.yml` files in `build/stacks-tpl`
  - merge every file with base-template and output to `stacks-gen`
    - if there is a folder with the same name, but without `.tpl.yml` suffix, repeat this process with the file generated above as *base-template*

- output is done in flat files
- files are merged recursive as PHP arrays
- special rule: `.service: CLEAN` or `.attribute: CLEAN` removes the attribute before merging the arrays

### Known limitations

You can not unset values in an attribute list/array/hashmap selectively.

repository: chinajohnwoo/app

repo_name: chinajohnwoo/app


text:
<!--#echo json="package.json" key="name" underline="=" -->
repeat-args
===========
<!--/#echo -->

<!--#echo json="package.json" key="description" -->
Yet another take at repeating sequences (string, array, array-like, buffer),
also in browsers (UMD).
<!--/#echo -->

API
---

It's all about _repeaters_.
* They're functions that can remember and take parameters.
* The _essential_ parameters are a _source_ sequence
  and a target quantity _length_.
* Repeaters can't learn, they can only evolve:
  When you give a parameter to a repeater,
  it will always produce something new,
  based on the new parameter and the ones it remembers.
  * When you provide the last missing essential parameter, by default
    you get a sequence with _length_ items from _source_, repeated in
    original order if necessary.
    You can modify this default behavior by configuring
    the _addFunc_ parameter – see below.
  * When an essential parameter remains unknown, you get
    a new repeater that remembers your new parameter and
    all the ones that its producer knew.

This module exports a repeater that knows none of the
essential parameters, so you have something to start with:

<!--#include file="test/usage.js" start="  //#require" stop="  //#"
  outdent="  " code="javascript" -->
<!--#verbatim lncnt="3" -->
```javascript
var r = require('repeat-args'), x = '.o°';
```
<!--/include-->

All repeaters have this interface:

### r(…stuff)

With less than one argument, use an empty string as the _source_ parameter.
(Chosen because it is a sequence of length 0, and also a false-y value.)

<!--#include file="test/usage.js" start="  //#r-no-args" stop="  //#"
  outdent="  " code="javascript" -->
<!--#verbatim lncnt="6" -->
```javascript
equal(r().times(2),     '');
equal(r().times(0),     '');
equal(r().len(2),       '');
equal(r().len(0),       '');
```
<!--/include-->

With at least one argument, of which the first one is recognized as a sequece:
Merge all arguments into a sequence of the same type as the first argument,
and use that combined sequence as the _source_ parameter.

<!--#include file="test/usage.js" start="  //#r-times3-brackets" stop="  //#"
  outdent="  " code="javascript" -->
<!--#verbatim lncnt="5" -->
```javascript
equal(r.times(3)(x),           '.o°.o°.o°');
equal(r.times(3)([x]),        ['.o°', '.o°', '.o°']);
equal(r.times(3)([ [x] ]),  [ ['.o°'], ['.o°'], ['.o°'] ]);
```
<!--/include-->

<!--#include file="test/usage.js" start="  //#r-hi57" stop="  //#"
  outdent="  " code="javascript" -->
<!--#verbatim lncnt="8" -->
```javascript
equal(r('h', 'i', 5, 7).times(0),   '');
equal(r('h', 'i', 5, 7).times(2),   'hi57hi57');
equal(r(['h', 'i', 5, 7]).times(2),
        ['h', 'i', 5, 7, 'h', 'i', 5, 7]);
equal(r([ ['h', 'i', 5, 7] ]).times(2),
        [ ['h', 'i', 5, 7], ['h', 'i', 5, 7] ]);
```
<!--/include-->

If none of the above was applicable, behave as `r.arar(…stuff)` would.

<!--#include file="test/usage.js" start="  //#r-69ab" stop="  //#"
  outdent="  " code="javascript" -->
<!--#verbatim lncnt="9" -->
```javascript
equal(r(6, 9, 'a', 'b').times(2),
      [ 6, 9, 'a', 'b', 6, 9, 'a', 'b' ]);
// same as:
equal(r([], 6, 9, 'a', 'b').times(2),
          [ 6, 9, 'a', 'b', 6, 9, 'a', 'b' ]);
// to force a string instead:
equal(r('', 6, 9, 'a', 'b').times(2),   '69ab69ab');
```
<!--/include-->

### r.len(q)

Use `q` as the _length_ parameter.

### r.times(n), r.n(n)

Use "`n` times the length of _source_" as the _length_ parameter.
The formula will be calculated as soon as the _source_ parameter is known,
which might be immediately.

### r.arar(…stuff)

Put all (0 or more) arguments into an array (arar = "ARguments ARray")
and use that as the _source_ parameter.

<!--#include file="test/usage.js" start="  //#r-arar" stop="  //#"
  outdent="  " code="javascript" -->
<!--#verbatim lncnt="5" -->
```javascript
equal(r.times(2).arar(),          []);
equal(r.times(2).arar(42),        [42, 42]);
equal(r.times(2).arar(3.14, 15),  [3.14, 15, 3.14, 15]);
```
<!--/include-->

### r.seq(string | buffer | array | list)

Use the first argument as the _source_ parameter.
The _list_ means anything that `Array.prototype.slice` can make an array from.

<!--#include file="test/usage.js" start="  //#buffer" stop="  //#"
  outdent="  " code="javascript" -->
<!--#verbatim lncnt="9" -->
```javascript
x = ifSupported(function () { return Buffer.from('.o°'); });
if (x) {
  equal(x.length, 4);     // in UTF-8, '°' costs 2 bytes.
  equal(r.times(3)(x),    Buffer.from('.o°.o°.o°'));
  equal(12,               Buffer.from('.o°.o°.o°').length);
  equal(r.len(9)(x),      Buffer.from('.o°.o°.'));  // 7 chars in 9 bytes
}
```
<!--/include-->

### r.str(x)

Shorthand for `r.seq(String(x))`.

<!--#include file="test/usage.js" start="  //#r-str" stop="  //#"
  outdent="  " code="javascript" -->
<!--#verbatim lncnt="5" -->
```javascript
equal(r.times(3).str(),           'undefinedundefinedundefined');
equal(r.times(3).str(42),         '424242');
equal(r.times(3).str(3.14, 15),   '<IP_ADDRESS>');
```
<!--/include-->

### r.func(add)

Use `add` as the _addFunc_ parameter. The _addFunc_ should be a function.
It will be invoked with two arguments `accum` and `maxN`.
The `accum` (accumulator) is a sequence in which elements are collected.
When it is long enough, that will be the repeater's result.

The `maxN` argument is a number that tells _addFunc_ up to how many new
elements it shall produce in this invocation.
The _addFunc_ may safely ignore `maxN` in cases where it produces at most
one element.
(It's the repeater's job to make sure to either not request less than one
element, or to discard the excess ones.)

If _addFunc_ has produced exaclty one element and it is of another type
than the accumulator, that element may be returned as-is.
In all other cases (same type, multiple elements, no elements),
the _addFunc_ should return a sequence of the same type as the accumulator.

Returning an empty sequence indicates that no more values can be produced,
even in future attempts. The repeater then enters _futile mode_.
The _addFunc_ must not make any assumptions about how often the repeater in
futile mode will invoke it to request more elements. (At time of writing,
it stops immediately.)
A repeater may optionally leave futile mode if any new elements are produced.
(Not really relevant since the _addFunc_ won't know about that.)

<!--#include file="test/usage.js" start="  //#fiboArg" stop="  //#"
  outdent="  " code="javascript" -->
<!--#verbatim lncnt="11" -->
```javascript
function fiboArg(accum) {
  var n = accum.length;
  return (accum[n - 1] + accum[n - 2]);
}
equal(r.func(fiboArg).times(4)(1, 1),     [ 1, 1, 2, 3, 5, 8, 13, 21 ]);
equal(r.func(fiboArg).len(8)(1, 1),       [ 1, 1, 2, 3, 5, 8, 13, 21 ]);
equal(r.func(fiboArg).len(8)('AB', 'rs'), 'ABrssrrs');
equal(r.func(fiboArg).len(6)(['AB', 'rs']),
  [ 'AB', 'rs', 'rsAB', 'rsABrs', 'rsABrsrsAB', 'rsABrsrsABrsABrs' ]);
```
<!--/include-->

### r.mthd(add)

Like `r.func` but the _addFunc_ is invoked with just the `maxN` argument,
and its invocation context (`this`) will be set to the accumulator.

<!--#include file="test/usage.js" start="  //#fiboMtd" stop="  //#"
  outdent="  " code="javascript" -->
<!--#verbatim lncnt="11" -->
```javascript
function fiboMtd() {  // no named arguments since we ignore maxN
  var accum = this, n = accum.length;
  return (accum[n - 1] + accum[n - 2]);
}
equal(r.mthd(fiboMtd).times(4)(1, 1),     [ 1, 1, 2, 3, 5, 8, 13, 21 ]);
equal(r.mthd(fiboMtd).len(8)(1, 1),       [ 1, 1, 2, 3, 5, 8, 13, 21 ]);
equal(r.mthd(fiboMtd).len(8)('AB', 'rs'), 'ABrssrrs');
equal(r.mthd(fiboMtd).len(6)(['AB', 'rs']),
  [ 'AB', 'rs', 'rsAB', 'rsABrs', 'rsABrsrsAB', 'rsABrsrsABrsABrs' ]);
```
<!--/include-->

<!--#toc stop="scan" -->

Known issues
------------

* It can't work async. Try the `times` function from the `async` module.
  or promises.
* Needs more/better tests and docs.

License
-------
<!--#echo json="package.json" key=".license" -->
ISC
<!--/#echo -->

license: ISC

repository: mk-pmb/repeat-args-js

repo_name: mk-pmb/repeat-args-js


text:
# Flying Toasters Screensaver and Clock

I wanted to recreate the original After Dark flying toasters screensaver, but I didn't want to give up my [Padbury Clock screensaver](http://padbury.me/clock/).

So I combined them.

### Download

If you'd just like to use it, you can do that here: [Download](https://github.com/jamesmillerio/flying-toasters-clock/raw/master/dist/Flying%20Toasters%20Clock.zip)

### Modify

If you'd like to modify this screensaver to have more/less toast and toasters, just pull down the source and change the following line of [FlyingToastersView.swift](https://github.com/jamesmillerio/flying-toasters-clock/blob/master/flyingtoasters/FlyingToasterView.swift):

> let maxToastsAndToasters: Int = 30

![Flying Toasters!](https://raw.githubusercontent.com/jamesmillerio/flying-toasters-clock/master/screenshot.png)

repository: jamesmillerio/flying-toasters-clock

repo_name: jamesmillerio/flying-toasters-clock


text:
---
layout: page
title: Teaching
permalink: /teaching/
---

Academic Year 2022-2023

### [Labour Economics (UNIFE)](https://docente.unife.it/davide.antonioli/didattica)
Undergraduate
###  [Economics and Management of Innovation in Biotechnologies (UNIFE)](https://docente.unife.it/davide.antonioli/didattica)
Postgraduate course
###  [Economic Policy (UNIFE)](https://docente.unife.it/davide.antonioli/didattica)
Postgraduate course

-----

Academic Year 2021-2022

### [Labour Economics (UNIFE)](https://docente.unife.it/davide.antonioli/didattica)
Undergraduate course
### [Urban and Regional Economics (UNIFE)](https://docente.unife.it/davide.antonioli/didattica)
Undergraduate course
###  [Economics and Management of Innovation in Biotechnologies (UNIFE)](https://docente.unife.it/davide.antonioli/didattica)
Postgraduate course

-----

Academic Year 2020-2021

### [Labour Economics (UNIFE)](https://docente.unife.it/davide.antonioli/didattica)
Undergraduate course
### [Urban and Regional Economics (UNIFE)](https://docente.unife.it/davide.antonioli/didattica)
Undergraduate course

-----

Academic Year 2019-2020
### [Labour Economics (UNIFE)](http://www.unife.it/economia/economia/insegnamenti/economia-del-lavoro/programmi-a-a-2018-2019/economia-del-lavoro?year=2019)
Undergraduate course

-----

Academic Year 2018-2019

### [Economic Policy (UNICH)](http://elearning.unich.it/enrol/index.php?id=261)
Undergraduate course

-----

### [European Economic Policy (UNICH)](http://elearning.unich.it/enrol/index.php?id=259)
Postgraduate course

-----

### [PhD in ACCOUNTING, MANAGEMENT AND BUSINESS ECONOMICS (UNICH)](http://www.dea.unich.it/ricerca)
Personnel Economics

-----

<!-- ### [Labour Economics (UNIFE)](http://www.unife.it/economia/economia/insegnamenti/economia-del-lavoro)
Undergraduate course of Labour Economics (L18) -->


text:
---
layout: page
title: projects
permalink: /projects/
---

## Lately

- I've been working on a floor-to-ceiling terraform-serverless-react app that can be spun up and serve a static page from nothing. you will be able to see it at [my other site](https://sandrobraidotti.com) and see [the code](https://github.com/abraidotti/sandrobraidotti.com) when ready.

- I've also been customizing some boilerplate python hacking tools with scapy

- I need to figure out the best way to show off my best Splunk dashboards

===============================================================================

## These are all pretty old by now

### *[Philly Bike Finder](http://pbf-react.netlify.com)* - a location tool for Indego bike stations

    Show details

made with React and Bootstrap

uses: Google Maps API, Indego bikes API

see the git repo for more information.

### *[Drizzl v2](http://drizzl-react.netlify.com)* - a generative weather-art app

    Show details

made with React and Material UI

uses: particles.js, the Dark Sky weather API, and lots of colors

see the git repo for more information.

### *[Really Philly](https://reallyphilly.netlify.com/)* - a tool for exploring Philly's 311 service

    Show details

made with: React, React Router, and Philly's 311 API

see the git repo for more information.

## earlier projects

### *[Trippin](http://trippin-app.herokuapp.com)* - a trip and event planner

    Show details

developed in a group with Devin Hart and Nikki Witte

made with Ruby on Rails and styled with Skeleton.css

uses: Ruby on Rails, Google Maps API, Simple Calendar gem

see the git repo for more information.

### *[Drizzl v1](http://drizzl.herokuapp.com)* - a generative weather-art app

    Show details

made with Node/Express.js

uses: Google Maps API, Darksky.net API, html canvas

see the git repo for more information.

### *[Cash Flow PA](https://github.com/phrig/cash_flow_pa)* - a Pennsylvania election money mapper

    Show details

developed with PhRIG

made with Rails and styled with Bootstrap

uses: Leaflet Gem, lots of federal and state open data sets

see the git repo for more information.


text:
# Related Works

## Cache-based side-channel attacks detection through Intel Cache Monitoring Technology and Hardware Performance Counters
Use PMU to record LLC-misses, LLC-references, iTLB-cache-misses and iTLB-r-accesses counts
and apdot anomaly detection (Gaussian anomaly detection) to detect cache
 side-channel attacks.

 No defense or mitigation.


text:
+++
Categories = ["Development", "DDD"]
Description = "DDD elevator pitch"
date = "2015-10-07T11:07:19+02:00"
title = "DDD elevator pitch"
+++

DDD elevator pitch@ToJans

In business, you make fine-grained adjustments all the time, in order to stay ahead of the competition.

Software tends to be rigid and hard to change.

Domain-Driven Design tackles this paradox, and considers software a living thing - just like your business.

By making the implicit concepts from your business explicit, DDD will give your software the ability to keep up with the agility that your business requires.


text:
---
layout: page-fullwidth
title: Oops!  Nothing here.
#subheadline: "TODO"
description: "Maybe the webpage moved or we deleted it. Or did you maybe mistype the URL?"
header:
   image: "header_image_alt.jpg"
   background-color:  "#fafafa"
permalink: "/404.html"
---
## No problem!

Try [starting over]({{ site.url }}) or **searching this site**:

{% include google_search.html %}

<form style="padding-bottom: 200px;" onsubmit="google_search()" >
  <input type="text" id="google-search" placeholder="{{ site.data.language.enter_search_term }}">
</form>


text:
# List services

```bash
{{command_name}}
```

# List types of virtual machines

```bash
{{command_name}} --resource vm --type flavour
```


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

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

# 0.3.2 - 2022-05-17

## Added

1. Added `valid` logging level.

# 0.3.1 - 2020-12-05

## Fixed

1. Fixed log time output to use seconds, not fractional seconds.

# 0.3.0 - 2020-03-12

## Changed

1. Swapped out `lib/json2.js` for [extendscript-json](https://github.com/theasci/extendscript-json).

# 0.2.1 - 2020-03-03

## Changed

1. Updated [jasminejsx](https://github.com/theasci/jasminejsx) to version 0.2.0 to handle new `Global` object.

# 0.2.0 - 2020-03-03

## Changed

1. `index.jsx` will attempt to get the rootPath from a `Global.rootPath` before looking at a global `rootPath` variable. `README.md` has been updated accordingly.

## Added

1. Added `script/repl.sh` that uses [extendscript-repl](https://github.com/theasci/extendscript-repl) so that we can play around with and test values.

# 0.1.1 - 2019-10-23

## Added

1. TypeScript definitions by [@lumenn](https://github.com/lumenn)

# 0.1.0 - 2019-10-21

## Changed

1. Refactor Logger variables that should be private. Additional tests ensure logging level is met before outputting to the file.

## Removed

1. The log ID outputted on each line. This value becomes confusing if the log isn't wiped and is latter written to with a different Logger. instance.

# 0.0.2 - 2019-10-17

## Changed
1. Swap logger construct parameters. Log path is likely to be used more than level.

# 0.0.1 - 2019-10-17

## Added
1. Initial concept used with [jasminejsx](https://github.com/theasci/jasminejsx).

repository: theasci/extendscript-logger

repo_name: theasci/extendscript-logger


text:
---
layout: section
section: core
title: Sample
namespace: Sample
---

Components for down-sampling data using a variety of methods including mode-median `fc.data.sampler.modeMedian`, largest triangle one bucket `fc.data.sampler.largestTriangleOneBucket` and three bucket `fc.data.sampler.largestTriangleThreeBucket`.
For further details, see the [d3fc-sample](https://github.com/d3fc/d3fc-sample) GitHub page.


text:
# cyberpod_sim_ros
This code was used to produce the simulation results in the IROS 2021 paper titled: "Measurement-Robust Control Barrier Functions: Certainty in Safety with Uncertainty in State" ([Arxiv link](https://arxiv.org/pdf/2104.14030.pdf)).

To install and run this package, you'll need a working ROS environment. This repo was tested using Ubuntu 18.04 and Ros Melodic.

Clone the vision packages into your catkin_workspace's src file:
* [**rviz_camera_stream**](https://github.com/lucasw/rviz_camera_stream.git) Rviz plugin that publishes camera streams
* [**rviz_lighting**](https://github.com/mogumbo/rviz_lighting.git) Rviz plugin that provides ambient lighting

 You'll also need the Python [**ECOS**](https://github.com/embotech/ecos-python) package which can be installed via:
> pip install ecos

<!--
## Install OSQP_embedded
*clone from bitbucket*
*enter directory*
mkdir build
cd build
cmake ..
sudo make install

## Install ASIF++
*clone from bitbucket*
*go to directory*
mkdir build
cd build
cmake ..
ccmake .
*change osqp_embedded to true*
sudo make install
-->

## Running repo
<!--
* go to top level of catkin workspace
* 'catkin_make' whenever code changes -->
Navigate to your catkin_workspace
>cd catkin_workspace

Make the workspace
>catkin_make

Source the setup file (this must be done in every new terminal)
> source devel/setup.bash

Adjust the epsilon value and launch the main script
> roslaunch cyberpod_sim_ros main_mrcbf.launch epsilon:=0.0

Open a new terminal, source the setup file and run the rosservice command to start the simulation:
>rosservice call /cyberpod_sim_ros/integrator/ui "cmd: 1
data:-0"
  * The commands values are: 0 stops, 1 starts, 4 resets

## Recordings
Recordings will appear in the */bags* folder in the repo and in that folder is another readme for how to format the data.

## Relevant Portions of the Code
* cyberpod_sim_ros/
    * include/
        * dynamics.hpp
    *   launch/
        * main_mrcbf.launch
        * mrcbf_with_learning.launch
        * sample_state_space.launch
    * msg/
        * cmd.msg
        * input.mcg
        * learning_data.msg
        * state.msg
    * src/
        * integrator_node.cpp
        * grid_state_space_node.cpp
        * sensor_node.cpp
        * controller_node.cpp
        * src_python/
            * data_logger.py
            * ecos_fitler_node.py
            * perception_node.py
    * srv/
        * ui.srv
    * URDF/
        * cyberpod.urdf

## Key Features of Main Simulation:
***main_marcbf.launch***
    launches the main simulation

***mrcbf_with_learning.launch***
    launches the simulation with learning in the loop (this requires learning data which can be generated using the notebooks). The data couldn't be uploaded due to size. Please contact the Ryan if you would like a copy of the data.

***dynamics.hpp***
    the dynamics for the cyberpod as derived from the Euler-Lagrange equations

***msg/***
    the four messages listed above are the custom messages used to relay messages between the nodes of simulation and also between the user and the system

***srv/ui.srv***
    the service for the user to interact with the simulation

***URDF***
    the system's visual model rviz visualisations

**Nodes:**
* integrator_node.cpp
    * serves as the main physics engine for the system, receives inputs from ecos_filter_node and outputs integrated states
* perception_node.py
    * recieves image data and outputs state estimates
* sensor_node.cpp
    * receives state values from integrator node state estimates from perception_node and outputs "measured states" with true state values used whenever they cannot be attained from the image, such as velocity.
* controller_node.cpp
    * receives state estimates and output desired input based on PD feedback gains
* mrcbf_filter_node.py
    * receives state estimates and desired input and outputs minimally adjusted input to guarantee safety

## Main Code for Data Collection
* sample_state_space.launch
    * launch data collection procedure
* grid_state_space_node.cpp
    * iterates through a gridding of the state space


text:
# DevDay "Containers orchestration with Kubernetes and OpenShift"

![meetup](images/meetup.png)

This repo is used for hosting the demo showed during the "Containers orchestration with Kubernetes and OpenShift" meetup
in Naples (March 28th, 2018) and organized by [DevDay](http://www.devday.it/) community.

Following the links to the resources for this meetup :

* [slides](https://www.slideshare.net/paolopat/containers-orchestration-with-kubernetes-and-openshift-92280115) on Slideshare
* [video](https://www.youtube.com/watch?v=iUGJjoTqNn0) on YouTube (DevDay channel)

Following the different examples provided in this demo.

* [Pods](01-pods/01-pods.md)
* [ReplicaSets](02-replicasets/02-replicasets.md)
* [Services](03-services/03-services.md)
* [Volumes](04-volumes/04-volumes.md)
* [ConfigMaps](05-configmaps/05-configmaps.md)
* [Deployments](06-deployments/06-deployments.md)
* [Ingress](07-ingress/07-ingress.md)

The Vert.x based applications used into the Docker images for this playground can be built as described [here](./vertx-http-app/README.md).

repository: ppatierno/devday-kubernetes-openshift

repo_name: ppatierno/devday-kubernetes-openshift


text:
## Let's build a C program which reads `stdin` into a buffer

Prerequisites:
- [Let's build a program written in C](../c-program/README.md)
- [Let's build a basic Makefile](../makefile/README.md)

Create a [basic C program](../c-program/README.md) named `stdin.c`:

```c
#include <stdlib.h>

int main(void) {
    return EXIT_SUCCESS;
}
```

We'll start off by creating a [statically allocated](https://en.wikipedia.org/wiki/Static_variable) buffer of 10[KiB](https://en.wikipedia.org/wiki/Kibibyte):

```c
char buffer[10 * 1024];
```

Read up to 10KiB from `stdin` by calling `fread()`:

```c
fread(buffer, sizeof(char), stdin);
```

`fread` is defined in `stdio.h`.

```c
#include <stdio.h>
```

```
$ cat /usr/include/stdio.h | grep fread
size_t	 fread(void * __restrict, size_t, size_t, FILE * __restrict);
```

Read about the specifics of how to use `fread` by opening its [man page](https://en.wikipedia.org/wiki/Man_page):

```
$ man fread
```

If something went wrong with `fread`, print out the error and exit:

```c
if (ferror(stdin)) {
    perror("Error reading from stdin");
    exit EXIT_FAILURE;
}
```

The code thus far:

```c
#include <stdlib.h>
#include <stdio.h>

char buffer[10 * 1024];

int main(void) {
    fread(buffer, sizeof(char), sizeof(buffer), stdin);
    if (ferror(stdin)) {
        perror("Error reading from stdin");
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}
```

Build your program using a `[Makefile](../makefile/README.md)`:

```make
a.out: stdin.c
	gcc -Wall -Werror stdin.c

clean:
	rm -f a.out

.PHONY: clean
```

```
$ make
```

Run your program:

```
$ ./a.out
```

You can type text into it, which it will read and store into `buffer`.  Type CONTROL+d (which sends the [EOF character](https://en.wikipedia.org/wiki/End-of-file) to your terminal) to terminate the input and quit `a.out`.

You can also pipe random data into your program:

```
$ cat /dev/urandom | ./a.out
```

`a.out` will read 10,239 characters from `stdin`, then terminate the `buffer` with a NULL character.

(Note that this is technically an [off-by-one error](https://en.wikipedia.org/wiki/Off-by-one_error), since the goal was to read 10,240 characters!).

repository: pepaslabs/lets-build

repo_name: pepaslabs/lets-build


text:
### libyaml-cpp
A lightweight C++ wrapper for libyaml

We wanted to use yaml for our code instead of using the Windows registry. However, the choices for C++ yaml parsing and emitting were limited. One prominent choice would require us to use boost.  However, using libyaml by itself using tokens and lexical parsing also seemed tedious. We wanted a Ruby-esque way to read yaml files.

The difficulty of implementing a C++ yaml reader that is like one in Ruby is that we need a single container that can have a vector type, string type, or map type.  Thus, we have a class called MapObject which implements all three types.

It is up to the user to test that the object type using _type to determine whether the current node is a map, vector, or string.

For example, you might use it like so to read a YAML file
```
- name: Ogre
  position: [0, 5, 0]
  powers:
    - name: Club
      damage: 10
    - name: Fist
      damage: 8
- name: Dragon
  position: [1, 0, 10]
  powers:
    - name: Fire Breath
      damage: 25
    - name: Claws
      damage: 15
- name: Wizard
  position: [5, -3, 0]
  powers:
    - name: Acid Rain
      damage: 50
    - name: Staff
      damage: 3
```

```
FILE *fh;
fh = fopen("monsters.yml", "rb");

MapObject mapObject = MapObject::processYaml(fh);

std::cout << "The first monster is " << mapObject.mapObjects[0].mapPtr->map["name"].value << "\n";
```

Sorry for the lack of documentation. That's where you guys come in :)

repository: kailushan/libyaml-cpp

repo_name: kailushan/libyaml-cpp