text:
#PRU Speak encoding

> NOTE : The short forms used in this encoding doc are as follows :

>         C : constant (value is the constant specified)

>         V : variable (value is the address where variable V is located)

>         Arr[C] => V (since, the final value is address(Arr) + C, viz a variable).
  Note that V will be used instead of Arr[C] throughout the document.

>         Arr[V] : array indexed by variable V

(I should probably write how the variable stuff work here...
and also how the doc is structured)

##1. SET instruction
The SET instruction is of the form

```
SET x, y
```
where **x** (operand-1) can be either **V or Arr[v]** whereas **y** (operand-2) can be either **C, V, Arr[v]**.

The general function of this instruction is to set variable values.
(In some cases it is also used to create variables)

There are many possible ways a **SET** instruction can be used based on how we choose **x** and **y**
There are three possible opcodes (as given below) that handle all conditions of x, y.

> OPCODE used : 0x10 (16) to 0x12 (18)

###1.a ```SET V, C```

This is a 32 bit instruction. This instruction is the case when operand-1 is a **V or A[c]** and opernad-2 is a **constant (max 16 bit)**.

**opcode**

```c
0x10 (16)
```

**operation**
```
Sets the value of variable V to the 16 bit int value C.
If V has not been previously defined, it creates and assigns.
```

**encoding format** (each value separated by a comma takes one byte)
```c
OPCODE, VARIABLE, CONST-hi, CONST-lo

Byte3 : 0001-0000 : (OPCODE - Fixed)
Byte2 : VARIABLE  : (address of the variable V)
Byte1 : CONST-hi  : (MS-byte of constant C)
Byte0 : CONST-lo  : (LS-byte of constant C)

```

**Example**
```
coming soon :)
```

###1.b ```SET V1, V2```

This is a 32 bit instruction. This instruction is the case when operand-1 and operand-2 are either **V** (or Arr[c])

**opcode**

```c
0x11 (17)
```

**operation**
```
Sets the value of variable V1 to the value of variable V2.
If V1 has not been previously defined, it creates and assigns.
(give some more explanation? or put that in the examples? - I think in example is better)
```

**encoding format** (each value separated by a comma takes one byte)
```c
OPCODE, VARIABLE, unused, VARIABLE

Byte3 : OPCODE    : 0001-0001   (OPCODE - Fixed)
Byte2 : VARIABLE  : (address of the variable V1)
Byte1 : unused    : (unused)
Byte0 : VARIABLE  : (address of the variable V2)

```

**Example**
```
coming soon :)
```

###1.c ```SET x, y```

This is a **64 bit** instruction. This instruction is the case when either **x** (operand-1) or **y** (operand-2)
is of the form **Arr[v]**.

The possible forms of instructions :
```
SET V1, Arr[V2]
SET Arr[V], 280
SET Arr[V1], V2
SET Arr[V1], Arr[V2]
```

**opcode**

```c
0x12 (18)
```

**operation**
```
Sets the value of variable "x" to the value of "y"
If "x" is a variable (not Arr[v]) and has not been previously defined, it creates and assigns.
If "x" is of type Arr[v], and Arr has not been defined, it is an error.
```

**encoding format** (each value separated by a comma takes one byte)
```
OPCODE, OP_type , OP1.b, OP1.a
unused, unused  , OP2.b, OP2.a

(OP1 : x, OP2 : y)

Byte3 : OPCODE    : 0001-0010   (OPCODE - Fixed)
Byte2 : OP_type   : (operand type - since the operands can be of any type, this indicates what the operands are)
Byte1 : OP1.b     : (reserved for operator 1, actual value depends on OP_decider)
Byte0 : OP1.a     : (reserved for operator 1, actual value depends on OP_decider)

Byte4 : OP2.b     : (reserved for operator 2, actual value depends on OP_decider)
Byte5 : OP2.a     : (reserved for operator 2, actual value depends on OP_decider)
Byte6 : unused    : unused
Byte7 : unused    : unused

OP_Type (8 bits)

00  00  - 0000
\ / \ /   \  /
 x   y    unused

  bit 7,6 : type of operand x
  bit 5,4 : type of operand y

bit encoding that indicate what the corresponding operators are :
(and what they represent in the encoding in each case)

00 => C (Constant)
  OP.a : Const-lo
  OP.b : Const-hi

01 => V (Variable)
  OP.a : Variable address of V
  OP.b : unused

10 => Arr[V]
  OP.a : Variable address of V
  OP.b : Array address of Arr.

(add a simple example here)
```

**Example**
```
coming soon :)
```

##2. SET RES[] instruction

This instruction is of the form
```
SET RES[x], y
```
Where **RES** is a reserved array variable such as **DIO, PWM, COM, TMR, AIO**;

**x** can be either **C or V** where as **y** (operand-2) can be either **C, V, Arr[v]**.

This behaves like a regular SET instruction, but has been given special opcodes as :
  * These instruction use reserved arrays
  * They are used often, so giving exclusive byte code makes execution faster on the PRU
  * Normally these sort of instructions will take 64bits; whereas here all take only 32bits

Hence these inst are not compiled as a part of normal **SET** instruction.

> OPCODE used : 0x01 (1) to 0xFF (15)

###2.a ```SET DIO[x], y```

This is a 32 bit instruction. Here **x** and **y** can be either a Constant (C) or Vriable(V).

The possible forms of the instruction :

```
SET DIO[C], C
SET DIO[C], V
SET DIO[V], C
SET DIO[V], V
```

**opcode**
```c
0x01 (01)
```

**operation**
```
Sets the specified digital output to either high or low
(see more in the examples)
```

**encoding format**
```
OPCODE, OP_type, OP1, OP2

Byte3 : OPCODE    : 0000-0001   (OPCODE - Fixed)
Byte2 : OP_type   : (operand type - this indicates what type the operands are)
Byte1 : OP1       : (not exactly operand1, but rather 'x' in DIO[x])
Byte0 : OP2       : (operand2, (i.e.) "y"))

Note : actual value of OP1 and OP2 will depend on type of "x" and "y".
       and the type information is encoded in OP_type as given below.

OP_type (making sense of the 8 bits)

0 0 00-0000
| | \     /
x y  unused

  bit 7 - type of "x"
  bit 6 - type of "y"

semantics
  0 => type is constant C
  1 => type is Variable V

(add a simple example here)
```

**Example**
```
coming soon :)
```

###2.b ```SET DIO[C], Arr[V]```

This is a 32 bit instruction. Here first operand is **DIO** indexed by a Constant (C) and the second operand is a variable indexed Array (Arr[v]).

**opcode**
```c
0x02 (02)
```

**operation**
```
Sets the specified digital output to either high or low
(see more in the examples)
```

**encoding format**
```
OPCODE, CONST, Arr, VARIABLE

Byte3 : OPCODE    : 0000-0010   (OPCODE - Fixed)
Byte2 : CONST     : CONSTANT value C
Byte1 : Arr       : Array address
Byte0 : VARIABLE  : address of variable V

(add a simple example here)
```

**Example**
```
coming soon :)
```

###2.c ```SET DIO[V1], Arr[V2]```

This is a 32 bit instruction. Here first operand is **DIO** indexed by a Variable (V1) and the second operand is a variable indexed Array (Arr[v2]).

**opcode**
```c
0x03 (03)
```

**operation**
```
Sets the specified digital output to either high or low
(see more in the examples)
```

**encoding format**
```
OPCODE, VARIABLE, Arr, VARIABLE

Byte3 : OPCODE    : 0000-0010   (OPCODE - Fixed)
Byte2 : VARIABLE  : address of variable V1
Byte1 : Arr       : Array address
Byte0 : VARIABLE  : the array index value - variable value V2

(add a simple example here)
```

**Example**
```
coming soon :)
```

###2.d ```SET PWM[x], y```

This is a 32 bit instruction. Here **x** and **y** can be either a Constant (C) or Vriable(V).

The possible forms of the instruction :

```
SET PWM[C], C
SET PWM[C], V
SET PWM[V], C
SET PWM[V], V
```

**opcode**
```c
0x04 (04)
```

**operation**
```
Sets the specified PWM output to the mentioned value
(see more in the examples)
```

**encoding format**
```
Same as 2.a (change only opcode)
```

**Example**
```
coming soon :) - or see 2.a again?
```

###2.e ```SET PWM[C], Arr[V]```

This is a 32 bit instruction. Here first operand is **DIO** indexed by a Constant (C) and the second operand is a variable indexed Array (Arr[v]).

**opcode**
```c
0x05 (05)
```

**operation**
```
Sets the specified PWM output to the mentioned value
(see more in the examples)
```

**encoding format**
```
same as 2.a
```

**Example**
```
coming soon :)
```

###2.f ```SET PWM[V1], Arr[V2]```

This is a 32 bit instruction. Here first operand is **DIO** indexed by a Variable (V1) and the second operand is a variable indexed Array (Arr[v2]).

**opcode**
```c
0x06 (06)
```

**operation**
```
Sets the specified PWM output to the mentioned value
(see more in the examples)
```

**encoding format**
```
same as 2.a
```

**Example**
```
coming soon :)
```

###2.x AIO, TMR, COM Instructions

> Just like DIO & PWM, the above mentioned instructions have 3 opcodes for each of the following instruction type
  * SET RES[C], C/V
  * SET RES[C], Arr[V]
  * SET RES[V], Arr[V]

**Only** things that change are the **operation** and **OPCODE**. (encoding and examples are more or less the same)

####Operation
```
AIO : Sets the value of the anolog output
COM : Writes the value to the indexed com port.
TMR : Sets the timer value
```

####OPCODE
```
AIO : 0x07, 0x08, 0x09
COM : 0x0A, 0x0B, 0x0C
TMR : 0x0D, 0x0E, 0x0F
```

##3. IF instruction

This instruction is of the form
```
IF ( x <cond> y ) GOTO z
```
Where **x** (first operand), **y** (second operand), **z** (third operand) can be any of C, V, Arr[V].
Here <cond> is a relational operator such as '>', '<', '==', '!=' etc.

There is no different cases for this instruction, rather one **64 bit** instruction which handles all possible variable types internally.

**opcode**
```python
The **OPCODE** starts from 0x20 (0b0010-0000) and ends at 0x2F (0b0010-1111).
How this works is this instruction reserves the "0b0010-xxxx" instruction space.
The last 4 bits takes its value based upon <cond>. The mapping is as shown below.

cond_code = {
				'=='	: 0b0000,
				'!='	: 0b0001,
				'>='	: 0b0010,
				'<='	: 0b0011,
				'>'	: 0b0100,
				'<'	: 0b0101
	}

```

**operation**
```
The comparision is carried out between "x" and "y", if the result is true, then the IP (inst pointer) jumps to the inst number specified by "x"
```

**encoding**
```
OPCODE, OP_type, OP1.b, OP1.a
OP3.b ,	OP3.a,	 OP2.b, OP2.a

(x : OP1, y: OP2, z : OP3)

Byte3 : OPCODE    : 0001-0010   (OPCODE - Fixed)
Byte2 : OP_type   : (operand type - since the operands can be of any type, this indicates what the operands are)
Byte1 : OP1.b     : (reserved for operator 1, actual value depends on OP_decider)
Byte0 : OP1.a     : (reserved for operator 1, actual value depends on OP_decider)

Byte4 : OP2.b     : (reserved for operator 2, actual value depends on OP_decider)
Byte5 : OP2.a     : (reserved for operator 2, actual value depends on OP_decider)
Byte6 : OP3.a	  : (reserved for operator 3, actual value depends on OP_decider)
Byte7 : OP3.b     : (reserved for operator 3, actual value depends on OP_decider)

Note : actual value of OP1 and OP2 will depend on type of "x" and "y".
       and the type information is encoded in OP_type as given below.

OP_type (making sense of the 8 bits)

00  00  - 00  00
\ / \ /  \  /\  /
 x   y    z  unused

  bit 7,6 : type of operand x
  bit 5,4 : type of operand y
  bit 3,2 : type of operand z

bit encoding that indicate what types the corresponding operators are :
(and how they are placed in the byte encoding in each case)

00 => C (Constant)
  OP.a : Const
  OP.b : unused

01 => V (Variable)
  OP.a : Variable address of V
  OP.b : unused

10 => Arr[V]
  OP.a : Variable address of V
  OP.b : Array address of Arr.

(add a simple example here)
```

