text:
<!DOCTYPE html>

 Classes, Functions, and Objects

			Prerequisites

			 Variables

			 Operators

			 Functions

	Dividing programs up into objects and classes is the primary way Java programs are organized. This is in contrast to some other languages, such as C, where the primary way to divide up the tasks of a program is by placing common sets of instructions inside another kind of unit called a function.

	Before waxing philosophical, let's take a look at our HelloWorld program from the very first class and look for  objects , classes , and functions. Don't worry if some of the punctuation or purpose isn't yet clear. You will come to an in-depth understanding over time. For now, let's just establish recognition.

package CSC110;

public class HelloWorld {
	public static void main(String args[]){
		System.out.println("Hello World!");
		System.out.println("Goodbye World!");
	}
}

	In this program, the line public class HelloWorld declares the existence of a class called HelloWorld. Everything between the curly braces after HelloWorld is part of the class definition. Programs can have more than one class, as we saw with Peter Adamson's StringSorter program, but traditionally in Java, there is only one class per file. For now, you can think of a class as a kind of container that helps to organize a program by grouping common data and operations or functions that need to be performed on that data.

	The next line in our program, public static void main(String args[]) declares the existence of a function named main. It is actually a very special function that always acts as the entry point into any Java program. Everything between the main function's curly braces comprises the main function's definition. The very first line where the main function is declared is sometimes called the signature or head and the code between the curly braces where all the work happens is often called the function body.

	Because the main function is inside of the class definition for HelloWorld, main is said to belong to the HelloWorld class.

	Inside the main function are two more lines of code:

System.out.println("Hello World!");

System.out.println("Goodbye World!");

	Both of these lines are called function calls. A function call is a way of requesting the code inside a function definition to execute. Whenever you see a function name with parentheses at the end, a function is being called to execute whatever lines are contained within its curly braces. The name of the function in this case is called println(). As we know, its job is to print out whatever text is passed to it inside the parentheses. After these two function calls execute, your terminal screen will look like this:

Hello World!
Goodbye World!

Though we don't see it in this file, println does have a function declaration and a function definition within the Java SDK. Our HelloWorld code is relying on packages of pre-written Java classes to do a lot of the heavy-lifting for us so that we can get up and running quickly.

When we run our Java program, the main function is called. main then calls both of our println functions. println is being called from a class named System that owns an object named out which itself owns the function named println (in case you were curious). I know that's a mouthful. The important thing to remember is that:

 println belongs to a kind of container called an object

 you don't need to know very much about how println works in order to use it

If you know what kind of data the function wants you to pass into it and what the function is supposed to  output, you are all set to use that function. It is one of the great advantages of dividing programs up into functions, classes, and objects.

	But now you may be wondering, knowing that objects, classes, and functions are kinds of containers, what in the world the difference between them is. Fear not, we're about to explain!

	Let's look at a more elaborate version of a class in order to get a stronger grasp on the concepts.

	Before continuing, make sure you review the concept of variables and the concept of operators to get the most out of the example below. As a quick reminder, variables store data for later use. Operators perform operations on variables or other data and produce a result (very much like a function. In fact, under the hood that is what operators are-- functions that get to be written in a special way).

The example:

package CSC110;

public class Calculator{

	public static void main(String args[]){

				Calculator.doArithmetic();
				System.out.println("");
				System.out.println("");
				Calcultor.doArithmetic();

	}

	public static double add(double augend, double addend){
		double answer = augend + addend;

		return answer;
	}

	public static double subtract(double minuend, double subtrahend){
		double answer = minuend = subtrahend;

		return answer;
	}

	public static double multiply(double multiplicand, double multiplier){
		double answer = multiplicand * multiplier;

		return answer;
	}

	public static double divide(double dividend, double divisor) {
		double answer = dividend / divisor;

		return answer;
	}

	public static void doArithmetic(){
		double operand1 = 100;
		double operand2 = 5;

		double sum = Calculator.add(operand1, operand2);
		double difference = Calculator.subtract(operand1, operand2);
		double product = Calculator.multiply(operand1, operand2);
		double quotient = Calculator.divide(operand1, operand2);

		double sum2 = Calculator.add(100, 50);

		System.out.println("Our two operand are: " + operand1 + " and " + operand2);
		System.out.println("The output of our add function is: " + sum);
		System.out.println("The output of our subtract function is: " + difference);
		System.out.println("The output of our multiply function is: " + product);
		System.out.println("The output of our divide function is: " + quotient);
		System.out.println("");
		System.out.println("The output of our second sum is: " + sum2);
		System.out.println("");
		System.out.println("");
		System.out.println("Thank you for running the Calculator program!");
		System.out.println("");
	}
}

	Here is the resulting output of that code:

//insert output here

	You'll want to draw your attention to a few things here.

 The main function, where all of the code starts has only four lines. It calls a function named doArithmetic() twice. It also calls println() twice as well.

 The doArithmetic() function is prefixed with the name of our class, Calculator. This is because all of our functions are owned by this class. From inside the class, we could choose to omit this prefix, but if we were ever to use these functions outside of this class, the prefix would be required, just like it is for System.out.println()

 There are four custom-made functions:  add(), subtract(), multiply, and divide() that are called from inside doArithmetic()

 Inside the body of the doArithmetic() function there are a lot of instructions. This function calls add(), subtract(), multiply(), and divide() with add() being called twice, each time with different input parameters. It then takes the results of all of those function calls and prints them to the screen

 There are two variables at the start of doArithmetic() named operand1 and operand2. The data stored in these variables, 100 and 5 respectively, is passed to each of our arithmetic functions to be processed and the answer returned

 In the output section, all of the println statements happen twice. This is because we called doArithmetic two times

 There is a keyword static preceding all of the function names. We'll discuss why later.

	This version of our program is organized into separate functions, much more like a C program. There is nothing wrong with this. It is a completely fine design. But this doesn't help us learn about objects and classes. Fortunately, we can change that. Simply by moving a few things around, we can organize our program into an object-oriented design.

Before going further though lets talk about what object and classes are at a high level. Like functions, classes group related sets of instructions together within curly braces (inside the class definition's body). Classes themselves often own many functions. In the above program, for instance, the class Calculator owns the functions add(), subtract(), multiply(), divide(), and doArithmetic(). Of course, if this was all a class did, they wouldn't be much more than a nice way of packaging functions into groups. Classes have two other crucial abilities that radically alter the way programmers organize their code.

Classes can own data (stored in variables)

Classes can construct objects

	You can think of classes as a template that defines a new type of variable. You can then use this template to construct new variables of that type. The new variable or object can own a group of other variables as well as a group of functions. The class defines what these variables and functions are that belong to the new object and is also responsible for creating the object. In some ways the class is simultaneously a blue-print for how to make an object and a factory that builds the object.

	Before going on further, let's look at the object-oriented redesign of Calculator so that we can analyze it:

package CSC110;

public class Calculator{

  public static void main(String args[]){
		System.out.println("Welcome to the Calculator main function!");

		//create two new objects of type Calculator
		Calculator calculateByTen = new Calculator(2, 10);
		Calculator calculator2 = new Calculator();

		//set the member variables of the second object
		calculator2.setOperands(3,5);

		//call doArithmetic on both objects
		calculateByTen.doArithmetic();
		calculator2.doArithmetic();

		//change the values of the variables of the second object
		calculator2.setOperands(20, 5);
		calculator2.doArithmetic();

		//call do arithmetic for the first object again to show that it's values remain the same
		calculateByTen.doArithmetic();

		System.out.println("The program is complete! Thanks for using!");
  }

	public Calculator(){
		this.operand1 = 0;
		this.operand2 = 0;
	}

	public Calculator(double op1, double op2){
		this.operand1 = op1;
		this.operand2 = op2;
	}

	public double getOperand1(){
		return this.operand1;
	}

	public double getOperand2(){
		return this.operand2;
	}

	public void setOperand1(double val){
		this.operand1 = val;
	}

	public void setOperand2(double val){
		this.operand2 = val;
	}

	public void setOperands(double val1, double val2){
		this.operand1 = val1;
		this.operand2 = val2;
	}

  public double add(){
    double answer = this.operand1 + this.operand2;

    return answer;
  }

  public double subtract(){
    double answer = this.operand1 - this.operand2;

    return answer;
  }

  public double multiply(){
    double answer = this.operand1 * this.operand2;

    return answer;
  }

  public double divide() {
    double answer = this.operand1 / this.operand2;

    return answer;
  }

  public void doArithmetic(){

    double sum = this.add();
    double difference = this.subtract();
    double product = this.multiply();
    double quotient = this.divide();

		System.out.println("");
		System.out.println("-----------------------------------------------------------------------------");
		System.out.println(" calculator output:");
		System.out.println("-----------------------------------------------------------------------------");
    System.out.println("Our two operands are: " + this.getOperand1() + " and " + this.getOperand2());
    System.out.println("The output of our add function is: " + sum);
    System.out.println("The output of our subtract function is: " + difference);
    System.out.println("The output of our multiply function is: " + product);
    System.out.println("The output of our divide function is: " + quotient);
    System.out.println("");
    System.out.println("");
    System.out.println("doArithmetic() is complete!");
    System.out.println("");
  }

	private double operand1;
	private double operand2;
}

gha_language: Java


text:
# Two Approaches, the 'Classic' One & the Angular Way

Qlik Sense offers ***two different approaches to develop visualization extension***. One of the approaches is very similar to the extension concept in QlikView, I call it the „Classic Approach“:

You already got to know this approach, which uses the `paint` method, and it was used and described in entire part 1 of this tutorial. Since this approach is very similar to how one has developed extensions in QlikView, this is probably also the favorable approach if you are considering to migrate extensions from QlikView to Qlik Sense.

The other approach is using one of the main underlying technologies of the Qlik Sense client, AngularJS.

## Short introduction to AngularJS
If you haven't worked with AngularJS so far, I can just recommend to start understanding it, at least the basics. Since AngularJS is the [most famous framework](http://www.google.com/trends/explore#cat=0-5&q=angular%2C%20ember%2C%20knockout%2C%20react&date=1%2F2011%2055m&cmpt=q&tz=Etc%2FGMT-2) to build dynamic web apps it's definitely worth investing the time.
AngularJS is created by Google and is described on the AngularJS website as follows:

> AngularJS is a structural framework for dynamic web apps. It lets you use HTML as your template language and lets you extend HTML's syntax to express your application's components clearly and succinctly. Angular's data binding and dependency injection eliminate much of the code you would otherwise have to write.

Here are some resources I recommend:

* [Official AngularJS site](https://angularjs.org/) and especially the [tutorial](https://docs.angularjs.org/tutorial) (really great)
* Overview of [AngularJS learning materials on GitHub](https://github.com/jmcunningham/AngularJS-Learning)
* Videos
	* ... on [Pluralsight](http://www.pluralsight.com/) (you need an account)
	* ... on [egghead.io](https://egghead.io/) (most of the basic videos are freely accessible)

---
**Qlik Sense Visualization Extension Tutorial**, Version 0.13.2

Last update: 2015-07-14

[Overview of all chapters](https://github.com/stefanwalther/qliksense-extension-tutorial)

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# analog-multiplexer
A platform agnostic driver for 4051 and 4067 series analog multiplexers targetting the Rust embedded-hal

This crate provides an interface, `Multiplexer` that makes it trivially easy
to select channels on any given 74HC4051 or 74HC4067 series analog multiplexer.
Internally it keeps track of each multiplexer's state, allowing you to
check what channel is presently active or to enable/disable the multiplexer
at will.

# Supported Hardware (Analog Multiplexers)

* 4067 series: [74HC4067](https://assets.nexperia.com/documents/data-sheet/74HC_HCT4067.pdf)
* 4051 series: [74HC4051](https://www.ti.com/lit/ds/symlink/cd74hc4051-ep.pdf)
* ...and any other similar IC that uses three or four channel select pins

# Usage

Here's an imaginary example using a 74HC4067 with a Blue Pill (stm32f104) board...

```rust
// NOTE: This is pseudocode. It's just meant to get the concept across :)
use analog_multiplexer::Multiplexer; // Important part

use stm32f1xx_hal::gpio::State;
// The pins we're using:
use stm32f1xx_hal::gpio::gpiob::{PB0, PB5, PB12, PB13, PB14, PB15};
use stm32f1xx_hal::{adc}; // So we can read an analog pin (PB0)

fn main() {
    // stm32f1xx_hal boilerplate...
    let device = pac::Peripherals::take().unwrap();
    let mut flash = device.FLASH.constrain();
    let mut rcc = device.RCC.constrain();
    let mut _afio = device.AFIO.constrain(&mut rcc.apb2);
    let _clocks = rcc
        .cfgr
        .use_hse(8.mhz())
        .sysclk(72.mhz())
        .pclk1(36.mhz())
        .freeze(&mut flash.acr);
    // Setup ADC (we're using ADC1 for this example since we're reading PB0)
    let adc1 = adc::Adc::adc1(device.ADC1, &mut rcc.apb2, _clocks);
    // Setup GPIOB (so we can access the ADC via PB0)
    let mut gpiob = device.GPIOB.split(&mut rcc.apb2);
    // Configure PB0 as an analog input (all channels lead to this analog input pin!)
    let analog_pin = gpiob.pb0.into_analog(&mut gpiob.crl);
    // Setup PB12-PB15 for accessing S0-S3 on the 74HC4067 multiplexer
    let s0 = gpiob
        .pb12
        .into_push_pull_output_with_state(&mut gpiob.crh, State::Low);
    let s1 = gpiob
        .pb13
        .into_push_pull_output_with_state(&mut gpiob.crh, State::Low);
    let s2 = gpiob
        .pb14
        .into_push_pull_output_with_state(&mut gpiob.crh, State::Low);
    let s3 = gpiob
        .pb15
        .into_push_pull_output_with_state(&mut gpiob.crh, State::Low);
    // NOTE: On some multiplexers the S0-S3 pins are labeled A, B, C, D
    // Enable pin...  If you want to be able to enable/disable the multiplexer on-the-fly
    let en = gpiob
        .pb5
        .into_push_pull_output_with_state(&mut gpiob.crl, State::Low);
    // TIP: Just run a wire from EN to GND to keep it enabled all the time
    // Multiplexer pins are given as a tuple in the order S0-S3 then enable pin (EN):
    let pins = (s0,s1,s2,s3,en); // For 16-channel
    // let pins = (s0,s1,s2,en); // For 8-channel
    let mut multiplexer = Multiplexer::new(pins); // The important part!
    multiplexer.enable(); // Make sure it's enabled (if using EN pin)
    loop {
        for chan in 0..multiplexer.num_channels {
            multiplexer.set_channel(chan); // Change the channel
            let data: u16 = adc1.read(&mut *analog_pin).unwrap();
            // Do something with the data here
        }
    }
}

```

# Working Example

There's a *proper* working example in the `examples` directory (`read_all`) that uses [RTIC](https://rtic.rs) and probe-rs to great effect.  It requires an ST-LINK programmer, a Blue Pill board, and [probe-run](https://crates.io/crates/probe-run).

Here's me using it to read a hall effect sensor on channel 15:

![Reading a hall effect sensor on channel 15](https://thumbs.gfycat.com/FlippantAptHadrosaurus-size_restricted.gif)

# License

Licensed under:

* Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)

repository: BinaryBearzz/analog-multiplexer

repo_name: BinaryBearzz/analog-multiplexer


text:
PAYPAL GATEWAY (for Laravel Shop Package)
--------------------------------

[![Latest Stable Version](https://poser.pugx.org/amsgames/laravel-shop-gateway-paypal/v/stable)](https://packagist.org/packages/amsgames/laravel-shop-gateway-paypal)
[![Total Downloads](https://poser.pugx.org/amsgames/laravel-shop-gateway-paypal/downloads)](https://packagist.org/packages/amsgames/laravel-shop-gateway-paypal)
[![License](https://poser.pugx.org/amsgames/laravel-shop-gateway-paypal/license)](https://packagist.org/packages/amsgames/laravel-shop-gateway-paypal)

PayPal Gateway solution for [Laravel Shop](https://github.com/amsgames/laravel-shop).

## Gateways

This package comes with:

* Direct Credit Card payments

* PayPal Express payments

## Contents

- [Installation](#installation)
- [Configuration](#configuration)
    - [Authentication](#authentication)
- [Gateway Usage](#gateway-usage)
    - [Direct Credit Card](#direct-credit-card)
    - [PayPal Express](#paypal-express)
        - [Configuration](#configuration-1)
        - [Usage](#usage)
- [License](#license)
- [Additional Information](#aditional-information)

## Installation

In order to install Laravel Shop, you can run

```json
"amsgames/laravel-shop-gateway-paypal": "v1.0.0"
```

to your composer.json. Then run `composer install` or `composer update`.

Then in your `config/shop.php` add

```php
'paypal'            =>  Amsgames\LaravelShopGatewayPaypal\GatewayPayPal::class,
'paypalExpress'     =>  Amsgames\LaravelShopGatewayPaypal\GatewayPayPalExpress::class,
```

in the `gateways` array.

## Configuration

### Authentication

Set your PayPal app authentication credentials in `config/services.php`, like:

```php
    'paypal' => [
        'client_id' => env('PAYPAL_CLIENT_ID', ''),
        'secret' => env('PAYPAL_SECRET', ''),
        'sandbox' => env('PAYPAL_SANDBOX', true),
    ],
```

**NOTE:** Change `sandbox` to false when going live.

## Gateway Usage

### Direct Credit Card

The only additional step needed for this to work is to add the credit card information before `checkout` and before `order placement`, like:

```php
// (1) - Set gateway
Shop::setGateway('paypal');

// (2) - Add credit card for validation
Shop::gateway()->setCreditCard(
  $cartType   = 'visa',
  $cardNumber = '4111111111111111',
  $month      = '1',
  $year       = '2019',
  $cvv        = '123',
  $firstname  = 'John',
  $lastname   = 'Doe'
);

// (3) - Call checkout
if (!Shop::checkout()) {
  echo Shop::exception()->getMessage(); // echos: card validation error.
}

// (4) - Create order
$order = Shop::placeOrder();

// (5) - Review payment
if ($order->hasFailed) {

  echo Shop::exception()->getMessage(); // echos: payment error.

}
```

**NOTE:** If you are calling `Shop::checkout()` in a different controller or view than `Shop::placeOrder`, be sure to recall `setCreditCard()` before calling `Shop::placeOrder()` in your second controller. This package does not stores credit card data.

**RECOMMENDATION:** Use SSL to secure you checkout flow when dealing with credit cards.

### PayPal Express

If you don't want to deal with credit card forms and SSL, you can us PayPal Express instead. PayPal Express handles the payment process outside your website and returns with the results.

Look at [PayPal's documentation](https://developer.paypal.com/docs/classic/express-checkout/integration-guide/ECGettingStarted/) for more information about this process.

#### Configuration

PayPal will callback Laravel Shop and this gateway with the results. Laravel Shop will then redirect the customer to the route name set in `config/shop.php` and will pass by as parameter the `Order Id`. Set up this route before using this gateway.

```php
    /*
    |--------------------------------------------------------------------------
    | Redirect route after callback
    |--------------------------------------------------------------------------
    |
    | Which route to call after the callback has been processed.
    |
    */
    'callback_redirect_route' => 'home',
```

#### Usage

```php
// (1) - Set gateway
Shop::setGateway('paypalExpress');

// (2) - Call checkout / OPTIONAL
// You can call this to keep a standard flow
// Although this step for this gateway is not needed.
Shop::checkout();

// (3) - Create order
$order = Shop::placeOrder();

// (4) - Review order and redirect to payment
if ($order->isPending) {

  // PayPal URL to redirect to proceed with payment
  $approvalUrl = Shop::gateway()->getApprovalUrl();

  // Redirect to url
  return redirect($approvalUrl);
}

// (5) - Callback
// You don't have to do anything.
// Laravel Shop will handle the callback and redirect the customer to the configured route.
```

## License

This package is free software distributed under the terms of the MIT license.

## Additional Information

This package uses the official [PayPal PHP SDK](https://github.com/paypal/PayPal-PHP-SDK).


text:
# Kubernetes Code of Conduct Committee (CoCC)

The Kubernetes Code of Conduct Committee (CoCC) is the body that is responsible for enforcing and maintaining the Kubernetes Code of Conduct.

The members and their terms are as follows:
- Jaice Singer Dumars (Google) - 2 years
- Paris Pittman (Google) - 2 years
- Carolyn Van Slyck (Microsoft) - 1 year
- Eric Paris (Red Hat) - 1 year
- Jennifer Rondeau (Heptio) - 1 year

Please see the [bootstrapping document](./bootstrapping-process.md) for more information on how members are picked, their responsibilities, and how the committee will initially function.

_More information on how to contact this committee and learn about its process to come in the near future. For now, any Code of Conduct or Code of Conduct Committee concerns can be directed to<EMAIL_ADDRESS>

repository: carsonoid/community

repo_name: carsonoid/community


text:
# My Dotfiles

This is a simple dotfile for my basic setup

## Dependencies

If using MacOS, homebrew is a good thing to have, the script tries to install dependencies automatically
(for Arch, yay is installed for AUR packages)

- zsh
- starship (prompt)
- znap (plugin manager)

Optional:
- yay (who doesn't like yogurt?)
- ssh-keygen (openssh)
- xclip (I like pbcopy and pbpaste 😂)
- some nerd-font
- fzf (fuzzy search change lives)

## Setting Up

```shell
git clone https://github.com/luancm/dotfiles ~/.dotfiles
source ~/.dotfiles/install
```

repository: luancm/dotfiles

repo_name: luancm/dotfiles


text:
# M(eta)-Lisp

A simple Lisp interpreter written in C++ and inspired by [this essay](http://www.michaelnielsen.org/ddi/lisp-as-the-maxwells-equations-of-software/). The goal is to create an interpreter for Lisp that is functional enough to implement Lisp within Lisp itself.

## Usage
### Requirements

* Linux:   Download and install Clang/LLVM (Or modify the makefile as appropriate if using a different compiler frontend), bison/flex.
* macOS:   Download and install bison/flex using homebrew and the Xcode command line tools.
* Windows: Download and install Clang/LLVM, MingGW-64, make, bison/flex, and add to path.

### Building

Simply run `make all` in the root directory of the project to build the interpreter.

### Running

We can run the built `mlisp` executable to launch a REPL:

```
$./mlisp
M-Lisp>(+ 1 1)
2
```

We can also use `--single-use` to read from `stdin` and execute directly:

```
$./mlisp.exe --single-use "(+ 1 (+ 1 1)) (+ 1 1)"
3
2
```

## Language

The full set of operator and keywords supported by M-Lisp can be found in its [language specification](language.md).

repository: Merctron/M-Lisp

gha_license_id: MIT

repo_name: Merctron/M-Lisp


text:
## OSBD Workshop Materials

Materials for talk on Dask & Numba at the Open Science in Big Data workshop
[(OSBD 2016)](https://osbd.github.io/).

Slides can be viewed [here](http://jcrist.github.io/talks/osbd_workshop/slides.html).

The rendered example notebook can be viewed
[here](http://nbviewer.jupyter.org/github/jcrist/talks/blob/master/osbd_workshop/Ocean%20Temperature%20Data.ipynb).

### Setup environment

```bash
$ conda create -n osbd python=3.5
$ source activate osbd
$ conda install dask distributed jupyter matplotlib numba zarr -c conda-forge
```

### Downloading example data

The ocean temperature example uses a full dataset from the
[esrl.noaa.gov](http://www.esrl.noaa.gov/psd/thredds/dodsC/Datasets/noaa.oisst.v2.highres/catalog.html)
catalog. To download the data, run the `get_data.py` script. Note that
depending on your connection, this may take a very long time. It will download
~15 GB of data to disk, then convert it to a `zarr` array.


text:
# Introduction to the Astrolabe Platform Export

Astrolabe Diagnostics provides complete access to the analysis conducted by the platform. In addition to browsing through the Astrolabe app, you are welcome to download the experiment export file, `experiment.zip`. This file includes all analysis results in various formats.

> Throughout this guide technical notes appear in blockquote.
>
> The examples here use data from [Tordesillas et al., J Allergy Clin Immunol, 2016](https://www.ncbi.nlm.nih.gov/pubmed/27531074). You can download the raw data from [the FlowRepository repo](https://flowrepository.org/id/FR-FCM-ZZTW), or download the [Astrolabe `experiment.zip` file]().

**TODO update link to file above**

The file includes the following directories:

- `/analysis/fcs`. FCS output of the Astrolabe automatic gating tool.
- `/reports/`. Figures and CSV files for each sample and for the experiment analyses.
- `/analysis/`. RDS files which can be loaded in R using the `orloj` package.

Each of these directories is further explored in the following sections.

> Sample-specific results are identified using the sample name that was entered when configuring the experiment in Astrolabe.

## Automatic Gating FCS Files

The `/analysis/fcs` directory includes the output of the Astrolabe automatic gating tool. Each of the sample FCS files is exported to a separate directory whose name is the sample name. Within the directory of a given sample, you will find a set of FCS files, one for each of the cell subsets that were identified for this sample. These are standard FCS files and you can load them in any other software, the same way you would load any other CyTOF or flow cytometry FCS file.

> Astrolabe follows a hierarchical automated gating algorithm. Briefly, all cells begin in a `Root` level. Cells are then iteratively classified into subsets of their current level until each cell belongs to a terminal label. As an example, a cell could start at `Root`, then get classified as `Myeloid`, and finally as `CD16+ Monocyte`.
>
> The platform offers two types of terminal labels. The `Assignment` level terminal labels follow a manually curated cell subset hierarchy which is built separately from the data set. The `Profiling` level extends the `Assignment` labels through an agnostic classification step that looks for strong separation within the data (across samples). For example, in the Tordesillas et al. data set, `CD16+ Monocyte` cells were further classified as `CD16+ Monocyte CD66a+` and `CD16+ Monocyte CD66a-`.

Within a sample directory, the file names follow the syntax `[sample_file_name].[subset].fcs`. The sample file name is the same as the file that was uploaded to the platform during experiment setup. The subset corresponds to the cell subset, as classified by the `Assignment` level. Each cell is exported to the lowest level subset for it. For example, if a cell was classified as both a `T Cell` and a `CD4+ T Cell`, it will be exported to `[sample_file_name].CD4__T_Cell.fcs`.

Several files warrant special attention. `[sample_name].bead.fcs` has the CyTOF calibration beads that were identified by Astrolabe. `[sample_name].Debris.fcs` has any events were negative for all major subset markers -- these are treated as debris by Astrolabe. `[sample_name].Root_unassigned.fcs` has events that were positive for at least one major subset marker, but could not be classified into any subset.

## Reports

The `/reports/` directory includes figures (in JPEG format) and CSV files for each of the experiment samples. The reports for each sample are exported in a directory with that sample name. In addition, `/reports/` includes two experiment-wide reports: `experiment_cell_counts`, which includes cell subset counts over all samples, and `differential_abundance_analysis`, which includes the result of the differential abundance analysis.

### Sample Report Directories

Each sample report directory includes three sub-directories.

If any CyTOF calibration beads were identified for the sample, biaxial plots that report on the bead gate will be exported to `/reports/[sample_name]/beads/`. The biaxial plots correspond to Ce140 versus Eu151, Ho165, and Lu175, covering the four elements that constitute the beads. Blue dots are bead events and red dots are non-bead events.

*CD140 versus Eu151 for sample `C1 15min antiIgE`. Beads are in blue, non-bead events are in red.*

Cell assignment heatmaps are available in `/reports/[sample_name]/cell_assignments/`. There are heatmap files for the `Assignment` and `Profiling` gating levels. In each of heatmap, the X-axis corresponds to classification channels (as supplied during experiment setup), the Y-axis corresponds to cell subsets, and tile values are the median intensity of that channel in that subset. Channel intensities are scaled to a 0..100% range in order to clearly visualize varying intensities across channels.

*Assignment level heatmap for C1 15min antiIgE*

In addition to the JPEG figure, each level includes a CSV file with the data that was used to generate the figure, such as [`Assignment.jpg.csv`](examples/cell_assignments_Assignment.jpg.csv) for the heatmap above.

Finally, cell subset counts for the two gating levels are in `/reports/[sample_name]/subset_counts/`, along with respective CSVs such as [`Assignment.jpg.csv`](examples/cell_counts_Assignment.jpg.csv).

*Assignment level cell counts barplot for C1 15min antiIgE*

### Experiment Cell Counts

Figures visualizing subset cell counts across all samples in the experiment can be found in the `/reports/experiment_cell_counts/` directory. As before, Astrolabe exports reports for the `Assignment` and `Profiling` levels separately.

For each level, you will find a subset cell count heatmap ([and the accommodating CSV file](examples/frequency_heatmap.jpg.csv)). Here, the X-axis corresponds to cell subsets, the Y-axis corresponds to samples, and tile values are the frequency of that subset in that channel.

*Subset cell counts for all samples in Tordesillas et al.*

For a clearer view of the cell frequencies for each given subset, consult the `/bar_plots/` directory for each level, which includes a separate bar plot for each subset (and, of course, the CSV file).

*CD4+ T Cell frequencies across all samples in Tordesillas et al.*

### Differential Abundance Analysis

Astrolabe utilizes the [edgeR](http://bioconductor.org/packages/release/bioc/html/edgeR.html) package for differential abundance analysis. We analyze each sample feature separately -- in this experiment, each of the patient, type, condition, and timepoint features will be tested. Within each feature, we would like to know whether the abundance (cell count) of each cell subset is different between feature values. In other words, we are asking "are granulocyte counts different between healthy controls and peanut allergic patients?", "are B cell counts different?", etc.

> The analysis is run for each of the label levels (so there is an `Assignment` analysis and a `Profiling` analysis).
>
> P values are adjusted for multiple comparisons using the Benjamini-Hochberg procedure, which is commonly referred to as FDR.

By default, the analysis is not paired: feature values are tested under the assumption that each sample is independent from all the others. However, a common pairing in experiment design is patient (for example, same patient, before or after treatment). If an experiment includes the `Patient` feature, then features will follow a paired analysis (which could improve P values dramatically).

> Only features that are independent from the `Patient` feature will be paired. Using Tordesillas et al. as an example, the `Type` feature is **dependent** on `Patient` (patients are either healthy controls or peanut allergic). The `Condition` feature is **independent** on `Patient`, since the same patient sample could be treated using anti IgE or peanut extract.

Differential abundance analysis figures are under the `/reports/differential_subset_analysis/` directory, which has a sub-directory for the `Assignment` and `Profiling` levels (similarly to the experiment cell counts figures). These are further sub-divided to the different features.

If a feature has only two values (such as `Type` in this experiment, which is either healthy or allergic), its directory will include a volcano plot:

*Volcano plot for the Type feature. Several cell subsets, such as granulocytes, have differential abundances.*

You can examine the relationship for a given cell subset using either a boxplot or a barplot:

*A boxplot of granulocyte cell counts for different patient types. Peanut allergic patients have higher granulocyte counts.*

*A barplot of granulcoyte frequencies for all patients. The peanut allergic patients are concentrated in higher frequencies.*

> As before, all of the above figures have a respective CSV file with the data that was used to generate them.

## Analysis

The `/analysis/` directory includes a set of analysis RDS files for each of the experiment samples, and several experiment-wide RDS files. These files include all of the analyses done by the Astrolabe platform, and can be loaded into R using the `orloj` package. Please consult the [package README.md file](README.md) for explanations on how to install and operate `orloj`.

repository: astrolabediagnostics/orloj

gha_language: R

repo_name: astrolabediagnostics/orloj


text:
re-thunderbird
==============

Thunderbird plugin for reverse tracking service re (see [ahx/re](http://github.com/ahx/re)).

Part of http://bremen.stadthack.de efforts to track back.

Uses the execellent [adam-p/markdown-here](http://github.com/adam-p/markdown-here) project as template.

Needs some loving...

### TODO
- error handling for missing to/from/subject
- omit first request (all request from composing entity)
- make transparent/automatic addition of tracker work (halfway done)
- ...

repository: Rockyspade/re-thunderbird

repo_name: Rockyspade/re-thunderbird


text:
# A boilerplate project for writing applications using Koa2 and React

## What?
I became disillusioned with frameworks for Node.js, so here is a comprehensive MVC boilerplate project with most of the modern application components implemented in a consistent code style without any frameworks (well, on backend anyway). Note that this stack assumes you have intermediate to advanced understanding of Node.js. It is not for beginners.

### Stack supports
 - Koa2 (i.e. async await - you need Node.js 7.6, 8+ highly recommended for debugging with inspector protocole)
 - React for frontend using Webpack
  - Modules
  - Async functions
 - Gulp asset pipeline (disabled by default - may conflict with some of the ports webpack uses)
 - MongoDB
 - MariaDB/MySQL
 - Migrations
 - SASS css preprocessor (uses .scss syntax by default)
 - Basic security (CSRF)
 - Both ejs and pug view engines

## How?
Get started with
```
git clone https://github.com/megakoresh/koa2-react.git yourprojectname
cd yourprojectname
rm -rf .git
git init .
```
You now have the code base for a new project. The base classes are documented as to what they do. Project is meant to allow easy extensibility without breaking code style. You might want to
  - Inject ORM (e.g. Sequelize or Mongoose) - wrap it with Database class methods, or Model class methods, then extend from it.
  - Security - place it in middleware package, then use where needed
  - Policies - Add them as static methods to Authenticator, then use them when setting routes in controllers
  - Foundation/Bootstrap - see comments in webpack config
  - Migrations - `npm install -g db-migrate` and `db-migrate create:sql my-new-migration -e test-maria`, see https://db-migrate.readthedocs.io/en/latest/ for details
  - Global configuration - place it to common package where appropriate, then require. For database-related things, place to database package
  - File uploads - change the body parser to something that supports files, or add a separate file handling middleware like multer

I highly recommend you use Visual Studio Code for developing Node.js applications and this one in particular. It already includes launch configurations for both frontend and backend debugging, and in general VSCode is nowadays the best Node.js development IDE. You will save a lot of time with it.

## Why?
I have used Sails.js for a long time, and in every single project, I spent more time fighting Sails and specifically - Waterline than building the actual application. I have used Meteor several times, and in every project when I wanted to change small details that made a lot of difference, I found it was impossible because "That's not how Meteor works". Same thing with Hapi. In the end, when you are building a more or less unique project (i.e. not yet another blog or web store or another kind of template site), you'll run into the framework's limitations sooner rather than later. Yes, building something without framework makes it more verbose, but with modern Javascript techniques and consistent code conventions that can be an avantage as well.

This project aims to give you a quick start by eliminating the tedium of setting up an application, as well as providing you with a reasonably flexible, yet consistent and robust coding style and architecture with proper error handling and an example of every boilerplate feature both in implementation and usage. It is *not* a generic solution that will cover every possible use case. It is a solution that will help cover *your* use case.

## TODO
  - Some kind of visual diagram for how the project is organized when I have time.
  - Some actual boilerplate functionality for React/Redux

## License
MIT


text:
node-extend
===========

Object extend function designed for config files.

Modified version of the node module node.extend, an implementation of jQuery extend.

Differences:

*	Deep copying is enabled by default.
*	Arrays are replaced instead of combined.

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

	npm install config-extend

Usage
-----

````javascript
var configExtend = require('config-extend'),
	production = {
		port: 1234,
		memcached: [
			'server1',
			'server2',
			'server3'
		]
	},
	staging = {
		port: 456,
		memcached: [
			'server4'
		]
	},
	devFoo = {
		memcached: [
			'localhost'
		]
	},
	objCombined = configExtend(production, staging, devFoo);

	/* objCombined Value:
		{
			port: 456,
			memcached: [
				'localhost'
			]
		}
	*/
````

repository: JamesHight/node-config-extend

gha_language: JavaScript

repo_name: JamesHight/node-config-extend


text:
# Are You Alive?

What does it mean to be alive?

Well we don't know what it means for you, but we know what it means for a Vitess
Cluster!

This project contains a simulated client application that can be used to measure
the health of a Vitess cluster over time.

## Design

For now, there is a specific database schema and vschema that you must apply to
the database that you are using for this test.

This client application:

1. Hammers the database with random data (not a load test though).
1. Measures all the important things:
   - Client connection errors
   - Write latency
   - Read latency from primaries
   - Read latency from replicas
   - Write errors
   - Read errors on primaries
   - Write errors on replicas
   - Errors in other operations on primaries and replicas (e.g. COUNT)
   - Latency on other operations on primaries and replicas (e.g. COUNT)
   - Data loss (by writing predictable data and testing for that)
1. Reports all these metrics to Prometheus.

That's it!

## Usage

First, [initialize your database with the correct schemas](schemas/README.md).

Run `are-you-alive --help` for usage.  You can use the command line flags to
control the dataset size, whether to target reads at primaries and replicas, your
mysql connection string, and the rate at which to send requests.

Example:

```
./are-you-alive --mysql_connection_string <mysql_connection_string>
```

Where `<mysql_connection_string>` points to the database you are trying to test,
and everything else will be set to defaults.

## Building

```
go build vitess.io/vitess/examples/are-you-alive/cmd/are-you-alive
```

## Testing

First, [install docker compose](https://docs.docker.com/compose/install/) and
make sure it's working.  Then run:

```
docker-compose build
docker-compose up
```

This will create a local mysqld and a local prometheus to scrape the app.  It
will also start the app with the `--initialize` flag which tells it to
automatically create the test database.  You might have to run this twice to
give mysql a chance to do its first initialization.

After you run docker compose, navigate to `http://localhost:9090` to see
Prometheus and `http://localhost:8080/metrics` to see the raw metrics being
exported.

## Test Specific Tablet Types

Queries can target specific tablet types. In the configuration file you simply
need to, for example, put "@primary" or "@replica" on the ends of your connection
strings.

## Push to Registry

If you have push access to the [planetscale public
registry](https://us.gcr.io/planetscale-vitess), you can use the following
commands to build and push the image:

```
make build
make push
```

repository: github/vitess-gh

gha_language: Go

repo_name: github/vitess-gh


text:
[![Deploy](https://get.pulumi.com/new/button.svg)](https://app.pulumi.com/new?template=https://github.com/pulumi/examples/blob/master/aws-ts-apigateway-lambda-serverless/README.md)

# Lambda-backed REST API

A simple API demonstrating an integration between AWS API Gateway (REST) and AWS Lambda.

## Deploying and running the program

This example provides API endpoints which are executed by lambda using TypeScript and AWS.

This sample uses the following AWS products:

- [Amazon API Gateway](https://aws.amazon.com/api-gateway/) is used as an API proxy
- [AWS Lambda](https://aws.amazon.com/lambda/) is used to process API events by executing typescript/javascript code

## Prerequisites

1. [Install Pulumi](https://www.pulumi.com/docs/get-started/install/)
2.  Create a new stack:

    ```bash
    $ pulumi stack init aws-ts-apigateway-lambda-serverless
    ```

3.  Set the AWS region:

    ```bash
    $ pulumi config set aws:region us-east-2
    ```

4.  Install NPM modules via `npm install` or `yarn install`.

## Deploy the App

1.  Run `pulumi up` to preview and deploy changes:

  ```bash
  `Updating (aws-ts-apigateway-lambda-serverless)

  View Live: https://app.pulumi.com/***/aws-ts-apigateway-lambda-serverless/aws-ts-apigateway-lambda-serverless/updates/1

      Type                                Name                                                                     Status
  +   pulumi:pulumi:Stack                 aws-ts-apigateway-lambda-serverless-aws-ts-apigateway-lambda-serverless  created
  +   └─ aws:apigateway:x:API             hello-world                                                              created
  +      ├─ aws:iam:Role                  hello-world40ecbb97                                                      created
  +      ├─ aws:iam:Policy                hello-world2bb21f83-LambdaFullAccess                                     created
  +      ├─ aws:iam:Role                  hello-world2bb21f83                                                      created
  +      ├─ aws:iam:Role                  hello-world4fcc7b60                                                      created
  +      ├─ aws:iam:Policy                hello-world40ecbb97-LambdaFullAccess                                     created
  +      ├─ aws:iam:Policy                hello-world4fcc7b60-LambdaFullAccess                                     created
  +      ├─ aws:lambda:Function           hello-world40ecbb97                                                      created
  +      ├─ aws:lambda:Function           hello-world2bb21f83                                                      created
  +      ├─ aws:iam:RolePolicyAttachment  hello-world2bb21f83-lambdaFullAccessCopyAttachment                       created
  +      ├─ aws:iam:RolePolicyAttachment  hello-world40ecbb97-lambdaFullAccessCopyAttachment                       created
  +      ├─ aws:lambda:Function           hello-world4fcc7b60                                                      created
  +      ├─ aws:iam:RolePolicyAttachment  hello-world4fcc7b60-lambdaFullAccessCopyAttachment                       created
  +      ├─ aws:apigateway:RestApi        hello-world                                                              created
  +      ├─ aws:apigateway:Deployment     hello-world                                                              created
  +      ├─ aws:lambda:Permission         hello-world-29d762f7                                                     created
  +      ├─ aws:lambda:Permission         hello-world-86405973                                                     created
  +      ├─ aws:lambda:Permission         hello-world-d21e9c98                                                     created
  +      └─ aws:apigateway:Stage          hello-world                                                              created

  Outputs:
      endpointUrl: "https://***.execute-api.us-east-2.amazonaws.com/stage/"

  Resources:
      + 20 created

  Duration: 36s`
  ```

2.  To view the runtime logs of the Lambda function, use the `pulumi logs` command. To get a log stream, use `pulumi logs --follow`.

## Clean Up

1.  Run `pulumi destroy` to tear down all resources.

2.  To delete the stack itself, run `pulumi stack rm`. Note that this command deletes all deployment history from the Pulumi console.

## Summary

In this tutorial, you built a lambda-backed API on AWS using API Gateway, lambda functions, and Pulumi. This serverless solution is highly scaleable, resilient, and stateless.

## Next Steps

- [Create a frontend to interact with this api](https://www.pulumi.com/docs/tutorials/aws/s3-website/)

repository: pulumi/examples

gha_language: TypeScript

repo_name: pulumi/examples


text:
# Server client PyChatCSA

## What is this?
A server-side chat a **PyChatCSA** client in Python written as part of training at GeekBrains.

gha_language: Python


text:
# Installation

`npm install`

# Start a provider node

`node_modules/.bin/ganache-cli`

# Continuous Organisation Decentralized Application

### Installation and Usage

Clone repository and run
```
npm install
```
Then launch the testpc server with
```
npm run ganache
```
and from a separate shell
```
npm run cli
```

Then point your browser to `http://localhost:8000` for the web version of the voting app.

The `cli.js` file includes the smart contract setup and deployment.

### Run test

After having launched `ganache`, launch:

`npm test`

repository: tiborvass/theme-default

repo_name: tiborvass/theme-default


text:
# Drawer as Side Navigation

This sample project shows one way to use the [Telerik Drawer](https://demos.telerik.com/blazor-ui/drawer/overview) as a side navigation in your project.

Key points of interest:

* All the logic, styles and code related to the drawer are in the `~/Shared/MainLayout.razor` file. You should separate them according to your project structure and best practices.

* Code comments in the file provide details.

* CSS rules define the size of the various containers and scrolling:
    * The drawer will take up the entire viewport.
    * Scrolling happens in the content area of the drawer only.
    * The sticky header stays above the content.

* The current page is denoted by the selected item in the drawer:
    * On initial load it is taken from the Data collection with the help of the `NavigationManager`.
    * On SPA navigation, the navigation happens in the `@Body` so the click selects the item and it does not dispose

* In this sample, the list of links is hardcoded for brevity. You can populate it later based on user roles and privileges or any other applicable business logic.

repository: telerik/blazor-ui

gha_language: C#

repo_name: telerik/blazor-ui


text:
# Monitioring

## Overview
Monitoring in Bigbang is deployed using the upstream chart  [kube-prometheus-stack](https://github.com/prometheus-community/helm-charts/tree/main/charts/kube-prometheus-stack)

Installs the kube-prometheus stack, a collection of Kubernetes manifests, Grafana dashboards, and Prometheus rules combined with documentation and scripts to provide easy to operate end-to-end Kubernetes cluster monitoring with Prometheus using the Prometheus Operator.

 ```mermaid
graph LR
  subgraph "Monitoring"
    alertmanagerpods("AlertManager Pod(s)") --> monitoringpods("Monitoring Pod(s)")
    alertmanagerservice{{AlertManager Service}} --> alertmanagerpods("AlertManager Pod(s)")
    alertmanagersvcmonitor("Service Monitor") --"Metrics Port"--> alertmanagerservice
    Prometheus --> alertmanagersvcmonitor("Service Monitor")
    grafanapods("Grafana Pod(s)") --> monitoringpods("Monitoring Pod(s)")
    grafanaservice{{Grafana Service}} --> grafanapods("Grafana Pod(s)")
    grafanasvcmonitor("Service Monitor") --"Metrics Port"--> grafanaservice
    Prometheus --> grafanasvcmonitor("Service Monitor")
    nodeexporterpods("Node-Exporter Pod(s)") --> monitoringpods("Monitoring Pod(s)")
    nodeexporterservice{{Node-Exporter Service}} -->  nodeexporterpods("Node-Exporter Pod(s)")
    nodeexportersvcmonitor("Service Monitor") --"Metrics Port"-->  nodeexporterservice
    Prometheus --> nodeexportersvcmonitor("Service Monitor")
    kubestatemetricspods("Kube-State-Metrics Pod(s)") --> monitoringpods("Monitoring Pod(s)")
    kubestatemetricsservice{{Kube-State-Metrics Service}} -->  kubestatemetricspods("Kube-State-Metrics Pod(s)")
    kubestatemetricssvcmonitor("Service Monitor") --"Metrics Port"-->  kubestatemetricsservice
    Prometheus --> kubestatemetricssvcmonitor("Service Monitor")
    Prometheus --> prometheussvcmonitor("Service Monitor")
    prometheussvcmonitor("Service Monitor") --"Metrics Port"--> prmetheussservice{{Prometheus Service}}
    prmetheussservice{{Prometheus Service}} --> Prometheus
    PromOperator ---|Manages/Creates| Prometheus
    VirtualServices --"App Port"--> alertmanagerservice
    VirtualServices --"App Port"--> grafanaservice
    VirtualServices --"App Port"--> Prometheus
  end
  subgraph "Logging"
    monitoringpods("Monitoring Pod(s)") ---|Logs|fluent(Fluentbit) --> logging-ek-es-http
    logging-ek-es-http{{Elastic Service<br />logging-ek-es-http}} --> elastic[(Elastic Storage)]
  end
  subgraph "Istio-system (Ingress)"
    ig(Ingress Gateway, Gateway) --> VirtualServices
  end

```

## Big Bang Touchpoints
### UI

Alertmanager, Prometheus and Grafana within the monitoring Package have UIs that are accessible and configurable. By default they are externally available behind an Istio installation.

### Storage
#### Alertmanager
Persistent storage values for Alert Manager can be set/modified in the Big Bang chart:

```yaml
monitoring:
  values:
    alertmanager:
      alertmanagerSpec:
        storage:
          volumeClaimTemplate:
            spec:
                storageClassName:
                accessModes: ["ReadWriteOnce"]
                resources:
                  requests:
                    storage: 50Gi
              selector: {}
```

#### Prometheus-Operator
Persistent storage values for Prometheus-Operator can be set/modified in the Big Bang chart:

```yaml
monitoring:
  values:
    prometheus:
      prometheusSpec:
        storageSpec:
          volumeClaimTemplate:
            spec:
                storageClassName:
                accessModes: ["ReadWriteOnce"]
                resources:
                  requests:
                    storage: 50Gi
              selector: {}
```

#### Grafana
Persistent storage values for Grafana can be set/modified in the Big Bang chart:

```yaml
monitoring:
  values:
    grafana:
      persistence:
        type: pvc
        enabled: false
        # storageClassName: default
        accessModes:
          - ReadWriteOnce
        size: 10Gi
        # annotations: {}
        finalizers:
          - kubernetes.io/pvc-protection
        # selectorLabels: {}
        # subPath: ""
        # existingClaim:
```

### Logging

Within the kube-prometheus-stack chart, you can customize both the LogFormat and LogLevel for the following components:
Note: within Big Bang, logs are captured by fluentbit and shipped to elastic by default.

#### Prometheus-Operator
LogFormat and LogLevel can be set for Prometheus-Operator via the following values in the Big Bang chart:
```yaml
monitoring:
  values:
    prometheusOperator:
      logFormat: logfmt
      logLevel: info
```

#### Prometheus
LogFormat and LogLevel can be set for Prometheus via the following values in the Big Bang chart:
```yaml
monitoring:
  values:
    prometheus:
      prometheusSpec:
         logFormat: logfmt
         logLevel: info
```

#### Alertmanager
LogFormat and LogLevel can be set for Alertmanager via the following values in the Big Bang chart:
```yaml
monitoring:
  values:
    alertmanager:
      alertmanagerSpec:
        logFormat: logfmt
        logLevel: info
```

#### Grafana
LogLevel can be set for Grafana via the following values in the Big Bang chart:
```yaml
monitoring:
  values:
    grafana:
      grafana.ini:
        log:
          mode: console
```

## Single Sign on (SSO)

SSO can be configured for monitoring through Authservice, more info is included in the following documentation:
[Monitoring SSO Integration](https://repo1.dso.mil/platform-one/big-bang/apps/core/monitoring/-/blob/main/docs/KEYCLOAK.md)

## Monitoring
Monitoring deployment has serviceMonitors enabled for
* core-dns
* kube-api-server
* kube-controller-manager
* kube-dns
* kube-etcd
* kube-proxy
* kube-scheduler
* kube-state-metrics
* kubelet
* node-exporter
* alert manager
* grafana
* prometheus
* prometheus-operator
* node-exporter

Note: Other packages are responsible for deploying Service Monitors for their components as needed.

### HA

High Availability can be accomplished by increasing the number of replicas for the deployments of Alertmanager, Prometheus and Grafana:

```yaml
monitoring:
  values:
    alertmanager:
      alertmanagerSpec:
        replicas:
    prometheus:
      prometheusSpec:
        replicas:
    grafana:
      replicas:
```

### Dependency Packages

When deploying BigBang, monitoring depends on gatekeeper and istio being installed prior.

```
  {{- if or .Values.gatekeeper.enabled .Values.istio.enabled }}
  dependsOn:
  {{- if .Values.istio.enabled }}
    - name: istio
      namespace: {{ .Release.Namespace }}
  {{- end }}
  {{- if .Values.gatekeeper.enabled }}
    - name: gatekeeper
      namespace: {{ .Release.Namespace }}
  {{- end }}
  {{- end }}
```


text:
### Introduction
[![WibmoPay PG SDK (Wibmo Pay)](https://img.shields.io/badge/sdk-Wibmo%20Pay-brightgreen.svg?style=flat-square)](https://github.com/mypoolin/mypoolin-sdk/wiki/Mypoolin-Payment-Gateway)

This is the documentation for integrating WibmoPaySDK payment gateway on your iOS app.
#### Features
+ UPI
+ Cards
+ Wallets
   - Paytm
   - Mobikwik

# Integration
## **WibmoPay PG Integration Steps in Swift-Xcode**
### Step 1.
Add this to your project **podfile** `pod WibmoPaySDK`.Minimum deployment target version for WibmoPaySDK is `9.0` and swift version `4.1` and WibmoPaySDK version is `0.1.8`.
### Step 2.
Go to terminals and go to project path and type `pod install`,By doing so WibmoPaySDK code is download to your project and you can invoke SDK methods as follow.
### Step 3.
Added the `import WibmoPaySDK`, Create a struct like below in your project controller(controller - where you would like to start calling SDK methods).
create struct xxxx : MerchantTxnProtocol{} ,then you would be asked to add Protocol methods and adding so your struct would look like as below.
```java
struct MerchantDetails: MerchantTxnProtocol {

    var merchantName: String

    var merchantKey: String

    var merchantCallbackUrl: String

    var merchantTxnAmount: String

    var merchantMessage: String

    var merchantTxnId: String

    var merchantPaymentOption: String

    var payerName: String

    var payerMobile: String

    var payerEmailId: String

    var buildEnv: BuildEnvironment
}
```
### Step 4.
---
## Request Code [SWIFT]
| Request Parameters| Type | Mandatory |
|:---|:---:|:---:|
| `"merchantName"`|String | Yes
| `"merchantAmount"`|String | Yes
| `"merchantTxnId"`|String | Yes
| `"merchantKey"`|String | Yes
| `"payerName"`|String | No
| `"payerMobileNo"`|String | No
| `"merchantMessage"`|String | No
| `"payerEmailId"`|String | No
| `"merchantPaymentOption"`|String | No
| `"callbackurl"`|String | Yes
---
### Step 5.
#### Merchant Details are passed to SDK as below.
```java
  let merchantDetails = MerchantDetails(merchantName: <YOUR-MERCHANT-ID>, merchantKey: <YOUR-MERCHANT-KEY>), merchantCallbackUrl: <YOUR-MERCHANT-CALLBACKURL>, merchantTxnAmount: <AMOUNT>, merchantMessage: <MESSAGE>, merchantTxnId: <UNIQUE-TRANSACTION-ID>, merchantPaymentOption: <PAYMENTOPTION>, payerName: <Name>, payerMobile: <MOBILE>, payerEmailId: <EMIAL ID>, buildEnv: <ENVINORMENT>).
```
### Example:
```java
let merchantDetails = MerchantDetails(merchantName: "test", merchantKey: "1f5abc6e46114094b7abdbbee19a5cb9", merchantCallbackUrl: "https://testpgupi.mypoolin.com/callback", merchantTxnAmount: "1", merchantMessage: "Test", merchantTxnId: merchantTxnId, merchantPaymentOption: "paytm,mobikwik,upi,cards", payerName: "Mypoolin", payerMobile: "9900456789", payerEmailId<EMAIL_ADDRESS>buildEnv:.staging)
```
#### Note:
- `buildEnv` can either be .staging or .production depending on your choice, based on the `buildEnv` base URL is set accordingly.

## Callback URL
The merchants are required to submit a redirection url to report the completion of the order. You can share your desired redirection url with our team on email - [`admin<EMAIL_ADDRESS>or [`help<EMAIL_ADDRESS>and we will configure it for you.

The returning checksum is calculated by using `username|order_id|merchant_txn_id|status|secret` and then creating a hash with `sha512` algorithm.
#### Example callback url can be as follow
- PRODUCTION callback URL `https://pgupi.mypoolin.com/callback`.
- TEST/STAGING URL `https://testpgupi.mypoolin.com/callback`.
- Merchant CUSTOM callback url should be - `https://<YOUR-DOMAIN-CALLBACK-URL>` (NOTE: if setting then it Should be notified to the integration/Business team [help@wibmopay.com]).

### Step 6.
#### Upadte merchant parameters and invoke transaction call as shown below
```java
  WibmoPaySdk.sdkManager.merchantDetails = merchantDetails
  WibmoPaySdk.sdkManager.performTransactionFor(fromController: self) { (response, error) in
            if let result = response {
                print(result.status) // example printing status
            } else if let error = error {
                print(error.localizedDescription)
            }
        }
```
 `performTransactionFor` call will internally do the following:
- check Internet(if not connected `Error` is thrown back to merchant app and merchant app can handle it accordingly).
- Generates checkSum using the request parameter.

## Response
| Response Parameters| Type | Mandatory |
|:---|:---:|:---:|
| `"merchant_name"` | String| yes
| `"order_id"` |String| yes
| `"merchant_txn_id"` |String| yes
| `"status"` |String| yes
| `"payment_mode"` |String| yes
| `"checksum"` |String| yes
| `"amount"` |String| yes
| `"commission"` |String| yes
| `"channel"` |String| yes

Response will be received to the controller class where your initiated the SDK methods.

## `Status` Code is as follow:
| STATUS CODES| Status| Description|
|:---|:---:|:---:|
|COMPLETED| Success| Success
|PENDING | |
|ABORTED | |
|FAILED  | |(for cases where there is error in creation)
|RETRIED | | (for cases where same merchant_txn_id is passed)
|DECLINED | |
|SETTLED | |

### Sample code for Response Handling:
We have added Completion Handler for receiving response and error from the SDK, Once transaction is completed control comes back to app and Merchant Response and Error is received to `performTransactionFor` method as shown below and Response and error can be handled by merchant accordingly, Below is the sample code to print the erorr and response:
```java
 WibmoPaySdk.sdkManager.performTransactionFor(fromController: self) { (response, error) in
            if let result = response {
                print(result.status) // example: we are printing status from the response.
            } else if let error = error {
                print(error.localizedDescription)
            }
        }
```
### Note.
Follow the below steps if any error/issues related to archiving
-  Go to root project and go to `Build Phase` and click on `+` symbol and select `New Run Script Phase` and the copy paste the below script inside `run script` before releasing the app to app store.
- link to find the script:
`http://ikennd.ac/blog/2015/02/stripping-unwanted-architectures-from-dynamic-libraries-in-xcode/`

#### For Integration reference a sample `WibmoPaydemo` app is pushed to GitHub with `wibmoPay` SDK integrated.

repository: mypoolin/WibmoPaySDK-iOS

repo_name: mypoolin/WibmoPaySDK-iOS


text:
---
hrs_structure:
  division: '1'
  volume: '2'
  title: '6'
  chapter: '46'
  section: 46-1.7
type: hrs_section
tags:
  - Government
menu:
  hrs:
    identifier: HRS_0046-0001_0007
    parent: HRS0046
    name: 46-1.7 Retention of emergency 911 recordings
weight: 3020
title: Retention of emergency 911 recordings
full_title: 46-1.7 Retention of emergency 911 recordings
---
**[§46-1.7] Retention of emergency 911 recordings.** Each county public safety answering point shall retain recordings of all emergency 911 telephone calls and radio dispatches for a period of not less than one year. [L 2005, c 192, §1]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# **Automating Genre Labeling With Classification Models**

by Matt Segall

### Overview

As a former professional musician, I've spent a lot of time thinking about what makes music "belong" to a certain genre. Musicians are known to argue tirelessly about subgenre, and perhaps give up entirely and declare genre a meaningless construct. Can a machine learning model learn to distinguish between musical genres? This philosophical inspiration led me to a more pratical problem of automatic the genre assignment process for new music submitted to Spotify's platform.

### Data

I began with a [dataset](https://www.kaggle.com/mrmorj/dataset-of-songs-in-spotify?select=genres_v2.csv) I found on Kaggle, of 50,000 songs pulled from Spotify's API over 15 different genres. That data set proved to be less succesful (more on that later), so I pulled a custom dataset through the API myself, with about 8,000 songs over eight genres.

### Process

I began building simple, out of the box models with most of the classifieds we were taught, and did not get great results. After digging into the data bit more, I concluded that the genres might be too similar for a basic protoype - dark trap and trap metal; techhouse and techno; trance and psytrance. There was very little variation in the features between genres. So how could I expect the model to distinguish a song’s genre?

 Instead of splitting hairs, I wanted to start off working with a dataset that contained much more easily differetiable genres. So, I went back and pulled a custom data set through our API of genres classical, country, electronic, hiphop, jazz, latin, pop and rock. These are certainly more major and distinct genres.

Now that I was feeling more confident in my dataset, I went forward with model selection, feature engineering, and hyperparameter tuning.

### Results

 Ultimately, an out of the box random forest model on my original features performed nearly as well as a tuned version with polynomial-transformed features, both achieving accuracies near 80%.

### Sources

Thank you to Jason LZP whose [post](https://levelup.gitconnected.com/extracting-and-analysing-spotify-tracks-with-python-d1466fc1dfee) on gitconnected really helped me navigate Spotify's API.

branch_name: refs/heads/main


text:
# Doctrine Migrations Task

[![Latest Stable Version](https://poser.pugx.org/soy-php/doctrine-migrations-task/v/stable)](https://packagist.org/packages/soy-php/doctrine-migrations-task) [![Total Downloads](https://poser.pugx.org/soy-php/doctrine-migrations-task/downloads)](https://packagist.org/packages/soy-php/doctrine-migrations-task) [![Latest Unstable Version](https://poser.pugx.org/soy-php/doctrine-migrations-task/v/unstable)](https://packagist.org/packages/soy-php/doctrine-migrations-task) [![License](https://poser.pugx.org/soy-php/doctrine-migrations-task/license)](https://packagist.org/packages/soy-php/doctrine-migrations-task)

## Introduction
This is a [Doctrine Migrations](https://github.com/doctrine/migrations) task for [Soy](https://github.com/soy-php/soy)

## Usage
Include `soy-php/doctrine-migrations-task` in your project with composer:

```sh
$ composer require soy-php/doctrine-migrations-task
```

Then in your recipe you can use the task as follows:
```php
<?php

$recipe = new \Soy\Recipe();

$recipe->component('default', function (\Soy\DoctrineMigrations\MigrateTask $migrateTask) {
    $migrateTask
        ->setBinary('../test/vendor/bin/doctrine-migrations')
        ->setCommandNamespace('migrations:')
        ->setConfiguration('../test/migrations.yml')
        ->setDbConfiguration('../test/db.php')
        ->setVerbose(true)
        ->run();
});

return $recipe;
```

repository: rskuipers/doctrine-migrations-task

branch_name: refs/heads/develop

repo_name: rskuipers/doctrine-migrations-task


text:
---
layout: post
title:  "Chess Embedding from lichess"
date:   2016-09-29
games:
- ilJjnzvT
- ZfLDSzYr
- tNTJjdFB
excerpt: "Tried the lichess embedding"
tag:
- Chess
- Dev
- Boooring
---

It's now possible to embed lichess games (any amount) at the front of the post with the post type. I tried to implement it with a custom tag like `{chess game_id}` but I think this is not supported by gh pages.

Now it works the following way:

Add this to the front matter (the cryptic stuff is the game id from a lichess game (the part between .org and /black: https://en.lichess.org/tNTJjdFB/black )

    games:
	- ZfLDSzYr
    - tNTJjdFB

It just works.

gha_language: HTML


text:
## Mocha Test Explorer and typescript
If you are using the Mocha Test Explorer extension for Visual Studio Code, and havn't configured it for typescript, you need to add the following to your settings.

Running the original (non-transpiled) sources directly by transpiling them on-the-fly using ts-node:
```
"mochaExplorer.files": "test/**/*.ts",
"mochaExplorer.require": "ts-node/register"
```

https://marketplace.visualstudio.com/items?itemName=hbenl.vscode-mocha-test-adapter

repository: continuemycoding/curve-interpolator

repo_name: continuemycoding/curve-interpolator


text:
# VolumeMovement

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**CutoverWindow** | **int32** | Time window in seconds for cutover. The allowed range is between 30 to 300 seconds. | [optional] [default to null]
**DestinationAggregate** | [***DiskAggregates**](disk_aggregates.md) |  | [optional] [default to null]
**PercentComplete** | **string** | Completion percentage | [optional] [default to null]
**State** | **string** | State of volume move operation. PATCH the state to \"aborted\" to abort the move operation. PATCH the state to \"cutover\" to trigger cutover. PATCH the state to \"paused\" to pause the volume move operation in progress. PATCH the state to \"replicating\" to resume the paused volume move operation. PATCH the state to \"cutover-wait\" to go into cutover manually. Change of state is only supported if volume movement is in progress. | [optional] [default to null]
**TieringPolicy** | **string** | Tiering policy for FabricPool | [optional] [default to null]

[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

gha_license_id: NOASSERTION


text:
# The update policy

Does Maven always download from `remote` repositories even if an artifact is already available in the `local` repository? To answer this question correctly, we need to dig deep into how we define `remote` repositories in Maven.

Remote repositories can be further divided into three: `release`, `snapshot`, and `plugin`.

- A `release` repository holds artifacts that have a fixed version. An artifact with the given `groupId` , `artifactId` , and `version` tags (`GAV` coordinates) is **the same all the time**. The following is an example of a released dependency. If you download this dependency today and then again in a month, both will be the same artifact:

```xml
<dependency>
    <groupId>com.googlecode.json-simple</groupId>
    <artifactId>json-simple</artifactId>
    <version>1.1</version>
</dependency>
```

- A `snapshot` repository holds artifacts that have a special version, which ends with `SNAPSHOT`. Any artifact that has the `SNAPSHOT` version **can change over time**. What you download from the repository might not be the same if you download it again in a month. The following is an example of a `SNAPSHOT` dependency. You add a `SNAPSHOT` version to the project artifacts, which are still under development. As a convention, the version to be released will be postfixed by the keyword `SNAPSHOT`:

```xml
<dependency>
    <groupId>org.apache.axis2</groupId>
    <artifactId>axis2-kernel</artifactId>
    <version>1.7.0-SNAPSHOT</version>
</dependency>
```

A `plugin` repository is a remote repository that holds plugins. A plugin repository can be a `release` repository or a `snapshot` repository.

Repositories that are defined in the super POM file are shown in the following configuration. Here, it's the same repository that acts as the `release` repository as well as the `plugin` repository. If we set `<snapshots><enabled>true</enabled></snapshots>`, then the corresponding repository is treated as a `snapshot` repository(我的疑问：应该是指即作为release repository，也作为snapshot repository吧？); if set to `false`, then it's a `release-only` repository:

```xml
  <repositories>
    <repository>
        <id>central</id>
        <name>Central Repository</name>
        <url>https://repo.maven.apache.org/maven2</url>
        <layout>default</layout>
        <!-- 关注点 -->
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </repository>
  </repositories>

  <pluginRepositories>
    <pluginRepository>
        <id>central</id>
        <name>Central Repository</name>
        <url>https://repo.maven.apache.org/maven2</url>
        <layout>default</layout>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
        <!-- 关注点 -->
        <releases>
            <updatePolicy>never</updatePolicy>
        </releases>
    </pluginRepository>
  </pluginRepositories>
```

Let's get back to our original question: does Maven always download artifacts from `remote` repositories, even if an artifact is already available in the `local` repository? This relies on the repository configuration. In the preceding code snippet from the super POM file, you will find the following under the `pluginRepository` section:

```xml
<releases>
    <updatePolicy>never</updatePolicy>
</releases>
```

The updatePolicy element can carry any of the values from `always`, `daily`, `interval:X`, or `never`. In this case, it is set to `never`, which means that the artifacts from this repository will be downloaded only if they are not available in the `local` repository. This is a perfectly valid configuration for a `release` repository. If this is a `snapshot` repository, then it won't work, and you might have to work with stale artifacts. For a `snapshot` repository, you have to set the value to `always`, `daily` or `interval:X`.

The `always` value means that Maven will always download the artifacts in every build. If the `updatePolicy` element says `daily`, then Maven will download the artifacts from the remote repository only once for a given day during the build. It compares the metadata associated with the `local` POM file with the remote one to see which has the latest timestamp. If the value is set to `interval:X` where `X` is an integer value in **minutes**, Maven will download the artifact only after this time interval.

The default value of the `updatePolicy` configuration is `daily`.

repository: lsieun/learn-Maven

repo_name: lsieun/learn-Maven


text:
# tadasknieza.com

[![Netlify Status](https://api.netlify.com/api/v1/badges/3351cba0-7fcf-4e3f-8415-11dc4e3c04b1/deploy-status)](https://app.netlify.com/sites/tknieza/deploys)

My personal website running on React and Node.js. Deployed using Netlify.

# Note

I've made my website open source for your inspiration, motivation, and curiosity. I encourage you to be creative and create unique, custom designs and content.

## Installation

Clone this repository to start tinkering around.

```bash
git clone https://github.com/tknieza/tadasknieza.com.git
```

## Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

## License

All my code is [MIT](https://choosealicense.com/licenses/mit/) licensed. External tools and libraries follow their respective licenses.


text:
# Conditional blocks

0 is true, any other value is false.

## Exit codes

* value between 0 - 255
* 0 is success, 1 default value for failure
* `true` and `false` are two commands that do nothing, but return exit codes 0 and 1 respectively.
* `$?` to get the previous foreground command exit status.
* `exit [exit_code]` built-in. returns exit code from script.

```Bash
true
echo $?

false
echo $?
```

## Standard exit codes

| Exit code | description                   |
| --------- | ----------------------------- |
| 0         | success                       |
| 1         | failure                       |
| 2         | shell builtin incorrect usage |
| 126       | command cannot execute        |
| 127       | command not found             |
| 128       | incorrect exit code argument  |
| 128 + num | fatal error signal "num"      |
| 130       | script killed with Ctrl + C   |
| 255*      | Exit code out of range        |

## If

`if-elif-else` statements can be nested

```Bash
# if syntax
# statements are executed if the expression evaluates to true which is 0
if expression
then
  # statements to be executed when expression returns true
else
  # statements to be executed when expression returns false
fi

# example
if true
then
  echo "hello"
fi

# using arithmetic expressions
if (( 10 > 5 ))
then
  echo "hello"
fi

# multiple conditions syntax
if expression_1
then
  # statements
elif expression_2
then
  # statements
else
  # statements
fi
```

## `case` statement

searches in order, executes first matching pattern. **globs**(wildcards and extended globs set using shell option) can be used in **pattern matching**.

```Bash
# Syntax
case variable in
pattern1)
  # statements
  ;;
pattern2|pattern3)
  # statements
  ;;
*)
  # statements
  ;;
esac
```

## Select

Uses `PS3` variable to print its prompt. Prompts user to make decision.User enters a number starting from 1 till the number of items in the values to be selected. Executes in loop till break keyword.

```Bash
# Syntax
# PS3="Prompt title here"
# select variable in value1, value2.... valueN
# do
#   # statements
#   break
# done

PS3="Select the fruit you like: "
fruits=("apple" "mango" "pineapple" "orange" "exit")
select fruit in "${fruits[@]}"
do
  if [[ $fruit == "exit" ]]
  then
    echo "Exiting..."
    break
  fi
  echo "Favorite fruit is : $fruit"
done
```

## Conditionals

| condition | descriptions                                                                                |
| --------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| !         | Negates a test or exit status                                                                                |
| `[ ]`     | tests expression in brackets and returns true or false. shell builtin. consider it obselete. same as the **test** builtin. Offers portability |
| `[[ ]]`   | tests expression in brackets and returns true or false. more flexibility than `[]`. Affects portability since POSIX doesnot support this      |

## Differences between `[ ]` and `[[ ]]`

* Within `[ ]`, variables should be quoted.
* Values should be escaped within `[ ]`
* `[ ]` uses `-a` for logical `AND` and `-r` for logical `OR` while `[[ ]]` can use `&&` and `||`
* `[[ ]]` can perform pattern matching using `=` operator and regular expression matching using `=~` operator.

**NOTE**: `[ ]` is a sh `test`. it is obsolete. Always use `[[ ]]` in bash scripting. `help test` gives notes on various tests available.

## Arithmetic tests

Comparison operators

* `-eq` - equals
* `-ne` - not equals
* `-lt` - less than
* `-le` - less than or equal to
* `-gt` - greater than
* `-ge` - greater than or equal to

## String tests

* `-z` - true if string is empty
* `-n` - true if string is not empty
* `string1 = string2` - equals
* `string1 == string2` - equals
* `string1 != string2` - not equals
* `string1 < string2` - lexicographic comparison
* `string1 > string2` - lexicographic comparison
Bash specific regex string comparison
* `string1 =~ string_regex` - regex equals

```Bash
msg="hello"

# ! negate the test espression result
if [[ ! -z $msg ]]
then
echo "message is not empty"
fi

# () group expressions, causing change in precedence.
if [[ ( cond1 && cond2 ) || cond3 ]]
then
# statements
fi
```

## File tests

Commonly used file tests are listed below. For more tests turn to the reference book.

* `-e FILE` - true if file exists
* `-f FILE` - true if exists and regular file
* `-d FILE` - true if FILE exists and is a directory
* `-p FILE` - true if FILE exists and named pipe file
* `-S FILE` - true if FILE exists and socket file
* `-h FILE` - true is FILE exists and is symbolic link
* `-O FILE` - true FILE exists and owned by currently logged in user (user whose context the BASH is executing)
* `-G FILE` - true if exists and owned by group of bash user
* `-r FILE` - true exists and readable by bash user
* `-w FILE` - true if exists and writable
* `-x FILE` - true if exists and executable
* `-s FILE` - true if exists and nonempty
* `FILE2 -nt FILE2` - newer than
* `FILE1 -ot FILE2` - older than

## Logical tests

Only supported inside `[[ ]]`

* `expr1 && expr2` - logical `AND`
* `expr1 || expr2` - logical `OR`

## Pattern tests

Only supported by `[[ ]]`

* `string = glob_pattern` or `string == glob_pattern` - true if string matches pattern
* `string =~ regex_pattern` - true if string matches **regex pattern**.

### Character classes for pattern matching

Syntax - `[[:class_name:]]`

| class  | description                 |
| ------ | --------------------------- |
| alnum  | alpha and digit             |
| alpha  | lower and upper             |
| ascii  | ASCII characters            |
| blank  | space and tab               |
| cntrl  | control characters          |
| digit  | `[0-9]`                     |
| graph  | alnum and punct             |
| lower  | lowercase characers `[a-z]` |
| print  | alnum + punct + space       |
| punct  | punctuation characters      |
| space  | `' '`, `\t`, `\n`, `\r`     |
| upper  | `[A-Z]`                     |
| word   | alnum + `_`                 |
| xdigit | hexadecimal digits          |

```Bash
# Syntax
# [[:class:]]
msg="Hello"

# check if every characters in the message is alphabet
for ((i=0; i<=${#msg}; i++))
do
  if [[ ${msg:$i:1} == [[:alpha:]] ]]
  then
    echo "Current character is a alphabet"
  fi
done
```

## Miscellaneous

* `-o OPT` - true if the shell option is set (option that was set using the **set builtin** and not using **shopt builtin**).

* `-v VAR` - true if shell variable is set.

```Bash
# Other options that can be set using set buitlin
# `help set` for more information on options that can be set using the **set** shell buitlin.
if [[ -o braceexpand ]]
then
  echo "braceexpand option is set"
fi

if [[ -v BASH_VERSION ]]
then
  echo "$BASH_VERSION"
fi
```

---

## References

* [Bash Guide by Joseph Deveau](https://www.amazon.in/BASH-Guide-Joseph-DeVeau-ebook/dp/B01F8AZ1LE/ref=sr_1_4?keywords=bash&qid=1564983319&s=digital-text&sr=1-4)
* [Arithmetic expressions with if](https://stackoverflow.com/questions/8304005/how-do-i-do-if-statement-arithmetic-in-bash)
* [Difference between \[ \] and \[\[ \]\]](https://stackoverflow.com/questions/3427872/whats-the-difference-between-and-in-bash)
* [Character classes and bracket expressions](https://www.gnu.org/software/grep/manual/html_node/Character-Classes-and-Bracket-Expressions.html)

gha_language: Awk


text:
# Changelog

## 0.4.0

* Enchantments
	* Add `addr` flag to support (un)serialize with (addr, byte) style
	  blobs

Changes

- Code generation now happends inline, and `mix cgen` task is removed
- Configuration now accepts both proplists and maps
- Move `vsn` argument in `Tinymesh.Config.serialize` into `opts` map
- Rename various configuration fields

repository: tinymesh/tm-proto-elixir

repo_name: tinymesh/tm-proto-elixir


text:
# Distributed Map/Reduce framework
It is framework, which you can easily use for Map/Reduce model. As C++ is compiled language, so it is not easy to spread code
among multiple computers. It is done by the use of shared library and polymorphism, so user need just to implement map, reduce
functions and serialization of used types (all primitive types are available). Moreover, on each computer data is processed
concurrently.

## Table of contents
 - [Dependencies](#requirements)
 - [Installing](#installing)
 - [Usage](#usage)
 - [Contributors](#contributors)

## Dependencies

For using this utility you need to have next third-pary libraries
- Libssh
- Boost (System, Filesystem, Program options)

In ubuntu you can easily intall them using next command:
```sh
sudo apt install libssh-dev libboost-all-dev
```

Also, Dockerfile is provided with preinstalled libraries. You can build it with command:
```sh
docker build . -t milishchuk/mapreduce
```

## Installing
```sh
mkdir build
cd build
cmake ..
make
make install
```
## Usage
This repo contains [example](https://github.com/RomanMilishchuk/distributed_map_reduce/tree/master/example), which you can use
for better understanding. We can divide implementing by next phases:

### Custom KeyValueType
If you need specific type for your data, you should implement `KeyValueType` interface with `void parse(const std::string&)`
and `std::string to_string() const` methods. Or you can use implemented primitives(char, int, double, long). Implement
custom `KeyValueTypeFactory` for this type.

### Map/Reduce
Implement `Map` and `Reduce` classes inherited by `map_base` and `reduce_base` interfaces.

### JobConfig
Implement function `std::shared_ptr<job_config> get_config()`, which will return config with `map`,`reduce` functions, and
Factories for `key_in`, `key_out`, `value_in`, `value_out`, `value_res`. For better understanding next diagram:
<pre>
                 map                     groupby                      reduce
key_in, value_in ==> key_out, value_out
key_in, value_in ==> key_out, value_out
key_in, value_in ==> key_out, value_out  ======> key_out, [value_out] =====> key_out, value_res
key_in, value_in ==> key_out, value_out
key_in, value_in ==> key_out, value_out
</pre>

### Shared library
Nextly, you need to make shared library with `std::shared_ptr<job_config> get_config()` function

### Run
You can use blocking `run_task_blocking` function or non-blocking `run_task`, which will return `std::future`. All data
to map nodes are read from files on corresponding computers.

### Preview
For quick enviroment setup you can use [run_example.sh](https://github.com/RomanMilishchuk/distributed_map_reduce/blob/master/run_example.sh)
script, which launchs 4 map nodes, reduce node and master node to which result will be returned.

## Contributors

Roman Milishchuk [@Midren](https://github.com/Midren)


text:
[docs](../../index.md) / [org.swiften.redux.core](../index.md) / [BatchAction](index.md) / [<init>](./-init-.md)

# <init>

`BatchAction(vararg actions: `[`IReduxAction`](../-i-redux-action.md)`)``BatchAction(actions: `[`Collection`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-collection/index.html)`<`[`IReduxAction`](../-i-redux-action.md)`>)`

An [IReduxAction](../-i-redux-action.md) that contains multiple other [IReduxAction](../-i-redux-action.md) instances that can be dispatched
individually.

gha_language: Kotlin


text:
# Basic Theme

This module is part of [TypiCMS](https://github.com/TypiCMS/Base), a multilingual CMS based on Laravel 5.

```
composer require webfactorybulgaria/theme-basic
```

in config/app.php:

before core add:
```
TypiCMS\Modules\Contacts\Shells\Providers\ModuleProvider::class,
TypiCMS\Modules\Slides\Shells\Providers\ModuleProvider::class,
TypiCMS\Modules\Partners\Shells\Providers\ModuleProvider::class,
```

after core add:
```
TypiCMS\Modules\ThemeBasic\Shells\Providers\ModuleProvider::class,
```

Run these commands in the CLI
```
php artisan vendor:publish
composer dump-autoload
php artisan migrate
php artisan db:seed --class=ThemeBasicSeeder
```

In gulpfile.js
cahnge
```
return gulp.src('resources/assets/less/public/master.less')
```
to
```
return gulp.src('resources/themes/basic/less/public/master.less')
```

then in the js-public section add
```
'node_modules/bootstrap/js/carousel.js',
```

run
```
gulp all
```

Change the permissions for public/uploads i.e.
```
chmod -R uog+w public/uploads
```

repository: webfactorybulgaria/Theme-Basic

repo_name: webfactorybulgaria/Theme-Basic


text:
---
uuid: 9d5a9718-6269-4166-aed6-49d40a2bb47a
layout: speaking
title: "Let's build a Serverless e-commerce from scratch!"
slug: 'lets-build-a-serverless-e-commerce-from-scratch'
date: 2022-05-26T10:00:00.000Z
author: Luciano Mammino
author_slug: luciano-mammino
header_img: null
status: published
language: en_US
presentation_language: en_US
meta_title: null
meta_description: null
event_name: "CityJS"
event_link: 'https://greece.cityjsconf.org/'
event_location: 'Cholargos Town Hall'
event_location_gps: "37.998063,23.800937"
event_city: 'Athens'
event_days: 'May 26, 2022'
is_workshop: true
slides_link: 'https://fth.link/sec'
video_link: ~
with: ~
---

What would you do if you had just invented a time machine?! I can give you an idea: what about setting up a business that allows people to travel back in time to attend some of the most iconic concerts in the history of rock music? Ok, I can give you something more, let's build this business together... on AWS, using Serverless technologies like Lambda, API Gateway and DynamoDB!

## Learnings

  - How to host a Single Page Application (SPA) on S3
  - How to write APIs with AWS Lambda and API Gateway
  - How to use DynamoDB to store the data for your APIs
  - How to process forms with AWS Lambda
  - How to publish messages (pub/sub) through SNS
  - How to store unit of works on SQS
  - How to create background workers with AWS Lambda
  - ... and a lot of other useful things, like:
  - Serverless Application Mode (SAM) and Cloudfront
  - AWS Roles, Policies and the security model in general
  - The AWS Command Line interface
  - Some bash tricks
  - Some other cool details about AWS and Serverless

## Pre-requisites

  - Entry level Knowledge of JavaScript/Node.js (just be comfortable with the basics)
  - Node.js installed (v16+):
  - Access to an AWS Account (yours or your company's one) where you can provision new resources (Lambda, DynamoDB, API Gateway, SQS, SNS)
  - The AWS CLI installed and configured
  - AWS SAM CLI installed


text:
# Anonymous Ident Engine

The anonymous ident engine allows you to quickly login without credentials.
This can be a useful timesaver during development.

The anonymous engine cannot be configured. It's always available under the name `anonymous`. It
grants the following access level:

* `anonymous` access level in production.
* `admin` access level in development mode.

When logging in, you do not have to pass credentials, and therefore may send `{}` or `null`.

repository: christopherobin/mage

repo_name: christopherobin/mage


text:
# Preparations

This topic describes the operations that you must complete before you can use Log Service to collect, transform, query, analyze, visualize, consume, or ship data or configure alert rules for data.

1.  Create an Alibaba Cloud account and complete real-name verification.

    For more information, visit the [Create Your Alibaba Cloud Account](https://account.alibabacloud.com/register/intl_register.htm) page.

2.  Activate Log Service.
    1.  Log on to the [Log Service console](https://sls.console.aliyun.com).
    2.  Activate Log Service as prompted.
3.  Before you call API operations, use SDKs, or use the command-line interface \(CLI\) to manage resources in Log Service, you must create an AccessKey pair.

    For more information, see [Obtain an AccessKey pair]().

4.  If you want to manage Log Service resources as a RAM user, you must create the RAM user and grant the required permissions to the RAM user.

    For more information, see [Create a RAM user and authorize the RAM user to access Log Service](/intl.en-US/Developer Guide/Access control RAM/Create a RAM user and authorize the RAM user to access Log Service.md).

5.  Create a Log Service project.

    For more information, see [Create a project](/intl.en-US/Preparation/Manage a project.md).

6.  Create a store.
    -   If you want to store log data, you must create a Logstore.

        For more information, see [Create a Logstore](/intl.en-US/Preparation/Manage a Logstore.md).

    -   If you want to store time series data, you must create a Metricstore.

        For more information, see [Create a Metricstore](/intl.en-US/Preparation/Manage Metricstores.md).

7.  Optional. Manage shards.

    For more information, see [Manage shards](/intl.en-US/Preparation/Manage shards.md).


text:
# pop - A quick android dialog building lib
[![License](https://img.shields.io/badge/license-Apache%202-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0) [![Android Arsenal](https://img.shields.io/badge/Android%20Arsenal-Pop-green.svg?style=true)](https://android-arsenal.com/details/1/3400)

![demo](https://github.com/00ec454/pop/blob/master/assets/pop.gif)

## Oneline of code and you have it.

```java
Pop.on(activity).with().title(R.string.title).body(R.string.body).show();
```

## How to include it in your project:

Add `compile 'com.vistrav:pop:2.3'` in your app's gradle.build file in `dependencies` section and that is it! Just like this.

```groovy
dependencies {
	compile 'com.vistrav:pop:2.3'
}
```

## Adding buttons and custom body
if you want to handle the button click, this is even more fun with naming and you can even have custom body of dialog.
```java
               Pop.on(this)
                    .with()
                    .title(R.string.title)
                    .icon(R.drawable.icon)
                    .cancelable(false)
                    .layout(R.layout.custom_pop)
                    .when(new Pop.Yah() {
                        @Override
                        public void clicked(DialogInterface dialog, View view) {
                            Toast.makeText(getBaseContext(), "Yah button clicked", Toast.LENGTH_LONG).show();
                        }
                    })
                    .when(new Pop.Nah() { // ignore if dont need negative button
                        @Override
                        public void clicked(DialogInterface dialog, View view) {
                            Toast.makeText(getBaseContext(), "Nah button clicked", Toast.LENGTH_LONG).show();
                        }
                    })
                    .show(new Pop.View() { // assign value to view element
                          @Override
                          public void prepare(View view) {
                            EditText etName = (EditText) view.findViewById(R.id.et_name);
                            Log.i(TAG, "etName :: " + etName.getText());
                            etName.setText("Test Name 123");
                          }
                     });
```

## You can contribute!
In case you think you have some improvement, please feel free do pull request your feature and I would be happy to include it. Let's make this Pop very easy to use and rich with features.

## Other Userful Libraries
#### Ask - Android runtime permissions make easy
[![Github](https://img.shields.io/badge/github-Ask-orange.svg)](https://github.com/00ec454/Ask) [![Android Arsenal](https://img.shields.io/badge/Android%20Arsenal-Ask-brightgreen.svg?style=flat)](http://android-arsenal.com/details/1/3465)

## License

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.


text:
# README
## This is the README for the "vscode-rjsx-client" extension
-------------------

#Installation
* Install extension with VS Code
* run gradle customBuild in rjsxlanguageserver folder
* make sure myinternet server is running
* open file what has rjsx extension OR select is as language from bottom right corner

# What's new 0.0.28
- Hovering over a component will show up some documentation, IF AVAILABLE
- SomeComponent.SomePartOfIt <--- WORKS!
- SomePartOfId <--- DOES NOT YET WORK!

repository: villematti/vscode-rjsx

repo_name: villematti/vscode-rjsx


text:
## Description:

Meant to startup a zookeeper node

#### Runtime options:

* __bash__:  allows you to jump in and check things out

#### Envrionment Variables

__ZK_ID__:  the ID of this particular server

__ZK_SERVERS__:  comma separated list of zookeeper IPS, e.g. zk01:2181,zk02:2181,zk03:2181,zk04:2181,zk05:2181

#### Volumes:

/var/lib/zookeeper:  inside the container, where the data and logs exists

repository: aglahe/docker-fun

repo_name: aglahe/docker-fun


text:
# Value-Noise
Both direct Java (in Processing) and shader generation of landscape/cloud textures using value noise

The file "basicValueNoiseShader.pde" contains the GLSL necessary to run from Processing.

Another file, "meshDeformNoiseShader.pde" renders a 3D landscape build from the noise generation.
It requires shader files from the "data" folder.

Example landscape generation:
https://youtu.be/JoQl_F_LYN0

repository: archive-for-processing/Value-Noise

repo_name: archive-for-processing/Value-Noise