**Example**
```
coming soon :)
```

##4. WAIT instruction
This instruction is of the form
```
WAIT x
```
where **x** (the only operand) can be of type **C or V or Arr[v]**

This is a 32 bit instruction.

**opcode**
```c
0x14 (20)
```
**operation**
```
Executing this command will pause the execution of the running script for
"x" mili seconds. (The wait is non blocking - more about this later)
```
**encoding**
```
OPCODE, OP_type, OP.b, OP.a

since the operand can be any of three types, the OP_type will tell us the
type of "x" in the instruction.

The OP_type is encoded as follows

00  00 - 0000
\/  \       /
x    unused

bit value to type of OP ("x") mapping :
00 => OP is of type 'C'
  OP.a = Const
  OP.b = unused

01 => OP is of type 'V'
  OP.a = VARIABLE
  OP.b = unused

10 => OP is of type Arr[V]
  OP.a = VARIABLE
  OP.b = ARR

```

**examples**
```
coming soon :)
```

##5. GOTO instruction
This instruction is of the form
```
GOTO x
```
where **x** (the only operand) can be of type **C or V or Arr[v]**

This is a 32 bit instruction.

**opcode**
```c
0x15 (21)
```
**operation**
```
Executing this command will cause the IP (instruction pointer) to jump to instruction number "x"
```
**encoding**
```
OPCODE, OP_type, OP.b, OP.a

since the operand can be any of three types, the OP_type will tell us the
type of "x" in the instruction.

The OP_type is encoded as follows

00  00 - 0000
\/  \       /
x    unused

bit value to type of OP ("x") mapping :
00 => OP is of type 'C'
  OP.a = Const
  OP.b = unused

01 => OP is of type 'V'
  OP.a = VARIABLE
  OP.b = unused

10 => OP is of type Arr[V]
  OP.a = VARIABLE
  OP.b = ARR

```

**examples**
```
coming soon :)
```
##6. GET instruction
This instruction is of the form
```
GET x
```
where **x** (the only operand) can be of type **C or V or Arr[v]**

This is a 32 bit instruction.

**opcode**
```c
0x16 (22)
```
**operation**
```
Executing this command will return the value of "x"
```
**encoding**
```
OPCODE, OP_type, OP.b, OP.a

since the operand can be any of three types, the OP_type will tell us the
type of "x" in the instruction.

The OP_type is encoded as follows

00  00 - 0000
\/  \       /
x    unused

bit value to type of OP ("x") mapping :
00 => OP is of type 'C'
  OP.a = Const
  OP.b = unused

01 => OP is of type 'V'
  OP.a = VARIABLE
  OP.b = unused

10 => OP is of type Arr[V]
  OP.a = VARIABLE
  OP.b = ARR

```

**examples**
```
coming soon :)
```

##7. ARITHMETIC and BIT instructions
This instruction is of the form
```
INS x, y
```
where **INS** is a arithmetic or bitwise operation command;
**x** (operand1) and **y** (operand2) can be of type **C or V or Arr[v]**

There are **32 bit** and **64 bit** variations for each instruction.

**opcode**
> Each **INST** uses 2 opcodes (one for 32 bit encoding, another for 64 bit) based on what the **x**, **y** values are.
  opcode starts from 48 (0011-0000), ends at 79 (0100-1111). Bit excoding is done based on this
  map containing **INST** to the LS nibble value of the corresponding OPCODE.
  ```python
  opcode_dict = {
		#These inst own the (0011-XXXX) address space
					'ADD'	: 48,
					'SUB'	: 50,
					'MUL'	: 52,
					'DIV'	: 54,
					'MOD'	: 56,
		#These inst own the (0100-XXXX) address space
					'BSL'	: 64,
					'BSR'	: 66,
					'AND'	: 68,
					'OR'	: 70,
					'NOT'	: 72
	}
  ```

###7.a ADD V, y

This is a 32 bit instruction where **y** can be a variable or constant.

**opcode**
```c
0x30 (48)
```

**operation**
```
Executing this command will add y to V and return the new value of V
```

**encoding**
```
OPCODE, OP_type, VARIABLE, OP

Byte3 : OPCODE    : 0011-0000   (OPCODE - Fixed)
Byte2 : OP_type   : (operand type - since the operands can be of any type, this indicates what the operands are)
Byte1 : VARIABLE  : (the address of variable V)
Byte0 : OP        : (reserved for operator 1, actual value depends on OP_decider)

since the operand can be C or V, the OP_type will tell us the type of "y" in the instruction.
The OP_type (8bits) is encoded as follows :
1000 - 0000
 |
 y

if bit 6 == 0
  type(y) = C
  OP -> C

if bit 6 == 1
  type(y) = VARIABLE
  OP -> address of variable "y"
```

**examples**
```
coming soon :)
```

###7.b ADD x, y

This is a **64 bit** instruction where either **x** or  **y** is of type Arr[V]
Note that **x** can't be of type C, while **y** can be of any type.

**opcode**
```c
0x31 (49)
```

**operation**
```
Executing this command will add y to x and return the new value of x
```

**encoding**
```
OPCODE, OP_type , OP1.b, OP1.a
unused, unused  , OP2.b, OP2.a

(OP1 : x, OP2 : y)

Byte3 : OPCODE    : 0011-0001   (OPCODE - Fixed)
Byte2 : OP_type   : (operand type - since the operands can be of any type, this indicates what the operands are)
Byte1 : OP1.b     : (reserved for operator 1, actual value depends on OP_decider)
Byte0 : OP1.a     : (reserved for operator 1, actual value depends on OP_decider)

Byte4 : OP2.b     : (reserved for operator 2, actual value depends on OP_decider)
Byte5 : OP2.a     : (reserved for operator 2, actual value depends on OP_decider)
Byte6 : unused    : unused
Byte7 : unused    : unused

OP_Type (8 bits)

00  00  - 0000
\ / \ /   \  /
 x   y    unused

  bit 7,6 : type of operand x
  bit 5,4 : type of operand y

bit encoding that indicate what the corresponding operators are :
(and what they represent in the encoding in each case)

00 => C (Constant)
  OP.a : Const-lo
  OP.b : Const-hi

01 => V (Variable)
  OP.a : Variable address of V
  OP.b : unused

10 => Arr[V]
  OP.a : Variable address of V
  OP.b : Array address of Arr.

(add a simple example here)
```

**examples**
```
coming soon :)
```

###7.x SUB, MUL, DIV, OR, AND, BSL/R, NOT instructions

These instructions are similar to **ADD** discussed above. Each have two versions - 32bit and 64 bit version.
The opcode for the 32 bit version has been mentioned at the begining of section 7, the OPCODE for 64 bit is opcode for 32 bit + 1
The encoding pattern is the same, only thing that changes is the pattern
**operation**
```
SUB x, y : x = x - y,  return x
MUL x, y : x = x * y,  return x
DIV x, y : x = x / y,  return x
AND x, y : x = x & y,  return x
OR  x, y : x = x | y,  return x
BSL x, y : x = x >> y, return x
BSR x, y : x = x << y, return x
NOT x, y : x = ~y,     return x
```

##8. HALT instruction

Simple instruction with no operands

**opcode**
```c
0x7F (127)
```

**operation**
```
Executing this instruction halts an ongoing BotSpeak script in the PRU.
If no script is running, this instruction does nothing.
```

**encoding**
```
OPCODE, unused, unused, unused

Byte3   : OPCODE : 0111-1111 (fixed)
Byte2-0 : unused : unused
```

**examples**
```
coming soon
```

##9. ABORT, DEBUG, RUN, (END)SCRIPT instructions

These instructions are known as **control instructions**. They are not run on the PRU, rather are interpreted on the Linux side. (userspace python lib for now, may later be moved to the kernel)

**opcode**
```c
None - it is not compiled,
rather the compiler framework itself interprets the cmd and does the needful.
```

**operation**
```
ABORT	: kills the current script, all variables and arrays defined are freed.
DEBUG	: streams the PRU Speak variables and state to the userspace.
SCRIPT	: marks the starting of a script.
ENDSCRIPT : marks the ending of a script.
RUN	: runs the most recently defined script.
```

**encoding**
```
NO enccoding
```

**examples**
```
coming soon
```

repository: deepakkarki/pruspeak

gha_language: C

repo_name: deepakkarki/pruspeak


text:
---
title: A great source of startup ideas
description: Turn a bureaucratic process into a good experience
date: '2016-05-04T01:55:37.857Z'
categories: []
keywords: []
slug: /a-great-source-of-startup-ideas-6d34ac3d88bd
---

I hate bureaucracy. I believe **we all hate bureaucracy**.

I've been taught to look at systems and think of ways to improve them. And let me tell you, **there is so much that can be improved in terms of bureaucracy**.

<!--more-->

Every time I'm at the bank, I think about the different ways that they could improve the **customer experience**.

Every time I'm at the [AFIP](http://afip.gov.ar/) (the Argentine [IRS](https://www.irs.gov/)), I think about the many ways that they could **simplify** their processes to get more people to pay their taxes.

I believe that the best systems provide **good experiences**, which encourage and guide the people who use them.

If you are looking for your **next startup idea**, _scratch your own itch_. Think about all the bureaucratic processes that you have to go through every month.

How could you improve them? Could you build a [productized service](https://casjam.com/why-productized-service/) around a **shitty government process**? Sure!

What would it take for you to make my life a little easier? How could you **save people time** by doing the annoying tasks that we do every month?

I would be happy to pay up to **$50** for _every hour you help me save_. I bet there are a lot of people in the same position.

You can count on **bureaucracies** moving slow (usually **very very slow**) on their process upgrades, which will only reduce the risk of your business failing.

Please **build a startup that will reduce the burden of bureaucracy** and bring it to Argentina (you will make a lot of money)

license: MIT

branch_name: refs/heads/main

extension: markdown

gha_language: CSS

gha_license_id: MIT

license_type: permissive


text:
# Word Scramble Game

## Prerequisites

You must install following to run application:
* Java 8
* Play Framework - activator
* [MongoDB](https://www.mongodb.com/download-center?jmp=docs#community)

Note: mongodb need to install in order to restore database for application.

## Installing Project

### Import mongo database

First, Open command prompt -> input following:
>`mongorestore --db word_scramble --collection words --drop --dir <bson files>`

Note: **<bson files>** here is path of bson file. For example:
> `mongorestore --db word_scramble --collection words --drop --dir \db_resource\word_scramble\words.bson`

### Run application

Run the following command in currect project folder:
`activator run`

branch_name: refs/heads/master

extension: md


text:
# 001 - Yii goals and values

## Goals

The Yii project goals are to build and maintain:

- Great tools.
- Great community.

## Values

We share some common values that apply to what we do.

### Being helpful

It applies to both technical decisions and community. Community-wise we value any high quality contribution, be it a
pull request or elaborative answer at the forum.

When following principles conflict we choose solution that is more helpful to community.

### Simplicity

Solutions should be simple yet elegant:

- We add complexity where necessary and avoid it otherwise.
- We do not tolerate ugly solutions unless there is no other way.
- Less rules are better than more rules.

### Explicitness

We prefer explicit solutions and code.

For example:

- Straightforward solution is better than over-abstracted one. That is not an excuse not to abstract though.
- Typecasting is better than type coercion, type-hinting is better than no type hinting.
- No magic unless necessary.
- Loud fails are preferred to silent fails.

### Consistency

We try being consistent in everything:

- Code style.
- Naming.
- Design.
- Structure.

### Convention over configuration

We provide sensible defaults and conventions that one could customize via configuration.
That allows to achieve flexibility without sacrificing simplicity.

### Practice-orientation

We prefer practice over theory.

For example:

- Solutions for known use cases should not over-engineered for flexibility if practically there is no need for it.
- Standard implementations should take practical usage into account.
- Experiments are preferred to theories.

## Performance

We believe that software should perform efficiently in terms of both resources consumption and how fast one can achieve goals using it.

repository: yiijan/docs

repo_name: yiijan/docs


text:
+++
title = "aws_albs Resource"
platform = "aws"
draft = false
gh_repo = "inspec-aws"

[menu.inspec]
title = "aws_albs"
identifier = "inspec/resources/aws/aws_albs Resource"
parent = "inspec/resources/aws"
+++

Use the `aws_albs` InSpec audit resource to test the configuration of a collection of Application Load Balancers.

For additional information, including details on parameters and properties, see the [AWS documentation on Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/APIReference).

## Installation

{{% inspec_aws_install %}}

## Syntax

Ensure that an `aws_albs` exists

```ruby
describe aws_albs do
  its('load_balancer_arns') { should include 'arn:aws:elasticloadbalancing' }
end
```

## Parameters

This resource does not require any parameters.

## Properties

`load_balancer_names`
: The names of the load balancers.

`load_balancer_addresses`
: A collection of the load balancers addresses.

`canonical_hosted_zone_ids`
: The IDs of the Amazon Route 53 hosted zone for the load balancers.

`dns_names`
: The DNS names of the load balancers.

`availability_zones`
: The Availability Zones for the load balancers.

`security_groups`
: The security groups for the load balancers. Valid only for load balancers in a VPC.

`schemes`
: The types of load balancers. Valid only for load balancers in a VPC.

`states`
: The states of the load balancers.

`subnets`
: A collection of the subnet ids.

`types`
: The types of the load balancers.

`vpc_ids`
: The IDs of the VPCs for the load balancers.

`zone_names`
: A collection of the names of the availability zones.

## Examples

**Test that an ALB has its availability zones configured correctly.**

```ruby
describe aws_alb('arn::alb') do
  its('zone_names.count')  { should be > 1 }
  its('zone_names')        { should include 'us-east-2a' }
  its('zone_names')        { should include 'us-east-2b' }
end
```

## Matchers

This InSpec audit resource has no special matchers.

{{% inspec_matchers_link %}}

### exist

The control will pass if the describe returns at least one result.

Use `should_not` to test the entity should not exist.

```ruby
describe aws_albs do
  it                             { should exist }
  its('availability_zones')      { should_not include 'us-east-1a'}
end
```

## AWS Permissions

{{% aws_permissions_principal action="ElasticLoadBalancing:Client:DescribeLoadBalancers" %}}

You can find detailed documentation at [Authentication and Access Control for Your Load Balancers](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/load-balancer-authentication-access-control.html)

repository: inspec/inspec-aws

gha_language: Ruby

gha_license_id: NOASSERTION

repo_name: inspec/inspec-aws


text:
# Physcia orbicularis var. orbicularis VARIETY

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
in Poetsch & Schiederman, Engl. Bot. 247 (1872)

#### Original name
Psora orbicularis Baumg.

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# React-Semantic.UI-Starter

## Out-of-box:

![](https://github.com/Metnew/react-semantic.ui-starter/blob/for-gh/screen.gif)

## DEMO: [You can find it here](https://metnew.github.io/react-semantic.ui-starter/)

[![Build Status](https://travis-ci.org/Metnew/react-semantic.ui-starter.svg?branch=master)](https://travis-ci.org/Metnew/react-semantic.ui-starter)
[![codecov](https://codecov.io/gh/Metnew/react-semantic.ui-starter/branch/master/graph/badge.svg)](https://codecov.io/gh/Metnew/react-semantic.ui-starter)
[![David](https://img.shields.io/david/metnew/react-semantic.ui-starter.svg)]()
[![David](https://img.shields.io/david/dev/metnew/react-semantic.ui-starter.svg)]()
[![bitHound Overall Score](https://www.bithound.io/github/Metnew/react-semantic.ui-starter/badges/score.svg)](https://www.bithound.io/github/Metnew/react-semantic.ui-starter)
[![Known Vulnerabilities](https://snyk.io/test/github/metnew/react-semantic.ui-starter/badge.svg)](https://snyk.io/test/github/metnew/react-semantic.ui-starter)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
<!-- [![JavaScript Style Guide](https://cdn.rawgit.com/feross/standard/master/badge.svg)](https://github.com/feross/standard) -->
<!-- [![Code Climate](https://codeclimate.com/github/codeclimate/codeclimate/badges/gpa.svg)](https://codeclimate.com/github/codeclimate/codeclimate) -->

### What is it?
Production-ready, performance-first, optimized, robust, fully-featured boilerplate/example for your **new Progressive Web App**.

#### Lighthouse result - [you can find it here](https://googlechrome.github.io/lighthouse/viewer/?gist=cd19fc335d4dc2abfbba10ee550bd0c8)
SPOILER: 97/100. It might be better/worse in your browser.

#### DOMContentLoaded, and etc:
When app is cached with Service Workers:
<img src="https://github.com/Metnew/react-semantic.ui-starter/blob/for-gh/after-cached.png" />

#### Includes:

- **[React](https://facebook.github.io/react/)** and **[Redux](http://redux.js.org/)**
- **[React-Router v4(!)](https://github.com/ReactTraining/react-router)** + **[React-Router-Redux v5(!)](https://github.com/reactjs/react-router-redux)**
- **[JSON-server](https://github.com/typicode/json-server)** - mock db.
- **[Redux-thunk](https://github.com/gaearon/redux-thunk)** and **[Redux-Devtools-Extension](https://github.com/zalmoxisus/redux-devtools-extension)**
- **[Fetch polyfill](https://github.com/github/fetch)**
- **[Semantic-ui-react](http://react.semantic-ui.com/)** - UI components.
- **[Store2](https://github.com/nbubna/store)** - LocalStorage access.
- **[Webpack 2](https://webpack.js.org)**:
    - babel (stage-0),
    - **HMR**, devServer, hotMiddleware,
    - better code optimization with **[Babel React Optimize](https://github.com/thejameskyle/babel-react-optimize)**,
    - Remove unused css with **[purifycss-webpack](https://github.com/webpack-contrib/purifycss-webpack)**
- **[Jest](https://facebook.github.io/jest/)** and **[Enzyme](https://github.com/airbnb/enzyme)** - awesome libraries for testing.
- **[why-did-you-update](https://github.com/garbles/why-did-you-update)** and **[React-Addons-Perf](https://facebook.github.io/react/docs/perf.html)** for better performance optimization.
- **[Lodash](https://lodash.com/)** - is a dependency of Semantic-ui-react, but with tree-shaking you import in bundle only code that you use.
- **[Offline-plugin](https://github.com/NekR/offline-plugin)**, **[webpack-manifest-plugin](https://github.com/danethurber/webpack-manifest-plugin)** and **[preload-webpack-plugin](https://github.com/GoogleChrome/preload-webpack-plugin)** for your next progressive app.
- [And more tools for building and testing...](https://github.com/Metnew/react-semantic.ui-starter/blob/dev/package.json)

### Usage

#### Install:
```bash
git clone https://github.com/Metnew/react-semantic.ui-starter.git
cd react-semantic.ui-starter && rm -rf .git
npm install
```

#### Run:

```bash
npm run dev # run app in dev mode
npm run db  # run mock db for app(from another process)
```

#### Build:

```bash
npm run build # build app
npm run build:demo # build with process.env.BUILD_DEMO = true
```

It generates `dist` folder.

#### Test:

```bash
npm run test # run tests with Jest
```

### FAQ

#### Where are static assets?
You can store static assets (images, videos) in `/static` folder.

#### Where is manifest.json?
You can find it in `webpack_config/config.js`

#### Is SSR available?
It's under active development inside `/server` folder.

#### How it differs from other starters?
Performance-first.
**Main purpose - build highly customizable skeleton for PWA, with SSR, following best practices.**

#### Is it official starter from semantic-ui-react ?
No, (currently no, but maybe... :wink:).

#### "You have a components folder and containers folder..and in the container you have another components folder?"

Components inside `containers/**/components` are components that are required by container.

For example, `Dashboard`(container) has `DashboardComponent`(component). You can think about `DashboardComponent` as "Isolated component", it isn't used in app anywhere except own parent-container.

Components in components are components that:
1. Don't have own logic and connection with state (as opposite to containers)
2. Aren't "isolated".(!)

As your app's components will increase in size, it can be refactored to similar structure that implemented in - [semantic-ui-react]( https://github.com/Semantic-Org/Semantic-UI-React/tree/master/src).

#### Where are tests?
There are tests for actions and for reducers.
Each reducer/action has own folder, where you can find:
1. Reducer/action itself.
2. Tests for it.

#### How to write tests?
You can find [action testing example here.](https://github.com/Metnew/react-semantic.ui-starter/blob/dev/common/actions/auth/index.test.js)
It uses [redux-mock-store.](https://github.com/Metnew/react-semantic.ui-starter/blob/dev/common/actions/auth/index.test.js)

#### How Auth works?
Migration from React-Router v3 to v4 may cause some problems.
There is no `onEnter` props in `Route` component.

But we still can solve it:
1. Create [global routing object.](https://github.com/Metnew/react-semantic.ui-starter/blob/dev/common/routing/index.jsx#L9)
2. Create [RouteAuth](https://github.com/Metnew/react-semantic.ui-starter/blob/dev/common/components/RouteAuth/index.jsx) component that protects child component from unauthorized users.
3. Pass function that checks is user allowed to visit route as prop [in every `RouteAuth` component.](https://github.com/Metnew/react-semantic.ui-starter/blob/dev/common/routing/index.jsx#L52)
4. When RouteAuth renders [it calls that function.](https://github.com/Metnew/react-semantic.ui-starter/blob/dev/common/routing/index.jsx#L52)
5. As [`authCheck` function can call redux store](https://github.com/Metnew/react-semantic.ui-starter/blob/dev/common/components/Root/index.jsx#L19-L30), we can access redux's state before `Route` is rendered.
6. Profit!!!!!
7. We have access to redux state in function that allows `Route` to be rendered.
8. Also, there is a handler for [auth logic in App container.](https://github.com/Metnew/react-semantic.ui-starter/blob/dev/common/containers/App/index.jsx#L178-L184)

#### How built app looks?
**[Like this.](https://github.com/Metnew/react-semantic.ui-starter/tree/gh-pages)**

#### Your code doesn't follow Standard.js!
Yes, because of tabs.
You can remove `rules` property from `.eslinrc.json` and it will follow. Also eslint `--fix` is active, you can change it in `/webpack_config/webpack.base.js`

### Also:

[Unstable branch with **latest features.**](https://github.com/Metnew/react-semantic.ui-starter/tree/dev)

> Have a question? Ask it. :wink:

PRs, and issues are welcome :smiling_imp:

### Author
Vladimir Metnew<EMAIL_ADDRESS>
### LICENSE

MIT

gha_language: JavaScript


text:
# teamTacos
making an angular app to get better at angular tests and js

[ ![Codeship Status for orieken/teamTacos](https://codeship.com/projects/de5f3ca0-207c-0133-f5de-5ae45cb2c8e5/status?branch=master)](https://codeship.com/projects/95699)

[deployed here](http://teamtacos.herokuapp.com/)

## deps

* phanomjs
* express-generator
* karma

## install

```
npm install
```

## start server

```
npm start
```

## Todo

* add links to all packages used
* add build on codeship with status icon
* add tests :)
* add all deps that need to be installed before you can run it
* create deploy to heroku
* add mongodb?

## Reference

* [Writing Reusable AngularJS Components with Bower](http://briantford.com/blog/angular-bower)

repository: orieken/teamTacos

repo_name: orieken/teamTacos


text:
# Debugging

# https://github.com/rails/webpacker/pull/2018

To debug:
```sh
bin/shakapacker --debug-shakapacker
```

And put a debugger statement in the file you're editing.

Here's how to configure the customizations:

[Webpack Configuration](https://github.com/shakacode/shakapacker#webpack-configuration)

repository: shakacode/react-webpack-rails-tutorial

repo_name: shakacode/react-webpack-rails-tutorial


text:
---
sidebar_position: 1
---

# Docker and Telescope

## Introduction

Telescope uses Docker to deploy all the different parts of our app. If you haven't
worked with Docker before, it's worth taking a few minutes to [learn how it works](https://docs.docker.com/get-started/).

You'll see Docker used in a few places

## Setup

See the [environment setup doc](../getting-started/environment-setup.md) for info specific to your platform.

Once installed, Docker uses the following commands:

- [`docker`](https://docs.docker.com/engine/reference/commandline/cli/)
- [`docker-compose`](https://docs.docker.com/compose/reference/)

## Running Telescope via Docker

We have a number of docker-compose files that control all the apps that we ship:

- `docker-compose.yml` - the development version of our "classic" Telescope app (front-end and back-end)
- `docker-compose-production.yml` - the production version of our "classic" Telescope app (front-end and back-end)

We also have files for our new Microservices Back-end:

- `./src/api/docker-compose-api.yml` - the development version
- `./src/api/docker-compose-api-production.yml` - the production version

The docker-compose files define a set of separate servers and services that can
be run together with a single command.

```
# run our development version of the entire Telescope app, building any containers as necessary
docker-compose -f docker-compose.yml up --build

# stop the running containers
docker-compose -f docker-compose.yml down
```

If you want to run a specific app or apps, you can name them:

```
# run our development version of the entire Telescope app, building any containers as necessary
docker-compose -f docker-compose.yml up --build login redis telescope
```

### Running the Microservices

See the [docs for running the services](../getting-started/environment-setup.md).

repository: Seneca-CDOT/telescope

repo_name: Seneca-CDOT/telescope


text:
# Sudoku Solver

JavaFX GUI app used to solve the classic 9 by 9 puzzle game [Sudoku](https://en.wikipedia.org/wiki/Sudoku).

## Inspiration/Description

Sudoku is fun and all but... why not solve it faster. Using a recursive backtracking algorithm, this app can solve all solvable sudoku boards given the initial board input.

## Usage

### Setup

1. Download this zip folder.
2. Open the project in a text editor supporting Java and JavaFX GUI.
3. Run Solver.java in console, a new window GUI should pop up.

### GUI

The GUI should initially be a 9 by 9 board of '-'. Enter the board that you want to solve using entries of integers 1 through 9. Otherwise, the message board below the buttons will print bad input. An example use case below:

The solution appears when you click solve!

## Build With

Eclipse IDE version 4.10.0

JavaFX 12

JRE 1.8.0_191

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details.


text:
# Employee_Directory

## Description
This Web app was created with React to be an employee directory. This directory allows for the user to filter the employees by name, email, phone number, and DOB in ascending and decending order.

## Table of Content

- [Installation](#installation)
- [Usage](#usage)
- [Author](#author)
- [Images](#images)
- [Demo](#demo)
- [Copyright](#copyright)

### Installation

No Installation required

### Usage

Once you visit the webpage you can click the button by each category to order or type in the seach bar to filter employees.

### Live Webapp

Try it out for yourself at [Employee Directory](https://tranquil-reef-24088.herokuapp.com/)

### Licence

This project is licensed under the MIT- License

### Author

Zach Greenberg

### Images

![FullList](./img/list.jpg)

![filter](./img/filter.jpg)

### Demo

![Demo](./img/Employee_Directory.gif)

#### CopyRight

Copyright 2020 © Zach Greenberg


text:
gerrit-scripts
==============

This collection of Python scripts contains various utilities for interacting
with the Gerrit code review system (<https://code.google.com/p/gerrit/>).

Disclaimers:
 * The scripts have been written mainly for use in the Gromacs project
   (<http://www.gromacs.org>), and may contain some things or defaults that are
   specific to the Gromacs setup, but should be easy enough to generalize if
   necessary.
 * The scripts have been tested against Gerrit Code Review 2.9.1 and 2.13.3.

repository: teemumurtola/gerrit-scripts

repo_name: teemumurtola/gerrit-scripts


text:
---
title: Week 20
date: "2020-05-17T00:00:00+00:00"
description: "Pricing"
icon: "🏷"
published: true
---

**Pricing**

Your pricing page might be distracting your leads from becoming customers. How can we make this experience better?

Here a few things to keep in mind when designing a pricing page:
- List your prices
- Add the features available at each price point
- Include testimonials and/or recognizable logos
- Highlight the plan you really want people to buy
- Show off your free trial if you have one
- Add some security logos and/or a money-back guarantee
- Here’s Grammarly’s upgrade page:

Design a pricing page for an app or service - have fun!


text:
# Laravel GHTK

[![Latest Version on Packagist](https://img.shields.io/packagist/v/vanthao03596/laravel-ghtk.svg?style=flat-square)](https://packagist.org/packages/vanthao03596/laravel-ghtk)
[![GitHub Tests Action Status](https://img.shields.io/github/workflow/status/vanthao03596/laravel-ghtk/run-tests?label=tests)](https://github.com/vanthao03596/laravel-ghtk/actions?query=workflow%3Arun-tests+branch%3Amain)
[![GitHub Code Style Action Status](https://img.shields.io/github/workflow/status/vanthao03596/laravel-ghtk/Check%20&%20fix%20styling?label=code%20style)](https://github.com/vanthao03596/laravel-ghtk/actions?query=workflow%3A"Check+%26+fix+styling"+branch%3Amain)
[![Total Downloads](https://img.shields.io/packagist/dt/vanthao03596/laravel-ghtk.svg?style=flat-square)](https://packagist.org/packages/vanthao03596/laravel-ghtk)

To get the latest version, simply require the project using [Composer](https://getcomposer.org). You will need to install any packages that "provide" `psr/http-client-implementation` and `psr/http-factory-implementation`. Most users will want:

For example, to use Guzzle 7:

```bash
$ composer require "vanthao03596/laravel-ghtk" "guzzlehttp/guzzle:^7.2" "http-interop/http-factory-guzzle:^1.1.0"
```

Once installed, if you are not using automatic package discovery, then you need to register the `Vanthao03596\LaravelGhtk\GhtkServiceProvider` service provider in your `config/app.php`.

You can also optionally alias our facade:

```php
        'Ghtk' => Vanthao03596\LaravelGhtk\Facades\Ghtk::class,
```

## Configuration

Laravel GHTK requires connection configuration.

To get started, you'll need to publish all vendor assets:

```bash
$ php artisan vendor:publish
```

This will create a `config/ghtk.php` file in your app that you can modify to set your configuration. Also, make sure you check for changes to the original config file in this package between releases.

There are two config options:

##### Default Connection Name

This option (`'default'`) is where you may specify which of the connections below you wish to use as your default connection for all work. Of course, you may use many connections at once using the manager class. The default value for this setting is `'main'`.

##### Ghtk Connections

This option (`'connections'`) is where each of the connections are setup for your application. Example configuration has been included, but you may add as many connections as you would like.

## Usage

##### GhtkManager

This is the class of most interest. It is bound to the ioc container as `'ghtk'` and can be accessed using the `Facades\Ghtk` facade. This class implements the `ManagerInterface` by extending `AbstractManager`. The interface and abstract class are both part of my [Laravel Manager](https://github.com/GrahamCampbell/Laravel-Manager) package, so you may want to go and checkout the docs for how to use the manager class over at [that repo](https://github.com/GrahamCampbell/Laravel-Manager#usage). Note that the connection class returned will always be an instance of `Vanthao03596\GhtkSdk\Client`.

##### Facades\Ghtk

This facade will dynamically pass static method calls to the `'ghtk'` object in the ioc container which by default is the `GhtkManager` class.

##### GhtkServiceProvider

This class contains no public methods of interest. This class should be added to the providers array in `config/app.php`. This class will setup ioc bindings.

##### Real Examples

Here you can see an example of just how simple this package is to use. Out of the box, the default adapter is `main`. After you enter your authentication details in the config file, it will just work:

```php
use Vanthao03596\LaravelGhtk\Facades\Ghtk;
// you can alias this in config/app.php if you like

Ghtk::shipment()
    ->calculateFee([
        'pick_province' => 'Hà Nội',
        'pick_district' => 'Quận Hai Bà Trưng',
        'province' => 'Hà nội',
        'district' => 'Quận Cầu Giấy',
        'address' => 'P.503 tòa nhà Auu Việt, số 1 Lê Đức Thọ',
        'weight' => 1000,
        'value' => 3000000,
        'transport' => 'fly',
        'deliver_option' => 'xteam',
        'tags'  => [1]
    ]);
// we're done here - how easy was that, it just works!

Ghtk::order()->createOrder([
    'products' => [
        [
            'name' => 'bút',
            'weight' => 0.1,
            'quantity' => 1,
            'product_code' => '23304A3MHLMVMXX625'
        ],
        [
            'name' => 'tẩy',
            'weight' => 0.2,
            'quantity' => 1,
            'product_code' => ''
        ]
    ],
    'order' => [
        'id' => 'a9',
        'pick_name' => 'HCM-nội thành',
        'pick_address' => '590 CMT8 P.11',
        'pick_province' => 'TP. Hồ Chí Minh',
        'pick_district' => 'Quận 3',
        'pick_ward' => 'Phường 1',
        'pick_tel' => '0911222333',
        'tel' => '0911222333',
        'name' => 'GHTK - HCM - Noi Thanh',
        'address' => '123 nguyễn chí thanh',
        'province' => 'TP. Hồ Chí Minh',
        'district' => 'Quận 1',
        'ward' => 'Phường Bến Nghé',
        'hamlet' => 'Khác',
        'is_freeship' => 1,
        'pick_date' => '2016-09-30',
        'pick_money' => 47000,
        'note' => 'Khối lượng tính cước tối đa: 1.00 kg',
        'value' => 3000000,
        'transport' => 'fly',
        'pick_option' =>'cod',
        'deliver_option' => 'xteam',
        'pick_session' => '2',
        'tags' => [ 1],
        'email' =><EMAIL_ADDRESS>        'use_return_address' => 1
    ]
]);
// this example is simple, and there are far more methods available
```

The ghtk manager will behave like it is a `Vanthao03596\GhtkSdk\Client` class. If you want to call specific connections, you can do with the `connection` method:

```php
use Vanthao03596\LaravelGhtk\Facades\Ghtk;

// select the your_connection_name connection, then get going
Ghtk::connection('your_connection_name')shipment()
    ->calculateFee([
        'pick_province' => 'Hà Nội',
        'pick_district' => 'Quận Hai Bà Trưng',
        'province' => 'Hà nội',
        'district' => 'Quận Cầu Giấy',
        'address' => 'P.503 tòa nhà Auu Việt, số 1 Lê Đức Thọ',
        'weight' => 1000,
        'value' => 3000000,
        'transport' => 'fly',
        'deliver_option' => 'xteam',
        'tags'  => [1]
    ]);
```

With that in mind, note that:

```php
use Vanthao03596\LaravelGhtk\Facades\Ghtk;

// writing this:
Ghtk::connection('main')->order()->checkStatus('S1.A1.17373471');

// is identical to writing this:
Ghtk::order()->checkStatus('S1.A1.17373471');

// and is also identical to writing this:
Ghtk::connection()->order()->checkStatus('S1.A1.17373471');

// this is because the main connection is configured to be the default
Ghtk::getDefaultConnection(); // this will return main

// we can change the default connection
Ghtk::setDefaultConnection('alternative'); // the default is now alternative
```

If you prefer to use dependency injection over facades like me, then you can easily inject the manager like so:

```php
use Vanthao03596\LaravelGhtk\GhtkManager;
use Illuminate\Support\Facades\App; // you probably have this aliased already

class Foo
{
    protected $ghtk;

    public function __construct(GhtkManager $ghtk)
    {
        $this->ghtk = $ghtk;
    }

    public function bar()
    {
        $this->ghtk->order()->checkStatus('S1.A1.17373471');
    }
}

App::make('Foo')->bar();
```

For more information on how to use the `Vanthao03596\GhtkSdk\Client` class we are calling behind the scenes here, check out the docs at https://github.com/vanthao03596/ghtk-sdk, and the manager class at https://github.com/GrahamCampbell/Laravel-Manager#usage.

## Testing

```bash
composer test
```

## Changelog

Please see [CHANGELOG](CHANGELOG.md) for more information on what has changed recently.

## Contributing

Please see [CONTRIBUTING](.github/CONTRIBUTING.md) for details.

## Security Vulnerabilities

Please review [our security policy](../../security/policy) on how to report security vulnerabilities.

## Credits

- [phamthao](https://github.com/vanthao03596)
- [All Contributors](../../contributors)

## License

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.


text:
# REST API Plugin

The `restplugin` is a core Agent Plugin used of exposing REST API for the following:
* Run VPP CLI commands
* Exposes existing Northbound objects
* Provides logging mechanism so that the VPPCLI command and response can be searched in elastic search

## VPP CLI commands
```
curl -H "Content-Type: application/json" -X POST -d '{"vppclicommand":"show interface"}' http://<IP_ADDRESS>:9191/
```

## Exposing existing Northbound objects
```
curl http://<IP_ADDRESS>:9191/interfaces
curl http://<IP_ADDRESS>:9191/bridgedomainids
curl http://<IP_ADDRESS>:9191/bridgedomains
curl http://<IP_ADDRESS>:9191/fibs
curl http://<IP_ADDRESS>:9191/xconnectpairs
curl http://<IP_ADDRESS>:9191/staticroutes

curl -H "Content-Type: application/json" -X POST -d '{"swIndex":"0"}' http://<IP_ADDRESS>:9191/interface/acl
```
## Logging mechanism
The REST API request is logged to stdout. The log contains VPPCLI command and VPPCLI response. It is searchable in elastic search using "VPPCLI".


text:
# Pleurage neglecta (E.C. Hansen) C. Moreau, 1954 SPECIES

#### Status
SYNONYM

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

#### Published in
Encyclop. Mycol. 25: 248 (1954)

#### Original name
Sordaria neglecta E.C. Hansen, 1876

### Remarks
null

path: /life/Fungi/Ascomycota/Sordariomycetes/Sordariales/Lasiosphaeriaceae/Arnium/Arnium olerum/ Syn. Pleurage neglecta/README.md


text:
innerbuilder [![Build Status](https://travis-ci.org/analytically/innerbuilder.png)](https://travis-ci.org/analytically/innerbuilder)
============

[IntelliJ IDEA](http://www.jetbrains.com/idea/) plugin that adds a 'Builder' action to the Generate menu (Alt+Insert)
which generates an inner builder class as described in Effective Java.

Follow [@analytically](http://twitter.com/analytically) for updates.

![screenshot](screenshot.png)

```java
public class YourTypicalBean {
  private final String foo;
  private String bar, baz;
  private int qux;

  private YourTypicalBean(Builder builder) {
    foo = builder.foo;
    bar = builder.bar;
    baz = builder.baz;
    setQux(builder.qux);
  }

  private void setQux(int qux) {
    this.qux = qux;
  }

  public static final class Builder {
    private final String foo;
    private String bar;
    private String baz;
    private int qux;

    public Builder(String foo) {
      this.foo = foo;
    }

    public Builder(YourTypicalBean copy) {
      foo = copy.foo;
      bar = copy.bar;
      baz = copy.baz;
      qux = copy.qux;
    }

    public Builder bar(String bar) {
      this.bar = bar;
      return this;
    }

    public Builder baz(String baz) {
      this.baz = baz;
      return this;
    }

    public Builder qux(int qux) {
      this.qux = qux;
      return this;
    }

    public YourTypicalBean build() {
      return new YourTypicalBean(this);
    }
  }
}
```

### Installation

In IntelliJ IDEA 12 or later, go to `File` > `Settings` > `Plugins`. Click the `Browse repositories` button, in
the search field, type `innerbuilder`. It should show up in the plugins list. Right-click it and select `Download and Install`.

#### Manual installation

Copy `innerbuilder.jar` to your `~/.IntelliJIdea12/config/plugins` directory.

### Usage

Use `Shift+Alt+B` or `Alt+Insert` and select `Builder...`. Choose the fields to be included and press `OK`. When generating a
builder when a builder already exists, the plugin will try to update it. It will add missing fields and builder methods, but
never remove any fields or methods.

### Rate

If you enjoy this plugin, please rate it on it's [plugins.jetbrains.com page](http://plugins.jetbrains.com/plugin/7354).

### Building

Run `mvn package`. It will download IntelliJ IDEA Community Edition to unpack jars and use them to compile the plugin.

### License

Licensed under the [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0).

Copyright 2013-2014 [Mathias Bogaert](mailto:mathias.bogaert@gmail.com).


text:
## Logging Journald
by Lukas Zapletal [![](https://secure.travis-ci.org/lzap/logging-journald.svg)](https://travis-ci.org/lzap/logging-journald)

* [Homepage](http://rubygems.org/gems/logging-journald)
* [Github Project](https://github.com/lzap/logging-journald)

### Description

**Logging Journald** is a plugin for [logging gem](https://github.com/TwP/logging) - the flexible logging library for use in Ruby programs. It supports logging to system journal via journald-logger and journald-native gems.

### Installation

```
gem install logging-journald
```

The gem provides journald appender and noop layout that does no formatting since core library does not provide such a layout. Apppender options are:

* name - name of the appender (required)
* ident - optional log ident (appender name by default)
* layout - optional layout (no formatting by default)
* mdc - log mdc into custom journal fields (true by default)
* ndc - log ndc hash values into custom journal fields (true by default)
* facility - optional syslog facility rendered as SYSLOG_FACILITY (LOG_USER (8) by default)
* extra - extra custom journal fields as hash

All custom fields are converted to uppercase by joudnald automatically, for more details [visit official documentation](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html).

### Examples

Use MDC to send arbitrary key/value pairs to system journal:

```ruby
require 'logging'

log = Logging.logger['app']
log.add_appenders(Logging.appenders.journald('myservice'))

# use mapped diagnostic context to send custom fields
Logging.mdc['signed_user'] = 'Ondra'
log.debug "blah blah"
```

The example above will be rendered as:

```
# journalctl -o verbose
  MESSAGE=blah blah
  SYSLOG_FACILITY=8
  SIGNED_USER=Ondra
  PRIORITY=2
  SYSLOG_IDENTIFIER=myapp
  _PID=25979
  _TRANSPORT=journal
  _UID=1000
  _GID=1000
  _MACHINE_ID=xxx
  _HOSTNAME=xxx
  _BOOT_ID=xxx
  ...
```

Mapped diagnostic contexts are great for global values like logged user, request or session id. There are two more options to send arbitrary key/value pairs:

```ruby
require 'logging'

log = Logging.logger['app']
log.add_appenders(Logging.appenders.journald('myservice'))

# nested diagnostic context is a stack of values and
# it can be used but only hashes are taken into account
begin
  Logging.ndc << { exception: err, backtrace: err.backtrace }
  log.fatal "an exception occured"
ensure
  Logging.ndc.clear
end

# hash can be provided instead of string but in this case
# layout cannot be used to format message in the system journal
log.info message: "this must be called 'message'", akey: "a value"
```

There are some examples in the [examples folder](/examples).

### License

The MIT License - see the [LICENSE](/LICENSE) file for the full text.

repository: lzap/logging-journald

repo_name: lzap/logging-journald


text:
# Deploy Decision optimization model

 In this tutorial you will Save model for deployment, promote it to deployment space, create deployment and create a job with assets added to space.

### Step 1. Save and promote model for deployment

 - Click Scenario that you need to deploy. From tutorial2 we will use *PromotionSelection2* scenario and deploy it.Click on three dots and click **Save for deployment** Give it a name and description which is option for example: PromotionSelection
 - A message pops to view the model in project. Click on it and you will see the model under Watson Machine Learning section in assets tab.You can see the model type is docplex and engine is 12.10. Note that this will only use the optimization model. It does not export the data or visualization. We will give the data once we deploy the model.

 ![Step1](../images/Tutorial3-Step1.gif)

- You can look at the input and output schema. The next thing is to promote the model to deployment space. click Promote to deployment space. This is separate space from development. So data scientist can work in Watson studio and then can promote it to separate space.

 ![Step1](../images/Tutorial3-Step1a.png)

- Select deployment space Example: *Retail_Lab_deployment space* Click Promote.

![Step1](../images/Tutorial3-Step1b.png)

- Click on deploy icon on right for PromotionSelection under assets tab. It will take you to a screen where it ask to give it name example:*promotionOpti* select the hardware configuration from the dropdown menu and keep the node to 1 (this is to define execution in parallel) and click Create.

![Step1](../images/Tutorial3-Step1c.gif)

You can see the deployment id generated which can be used to call from application written in C++, java or python to call this model and execute it.

### Step 2. Add data to deployment space

- Click the *Retail_Lab_deployment space* on the top left side.

![Step2](../images/Tutorial3-Step2.png)

- Click the **Drop files here or browse files to upload** on the right side and go to [data folder]() and select all the files and upload. We add the data input and output files so that we can execute the model along with input tables and solution will be populated in the solution tables.

### Step 3. Create job to test deployment
- Click Deployment tab to go to the model that was deployed in step1.
![Step3](../images/Tutorial3-Step3.png)

- Click promotionOpti
![Step3](../images/Tutorial3-Step3a.png)

- To create the job Click Create Job button and follow the steps
![Step3](../images/Tutorial3-Step3b.gif)

- Click on Jobname and you should see a screen similar to the one shown below where it shows that job completed running in 13 seconds. One can click on the run and look at the log in details.
![Step3](../images/Tutorial3-Step3c.png)

** This is end of this lab **


text:
---
layout: post
title:  "Brainhack Zurich 2018"
date:   2018-10-24 09:00:00
big: 1
project_categories: Events 2018
image: BrainhackZurich_logo_466x180.png
description: Brainhack Zurich 2018 will take place from October 24-26 at ETH Zurich & University Hospital Zurich.
---
## Brainhack Zurich 2018

Location: ETH Zurich, University Hospital Zurich

URL: [http://www.brainhackzurich.ch/](http://www.brainhackzurich.ch/)

Description: Zurich's first independent Brainhack event, jointly hosted by the ETH and University of Zurich. We bring together free and open neuroscience enthusiasts from around central Europe for two days of talks, tutorials, and collaborative hacking.

Contact information<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>


text:
# DataTransferLibrary

* Data Transfer Library is a Java based console application which uses a server client based program that communicates via Sockets and is capable of transferring        any content across multiple machines or the same machine.
* Multiple content as it can accept and transfer any kind of file extension i.e text, PDF , MP4 , png/jpeg , cpp , java , exe , zip etc.
* For Data transfer we have used a server program and client program in which the server can send the data and the client can download the same data .
* The library will work very efficiently if both the client and the server program are working on the same computer but if multiple machine transfers are happening that is we are using two different computers then both of these computers need to be on the same network for the library to work.
* Features : The library is a high speed, real-time, scalable, secure, reliable data transfer library which can be used by cross platform applications.
* can run on both Mac & Windows based system
* downloaded file will have the same name as was in server
* uses AES for encryption and decryption
* works in case of connection loss or slow connection by server or client

*Run :*
1. The system that wants to send the file should run FileTransferServer.java the console will display the Ip address of the server needs to pass this to the client
2. The client side should run FileTransferClient.java with the server IP received from the server
3. In server system then select a file to be transferred
4. Then the file will be Downloaded on the client system

*Complete Documentation containing user manual , design description , features provided , Test & Results etc. is available in file "Documentation of DataTransferLibrary.pdf"*


text:
# dig-ilp-rankings

Formulates the ILP model using Gurobi with variables as the extractions. Finally selects the most possible extractions.

## Running the ILP Rankings

* Load Properties File:

```
properties = json.load(codecs.open('properties_non_cluster.json', 'r', 'utf-8'))
```

* Init ILP Extractions With Dictionaries

```
ilp_formulation = ilp_extractions.ILPFormulation({
    'city-country':properties['city_country'],
    'city-state':properties['city_state'],
    'state-country': properties['state_country'],
    'city_alt': properties['city_alt'],
    'city_all': properties['city_all']
    }
```

* Run ILP over knowledge_graph

```
ilp_formulation.formulate_ILP(knowledge_graph)
```

* The ILP code will modify the knowledge_graph object passed


text:
Cypherpunks,

It's that time again.  My next gala costume ball is March 14th.
You are invited.  The full invitation is at:

		http://www.c2.net/~sandy/98mar.htm

Please read the invitation carefully.  The devil is always in the
details.

This notice is being sent via the Cypherpunks Announce List.  If
you don't want to be on the list, DON'T e-mail me.  I can't get
you off the list.  To get off the list, send e-mail to:

<EMAIL_ADDRESS>
As the first line of the message, write:

		unsubscribe cypherpunks-announce

Hope to see you on the 14th.

Regards,

 S a n d y

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

{% endraw %}
```

## Thread

+ Return to [March 1998](/archive/1998/03)

+ Return to "[Sandy Sandfort <sandfort<span>@</span>crl.com>](/authors/sandy_sandfort_sandfort_at_crl_com_)"

+ 1998-03-03 (Mon, 2 Mar 1998 23:11:04 -0800 (PST)) - COSTUME BALL - _Sandy Sandfort<EMAIL_ADDRESS>


text:
## What is it?

This is a simple reimplementation of Google's [SparseHash](https://code.google.com/p/sparsehash/)
library intended as both a learning and teaching excercise.

## How do I use it?

Either copy `./include/simple_sparsehash.h` and `./src/simple_sparsehash.c` into
your project and start using them, or:

```
    make
    sudo make install
```

Then when you build your project just link to the shared library with
`-lsimple-sparsehash`.

## Tests

Just `make && ./run_tests.sh`.

## Differences between the official version

* Doesn't support many of the things that the official version does, like
  iterators, swapping, deletion, etc.
* There are no 'default values' of sparse arrays. You access something that
  isn't real? You get `NULL`.

## Eventual TODO

* Store actual items in the arrays, not pointers to items.
* Resize the table down when it reaches an inverse occupancy or something.
* Store object size in the dictionary, so that we can make assumptions about
  array size. Right now it accepts any value, and is slightly slower due to not
  having any locality of reference, and having to jump to an extra location in
  memory. Maybe two different versions?
* Be able to delete things from the hashtable
* Refactor the get/set/rehash methods. They've got some really similar code.
* Speed it up, it's currently pretty damn slow.

repository: qpfiffer/Simple-Sparsehash

repo_name: qpfiffer/Simple-Sparsehash


text:
# Akamai EdgeKV
Akamai Edge Key-Value (EdgeKV) is a low-latency, distributed key-value store built to complement EdgeWorkers. EdgeKV enables you to build data-driven JavaScript applications that require fast, frequent reads and infrequent writes. This repo contains the API documentation for EdgeKV, the helper library for EdgeWorker bundles, and utilities to make using the product easier. Joint EdgeWorker/EdgeKV code samples that implement various EdgeKV use cases can be found [here](https://github.com/akamai/edgeworkers-examples/tree/master/edgecompute/examples).

> :warning: **Warning!**
> Akamai customers are responsible for maintaining control over the data hosted on this service and for appropriately using the data returned by EdgeKV. EdgeKV does not support storage of sensitive information where the consequence of an unauthorized disclosure would be a serious business or compliance issue. Do not use sensitive information when creating namespaces, groups, keys, or values.

## Subfolder organization
* **/apis**: EdgeKV administrative API documentation for Tech Preview
* **/lib**: EdgeKV JS API helper library and documentation
* **/utils**: EdgeKV helper utilities

## Resources
For more information on EdgeWorkers, please refer to the following resources:
* [EdgeKV Product Documentation](https://techdocs.akamai.com/edgekv/docs)
* [EdgeKV API Guide](https://github.com/akamai/edgeworkers-examples/blob/master/edgekv/apis/readme.md)
* [EdgeKV Release Notes](https://techdocs.akamai.com/edgekv/changelog)
* [EdgeKV Command-Line Interface (CLI)](https://github.com/akamai/cli-edgeworkers/blob/master/docs/edgekv_cli.md)
* [EdgeKV Recipes](https://techdocs.akamai.com/edgekv/recipes/send-a-constructed-response-to-a-web-page)

## Reporting Issues
If you experience any problems, please raise a Github issue or create a pull request with fixes, suggestions, or code contributions.

repository: mruizm/edgeworkers-examples

repo_name: mruizm/edgeworkers-examples


text:
---
layout: default
---

# 1996-08-08 - Re: crypto CD source

## Header Data

From: Ray Arachelian<EMAIL_ADDRESS>To: Adam Back<EMAIL_ADDRESS>Message Hash: 3fa42c658c1997bfe1a695191cb935426814073593021c509be1c30898f01841

Message ID: \<Pine.SUN.3.91.960807140506.3525A-100000@dorsai\>

Reply To<EMAIL_ADDRESS>UTC Datetime: 1996-08-08 01:30:51 UTC

Raw Date: Thu, 8 Aug 1996 09:30:51 +0800

## Raw message

```
{% raw  %}From: Ray Arachelian<EMAIL_ADDRESS>Date: Thu, 8 Aug 1996 09:30:51 +0800
To: Adam Back<EMAIL_ADDRESS>Subject: Re: crypto CD source
In-Reply-To<EMAIL_ADDRESS>Message-ID: <Pine.SUN.3.91.960807140506.3525A-100000@dorsai>
MIME-Version: 1.0
Content-Type: text/plain

On Tue, 6 Aug 1996, Adam Back wrote:

>
> Cypherpunks archive?
>
> 	http://infinity.nus.sg/cypherpunks/
>
> The earlier archives were at www.hks.net, try mailing<EMAIL_ADDRESS>

I've a bunch of .gz files for the filtered cypherpunks list I run, they
should contain stuff as far back as last year.  How would I get these to
ya?

==========================================================================
 + ^ + |  Ray Arachelian |FL|       KAOS KERAUNOS KYBERNETOS      |==/|\==
  \|/  |sunder@dorsai.org|UL|__Nothing_is_true,_all_is_permitted!_|=/\|/\=
<--+-->| --------------- |CG|What part of 'Congress shall make no |=\/|\/=
  /|\  | Just Say "No" to|KA|law abridging the freedom of speech' |==\|/==
 + v + | Janet Reno & GAK|AK|        do you not understand?       |=======
===================http://www.dorsai.org/~sunder/=========================
 Key Escrow Laws are the mating calls of those who'd abuse your privacy!

{% endraw %}
```

## Thread

+ Return to [August 1996](/archive/1996/08)

+ Return to "[Adam Back <aba@dcs.ex.ac.uk>](/authors/adam_back_aba_at_dcs_ex_ac_uk_)"
+ Return to "[Ray Arachelian <sunder@dorsai.dorsai.org>](/authors/ray_arachelian_sunder_at_dorsai_dorsai_org_)"
+ Return to "[Remo Pini <rp@rpini.com>](/authors/remo_pini_rp_at_rpini_com_)"

+ 1996-08-05 (Mon, 5 Aug 1996 18:28:19 +0800) - [Re: crypto CD source](/archive/1996/08/a244ae16aa4d75f7c33bfd8b53d044163f96447b1eb76317d12006c70cfa8ed5) - _Remo Pini<EMAIL_ADDRESS>  + 1996-08-06 (Wed, 7 Aug 1996 07:13:15 +0800) - [Re: crypto CD source](/archive/1996/08/03692e12c56cb8f1a2e0805994890adaff0c7d5cb69e1f0067b5e4f92737efc0) - _Adam Back<EMAIL_ADDRESS>    + 1996-08-08 (Thu, 8 Aug 1996 09:30:51 +0800) - Re: crypto CD source - _Ray Arachelian<EMAIL_ADDRESS>


text:
---
layout: post
title: "The Bitcoin Journey"
date: 2020-06-15
blocktime: 634843
image: /assets/images/btc16-bitcoin-journey.png
source: https://medium.com/@dergigi/the-bitcoin-journey-e9d958b108e7
author: Gigi
category: bitcoin
tags:
 - Bitcoin
 - Writing
translations:
 - language: German
   url: https://medium.com/aprycotmedia/die-bitcoin-reise-dab572e5ff72
   author: Ge3onim0 & Fab
   author_url: https://twitter.com/ge3onim0
---

A couple of weeks ago I had the immense pleasure of giving the opening
talk at the *Value of Bitcoin* conference. I would like to revisit some
ideas of this talk and maybe dig deeper into some parts. After all, my
keynote [*The Bitcoin Journey*](https://youtu.be/qVuFX0LkNDQ) was
restrained by time: 21 minutes.

Again, I will look at the Bitcoin journey in two parts:

1.  The journey of a bitcoiner
2.  The journey of Bitcoin

{% include image.html name="002.png" %}

### Part 1: The Journey of a Bitcoiner

The natural reaction upon encountering Bitcoin for the first time is to
dismiss it. Most people reject the idea that Magic Internet Money could
work, or could be interesting, or could fix any woes that society might
have. Outright dismissal was my first reaction as well: "Oh, this will
never really work. It will get hacked one day and all your funny
internet money will be gone." Alas, at least I can find comfort in the
fact that I'm not alone with my initial reaction. While some bitcoiners
understood the gravity of the situation immediately, most of us mere
mortals had to be confronted with Bitcoin multiple times before we took
a closer look.

In short, the journey of a bitcoiner usually goes like this:

1.  This will never work.
2.  Why isn't it dead yet?
3.  Oh, this is interesting ...
4.   Up is down, down is up, a lot of
things don't make sense at first, and the longer you look at it the more
confusing it gets. However, there is some order to this chaos. It's just
not apparent at first.

{% include image.html name="mc-escher-relativity.jpg" %}

The reason for this initial confusion is, I believe, twofold. First,
Bitcoin is extremely interdisciplinary. It spans a lot of topics, even
if you just want to get a rudimentary understanding of it. You will
probably have to learn some cryptography (at least what the difference
between a public key and a private key is), some computer science (how
does a decentralized network differ from other computer systems), some
trading (where can I buy bitcoin and why does it have the price it
currently has), and some game theory (who controls Bitcoin and why is it
so hard to change or shut down) just to get started. Curiously, the
deeper you dig, the more disciplines will pop up: macroeconomics,
scalability, elliptic curve cryptography, monetary policy, the history
of money, the measure and study of scarcity, smart contracts,
programming and scripting languages, incentive structures, laws,
regulations, privacy, security, psychology, even biology. The list of
topics is practically endless.

This idea is quite beautifully illustrated by what I would call The
Bitcoin Flower ([Unchained
Capital](https://unchained-capital.com/blog/blockchain-spectrum/), 2017)
and The Bitcoin Learning Spiral ([Block
Tower](https://thecryptocurrencyinvestor.files.wordpress.com/2018/05/bt-educationpdf.pdf),
Ari Paul, 2018).

{% include image.html name="006.png" %}

{% include image.html name="007.png" %}

The downside of this multidisciplinary nature is that understanding
Bitcoin doesn't come easy. The upside is that many roads might lead you
to take a closer look at Bitcoin. In other words: many entries lead down
this particular rabbit hole. Whether you have a background in computer
science, finance, trading, cryptography, physics, economics, are a gold
bug, a classical liberal, or have flirted with the idea of
cryptoanarchy. All these backgrounds can give you a head-start.

What is interesting, though, is that so many people from so many
different backgrounds arrive at the same conclusion: bitcoin is the
money of the future. While the rabbit hole has many entries, in the end,
all roads lead to Bitcoin.

{% include image.html name="011.png" %}

### Part 2: The Journey of Bitcoin

Bitcoin is a zero-to-one invention. Before Satoshi invented Bitcoin,
real digital scarcity did not exist; the double-spending problem was
unsolved. Today, we live in a world where Bitcoin exists. More
importantly, we live in a world where bitcoin has value.

Thus, we can identify three stages:

-   Stage 0: Bitcoin does not exist.
-   Stage n: Bitcoin exists.
-   Stage N: bitcoin has value.

{% include image.html name="015.png" %}

Stage N is important because Bitcoin's underlying NgU technology
requires that bitcoin has some value. Once it acquires value --- any
value --- Bitcoin's eternal feedback loop kicks in.

{% include image.html name="017.png" %}

Satoshi alluded to this feedback loop in his writings.

> It might make sense just to get some in case it catches on. If enough
> people think the same way, that becomes a self fulfilling prophecy."
> --- [Satoshi
> Nakamoto](https://satoshi.nakamotoinstitute.org/emails/cryptography/17/)

Over the last couple of years all kinds of people ---
[artists](https://hodlr.rocks/satoshi-series/satoshi-rides-the-waves-of-change-series-of-10/),
researchers, quants, traders, commentators, in short: bitcoiners from
all walks of life --- noticed that Bitcoin seems to come in waves. In
2018, Hasu and Nic Carter published [Visions of
Bitcoin](http://fakehost/@nic__carter/visions-of-bitcoin-4b7b7cbcd24c),
describing the various competing narratives that were used to describe
Bitcoin up to this point: e-cash proof of concept, censorship-resistant
e-gold, cheap payments network, programmable shared database, anonymous
darknet currency, reserve currency for crypto, and finally: an
uncorrelated financial asset.

More recently, Plan B published his [Stock-to-Flow Cross Asset
Model](http://fakehost/@100trillionUSD/bitcoin-stock-to-flow-cross-asset-model-50d260feed12)
(S2FX) which identifies distinct clusters by looking at the
stock-to-flow and market value of bitcoin. He identified four distinct
clusters:

1.  Proof of Concept
2.  Payments
3.  E-Gold
4.  Financial Asset

{% include image.html name="021.png" %}

If the model holds, we are about to enter Phase 5. How Bitcoin will
manifest in this phase will be known only in hindsight.

Another analysis regarding the wavy nature of Bitcoin was done by
Unchained Capital, first published in 2018. Their [HODL
Waves](https://unchained-capital.com/hodlwaves/) beautifully show the
age distribution of the Bitcoin UTXO set. In essence, we can see that a
certain percentage of people choose to hold bitcoin for the long term,
i.e. for several years. They identified various HODL waves just by
looking at the UTXO age: the Genesis HODL, the HODL of 2011, and the
HODL of 2014. By looking at the most recent data we can also identify a
HODL of 2018.

{% include image.html name="026.png" %}

The most entertaining analysis is [this
video](https://youtu.be/XbZ8zDpX2Mg) by Alex Millar, published in 2015.
He is looking purely on price, showing how bitcoin tends to accrue value
in a massive run-up, only to crash down hard a short time later.
However, the price floor after the crash is usually way higher than the
previous low, resulting in an upwards trend in the long run.

These various phases and waves show that Bitcoin has a cyclical nature.
We already saw how demand, price, and security form an eternal feedback
loop. However, many different aspects of Bitcoin are cyclical. Adoption,
development, mining, difficulty adjustments, reward eras --- all of them
are cyclical. Granted, the halvings will stop in about 120 years, but
the other cycles will most likely continue.

### Part 3: Coming Full Circle

The essence of Bitcoin, the one thing that is truly unchanging, is the
output of the system: the UTXO set. Nodes work together to constantly
append it, verifying blocks and transactions, adding what is valid and
discarding what is invalid. The chain tip is the shared understanding of
all nodes: the version of the ledger which is most accurate and
up-to-date.

Similarly, people are building a shared corpus of knowledge and mental
models trying to figure out what Bitcoin is. Bitcoiners work together to
constantly add to the knowledge, incorporating what is valid and
meaningful, discarding what is invalid or doesn't make sense. Our shared
understanding of Bitcoin can be seen as a Schelling Point: the
conclusion that most people arrived at after intense study, often
without indoctrination or communication with others.

{% include image.html name="041.png" %}

A Bitcoin node doesn't trust what others are saying: it verifies all
data as best as it can. Similarly, most bitcoiners don't trust what
others are saying: they verify narratives and mental models as best as
they can.

Just like Bitcoin is a game without an end, falling down the Bitcoin
rabbit hole is a journey without an end. Bitcoin is an ever-changing,
organic system. It will evolve, as will our individual and collective
understanding of it. In other words: I believe that the reason why
no-one has found the bottom of the rabbit hole yet is that there is no
bottom. The rabbit hole is circular. In the coming years and decades,
many people will try to fully understand what Bitcoin is and what it
might become. But try as we might, I'm afraid a complete understanding
will never be gained. We will all have to find our peace with this alien
technology, or we are bound to walk in paradoxical circles around it in
our quest to full comprehension.

{% include image.html name="045.png" %}

In the end, if Bitcoin continues to be successful, it is bound to
disappear. Just like the internet and electricity before it, it will
move to the background, like running water in your home or the air you
breathe. Everyone will take Bitcoin for granted. Consequently,
bitcoiners will disappear. Just like today, you don't have to identify
as an "internet person" anymore, in the future, you won't have to
identify as a bitcoiner anymore. When this day comes, we will have
entered the final stage.

Stage O: Bitcoin is Omnipresent.

---

### Further Resources

- [Recording of the talk](https://youtu.be/qVuFX0LkNDQ) on YouTube
- [Slides](https://speakerdeck.com/dergigi/the-bitcoin-journey) on SpeakerDeck
- [21 Lessons](https://21lessons.com) aka my journey down the rabbit hole


text:
  react-colorful is a tiny color picker component for modern React apps.

## Features

- **Small**: Just 1,5 KB (minified and gzipped). [Size Limit](https://github.com/ai/size-limit) controls the size.
- **Fast**: Built with hooks and functional components only.
- **Bulletproof**: Written in strict TypeScript and covered by 20+ tests.
- **Simple**: The interface is straight forward and easy to use.
- **Mobile-friendly**: Works well on mobile devices and touch screens.
- **No dependencies**

## Live demos

- [Website](https://omgovich.github.io/react-colorful)
- [CodeSandbox](https://codesandbox.io/s/react-colorful-demo-u5vwp)

## Install

```
npm install react-colorful --save
```

## Usage

```js
import ColorPicker from "react-colorful";
import "react-colorful/dist/index.css";

const YourComponent = () => {
  const [color, setColor] = useState("#aabbcc");
  return <ColorPicker color={color} onChange={setColor} />;
};
```

## Supported color models

The default **react-colorful**'s input/output format is a HEX string (like `#ffffff`). In case if you need another color model, we provide 5 additional color picker bundles.

  How to use another color model

#### Available pickers

| Import path                  | Value example                | Size (gzipped) |
| ---------------------------- | ---------------------------- | -------------- |
| `"react-colorful/rgb"`       | `{ r: 255, g: 255, b: 255 }` | ~1,4 KB        |
| `"react-colorful/rgbString"` | `"rgb(255, 255, 255)"`       | ~1,5 KB        |
| `"react-colorful/hsl"`       | `{ h: 0, s: 0, l: 100 }`     | ~1,2 KB        |
| `"react-colorful/hslString"` | `"hsl(0, 0%, 100%)"`         | ~1,3 KB        |
| `"react-colorful/hsv"`       | `{ h: 0, s: 0, v: 100 }`     | ~1,2 KB        |

#### Code example

```js
import RgbColorPicker from "react-colorful/rgb";
import "react-colorful/dist/index.css";

const YourComponent = () => {
  const [color, setColor] = useState({ r: 50, g: 100, b: 150 });
  return <RgbColorPicker color={color} onChange={setColor} />;
};
```

[Live demo →](https://codesandbox.io/s/react-colorful-rgb-o9q0t)

## Overriding styles

The easiest way to tweak react-colorful is to create another stylesheet to override the default styles.

```css
.react-colorful {
  height: 250px;
}
.react-colorful__saturation {
  bottom: 30px;
  border-radius: 3px 3px 0 0;
}
.react-colorful__hue {
  height: 30px;
  border-radius: 0 0 3px 3px;
}
.react-colorful__saturation-pointer {
  border-radius: 5px;
}
.react-colorful__hue-pointer {
  border-radius: 2px;
  width: 15px;
  height: inherit;
}
```

[See examples →](https://codesandbox.io/s/react-colorful-customization-demo-mq85z?file=/src/styles.css)

## How to paste or type a color?

As you probably noticed the color picker itself doesn't include an input field, but don't worry if you need one. **react-colorful** is a modular library that allows you to build any picker you need. Since `v2.1` we provide an additional component that works perfectly in pair with our color picker.

  How to use HexInput

```diff
import ColorPicker from "react-colorful";
+import HexInput from "react-colorful/HexInput";
import "react-colorful/dist/index.css";

const YourComponent = () => {
  const [color, setColor] = useState("#aabbcc");
  return (
    <div>
      <ColorPicker color={color} onChange={setColor} />
+     <HexInput color={color} onChange={setColor} />
    </div>
  );
};
```

[Live demo →](https://codesandbox.io/s/react-colorful-hex-input-demo-0k2fx)

`HexInput` doesn't have any default styles, but accepts all properties that a regular `input` tag does (such as `className`, `placeholder` and `autoFocus`). That means you can place and modify this component as you like. Also, that allows you to combine the color picker and input in different ways.

By the way, `HexInput` is also minimalist-friendly — only 400 bytes gzipped.

## TypeScript Support

**react-colorful** supports TypeScript and ships with types in the library itself; no need for any other install.

  How you can get the most from our TypeScript support

While not only typing its own functions and variables, it can also help you type yours. Depending on the component you're using, you can also import the type that is associated with the component. For example, if you're using our HSL color picker component, you can also import the `HSL` type.

```ts
import HslColorPicker, { HSL }  from "react-colorful/hsl";

const myHslValue: HSL = { h: 0, s: 0, l: 0 };
```

Take a look at [Supported Color Models](#supported-color-models) for more information about the types and color formats you may want to use.

## Usage with Preact

**react-colorful** will work flawlessly with Preact out-of-the-box if you're using [Preact-CLI](https://github.com/preactjs/preact-cli), [NextJS with Preact](https://github.com/vercel/next.js/tree/canary/examples/using-preact), or a few other tools/boilerplates thanks to aliasing.

If you're using another solution, please refer to the [Aliasing React to Preact](https://preactjs.com/guide/v10/getting-started#aliasing-react-to-preact) section of the Preact documentation.

## Why react-colorful?

Today each dependency drags more dependencies and increases your project’s bundle size uncontrollably. But size is very important for everything that intends to work in a browser.

**react-colorful** is a simple color picker for those who care about their bundle size and client-side performance. It's fast and lightweight because:

- has no dependencies (no risks in terms of vulnerabilities, no unexpected bundle size changes);
- built with hooks and functional components only (no classes and polyfills for them);
- ships only a minimal amount of manually optimized color conversion algorithms (while most of the popular pickers import entire color manipulation libraries that increase the bundle size by more than 10 KB and make your app slower).

To show you the problem that **react-colorful** is trying to solve, we have performed a simple benchmark (using [bundlephobia.com](https://bundlephobia.com)) against popular React color picker libraries:

| Name               | Size (minified)                                                                                | Size (gzipped)                                                                                | Dependencies |
| ------------------ | ---------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | ------------ |
| **react-colorful** | [![](https://badgen.net/bundlephobia/min/react-colorful?color=6ead0a&label=)](https://bundlephobia.com/result?p=react-colorful)    | [![](https://badgen.net/bundlephobia/minzip/react-colorful?color=6ead0a&label=)](https://bundlephobia.com/result?p=react-colorful)    | **0**        |
| react-color        | [![](https://badgen.net/bundlephobia/min/react-color?color=red&label=)](https://bundlephobia.com/result?p=react-color)             | [![](https://badgen.net/bundlephobia/minzip/react-color?color=red&label=)](https://bundlephobia.com/result?p=react-color)             | 6            |
| react-input-color  | [![](https://badgen.net/bundlephobia/min/react-input-color?color=red&label=)](https://bundlephobia.com/result?p=react-input-color) | [![](https://badgen.net/bundlephobia/minzip/react-input-color?color=red&label=)](https://bundlephobia.com/result?p=react-input-color) | 7            |
| rc-color-picker    | [![](https://badgen.net/bundlephobia/min/rc-color-picker?color=red&label=)](https://bundlephobia.com/result?p=rc-color-picker)     | [![](https://badgen.net/bundlephobia/minzip/rc-color-picker?color=red&label=)](https://bundlephobia.com/result?p=rc-color-picker)     | 5            |

## Companies using react-colorful

  Resume.io — online resume builder with over 7,800,000 users worldwide

## Roadmap

- [x] Additional modules to support different RGB, HSL and HSV color models
- [x] HEX input component
- [x] TypeScript support
- [x] Rewrite the codebase to TypeScript
- [ ] Alpha channel support (RGBA and HSLA color models)

repository: byr-gdp/react-colorful

repo_name: byr-gdp/react-colorful


text:
# Lazy Hangout
## Introduction
**Lazy Hangout** is a simple utility that aims to automate the generation of
a Google Hangout link. Often, I tend to converse with my friends over Google
Hangout and it feels quite cumbersome to navigate through my web browser in
order to start a Hangout chat.

## Get Started
Please follow the instructions step-by-step as it will aid the process of setting
up this utility.

### Pre-requisites
- Go

### Service Account
1. Create a [service account]((https://cloud.google.com/iam/docs/service-accounts))
for **Google Calendar API**
2. By now, you should get a `.json` file with your service account's credentials
3. Place your credential file anywhere that *feels* secure to you

### Environment Variable
The absolute file path in `HANGOUT_CREDENTIALS_PATH` is used to locate your credential
file.

```bash
export HANGOUT_CREDENTIALS_PATH="<absolute-path-to-your-credential-file>"
```

### Build
The last step is to clone this repository and build the project.

```bash
git clone https://github.com/LeonLyx/lazy-hangout.git
cd lazy-hangout
make build
```

Once done, you should be able to generate a hangout link by executing `hangout-generator`
on your favourite terminal.

repository: LeonLyx/lazy-hangout

repo_name: LeonLyx/lazy-hangout


text:
# react-memory-game
This is a tutorial repository for learning react.

## DEMO
Check [HERE!](https://tofuwa.github.io/react-memory-game/)

## Documents
Check docs/

# License
MIT License Copyright (c) 2021 TOFUWA

repository: tofuwa/react-memory-game

repo_name: tofuwa/react-memory-game


text:
# AspnetMicroservices
AspnetMicroservices

This project contains details about configuring various service in form of Microservice and details. You will learn about how to do everything by going to following category

- [General](src/README.md)
- [MongoDB](src/Services/Catalog/README.md)

repository: vinothvsbe/AspnetMicroservices

repo_name: vinothvsbe/AspnetMicroservices


text:
--------------------------------------------------------------------------------

## Treebank Statistics (UD_Czech)

There are 26 `PUNCT` lemmas (0%), 27 `PUNCT` types (0%) and 221049 `PUNCT` tokens (15%).
Out of 17 observed tags, the rank of `PUNCT` is: 14 in number of lemmas, 15 in number of types and 2 in number of tokens.

The 10 most frequent `PUNCT` lemmas: _,, ., -, ", ), (, :, ?, /, *_

The 10 most frequent `PUNCT` types:  _,, ., -, ", ), (, :, ?, /, *_

The 10 most frequent ambiguous lemmas: _/_ ([PUNCT]() 700, [SYM]() 18), _o_ ([ADP]() 10328, [PUNCT]() 100, [NOUN]() 10, [ADJ]() 3, [INTJ]() 2), _x_ ([SYM]() 120, [NOUN]() 70, [PUNCT]() 3)

The 10 most frequent ambiguous types:  _/_ ([PUNCT]() 700, [SYM]() 18), _o_ ([ADP]() 9669, [ADJ]() 110, [PUNCT]() 99, [NOUN]() 4), _x_ ([SYM]() 120, [NOUN]() 41, [PUNCT]() 3)

* _/_
  * [PUNCT]() 700: _Přenosová rychlost : ( A 4 / sec ) 12_
  * [SYM]() 18: _Potřebujete jen 1 / 4 vody , takže sprcha vás stojí 0.46 Kč ._
* _o_
  * [ADP]() 9669: _Hodnota thajského vývozu se každým rokem zvyšuje o více než 12 % ._
  * [ADJ]() 110: _Monet , spol . s r . o ._
  * [PUNCT]() 99: _Bohužel dnes existuje jakási nevstřícnost ze strany legislativy . o_
  * [NOUN]() 4: _Vítězem se stal britský boxer Benn , který vyhrál k . o . v desátém kole ._
* _x_
  * [SYM]() 120: _Rozměry : ( mm ) 452 x 380 x 230_
  * [NOUN]() 41: _* s ( x ) = 1 , je - li vrchol x obsazen ( neshořelým ) stromem ,_
  * [PUNCT]() 3: _x - údaje za 1 . pololetí_

## Morphology

The form / lemma ratio of `PUNCT` is 1.038462 (the average of all parts of speech is 2.195970).

The 1st highest number of forms (2) was observed with the lemma “-”: _-, -103_

The 2nd highest number of forms (1) was observed with the lemma “!”: _!_

The 3rd highest number of forms (1) was observed with the lemma “"”: _"_

`PUNCT` does not occur with any features.

## Relations

`PUNCT` nodes are attached to their parents using 3 different relations: [cs-dep/punct]() (221012; 100% instances), [cs-dep/root]() (33; 0% instances), [cs-dep/conj]() (4; 0% instances)

Parents of `PUNCT` nodes belong to 18 different parts of speech: [VERB]() (126034; 57% instances), [NOUN]() (40351; 18% instances), [PROPN]() (19453; 9% instances), [ADJ]() (17759; 8% instances), [NUM]() (11568; 5% instances), [ADV]() (3039; 1% instances), [PRON]() (1659; 1% instances), [PART]() (535; 0% instances), [PUNCT]() (157; 0% instances), [DET]() (130; 0% instances), [CONJ]() (90; 0% instances), [INTJ]() (69; 0% instances), [SYM]() (66; 0% instances), [ADP]() (61; 0% instances), [ROOT]() (33; 0% instances), [SCONJ]() (32; 0% instances), [X]() (11; 0% instances), [AUX]() (2; 0% instances)

220958 (100%) `PUNCT` nodes are leaves.

36 (0%) `PUNCT` nodes have one child.

34 (0%) `PUNCT` nodes have two children.

21 (0%) `PUNCT` nodes have three or more children.

The highest child degree of a `PUNCT` node is 23.

Children of `PUNCT` nodes are attached using 11 different relations: [cs-dep/punct]() (154; 63% instances), [cs-dep/dobj]() (23; 9% instances), [cs-dep/nmod]() (18; 7% instances), [cs-dep/conj]() (13; 5% instances), [cs-dep/nsubj]() (12; 5% instances), [cs-dep/nummod]() (10; 4% instances), [cs-dep/advmod]() (5; 2% instances), [cs-dep/dep]() (4; 2% instances), [cs-dep/cc]() (2; 1% instances), [cs-dep/ccomp]() (1; 0% instances), [cs-dep/parataxis]() (1; 0% instances)

Children of `PUNCT` nodes belong to 8 different parts of speech: [PUNCT]() (157; 65% instances), [NOUN]() (47; 19% instances), [NUM]() (24; 10% instances), [ADV]() (5; 2% instances), [PROPN]() (5; 2% instances), [CONJ]() (2; 1% instances), [VERB]() (2; 1% instances), [ADJ]() (1; 0% instances)

repository: coltekin/docs

branch_name: refs/heads/pages-source

repo_name: coltekin/docs


text:
  Utility Bot

Moderation, Games, Utilites, Music and much more!

  Overview
  •
  Setup
  •
  Plugins
  •
  Community
  •
  License

# Overview
The goal of UtilityBot is to make managing a server easy and convienent with many useful commands!

# Plugins
Utility Bot is a bot that makes managing servers of any size easy, with per-channel mutes, moderation, memes, premium features and lots more!

Here are a few examples:

- Ban
- Soft Ban
- Music
- Moderation
- Utilites
- Purge
- Edit roles
- Logging categories e.g: moderation, action logs message logs.

We are still working on **Utility Bot** and we appreciate constructive critiscm and feedback to better develop the bot. We also appreciate pull requests to update commands and more! So don't hesitate to contribute.

# License
Released under the [MIT License](https://opensource.org/licenses/MIT) license.

Logo created by [PineappleRind](https://pineapplerind.github.io)

# Contributors
- Andrew Nijmeh
- PineappleRind
- Aditya Kapoor
- flopana
- svcodes
- yak-fumblepack

# Donators
> Over here we will have a list of all our donators who have donated via patreon! you can donate via clicking on the sponsor button on the top of the repository and clicking on the patreon link.

repository: discordutilitybot/utilitybot

branch_name: refs/heads/dev

gha_language: Python

repo_name: discordutilitybot/utilitybot


text:
---
layout: post          #important: don't change this
title: "Using exceptionless to track exceptions in your VS Extension"
date: 2014-12-06 23:09:52
author: utkarsh
tags: [Extensions, VisualStudio]
categories:
- "extensions"
- "Visual Studio"
- "Tools"
description: "Using exceptionless to track exceptions in your VS Extension"
img:        #place image (850x450)
thumb: thumb-icon-utkarsh.jpg    #place thumbnail (70x70)
---
In the current competitive world, everyone knows releasing the product to market is only half the battle. You are expected to continuously monitor application for its usage, memory consumption, errors, to quickly address any issues in your application. Quickly addressing issues your customers facing is essential to keep existing customers with your product. There are already many solutions available in the market, which provide complete application monitoring and analytics for your application. Some popular ones are, [Microsoft Application Insights](http://www.visualstudio.com/en-us/explore/application-insights-vs.aspx) and [Telerik Analytics](http://www.telerik.com/analytics). However, if you are looking for tracking only exceptions in your applications and not interested in other usage trends, so that you quickly track unhandled exceptions, you have a friend in [exceptionless.com](https://exceptionless.com/)

![image](/images/screenshots/utkarsh//2014_12_06_using_exceptionless_to_track_Image1.png "image")

**Few of its main features include:**

*   Real time error notification
*   Group error messages
*   Error trends and more

### Integrating exceptionless

For this post, I will be integrating with VS Extension which I am working on. I am using WPF

1. Create a exceptionless account and then create a project for your application.

2. Select the project type in the you are building app – I chose WPF for my extension, however exceptionless supports many projects like ASP.NET MVC, WebAPI, Windows Forms and even Console applications

3. Based on your application type, install the nuget package.

![image](/images/screenshots/utkarsh//2014_12_06_using_exceptionless_to_track_Image2.png "image")

4. Get the app key from exceptionless and usually you need update your appKey in config file for any other type of applications. Because VS extensions emit the assembly and loaded by Visual Studio, you cannot use app.config. Instead you need to add appKey in AssemblyInfo.cs as below.

```cs
[assembly:Exceptionless("xxxxxxxxxxxxxxxxxxxxxxxxxxxxx")]
```

5. Finally, you need to register your exceptionless in the application initialization. For VS extension, it will be in `Initialize` method `<ExtensionName>Package.cs`

```cs
protected override void Initialize()
{
    base.Initialize();
    ExceptionlessClient.Current.Register();
    //Continue with your code
}
```
6. Once you configured, all unhandled exceptions are automatically reported. You can manually report your handled exceptions from anywhere in the code as below

```cs
try
{
    //code throwing exception
}
catch (Exception exception)
{
    exception.ToExceptionless().Submit();
}
```

You can also pass any other information (your custom object or add custom tags) with exceptions.

```cs
try
{
    throw new ApplicationException(Guid.NewGuid().ToString());
}
catch (Exception ex)
{
    ex.ToExceptionless()
        .AddObject(order, "Order",
			excludedPropertyNames: new [] { "CreditCardNumber" },
			maxDepth: 2)
        .AddTags("Order", "User")
        .MarkAsCritical()
        .SetUserEmail(user.EmailAddress)
        .Submit();
}
```

That's it! You will receive your exceptions with full stack trace in real time with nice charts as below.

![image](/images/screenshots/utkarsh//2014_12_06_using_exceptionless_to_track_Image3.png "image")

You can dig in inside individual exceptions to view full stack trace.

![image](/images/screenshots/utkarsh//2014_12_06_using_exceptionless_to_track_Image4.png "image")

### Exceptionless is open source!

Exceptionless is completely open source and code is actively developed on [Github](https://github.com/exceptionless/Exceptionless). This has the Api and the the code for the exceptionless UI you saw in above screenshots. That means, **you can completely host it in your own web server and integrate inside your applications**. Having said that, you can simply use hosted exceptionless.com to quickly use it for your applications without setting up any infrastructure.

**Note:**

During debugging my VS extension, I kept on getting this error dialog in VS Experimental Instance. I have mailed them about the same, will update this post if I get any answer from them. Please see that this exception dialog was seen only in extensibility project type and rest other projects worked just fine.

![image](/images/screenshots/utkarsh//2014_12_06_using_exceptionless_to_track_Image5.png "image")

repository: ajeetblog/newthm

repo_name: ajeetblog/newthm