text:
#Build Queries with the SELECT statement

Retreive data from a table and/or view with a *query*.  Combine with a hierarchical query or subqueries which are covered after the basiscs.
_____
General syntax:

>SELECT   *expression_lists*, comma separated, becomes a column in the results.
>
>FROM     *data_source*
>
>WHERE    *predicates*
>
>GROUP BY *expression_lists*
>
>HAVING   *predicates*
>
>ORDER BY *expression_lists*

_____
**SELECT Statements**

Return specific list of columns, all * or an expression
Select expressions example:

>SELECT name, ROUND(population * 0.90, 0)
>
>FROM county;

Oracle has a special table that contains one row of the current date time:

>SELECT SYSDATE
>
>FROM dual;

MySQL select date time:

>SELECT getdate();

Specify an alias for the expression, separate by at least one space:

>SELECT id, name,
>
>   ROUND(population * 0.90, 0) est_pop  --optional AS est_pop
>FROM county;

Case and Punctuation in Names:

Subqueries in the SELECT statement:

Qualifying column names:

ALL and DISTINCT:
Eliminate duplicate rows in the result set.

____
**Predicates**

|Comparison operators  | Usage                                            |

|---------------------:|--------------------------------------------------|

|=                     | Equals                                           |

|!= , <>               | Inequality                                       |

|< , <=                | Less than or equal to                            |

|>, >=                 | Greater than or equal to                         |

|BETWEEN               | Is value within range                            |

|EXISTS, NOT EXISTS    | Does it match a condition                        |

|IN                    | Is value contained in a set of specified values  |

|IS NOT NULL           | Nullity tests                                    |

|LIKE, NOT LIKE        |Does a value match a pattern                      |

|LIKEC, LIKE2, LIKE4   |Oralc only: Unicode chars, code units, code points|

|REGEXP, RLIKE         |MySQL only, comparison operators                  |

|REGEXP_LIKE           |Oracle only, value matches pattern tests          |

____
____
*WHERE  examples* Between:

>SELECT c.name
>
>FROM county c
>
>WHERE c.population BETWEEN 5432 AND 12345;

Between with operators:

>SELECT c.name
>
>FROM county c
>
>WHERE   c.population >= 5432
>
>    AND c.population <= 12345;

Exists:

>SELECT o.id, o.name
>
>FROM owner o
>
>WHERE EXISTS (SELECT * FROM upfall u     --replace with NOT EXISTS as needed
>
>    WHERE u.owner_id = o.id);

In:

>SELECT o.id, o.name
>
>FROM owner o
>
>WHERE o.id IN (1,3,5,7);

Another IN example, should return the same as above EXISTS example:

>SELECT o.id, o.name
>
>FROM county c
>
>WHERE o.id IN (SELECT u.owner_id
>
>    FROM upfall u);

Null examples:

>IS NULL
>
>IS NOT NULL

LIKE, NOT LIKE
Provides basic pattern-matching predicates. %Percent multi-char, _underscore one-char.

>SELECT u.id, u.name
>
>FROM upfall u
>
>WHERE u.name LIKE '%Pirates%';

Find all falls without "Pirates", PostgreSQL and MySQL:

Use the backslash character

>SELECT u.id, u.name
>
>FROM upfall u
>
>WHERE u.name NOT LIKE '%\%%'; --find all falls w/o % in the name

The ESCAPE clause in PostgreSQL and MySQL if you need to quote the backslash

>SELECT u,id, u.name
>
>FROM upfallu
>
>WHERE u.name NOT LIKE '%\%%'   ESCAPE '\\';

ESCAPE example for Oracle syntax:

>SELECT u.id, u.name
>
>FROM upfall u
>
>WHERE u.name NOT LIKE '%\%%' ESCAPE '\';

repository: worker-bee-micah/sql

repo_name: worker-bee-micah/sql


text:
# Effective Data Visualization
## PyCon 2020
This is a tutorial as part of PyCon 2020 https://us.pycon.com
The presentation page is https://us.pycon.org/2020/schedule/presentation/74/
This tutorial has become a fully online tutorial due to PyCon moving to an online format due to CoViD-19. The video is published at https://www.youtube.com/watch?v=cNXioWhEeJc

## Author
This tutorial is written by Husni Almoubayyed.

Please contact me for any suggestions, comments, or discussions.

Please open a GitHub issue if you find anything that need corrections, additions, or things that need to be updated as time goes by.

You can find up to date ways to contact me at https://husni.space

## About
From picking the right plot for the particular type of data, statistic, or result; to pre-processing sophisticated datasets, and even making important decisions about the aesthetic of a figure, visualization is both a science and art that requires both knowledge and practice to master.

This tutorial is for python users who are familiar with python and basic plotting, and want to build strong visualization skills that will let them effectively communicate any data, statistic, or result.

We will use python libraries such as seaborn, matplotlib, plotly, and sklearn; and discuss topics such as density estimation, dimensionality reduction, exploring similar datasets, interactive plotting, and making suitable choices for communication. Drawing examples from datasets in the scientific, financial, geospatial (mapping) fields and more.

## Installation

In your terminal, run

```
git clone https://github.com/hsnee/PyCon2020_DataVisualizationTutorial.git
```

to download the content of this tutorial.

After that, you can run
```cd PyCon2020_DataVisualizationTutorial
jupyter notebook Effective_Data_Visualization_Workbook.ipynb
```
This assumes you have a Python version >3.7 and Jupyter installed. If not, an easy way to get this with most of the libraries needed for the tutorial is to install the latest https://anaconda.com distribution for your system, or to simply just visit https://bit.ly/PyConViz20 for a Google Colab-hosted version of this tutorial (or https://bit.ly/PyConViz20Full for the full version with all the solutions).

## Acknowledgement
A lot of people have helped shape my understanding of data visualization throughout the years, either throughout conversations with them, being directly taught by them, or being influenced by their work. I am indebted to the [LSSTC Data Science Fellowship Program](http://astrodatascience.org) (in particular, Adam Miller and Lucianne Walkowicz), Jake Vanderplas, Skipper Seabold, and to many helpful comments and discussions throughout the years by my supervisor Rachel Mandelbaum.

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
## Homework 6

### C Exercises

Modify the link below so it points to the `ex06` directory in your
student repository.

[Here is a link to the ex06 directory in my repository](https://github.com/willythor/ExercisesInC/tree/master/exercises/ex06)

### Think OS Chapter 6 reading questions

**Memory management**

1) Which memory management functions would you expect to take constant time?
Which ones take time proportional to the size of the allocated chunk?

constant time:
- realloc (if the new size is smaller)
- free
- malloc (provided sbrk doesn't have to be called)

time proportional to size of allocated chunk:
- calloc

2) For each of the following memory errors, give an example of something that might go wrong:

a) Reading from unallocated memory.

A segmentation fault might occur, or it'll read from memory and recieve what ever happened to be stored at the given locations.

b) Writing to unallocated memory.

A long time might pass until that portion of memory is read from and then the possible error will be very hard to diagnose.

c) Reading from a freed chunk.

The same as reading from an unallocated portion of memory.

d) Writing to a freed chunk.

The same as writing to an unallocated portion of memory.

e) Failing to free a chunk that is no longer needed.

You could run out of memory if you computer is not using a virtual memory address.

3) Run

```
    ps aux --sort rss
```

to see a list of processes sorted by RSS, which is "resident set size", the amount of physical
memory a process has.  Which processes are using the most memory?

Chrome, Visual Studio Code

4) What's wrong with allocating a large number of small chunks?  What can you do to mitigate the problem?

It'll cause fragmentation and make it very slow to allocate memory in the future. According to something I read on stackoverflow, a possible solution is writing your own custom memory allocator.

If you want to know more about how malloc works, read
[Doug Lea's paper about dlmalloc](http://gee.cs.oswego.edu/dl/html/malloc.html)

repository: willythor/ExercisesInC

repo_name: willythor/ExercisesInC


text:
---
type: rule
title: Production - Do you know the correct way to frame your subject?
uri: production-do-you-know-the-correct-way-to-frame-your-subject
authors:
  - title: Titus Maclaren
    url: https://ssw.com.au/people/titus-maclaren
related: []
redirects: []
created: 2011-10-19T15:23:00.000Z
archivedreason: null
guid: 2bbd6c36-1fbd-4b51-bb93-cfc408e54c17

---

When filming a subject (or subjects) there are numerous ways to frame them.

<!--endintro-->

Basic rules to follow include:

1. Avoid positioning them on opposite, far sides of the frame, as this creates a feeling of emotional distance between the two characters. Distances seem bigger in the camera, so position your subjects as close together as they are comfortable with, especially if you are using tight framing and/or filming with one camera.
2. By using the rule of thirds, you can create more visually pleasing shots. That is, if you divide the x and y axis's into 3 segments, the lines diving these segments should align with certain lines in the image. The intersection of these lines is a good place to position a focal point such as someone's eye.
3. Avoid too much space in the frame, especially if space has nothing in it. This is referred to as Dead Space. This can occur when the subjects are placed in front of a blank wall.
4. If you can (such as if you have access to 2 or more cameras) avoid filming directly side on, at 90 degrees to the subjects. Always try to be as face-on with your subject as possible.
5. Try and have an interesting background. Patterns, movement, and depth can help to create a more interesting shot.
6. For corporate and educational videos, a mid-shot works well to capture the content. This is from the belly button up.
7. Avoid areas of high contrast - a hot spot (where the light is concentrated into a pure white) or a very dark spot or section of the frame in a predominantly light frame can draw the viewer's eye. If this is not what you want them to focus on, don't include it in the frame.
8. If there is only one person in the frame (or if two people are looking the same direction), place them on the opposite side to the direction they're looking for. That is if they're looking left to right, place them on the left side of the frame. If this is not followed, your subject will be pressed up against the edge of the frame and this can create an uncomfortable feeling for the audience.

::: bad
![Figure: Bad example – too much dead space, the characters are unevenly placed, there is an uninteresting background, it's side on and the framing is too far out](video-fram-bad-example.jpg)
:::

::: good
![Figure: Good example – the rule of thirds followed, mid-shot, interesting background, no dead space, fairly face on, subject placed on the right side because he's looking from right to left (leading room)](video-fram-good-example.jpg)
:::

When positioning your subjects it is important to remember several factors:

1. It is a good idea (if you want to have one of your subjects more face on) to have the interviewee more face-on than the interviewer.
2. The interviewer should be on the right side of the frame - you'll notice talk show hosts will always look right to left.
3. The interviewer should avoid leaning into the interviewee too much as it might make them feel uncomfortable and seem a little weird in the frame.
4. The best way to position your subjects is at 90° to each other and at 45° to the camera:

::: bad
![Figure: Bad example - Interviewee (left) is facing toward the interviewer (right) too much and the interviewer is faced towards the camera too much](bad-interview-positions.jpg)
:::

::: good
![Figure: Good example - position your subjects properly to create an unbiased interview](interview positions.jpg)
:::

When doing an over the shoulder shot (OTS) for a corporate video, it is generally best to stay at a level height with the subject. Looking up or down at them can create unnecessary meaning in the shot. It is also a good idea to avoid using the wide-angle setting on your camera as it makes the subject seem distant and small in comparison to the person whose shoulder we can see.

::: bad
![Figure: Bad example – looking down at the subject with a wide-angle lens setting](bad OTS example.jpg)
:::

::: good
![Figure: Good example – level height, zoom level not set to wide-angle](Good OTS example.jpg)
:::

::: bad
![Figure: Bad example – head not close enough to the top and hand gestures not visible](framing-bad.jpg)
:::

::: good
![Figure: Good example – head close to the top and hand gestures visible](framing-good.jpg)
:::

branch_name: refs/heads/main

gha_language: TSQL


text:
Unqualified attribute selectors, such as `[type=text]`, match all elements first and then check their attributes. This means they have the same performance characteristics as the universal selector (`*`). Similar to the universal selector, unqualified attribute selectors cause performance issues when used as the key part (far-right) of a selector.

```
/* BAD */
.mybox [type=text] {
    background: #fff;
    color: #000;
    background: rgba(255, 255, 255, 0.5);
}
```

# How do I fix this ?

Don't make the unqualified attribute the key part of the selector, i.e. don't put it at the far right (which gets parsed first).

```
/* GOOD */
.selected [type=text] a {
    color: red;
}
```

# Resources

* [CSSLint - Disallow unqualified attribute selectors](https://github.com/CSSLint/csslint/wiki/Disallow-unqualified-attribute-selectors)

repository: dancyfits/css

repo_name: dancyfits/css


text:
---
layout: creature
name: "Ghoul, Imperial"
tags: [medium, undead, cr4, tome-of-beasts]
cha: 14 (+2)
wis: 14 (+2)
int: 13 (+1)
con: 12 (+1)
dex: 14 (+2)
str: 16 (+3)
size: Medium undead
alignment: lawful evil
challenge: "4 (1100 XP)"
languages: "Common, Darakhul, Undercommon"
senses: "darkvision 60 ft., passive Perception 12"
damage_immunities: "poison"
condition_immunities: "charmed, exhaustion, poisoned"
speed: "30 ft., burrow 15 ft."
hit_points: "93 (17d8 + 17)"
armor_class: "16 (breastplate)"
---

***Turning Defiance.*** The iron ghoul and any ghouls within 30 feet of it have advantage on saving throws against effects that turn undead.

### Actions

***Multiattack.*** The imperial ghoul makes one bite attack and one claws attack.

***Bite.*** Melee Weapon Attack: +5 to hit, reach 5 ft., one target. Hit: 12 (2d8 + 3) piercing damage, and if the target creature is humanoid it must succeed on a DC 11 Constitution saving throw or contract darakhul fever.

***Claws.*** Melee Weapon Attack: +5 to hit, reach, one target. Hit: 17 (4d6 + 3) slashing damage. If the target is a creature other than an elf or undead, it must succeed on a DC 11 Constitution saving throw or be paralyzed for 1 minute. The target repeats the saving throw at the end of each of its turns, ending the effect on itself on a success.

***Light Crossbow.*** Ranged Weapon Attack: +4 to hit, range 80/320, one target. Hit: 8 (1d8 + 2) piercing damage.

gha_language: CSS

gha_license_id: NOASSERTION


text:
---
layout: default
---

# 1997-09-13 - Re: If you don't have anything to say in the Subject line, why should we expect you have anything to say in the message body?

In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Brian B. Riley wrote:

>   Don'tget me wrong. It scares the hell out of me too, but maybe, in
> addition to that various things Tim has suggested we might also
> consider how to make the GAK as secure as cam be to minimize its
> potential for disaster.

  Glad, you asked...
  The reason I am posting as 'Fuck You' is that it saves time giving
my standard answer to the increasing number of idiots, schills, and
pawns on the CypherPunks list, these days.
   I 'like' saying, "Fuck You."
I like it a lot.
  Men...

  Oh yeah...about the post I am replying to, here.
  Brian. The bytes you saved by not including a Subject header were more
than wasted by the useless words you put in the message body.

  Close, but no cigar, Bri. Let me rephrase that for you.
   "we might also consider how to make the GAK as 'apparently' secure as
cam (bad grammar and spelling left intact) to minimize its potential for
disaster."
  There _is_ no 'secure' in the government computer lexicon, Bri. Not
even in the 'Cyphernomicon' will you find the word 'secure' found, used
as a substite for the phrase, "We're SAFE now, the government is using
a 'rubber'."

  Go back outside and come in again, next time with a Subject header and
a new list persona. You've pretty much ruined the one you're using now.

 - _Fuck You<EMAIL_ADDRESS>  + 1997-09-14 (Sun, 14 Sep 1997 12:56:39 +0800) - [Make GAK or back doors better?  Hell NO!](/archive/1997/09/887c9d3cf3594e4b0cba45bdc987705b22ca9f67e5f059f8ee0825cf318cf0c9) - _"Attila T. Hun"<EMAIL_ADDRESS>

gha_license_id: MIT


text:
# djtext
djtext provides functions to handle localization.

Based on [Anton Gushcha](https://github.com/NCrashed/dtext) similar work.

Example:
```
import std.stdio, std.opt, dtext;

void main(string[] args) {
  string locale;
  getopt(args, "l|lang", &locale);

  defaultLocale = locale;
  writeln(_("Hello, world!")); \\ or use getdtext
}
```

If text for translation cannot be found in specified locale name, the text can be saved and written down to a special fuzzy texts file at program shutdown. That should help to add new localization fast and without program recompilation.

## License
Distributed under the Boost Software License, Version 1.0. See copy at http://www.boost.org/LICENSE_1_0.txt.


text:
# gsMeshUtilities

Open-Souce (MIT License) command-line utilities for mesh and geometry things.

Questions? Contact Ryan Schmidt [@rms80](http://www.twitter.com/rms80) / [gradientspace](http://www.gradientspace.com)

# General Notes

You can find pre-built windows executables in the top-level **builds** folder.

# gsMeshSimplify

Reduce triangle count for a mesh. Currently supports *OBJ*, *STL*, and *OFF*.

Usage:
```
gsMeshSimplify options <inputmesh>
options:
  -percent <N>        : reduce to this percentage (real-value)
  -tcount <N>         : reduce to this triangle count (int)
  -output <filename>  : output filename - default is inputmesh.reduced.fmt
  -v                  : verbose
```

# gsMeshConvert

Convert between mesh formats. Currently supports *OBJ*, *STL*, and *OFF*.

Usage: **gsMeshConvert.exe** *inputmesh.ext* *outputmesh.ext*

(pretty basic so far)

# gsMeshSplit

Some (most?) tools that support textured OBJ meshes have limitations in some way. For example, many (eg xNormal) do not support having multiple texture images (ie materials) for a single file. In addition many rendering tools do not support OBJs with multiple UV values per vertex. This utility takes an input OBJ/MTL pair with these properties and produces a set of "simple" output OBJ/MTL files - one material per OBJ, no shared vertices along UV seams.

Usage: **gsMeshSplit.exe** (options) input.obj

Options:
**-output** *directory_path* - output folder for set of OBJ files

The set of output files for input.obj will be named input_material0.obj, input_material1.obj, each with a .mtl file having the same name.

Note that this utility does not handle the texture images at all. It doesn't open them, doesn't copy them, etc. Only the OBJ and MTL files are read and generated.

# gsPolyFontGenerator

Generate polygon font file. Each font element is stored as a set of [geometry3Sharp](https://github.com/gradientspace/geometry3Sharp) **GeneralPolygon2d** objects. The set of available elements (ie letterforms) is stored in a g3Sharp **PolygonFont2d** object, which is directly serialized. Use **PolygonFont2d.ReadFont(filename)** to load the font file. The storage format is binary and subject to change if serialization of the above changes. A version number is stored in the binary file, it is the first 32-bit integer and currently is 3.

Usage: **gsPolyFontGenerator.exe** *options* *output_filename.bin*

Options:

* `-emsize <int>`    emSize of font. larger emSize results in more segments for curves
* `-font <fontname>`    string name of font. If it crashes, you don't have that font
* `-style <style>`      valid styles are `bold`, `italic`, `regular`
* `-string <s>`         font will contain a single "character" that is this entire string

By default the font contains the characters in this string (you can modify it in the code)
```
string characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,;:-+=!?()[]<>{}|~@#$%^&*_/\\\"'`©™";
```
Each letter is generated separately in whatever coordinates System.Drawing.GraphicsPath uses. No character spacing info is provided, I tend to use this with monospace fonts and a constant spacing, and calculate my own geometric transformations of each character.

*However*, if you want proper layout for a specific string, then you can use the `-string` option. In this case the "font" will be a single "character" which contains polygons for the full string, with appropriate positioning. If you would like multiple such strings in a single font file, hardcode them into the `strings` array in Program.cs. *Or improve option handling and submit a PR!*

# sdkmeshToOBJ

Microsoft has released some awesome mesh-processing tools under the MIT license, in
particular https://github.com/Microsoft/UVAtlas is a fantastic tool for auto-generating UV maps for
unstructured triangle meshes. However, this tool only outputs a weird *.sdkmesh* format that almost
no other tool supports. So, *sdkmeshToOBJ* converts this format to a standard OBJ with UV-coordinates.

Usage: **sdkmeshToOBJ.exe** *your_file.sdkmesh*

Output is **file.sdkmesh.obj**

Current Limitations: only the first mesh in the sdkmesh file is converted. And, it appears that sdkmesh files can contain multiple vertex buffers for a single mesh, but that isn't supported either.


text:
![Logo](http://www.shaghighi.ir/findip/Files/ipz.gif)

----------

[![PyPI version](https://badge.fury.io/py/ipz.svg)](https://badge.fury.io/py/ipz)
[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/sepandhaghighi/ipz/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/sepandhaghighi/ipz/?branch=master)
[![Build Status](https://scrutinizer-ci.com/g/sepandhaghighi/ipz/badges/build.png?b=master)](https://scrutinizer-ci.com/g/sepandhaghighi/ipz/build-status/master)

----------

# IPZ is a simple library for extracting local and global ip in python scripts

By [Sepand Haghighi](http://www.shaghighi.ir)

###Version : 0.1

</hr>
</hr>
## Download ##

- [Download](https://github.com/sepandhaghighi/ipz/archive/v0.1.zip) source from github
- Download from pypi `pip install ipz`

## Usage ##

```python

import ipz

local_ip=ipz.local_ip() # as string
global_ip=ipz.global_ip() # as string

```

In Error State Output is `Error` String

repository: sepandhaghighi/ipz

repo_name: sepandhaghighi/ipz


text:
# cellularAutomata

a small application for running cellular automata from random inputs, using comonads

## usage

the program will default to the size of the window
`-w` and `-h` inputs can be given to determine the width and height, respectively

## requirements

  * `getOpt`
  * `ncurses` (for detecting term width/height)

## building / running

builds using nix

from a local folder:
```
nix build .
./result/bin/cellularAutomata
```

from the repo directly:
```
nix run github:techieAgnostic/cellularAutomata -- -w 40 -g 25
```

it may also be included as a flake input, as one normally would, and added to the package list using the included overlay

## discussion

this program was an exercise in using comonads to simulate cellular automata.

### cellular automata

a cellular automaton is defined by a calculation on a local space, which is applied to a global space of cells.

in a one dimensional cellular automata, each cell has two immediate neighbors, to the left and right of it.

additionally, each cell may be in one of two state - Alive, or Dead.

this program has a hard-coded (for now) xor-based rule that works as follows:

regardless of the state of the current cell, it will become Alive if one of its neighbors is alive, but not both, otherwise it will Die.

this local behaviour, when viewed on a global scale, can provide emergent behaviour, in this case a nice triangular pattern (when viewed over time).

### comonads

a comonad is the dual to a monad.

it is defined by two operations, `extract` and `duplicate`.

`extract` takes a comonad (which wraps some base type) and returns a single item of that type, it can be seen in the semantics of a cellular automata space as `extract`ing the focussed cell from the global space.

`duplicate` takes a comonad space, and wraps it in an extra layer of comonad, essentially creating a comonad of comonads. in semantics of a cellular automata, we can `duplicate` a space into that same space, but focussed on every possible cell in the space.

finally, a comonad is a functor, meaning it can be mapped over. we can use this to our advantage in the semantics of a cellular automata, by creating a function from a comonad space, to a cell state.

this function will be our transition function, and determines the new state of the focussed cell, using the non-focussed parts as its inputs.

by `duplicate`ing the comonad space, and mapping the transition function over this new universe of spaces, we get back a single universe, which represents the next step in time.

### laziness

due to haskell's laziness, the comonad space can (and should) be infinite in both directions, and as long as we remember to bound the space we want to print, our program will work properly.

as such, the functions to change our focus within the space assumes an infinite list, and i have defaulted to "clamping" our focus at the edges if a finite list is given on either direction. im not sure this is semantically the correct choice, but in regular usage (with infinite lists) it should not come up.

currently, as we are animating in a window, the program will turn the initially infinite grid into a grid the size of the window, therefore avoidinig memory leaks at the sides.

in the future if we add the ability to render animated gifs of a cellular automata, it may be of use to keep the infinite grid, in the knowledge that we will not be running it indefinitely, but instead collecting garbage at the end of the animation.

this is the difference between a truly infinite grid, and one that is simply larger than our viewspace (but still finite).

repository: techieAgnostic/cellularAutomata

repo_name: techieAgnostic/cellularAutomata


text:
# Next generation put in

[![License](https://img.shields.io/:license-mit-blue.svg)](https://github.com/1stBitcoin/NextGenerationPutIn/blob/master/LICENSE)

Next generation put in

Is an quick example of how visitors of your website can accept 3rd party content or other components.

Latest Version
----
Release 0.1.0 (Release Notes)

### Table of Contents
| No | Title							  |
|----|------------------------------------------------------------|
| 1  | [Why Next generation put in?](#why-next-generation-put-in) |
| 2  | [Technical Features](#technical-features)		  |
| 3  | [How to Install](#installation)				  |
| 4  | [Development](#development)				  |
| 5  | [License](#license)					  |

Why Next generation put in
----
  - To protect users privacy.
  - No need of user database.
  - Can also be used for exclude contents. (background picture, adult content etc..)
  - There are comments in the code so you can easily add & change it or integrate to your web.

[[back to top]](#table-of-contents)

Technical Features
----
  - **PHP** - Builds(compiles) the pages, reads and sets visitors COOKIEs.
  - **Ajax** - Manages to call external script.
  - **FontAwasome** - Icons.

[[back to top]](#table-of-contents)

Installation
----
Next generation put in requires web-server with PHP at least 5.6.

[[back to top]](#table-of-contents)

Development
----
No future development is scheduled for his project. Unless Ajax or PHP changes so this won't work.
Want to contribute? Great! Please do not hesitate to contribute to the development.

[[back to top]](#table-of-contents)

License
----
MIT

[[back to top]](#table-of-contents)


text:
---
layout: default
---

# 1995-11-30 - Re: ecash lottery (Was: ecash casino)

## Header Data

From: "E. ALLEN SMITH"<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 671ec76644a56c08bd751bcec59d960d10ea5269464673dc5614d20a300bd34b

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1995-11-30 05:44:58 UTC

Raw Date: Thu, 30 Nov 1995 13:44:58 +0800

## Raw message

```
{% raw  %}From: "E. ALLEN SMITH"<EMAIL_ADDRESS>Date: Thu, 30 Nov 1995 13:44:58 +0800
To<EMAIL_ADDRESS>Subject: Re: ecash lottery (Was: ecash casino)
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

From<EMAIL_ADDRESS>29-NOV-1995 23:16:11.12

Personally, I have long had great _hopes_ for using crypto for
non-sanctioned gambling, but I'm pretty skeptical that many people will do
it.  (And
gambling with no house cut is, at best, a wash.)
-----------------------
	How about gambling on something other than random numbers? Idea Futures
are one instance, as is sports gambling for those interested in that sort of
thing.
	-Allen

{% endraw %}
```

## Thread

+ Return to [November 1995](/archive/1995/11)

+ Return to "["E. ALLEN SMITH" <EALLENSMITH@ocelot.Rutgers.EDU>](/authors/e_allen_smith_eallensmith_at_ocelot_rutgers_edu_)"

+ 1995-11-30 (Thu, 30 Nov 1995 13:44:58 +0800) - Re: ecash lottery (Was: ecash casino) - _"E. ALLEN SMITH"<EMAIL_ADDRESS>


text:
---
title:  "2018 year end reflection questions"
tags: [reflection, learning, goals]
---

We don't reflect enough. While New Year's resolutions are a cultural norm, year end reflections seem to be much less discussed. Reflecting is difficult, but necessary to learn from the past. Ideally we'd all be reflecting more regularly; the end of 2018 provides a good excuse to start the habit and continue it on a more frequent monthly or weekly basis.

Below are the questions I used for my 2018 reflection along with some rationale:

**1. What went well?**

**2. What am I proud of / what did I overcome?**
  * People tend to obsess over their mistakes. It's helpful for mental health to also take credit for your successes

**3. What could have been improved?**
  * That said, knowing what you could have done better is also helpful. Importantly, focus on [bad processes rather than bad outcomes](http://michaelmauboussin.com/excerpts/MTYKexcerpt.pdf "Mauboussin on process vs outcome")

**4. What am I thankful for?**
  * Remember to be grateful for the opportunities you have. If these include friends and family, now's a great time to reach out

**5. What surprised me?**
  * This is more for fun, since surprises are by definition unexpected, and I'm unsure how much you can learn from this. It might be helpful if you can identify a common theme in your surprises

**6. What did I learn?**

**7. What needs to be left behind?**
  * Letting go is difficult. Be aware of sunk costs and behaviours to avoid

**8. How will I change?**

**9. Who will I connect with?**
  * Both new and old

**10. What are my goals? Of those, what are my top goals?**
  * [Advice that has been credited to Buffett](https://jamesclear.com/buffett-focus "Buffett on focus") on goal setting is worth thinking about, though that was just focused on career goals, and is possibly a [fake anecdote](https://www.cnbc.com/2018/06/05/warren-buffetts-answer-to-this-question-taught-alex-banayan-a-lesson.html "Buffett story?"). Your list likely expands when including other aspects of life e.g. physical, leisure etc. I do agree with the principle that you can't focus on too many things at once.

**11. What can I look forward to?**
  * End off with a positive note and think about what gets you excited about the year ahead

Some resources I took reference from:
1. [ibloom blog article](https://ibloom.us/blog/10-end-of-the-year-reflection-questions/ "ibloom article")
2. [Forbes article](https://www.forbes.com/sites/hennainam/2018/12/31/ten-questions-to-ask-in-your-personal-year-end-review/#43e05e127e7d "forbes article")

repository: leonlinsx/avoid-boring-people

gha_language: JavaScript

repo_name: leonlinsx/avoid-boring-people


text:
## Hybrid PKI on AWS

TODO: Fill this README out!

Be sure to:

* Change the title in this README
* Edit your repository description on GitHub

## Security

See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.

## License

This library is licensed under the MIT-0 License. See the LICENSE file.

The solution uses an offline root CA that can be operated on-premises or in an Amazon VPC, while the subordinate Windows CAs run on EC2 instances and are integrated with CloudHSM for key management and storage. To insulate the PKI from external access, the CloudHSM cluster are deployed in protected subnets, the EC2 instances are deployed in private subnets, and the host VPC has site-to-site network connectivity to the on-premises network. The Amazon EC2 volumes are encrypted with AWS KMS customer managed keys. Users and devices connect and enroll to the PKI interface through a Network Load Balancer.

This solution also includes a subordinate ACM private CA to issue certificates that will be installed on AWS services that are integrated with ACM. For example, ELB, CloudFront, and API Gateway. This is so that the certificates users see are always presented from your organization’s internal PKI.

**Prerequisites for deploying this hybrid internal PKI in AWS**
Experience with AWS Cloud, Windows Server, and AD CS is necessary to deploy and configure this solution.
An AWS account to deploy the cloud resources.
An offline root CA, running on Windows 2016 or newer, to sign the CloudHSM and the issuing CAs, including the private CA and Windows CAs. Here is an AWS Quick-Start article to deploy your Root CA in a VPC. We recommend installing the Windows Root CA in its own AWS account.
A VPC with at least four subnets. Two or more public subnets and two or more private subnets, across two or more AZs, with secure firewall rules, such as HTTPS to communicate with your PKI web servers through a load balancer, along with DNS, RDP and other port to communicate within your organization network. You can use this CloudFormation sample VPC template to help you get started with your PKI VPC provisioning.
Site-to-site AWS Direct Connect or VPN connection from your VPC to the on-premises network and other VPCs to securely manage multiple networks.
Windows 2016 EC2 instances for the subordinate CAs.
An Active Directory environment that has access to the VPC that hosts the PKI servers. This is required for a Windows Enterprise CA implementation.
Deploy the solution
The below CloudFormation Code and instructions will help you deploy and configure all the AWS components shown in the above architecture diagram. To implement the solution, you’ll deploy a series of CloudFormation templates through the AWS Management Console.

If you’re not familiar with CloudFormation, you can learn about it from Getting started with AWS CloudFormation. The templates for this solution can be deployed with the CloudFormation console, AWS Service Catalog, or a code pipeline.

**Download and review the template bundle**
To make it easier to deploy the components of this internal PKI solution, you download and deploy a template bundle. The bundle includes a set of CloudFormation templates, and a PowerShell script to complete the integration between CloudHSM and the Windows CA servers.

There are additional costs for resources deployed by this solution. The resources include: CloudHSM, ACM PCA, ELB, EC2s, S3, and KMS.
The solution also deploys some AWS Identity and Access Management (IAM) roles and policies.
To download the template bundle
Download or clone the solution source code repository from AWS GitHub.
Review the descriptions in each template for more instructions.
Deploy the CloudFormation templates
Now that you have the templates downloaded, use the CouldFormation console to deploy them.

**Deploy this template into an existing VPC to create the protected subnets to deploy a CloudHSM cluster.**

Navigate to the CloudFormation console.
Select the appropriate AWS Region, and then choose Create Stack.
Choose Upload a template file.
Select 01_PKI_Automated-VPC_Modifications.yaml as the CloudFormation stack file, and then choose Next.
On the Specify stack details page, enter a stack name and the parameters. Some parameters have a dropdown list that you can use to select existing values.
Choose Next, Next, and Create Stack.

**To deploy the PKI CDP S3 bucket template**

This template creates an S3 bucket for the CRL and AIA distribution point, with initial bucket policies that allow access from the PKI VPC, and PKI users and devices from your on-premises network, based on your input. To grant access to additional AWS accounts, VPCs, and on-premises networks, please refer to the instructions in the template.
Navigate to the CloudFormation console.
Choose Upload a template file.
Select 02_PKI_Automated-Central-PKI_CDP-S3bucket.yaml as the CloudFormation stack file, and then choose Next.
On the Specify stack details page, enter a stack name and the parameters.
Choose Next, Next, and Create Stack

**To deploy the ACM Private CA subordinate template**

This step provisions the ACM private CA, which is signed by an existing Windows root CA. Provisioning your private CA with CloudFormation makes it possible to sign the CA with a Windows root CA.

Navigate to the CloudFormation console.
Choose Upload a template file.
Select 03_PKI_Automated-ACMPrivateCA-Provisioning.yaml as the CloudFormation stack file, and then choose Next.
On the Specify stack details page, enter a stack name and the parameters. Some parameters have a dropdown list that you can use to select existing values.
Choose Next, Next, and Create Stack.

To deploy the Network Load Balancer template
In this step, you provision a Network Load Balancer.

**Navigate to the CloudFormation console.**

Choose Upload a template file.
Select 05_PKI_Automated-LoadBalancer-Provisioning.yaml as the CloudFormation stack file, and then choose Next.
On the Specify stack details page, enter a stack name and the parameters. Some parameters are filled in automatically or have a dropdown list that you can use to select existing values.
Choose Next, Next, and Create Stack.

**To deploy the HTTPS listener configuration template**

The following steps create the HTTPS listener with an initial configuration for the load balancer.

Navigate to the CloudFormation console:
Choose Upload a template file.
Select 06_PKI_Automated-HTTPS-Listener.yaml as the CloudFormation stack file, and then choose Next.
On the Specify stack details page, enter the stack name and the parameters. Some parameters are filled in automatically or have a dropdown list that you can use to select existing values.
Choose Next, Next, and Create Stack.

**To deploy the AWS KMS CMK template**

In this step, you create an AWS KMS CMK to encrypt EC2 EBS volumes and other resources. This is required for the EC2 instances in this solution.

Open the CloudFormation console.
Choose Upload a template file.
Select 04_PKI_Automated-KMS_CMK-Creation.yaml as the CloudFormation stack file, and then choose Next.
On the Specify stack details page, enter a stack name and the parameters.
Choose Next, Next, and Create Stack.

**To deploy the Windows EC2 instances provisioning template**

This template provisions a purpose-built Windows EC2 instance within an existing VPC. It will provision an EC2 instance for the Windows CA, with KMS to encrypt the EBS volume, an IAM instance profile and automatically installs SSM agent on your instance.

It also has optional features and flexibilities. For example, the template can automatically create new target group, or add instance to existing target group. It can also configure listener rules, create Route 53 records and automatically join an Active Directory domain.

Note: The AWS KMS CMK and the IAM role are required to provision the EC2, while the target group, listener rules, and domain join features are optional.

Navigate to the CloudFormation console.
Choose Upload a template file.
Select 07_PKI_Automated-EC2-Servers-Provisioning.yaml as the CloudFormation stack file, and then choose Next.
On the Specify stack details page, enter the stack name and the parameters. Some parameters are filled in automatically or have a dropdown list that you can use to select existing values.
Note: The Optional properties section at the end of the parameters list isn’t required if you’re not joining the EC2 instance to an Active Directory domain.

Choose Next, Next, and Create Stack.

**To integrate CloudHSM cluster to Windows Server AD CS**

Open the script 09_PKI_AWS_CloudHSM-Windows_CA-Integration-Playbook.txt and follow the instructions to complete the CloudHSM integration with the Windows servers.


text:
This directory contains the source for generating the visualizations in the parent directory.

The following source files are consumed by `sequencediagram.org` and then re-processed with Inkscape to convert font to `Consolas` and to correct the broken SVG markup:
   - `action_call_sequence_diagram.txt`

The following files source files are consumed by yEd and were saved as SVG with scale factor of `1.0`:
   - `simple_component_diagram.graphml`
   - `complex_component_diagram.graphml`
   - `archive_structure.graphml`

gha_language: Python


text:
## 8 - Text Charsets

In the previous tutorial, we learned how to create and render a bitmap, and how to enter bitmap-mode.

In this tutorial, we are going to use almost the same concepts, but instead of rendering bitmaps, we are rendering text. We are also going to use a custom charset instead of the pretty boring charset that’s default.

The default charset look like this:

First of all, I’m not good at creating fonts so I won’t teach you how to do this. Instead we are going to download a charset that is named Scrap Writer III 17. Don’t know who created it but if anyone knows, please let me know so I can add proper credits.

The Scrap Writer III 17 charset look like this:

Donwload the charset here: scrap_writer_iii_17.64c

Download other charsets from this page: http://kofler.dot.at/c64/ but remember, some of them might be copyrighted.

Rendering text

Rendering text is quite simple. All you need is to either use the default charset or a custom charset. Also, you will need the text you want to render.

Let’s write our program.

First, we want to clear the screen. You could use the method we created earlier, but to keep this example to the point, I’m going to use a function that is included on the Commodore 64 and located at $e544. This routine clears the screen.

Also, we want to set the screen color and the border color to something greenish.

````
    processor   6502
org    $1000

jsr $e544
lda #$0d
sta $d020
lda #$05
sta $d021
````

Then we load the custom charset, using the same method as in the previous tutorial about rendering bitmaps. Our screen memory is at $0400 and charset at $2000.

````
lda #$18
sta $d018
````

Now it’s time for the meat of this tutorial. The loop that writes the text! First, we set the x-register to zero. Then we load the x’th character of msg (declared in the bottom) into the accumulator.
````
ldx #$00
write:     lda    msg,x
````

Once it’s loaded, we jump to a subroutine that writes text to the screen. This routine is located at $ffd2. All it does is to write the value in the accumulator to the screen.
````
jsr    $ffd2
````
The text we want to render is 54 character long. We loop through each of the characters and write it to the screen.
````
inx
cpx    #54
bne    write
````
Next we are setting the color of our characters. This could be done in the loop above, but just to split the different functionality, I decided to create another loop that does this. The color is stored at $d800 and so on. We do this for each of the 54 characters.

````
ldx #$00
setcolor: lda #$07
sta $d800,x
inx
cpx #$54
bne setcolor
````
In the end, we create an infinite loop so we can see what we rendered.
````
loop:        jmp loop
````

Then we need to load our data. We create msg that contain the text we want to render
````
msg        .byte “C64 programming tutorial by digitalerr0r of Dark Codex”
````

And then we include our custom charset

````
    org    $1ffe
INCBIN “scrap_writer_iii_17.64c”
````

And that’s it for rendering text. If you run this example, you will see the same result as below.

Listing 8.1 – Rendering text
````
    processor   6502
org    $1000

jsr $e544
lda #$0d
sta $d020
lda #$05
sta $d021
lda #$18
sta $d018

ldx #$00
write:      lda    msg,x
jsr    $ffd2
inx
cpx    #54
bne    write

ldx #$00
setcolor:  lda #$07
sta $d800,x
inx
cpx #$54
bne setcolor
loop:        jmp loop

msg        .byte “C64 programming tutorial by digitalerr0r of Dark Codex”

    org    $1ffe
INCBIN “scrap_writer_iii_17.64c”
````


text:
This directory contains puppet manifests that configure a development
environment for the gateway service.

These manifests are applied automatically if you use Vagrant. To apply them
manually, run the following from the root of the project:

    sudo FACTER_user=$USER FACTER_project_path=$PWD puppet apply --modulepath puppet/modules puppet/init.pp


text:
---
title: Vuepress deploy时的若干问题
date: 2021-05-31 21:15:18
permalink: /pages/3379fb/
categories:
  - 技术文章
  - 常见 bug 修复
tags:
  -
---
1、在 LaTeX 公式中使用中文括号

```python
LaTeX-incompatible input and strict mode is set to 'warn': Unrecognized Unicode character "−" (8722) [unknownSymbol]
LaTeX-incompatible input and strict mode is set to 'warn': Unicode text character "（" used in math mode [unicodeTextInMathMode]
LaTeX-incompatible input and strict mode is set to 'warn': Unicode text character "）" used in math mode [unicodeTextInMathMode]
```

![image-20210531211556961](https://muyun-blog-pic.oss-cn-shanghai.aliyuncs.com/picgo/image-20210531211556961.png)

repository: flyingjerryhe/Wiki

path: /docs/03.技术文章/01.常见 bug 修复/03.Vuepress deploy时的若干问题.md

filename: 03.Vuepress deploy时的若干问题.md

repo_name: flyingjerryhe/Wiki


text:
# Open Runtime Module Library (ORML) Workshop

This is a workshop project for learning about blockchain runtime development with
[Substrate](https://substrate.dev/),
[FRAME](https://substrate.dev/docs/en/knowledgebase/runtime/frame) and the
[Open Runtime Module Library](https://github.com/open-web3-stack/open-runtime-module-library). This
project implements a simple exchange protocol that is built on top of the ORML
[Currencies](https://github.com/open-web3-stack/open-runtime-module-library/tree/master/currencies)
and [Tokens](https://github.com/open-web3-stack/open-runtime-module-library/tree/master/tokens)
pallets. After completing this workshop, participants should have a better understanding of how to
design and implement a FRAME pallet.

## Add ORML Pallets

Find the implementations for the Currencies and Tokens pallets in
[the runtime](blob/master/runtime/src/lib.rs). Notice that the Tokens pallet is configured with a
`CurrencyId` set that specifies a native token; the Currencies pallet is configured to depend on the
Tokens pallet.

## Define an Exchange Protocol

The Exchange pallet defines a simple interface that depends on the ORML pallets that were configured
in the previous step:

- `submit_order(from_id, from_amt, to_id, to_amt)`
- `take_order(order_id)`
- `cancel_order(order_id)`

## Build & Run

If you need to,
[set up your Substrate development environment](https://substrate.dev/docs/en/knowledgebase/getting-started/#manual-installation).
Then, build and run a development chain:

```shell
$ cargo run -- --dev --tmp
```

Once the node is running, use this link to open the Polkadot JS Apps UI and connect to the Substrate
node: https://polkadot.js.org/apps/#/settings/developer?rpc=ws://<IP_ADDRESS>:9944. Use the Settings >
Developer app and the contents of the [`types.json`](blob/master/types.json) file to add the
necessary types to the UI.

## Upstream

This project was forked from the
[Substrate Developer Hub Node Template](https://github.com/substrate-developer-hub/substrate-node-template).

license: Unlicense

repository: gdixon/polkadotHackathon

repo_name: gdixon/polkadotHackathon


text:
Medhavi - Intelligent Infrastructure

Madhavi offers the “Intelligence mapping services” to translate the workload
intent to traits available in Open Infrastructure. This service my meet the
75-80% of guarantees under given constraints. The idea here is to use
infrastructure effectively without resorting to costly tuning and manual
optimization.

What is Infrastructure: Infrastructure is any kind of resource like Baremetal,
Virtual Machines, Containers or any other instance of a device or clusters on
which one executes applications or functions. Infrastructure can be described
as Templates with traits associated with its attributes.

What is Intelligence? Intelligence herein is the qualitative intent, expressed
as hints or traits that can be used to place and Manage the expectations of the
type of workload with the real-time constraints.
Real-time constraints will be specified like execution time (hr, min, sec),
precision (FP64, FP32, Int16, In8), latency ( < 1ms, between 1-10 ms,
20 ms, >100ms). This can be managed by policy profiles.

Profiles - Policies Profile per workload type will help Medhavi Intelligence
Service to use hints and traits to deliver meeting the real-time constraints
on Infrastructure.

To start one would restrict to Policy profiles providing rules to optimize the
defined KPIs to 80%. Once that is achieved one can use the AB testing idea to
distibute 20% of the load to a different workload type cluster or node to
observe how KPIs can be improved to achiever say 90% optimization.
Thus this will give possible potential to collect data on workload and profiles
that can be learned over a period to achieve better resource utilization etc.

Medhavi Design:

We will start with Medhavi Compute Workload Manager to enable the Medhavi API through A primary and secondary controllers. The API certainly will start with Baseline API support to run job in a container, VM or a Baremetal object. At this time we will not dwell into task level, and assume Job level scheduling should suffice.

The other assumption we make is that since all workloads these day assume a cluster we will assume our standard cluster to be made of 4 nodes(1-4) with agents and node(0) as agent manager. Node may be Containers, VMs or Physical servres and for PoC they will be host endpoints. We also assume for now that we have a DB Manager with Primary Controller managing DB schemas for persistance, and some message to publish & subscribe resources and nodes for cluster to carry put job operations.

Resources managed by Node Agent Manager and sometimes also termed as Device Manager as it deals with low level resources like CPU, GPU, FPGA and they may directly work thorugh agents or via different modules external to Medhavi upstream.

Following is the elements of Medhavi to manage the workload Intelligently.

Baseline APIs(Medhavi): Note each job must get a minimum of 1 virtual core to execute and all jobs run in parallel
ConfigNode: Config Node Agt
MonNode: Monitor Node
RunJ: init job
CancelJ: terminate job
InfoS: get status of system
InfoQ:status of Job(s)
InfoJ: Job state (steps completed or remaining)
InfoJ: Timit (start, elapsed, limit)
InfoMap: Map of nodes running job
InfoTopo: Topology view of Map
DB.ValidUsers
DB.ValidClusters
DB.ValidAccounts

https://go.gliffy.com/go/share/image/sys6fe15wgf6jre8ibm3.png?utm_medium=live-embed&utm_source=custom

repository: opentechfn/medhavi

repo_name: opentechfn/medhavi


text:
# Sending Email using ASP.NET Core with FluentEmail
A simple example of a sending email project using ASP.NET Core with FluentEmail.

```
This tutorial is under construction!
```

What you need to do
-------------------

Considering that you know a little about .Net Core, open the 'Visual Studio Code' and create a new mvc project.

Open the file 'appsettings.json' and put yours configurations like the example below:

```json
{
  "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
      "Default": "Warning"
    }
  },
  "EmailSettings": {
    "FromName": "Your name",
    "FromAddress"<EMAIL_ADDRESS>    "ToEmail": "",
    "CcEmail": "",
    "BccEmail": "",
    "ServerAddress": "smtp.gmail.com",
    "ServerPort": 587,
    "ServerUseSsl": true,
    "Username": "",
    "Password": ""
  }
}
```

Configure this file using the data in the table below (or other server), Gmail and Hotmail worked with me:

| Server Name  | SMTP Address | Port  | SSL |
| ------------- | ------------- | ------------- | ------------- |
| Gmail | smtp.gmail.com | 587 | Yes |
| Hotmail | smtp.live.com | 587 | Yes |

License
-------

This example application is [MIT Licensed](https://github.com/anzolin/AspNetCoreSendEmailWithFluentEmail/blob/master/LICENSE).

About the author
----------------

Hello everyone, my name is Diego Anzolin Ferreira. I'm a .NET developer from Brazil. I hope you will enjoy this simple example application as much as I enjoy developing it. If you have any problems, you can post a [GitHub issue](https://github.com/anzolin/AspNetCoreSendEmailWithFluentEmail/issues). You can reach me out at<EMAIL_ADDRESS>


text:
# Private Functions

## Distances
```@docs
SyntheticGrids.haversine

SyntheticGrids.subs_dist
```

## Topology building
```@docs
SyntheticGrids.twst!

SyntheticGrids.reinforce!

SyntheticGrids.connect_buses!

SyntheticGrids.connect_subs!

SyntheticGrids.cluster_loads!

SyntheticGrids.fill_gen!

SyntheticGrids.cluster_load_gen!

SyntheticGrids.cluster_gens!
```

## Graphs
```@docs
SyntheticGrids.laplacian

SyntheticGrids.dijkstra

SyntheticGrids.floyd_warshall
```

## Transmission Line properties
```@docs
SyntheticGrids.linear_imped

SyntheticGrids.rand_imped

SyntheticGrids.volt_cap
```


text:
# 🥝 Kiwi

> Seamless syncing for Design Github Wikis

Kiwi was specifically designed to handle automatic Wiki deploys for [Help Scout's](https://www.helpscout.com/) Design System.

## Table of Contents

<!-- START doctoc generated TOC please keep comment here to allow auto update -->
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->

- [Setup](#setup)
  - [CI Variables](#ci-variables)
  - [Git User](#git-user)
- [Usage](#usage)
- [Examples](#examples)
  - [Netlify](#netlify)

<!-- END doctoc generated TOC please keep comment here to allow auto update -->

## Setup

### CI Variables

Add the following global environment variables to your build/CI tool:

```
GITHUB_USER = bob_belcher_2019
GITHUB_REPO = baby-you-can-chive-my-car-burger
TOKEN = CV9$Xc]6iZVJRJiE*uV6MooXg
LOCAL_DIR = burger-project
```

##### `GITHUB_USER`

The Github user name of your repository.

##### `GITHUB_REPO`

The Github repository name.

##### `TOKEN`

Your super secret [Github personal access token](https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/)

##### `LOCAL_DIR`

The directory of your (CI) local directory.

### Git User

Since Kiwi needs to push to a Github wiki, ensure that your environment's Git has been set up with a username and email:

```
git config --global user.email<EMAIL_ADDRESS>git config --global user.name "bob_belcher_2019"
```

## Usage

Once you have the above ☝ set up (it's very important!), all you have to do is run:

```
npx @helpscout/kiwi
```

## Examples

### Netlify

For [Netlify](https://www.netlify.com/), you can create a simple `netlify.sh` file (or call it whatever you'd like 😍)

```
# Configures the Git name and email for the commits
git config --global user.email<EMAIL_ADDRESS>git config --global user.name "bob_belcher_2019"

# Set the environment variables
export GITHUB_USER=bob_belcher_2019
export GITHUB_REPO=baby-you-can-chive-my-car-burger
export TOKEN=CV9$Xc]6iZVJRJiE*uV6MooXg
export LOCAL_DIR=repo

# Runs Kiwi
npx @helpscout/kiwi

# Creates an empty page for Netlify to deploy
mkdir public
touch public/index.html
```

With that, you can set up the following:

- **Build command**: `sh netlify.sh`
- **Publish directory**: `public`

repository: helpscout/kiwi

repo_name: helpscout/kiwi


text:
# usbic

## USB Image Cloner

A tool to clone an image to multiple usb devices.  This is useful to clone a Raspberry to multiple USB devices.

## Requirements

- Node JS
- Linux (tested on Ubuntu 18)

## Usage

node usbic.js source-image target-disk1 target-disk2 target-diskX

## Example using NPM

``` sh
sudo npm i -g usbic
sudo usbic 2019-07-10-raspbian-buster-lite.img /dev/sdb /dev/sdc
```

## Example using GitHub clone

``` bash
node usbic.js 2019-07-10-raspbian-buster-lite.img /dev/sdb /dev/sdc
```

## Developers

To create a single binary installer use nexe

``` sh
sudo npm i -g nexe
cat usbic.js | nexe
```

## Notes

Depending on your system permissions you may need 'sudo' to write to the USB devices.

repository: IceXPR/usbic

repo_name: IceXPR/usbic


text:
# react-annotation

Full documentation: [http://react-annotation.susielu.com](http://react-annotation.susielu.com)

![composable-annotation](composable-annotation.gif)

## Setup
### Using NPM

You can add react-annotation as a node module by running

```bash
npm i react-annotation -S
```

If you're new to using React, I suggest using [create-react-app](https://github.com/facebookincubator/create-react-app) to start your project

## Feedback
I would love to hear from you about any additional features that would be useful, please say hi on twitter [@DataToViz](https://www.twitter.com/DataToViz).

## Prior art

- [Andrew Mollica](https://bl.ocks.org/armollica/67f3cf7bf08a02d95d48dc9f0c91f26c), [d3-ring-note](https://github.com/armollica/d3-ring-note) D3 plugin for placing circle and text annotation, and [HTML Annotation](http://bl.ocks.org/armollica/78894d0b3cbd46d8d8d19d135c6ca34d)

- [Scatterplot with d3-annotate](https://bl.ocks.org/cmpolis/f9805a98b8a455aaccb56e5ee59964f8), by Chris Polis, example using [d3-annotate](https://github.com/cmpolis/d3-annotate)

- [Rickshaw](http://code.shutterstock.com/rickshaw/) has an annotation tool

- [Benn Stancil](https://modeanalytics.com/benn/reports/21ebfb6b6138) has an annotation example for a line chart

- [Adam Pearce](http://blockbuilder.org/1wheel/68073eeba4d19c454a8c25fcd6e9e68a) has arc-arrows and [swoopy drag](http://1wheel.github.io/swoopy-drag/)

- [Micah Stubbs](http://bl.ocks.org/micahstubbs/fa129089b7989975e96b166077f74de4#annotations.json) has a nice VR chart based on swoopy drag

- [Scott Logic](http://blog.scottlogic.com/2014/08/26/two-line-components-for-d3-charts.html) evokes “line annotation” in a graph (different concept).

- [Seven Features You’ll Want In Your Next Charting Tool](http://vis4.net/blog/posts/seven-features-youll-wantin-your-next-charting-tool/) shows how the NYT does annotations

- [John Burn-Murdoch](https://bl.ocks.org/johnburnmurdoch/bcdb4e85c7523a2b0e64961f0d227154) example with adding/removing and repositioning annotations

repository: hill-a/atom-config

repo_name: hill-a/atom-config


text:
# Godot-RTS-Camera-Updated
Updated RTS Camera, works much better.
Smooth camera with the ability to customize the camera completely, go wild!
I mean play with the editor exports, and don't open the camera.gd unless you want to, it's a lot of mess, I'll improve the camera later on.

This camera will be used in OpenSkyCity, so I will keep the camera up-to-date with the features I had in mind.

This camera controller also uses Actions, so you can change the actions with ease.

Currently this camera controller has:
1. [x] Edge scrolling (Scroll if mouse is on edge)
2. [x] Movement with WASD
3. [x] Rotation with QE
4. [x] Tilting with RF
5. [x] Zooming with ZX
6. [x] Zoom to cursor
7. [x] Tilt Shift (I guess) (Targeted zoom in code)
8. [x] Limits (clamp the camera to be limited in specific areas, only supports rect for now.)
9. [x] Panning with Right Mouse Button
10. [x] Mouse rotation with Left Mouse Button
11. [x] Zooming with mouse wheel and magnify gesture.
12. [x] Perspective panning (panning intensity is based on the distance)
13. [x] Inverting options, you can invert 85% of camera, except movement, which I guess isn't necessary, open a issue if you want it. It's easy to implement.
14. [ ] Speed boost is planned.

Todo for this camera:
```
1. Implement Speed Boost (Boost the speed with multiplier if the keys are kept pressed for more than 2 secs)
2. Implement following (Camera will follow specific item, if it is destroyed the camera will be placed back to where it was, can be customized to place it as it is or offset it by x units.)
3. Implement picture in picture mode (Like in OpenTTD and Transport Fever 2, will support customizations.)
```
and that's it!

Instruction to use the camera:
```
1. Clone the repository.
2. Copy over Camera.tscn and Camera.gd
3. Copy all actions.
4. Instantiate Camera.tscn into your scene, customize it.
5. and try out the game
6. customize it even more
7. try out the game
```
And enjoy!


text:
# Heading H1
Heading 1 text
## Heading H2
Heading 2 text
### Heading H3
Heading 3 text
#### Heading H4
Heading 4 text
##### Heading H5
Heading 5 text
###### Heading H6
Heading 6 text

# Bold
```
I just love **bold text**.

I just love __bold text__.
```
produces...
I just love **bold text**.

I just love __bold text__.

# Italics
```
Italicized text is the *cat's meow*.

Italicized text is the _cat's meow_.

This text is ***really important***.
```
produces...
Italicized text is the *cat's meow*.

Italicized text is the _cat's meow_.

This text is ***really important***.

# Block Quotes
```
>Here is a block Quote
>> Here is a nested block Quote

>Here
>> is
>>> another

> ### You can add other elements inside BQ!
> - like
> - bullet
> - points
>> 1. or
>> 1. numbered
>> 1. lists
```
produces...
  >   Here is a block Quote
  >>Here is a nested block Quote

  >Here
  >> is
      >>> another
> ### You can add other elements inside BQ!
> - like
> - bullet
> - points
>> 1. or
>> 1. numbered
>> 1. lists
# Lists ( and accidental diffing example :) )

diffing here happens because its inside a code block:

```
- First ( minus )
* second ( star )
+ Third ( plus )
  + with indent ( plus )
  - and another ( minus )
    - more indent?
      - and more?
        - no more
          1. and
          2. now
          3. numbered
* and back ( star )
```

produces...
- First ( minus )
* second ( star )
+ Third ( plus )
  + with indent ( plus )
  - and another ( minus )
    - more indent?
      - and more?
        - no more
          1. and
          2. now
          3. numbered
* and back ( star )

# Paragraphs
```
*   This is the first list item.
*   Here's the second list item.

>    I need to add another paragraph below the second list item.

*   And here's the third list item.
```
produces
*   This is the first list item.
*   Here's the second list item.

> I need to add another paragraph below the second list item.

*   And here's the third list item.

# Code Blocks
Code blocks are normally indented four spaces or one tab. When they’re in a list, indent them eight spaces or two tabs.

````
1.  Open the file.
2.  Find the following code block on line 21:

```html
  <html>
      <head>
        <title>Test</title>
      </head>
  </html>
```
3.  Update the title to match the name of your website.

json example :
```json
    {
      "firstName": "John",
      "lastName": "Smith",
      "age": 25
    }

````

produces...
1.  Open the file.
2.  Find the following code block on line 21:

```html
  <html>
      <head>
        <title>Test</title>
      </head>
  </html>
```
3.  Update the title to match the name of your website.

json example :
```json
    {
      "firstName": "John",
      "lastName": "Smith",
      "age": 25
    }
```
# Inline codeblocks

```
At the command prompt, type `ssh thisguy@thisServer echo "theCakeIsALie!"`.
```
produces...
At the command prompt, type `ssh thisguy@thisServer echo "theCakeIsALie!"`

# Images
```
1.  Open the file containing the Linux mascot.
2.  Marvel at its beauty.

![Tux, the Linux mascot](tux.png)

3.  Close the file.
```
produces...
1.  Open the file containing the Linux mascot.
2.  Marvel at its beauty.

    ![Tux, the Linux mascot](tux.png)

3.  Close the file.

# Horizontal Rules
To create a horizontal rule, use three or more asterisks, dashes or underscores on a line by themselves.
```
************
-----
___
```
produces...
To create a horizontal rule, use three or more asterisks, dashes or underscores on a line by themselves.

************
-----
___

# Links
To create a link, enclose the link text in brackets (e.g., [Duck Duck Go]) and then follow it immediately with the URL in parentheses (e.g; (https://duckduckgo.com)).
```
My favorite search engine is [Duck Duck Go](https://duckduckgo.com)

OR

My favorite search engine is [Duck Duck Go](https://duckduckgo.com "The best search engine for privacy").

ORRRRR

To quickly turn a URL or email address into a link, enclose it in angle brackets.

<https://www.markdownguide.org>

<EMAIL_ADDRESS>
```
produces...

My favorite search engine is [Duck Duck Go](https://duckduckgo.com)

OR

My favorite search engine is [Duck Duck Go](https://duckduckgo.com "The best search engine for privacy").

ORRRRR

To quickly turn a URL or email address into a link, enclose it in angle brackets.

<https://www.markdownguide.org>
<EMAIL_ADDRESS>
# Images
To add an image, add an exclamation mark (!), followed by alt text in brackets, and the path or URL to the image asset in parentheses. You can optionally add a title after the URL in the parentheses.
```
![Philadelphia's Magic Gardens. This place was so cool!](philly-magic-garden.jpg "Philadelphia's Magic Gardens")
```
produces...
![Philadelphia's Magic Gardens. This place was so cool!](philly-magic-garden.jpg "Philadelphia's Magic Gardens")

## link Images

To add a link to an image, enclose the Markdown for the image in brackets, and then add the link in parentheses.

```
[![An old rock in the desert](shiprock.jpg "Shiprock, New Mexico by Beau Rogers")](https://www.flickr.com/photos/beaurogers/31833779864/in/photolist-Qv3rFw-34mt9F-a9Cmfy-5Ha3Zi-9msKdv-o3hgjr-hWpUte-4WMsJ1-KUQ8N-deshUb-vssBD-6CQci6-8AFCiD-zsJWT-nNfsgB-dPDwZJ-bn9JGn-5HtSXY-6CUhAL-a4UTXB-ugPum-KUPSo-fBLNm-6CUmpy-4WMsc9-8a7D3T-83KJev-6CQ2bK-nNusHJ-a78rQH-nw3NvT-7aq2qf-8wwBso-3nNceh-ugSKP-4mh4kh-bbeeqH-a7biME-q3PtTf-brFpgb-cg38zw-bXMZc-nJPELD-f58Lmo-bXMYG-bz8AAi-bxNtNT-bXMYi-bXMY6-bXMYv)
```
produces...
[![An old rock in the desert](shiprock.jpg "Shiprock, New Mexico by Beau Rogers")](https://www.flickr.com/photos/beaurogers/31833779864/in/photolist-Qv3rFw-34mt9F-a9Cmfy-5Ha3Zi-9msKdv-o3hgjr-hWpUte-4WMsJ1-KUQ8N-deshUb-vssBD-6CQci6-8AFCiD-zsJWT-nNfsgB-dPDwZJ-bn9JGn-5HtSXY-6CUhAL-a4UTXB-ugPum-KUPSo-fBLNm-6CUmpy-4WMsc9-8a7D3T-83KJev-6CQ2bK-nNusHJ-a78rQH-nw3NvT-7aq2qf-8wwBso-3nNceh-ugSKP-4mh4kh-bbeeqH-a7biME-q3PtTf-brFpgb-cg38zw-bXMZc-nJPELD-f58Lmo-bXMYG-bz8AAi-bxNtNT-bXMYi-bXMY6-bXMYv)

# Tables
http://www.tablesgenerator.com/markdown_tables

```
| Tables   	|      Are      	|  Cool 	|
|----------	|:-------------:	|------:	|
| col 1 is 	|  left-aligned 	| $1600 	|
| col 2 is 	|    centered   	|   $12 	|
| col 3 is 	| right-aligned 	|    $1 	|
|   |   |   |

You can display a pipe (|) character in a table by using its HTML character code (|).
```
produces...

| Tables   	|      Are      	|  Cool 	|
|----------	|:-------------:	|------:	|
| col 1 is 	|  left-aligned 	| $1600 	|
| col 2 is 	|    centered   	|   $12 	|
| col 3 is 	| right-aligned 	|    $1 	|
|   |   |   |

You can display a pipe (|) character in a table by using its HTML character code (|).

# footnote

Here's a simple footnote,[^1] and here's a longer one.[^bignote]

[^1]: This is the first footnote.

[^bignote]: Here's one with multiple paragraphs and code.

    Indent paragraphs to include them in the footnote.

    `{ my code }`

    Add as many paragraphs as you like.

# Links to headers
```
[Footnotes](#footnote)
```
produces...
[Footnotes](#footnote)

# Definition Lists (TODO)
Some Markdown processors allow you to create definition lists of terms and their corresponding definitions. To create a definition list, type the term on the first line. On the next line, type a colon followed by a space and the definition.

First Term
: This is the definition of the first term.

Second Term
: This is one definition of the second term.
: This is another definition of the second term.

# Strikethrough
```
~~The world is flat.~~ We now know that the world is round.
```
produces...
~~The world is flat.~~ We now know that the world is round.

# Task lists (accidental diffing inside code block)
```
- [x] Write the press release
- [ ] Update the website
- [x] Contact the media
- [ ] Dont do anything else
```
produces...
- [x] Write the press release
- [ ] Update the website
- [x] Contact the media
- [ ] Dont do anything else

repository: RH-sdavey/sean-helper

branch_name: refs/heads/sean-branch

repo_name: RH-sdavey/sean-helper


text:
# Target MVD API

## _Rails 6 API edition_

I have created this API for learning purposes.

Thanks to Rootstrap devs for helping me to understand rails.

## Links
- [API Documentation](https://apitargetmvd.docs.apiary.io/)
- [Trello Guides](https://trello.com/b/6EIY1WIJ/rs-learning-camp-ruby-on-rails-edition)

## License

MIT

repository: keinydev/targetmvdapi

gha_language: Ruby

repo_name: keinydev/targetmvdapi


text:
# Name
quicrest - create rest server quickly  and easily on C++

Table of Contents
=================

* [Name](#name)
* [Description](#description)
    * [quickly develop rest server](#quickly develop rest server)
    * [easily debug](#easily debug)
    * [quickly automatic test](#quickly automatic test)
    * [automatic doc genarition] (#automatic doc genarition)
* [Author](#Author)
* [Copyright & License](#copyright--license)

description
======
create a rest server api quickly:

quickly develop rest server
======

easily debug
======

quickly automatic test
======

Author
======

lilei (李磊<EMAIL_ADDRESS>
[Back to TOC](#table-of-contents)

Copyright and License
=====================

This module is licensed under the BSD license.

Copyright (C) 2015-2016, by Lilei.

All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.

[Back to TOC](#table-of-contents)

repository: lilei/quicrest

repo_name: lilei/quicrest


text:
# [Dateline Quiz](http://alexa.amazon.com/#skills/amzn1.ask.skill.5bb6c047-90e2-45dd-b4ba-7f5ae1dd5d65)
![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png) 0

To use the Dateline Quiz skill, try saying...

* *Alexa Open Dateline Quiz*

* *Alexa Ask Dateline Quiz For Five Questions*

* *Alexa Ask Dateline Quiz For 10 Years*

How well do you know your recent history?
Try and guess the year from the provided clues.
If your're not sure keep asking for more clues.
Score more points the closer you are to the actual year.
Fun and educational for all the family.

***

### Skill Details

* **Invocation Name:** dateline quiz
* **Category:** null
* **ID:** amzn1.ask.skill.5bb6c047-90e2-45dd-b4ba-7f5ae1dd5d65
* **ASIN:** B01MFFXUC3
* **Author:** Ian Fletcher
* **Release Date:** November 9, 2016 @ 03:13:02
* **In-App Purchasing:** No


text:
# smtpproxy

A small SMTP Proxy Server written in Python

**Version**: 1.6.0

*smtpproxy* is a Python script that implements a small SMTP proxy server. It can be used, for example, when the real remote SMTP server requires applications to implement the pop-before-pp authentication scheme and the application doesn't have support for this scheme. An example for this are php-based applications such as the phpBB forum.

The proxy can also be extended by handlers to further process emails send by devices, for example for extracting voice messages received and forwarded by a local PBX. See the [Mail Handler](#mailhandler) section below.

The core of the *smtpproxy* is based on the *smtps.py* script by Les Smithon (original located at [http://www.hare.demon.co.uk/pysmtp.html](http://www.hare.demon.co.uk/pysmtp.html) but the link seems to be dead). Some small modifications to the original implementation were made to make the connection handling multi-threaded. This modified version of the the smtp-script is included in the zip-file.

The server stores received mails temporarily in a sub-directory *msgs*. A separate thread in the script is responsible to send the mails to the configured destination SMTP server, optionally performing the POP-before-SMTP authentication and calling email handlers.

## Changes

See [CHANGELOG.md](CHANGELOG.md) for a detailed list of changes.

## Installation

#### Prerequisites
- Python 2.6

#### Installation & Configuration
- Clone the repository or download the files to a directory.
- Edit the file smtpproxy.ini (see [Configuration](#configuration) instructions below).

#### Running
- Execute the script smtpproxy.py, eg. enter ``python smtpproxy.py`` on the command line.

The script creates a directory *msgs* for the the temporary files in the same directory as the script (if not specified otherwise in the configuration). The activities (and possible errors) are logged in the log file specified in the configuration file.

#### Install As a Service

Besides of running the *smtpproxy* from a command line the script can be installed as a system service. The script [smtpproxy.init.d](smtpproxy.init.d) can be used to set it for using init.d :

- Copy the script [smtpproxy.init.d](smtpproxy.init.d) to ``/etc/init.d/smtpproxy``
- Set the variable *DAEMON_PATH* in the script to the installation path of *smtpproxy*.
- Start the service, e.g. as root, via the *service* command: ``service smtpproxy start``.

## Configuration

The proxy server is configured by an ini-style configuration file in the current working directory of the server. The name of this file is *smtpproxy.ini*. The file [smtpproxy.ini.example](smtpproxy.ini.example) can be used as a start to setup a configuration file.

The individual sections are explained in the following sections.

### Basic Configuration \[config]

``` ini
[config]
port=25
sleeptime=30
debuglevel=0
waitafterpop=5
deleteonerror=true
```

- **port=<integer>** : This is the port for the local SMTP server. Optional. The default is *25*.
- **sleeptime=<integer>** : The time to wait for the relaying thread to wait between checks for work, in seconds. Optional. The default is *30*.
- **debuglevel=<integer>** : This sets the debuglevel for various functions. The default is *0* (no debug output). See [https://docs.python.org/3/library/smtplib.html#smtp-objects](https://docs.python.org/3/library/smtplib.html#smtp-objects) *SMTP.set_debuglevel* for further information.
- **waitafterpop=<integer>** : The time to wait after a first pop authentication attempt, in seconds. The default is *5*.
- **deleteonerror=<boolean>** : Delete a mail when an error occurs. The default *true*.

### Logging Configuration \[logging]

``` ini
[logging]
file=smtpproxy.log
size=1000000
count=10
level=INFO
```

- **file=<string>** : Path and name of the log file. Optional. The default is *smtpproxy.log*.
- **size=<integer>** : Size of the log file before splitting it up into a new logfile. Optional. The default is *1000000*.
- **count=<integer>** : Number of log files to keep. Optional. The default is *10*.
- **level=<string>** : One of *INFO*, *WARNING*, *ERROR* or *NONE*. In case of *NONE*, only critical errors are logged. Optional. The default is *INFO*.

### Sender's Mail Account Configuration

This section must be configured for each sender's mail account, so it may appear more than once in the configuration file.

Please note, that *smtpproxy* can connect to one or more remote SMTP servers. For each remote server a separate mail account section must be configured.

``` ini
[<mail address of the sender, eg<EMAIL_ADDRESS>localhostname=localdomain.com
smtphost=smtp.example.com
smtpsecurity=ssl
smtpusername=username
smtppassword=password
popbeforesmtp=true
pophost=pop.example.com
popport=995
popssl=true
popusername=username
poppassword=password
popcheckdelay=60
<EMAIL_ADDRESS>```

**General Settings**

- **localhostname=<string>** : The host name used by the proxy to identify the local host to the remote SMTP server. Optional.

**SMTP Settings**

- **smtphost=<string>** : The host name of the receiving SMTP server. Mandatory.
- **smtpport=<integer>** : The port of the receiving SMTP server. Optional. The default is depends on the *smtpsecurity* type (*none* and *tls*: 25, *ssl*: 465).
- **smtpsecurity=<string>** : Indicates the type of the communication security to the SMTP server. Either "tls", "ssl", or "none" (all lowercase, without ".."). The default is "none".
- **smtpusername=<string>** : The username for the SMTP account. Optional, but this entry must be provided if the SMTP server needs authentication.
- **smtppassword=<string>** : The password for the SMTP account. Optional, but this entry must be provided if the SMTP server needs authentication.
**PLEASE NOTE**: The password is stored in plain text! See also the discussion regarding [Security](#security).

**POP3 Settings**

- **popbeforesmtp=<boolean>** : Indicate whether POP-before-SMTP authentication must be performed. Optional, *true* or *false*. The default is *false*.
- **pophost=<string>** : The host name of the POP3 server. Mandatory only if *popbeforesmtp* is set to *true*.
- **popport=<integer>** : The port of the POP3 server. Optional. The default is *995*. Change this to *110* for non-SSL connections.
- **popssl=<bool>** :Indicates whether the POP connection should be using SSL. The default is true.
- **popusername=<string>** : The username for the POP3 account. Mandatory only if *popbeforesmtp* is set to *true*.
- **poppassword=<string>** : The password for the POP3 account. Mandatory only if *popbeforesmtp* is set to *true*.
**PLEASE NOTE**: The password is stored in plain text! See also the discussion regarding [Security](#security).
- **popcheckdelay=<integer>** : The time to wait before to re-authenticate again with the POP3 server, in seconds. Optional. The default is *60*.

**Mail Header Fields**

- **returnpath=<string>** : Specifies a bounce email address for a message. Optional.

**Refer to Another Configuration**

Instead of creating a new Sender's Mail Configuration for every account, one can setup an account by just referring to another configuration by using the ``use=`` configuration entry. This must be the only setting for this account.

- **use=<string>** : The name of another account configuration. If this is set then the configuration data of that account is taken instead.

## How to use

After configuring and starting the *smtpserver* the clients need to be configured to use the proxy. For this, usually the following values needs to be set:

- **SMTP Server Host**: This is the address or hostname of the host on which the *smtpserver* runs.
- **SMTP Server Port**: The port number on which the *smtpserver* listens locally for incoming connections. This is the value of the *port* entry in the *[config]* section of the configuration file.
- **e-mail User Name or Account**: The **local** user name. This is the account that was used as a section title to set the sender's mail account configuration, e.g<EMAIL_ADDRESS>in the example above.

## Security
### Account Information

Please note, that account information (usernames and passwords) are stored in plain text in the configuration file. You need to make sure that *smtpproxy*'s directory, can only be read and executed by the account under which the *smtpproxy* is run by setting the file permissions accordingly:

	$ chown -R <smtpproxy user>:<smtpproxy group> smtpproxy
	$ chmod 700 smtpproxy

### Local communication
So far, only unencrypted local communication is supported.

### Remote communication
POP3 communication can be secured by using SSL for POP3 (port 995). This is the default.

SMTP communication can be secured by using TLS for SMTP (on the same port), or SMTP over SSL.

## Mail Handler Extensions

Before forwarding a received mail, the *smtpproxy* can call handlers to process the mail. This feature can be used, for example, to extract and store voice messages that are forwarded by email from the answering machine of a home router. A handler can also be used to stop further processing / discarding an email.

During startup *smtpproxy* loads all python modules in the sub-directory *handlers*. Each module contains a class that is derived from the abstract class [MailHandler](MailHandler.py) and must implement the following methods:

- **MailHandler.isEnabled()** : Indicates whether a handler is enabled. Returns *True* or *False* respectively.
- **MailHandler.setLogger(logger)** : This method is used to inject the logger instance into the handler. The logger can be used to log results and debug messages from the handler.
- **MailHandler.handleMessage(message, mail, callback)** : This message is called to handle a message. The *message* is an email object that conforms to the Python email library package. *mail* is an internal Mail object with the fields 'Mail.to', 'Mail.frm' and 'Mail.msg'. *callback* is an object with two methods 'setTo(string)' and 'setFrom(string)' to set the respective header fields.  See [https://docs.python.org/2/library/email.html](https://docs.python.org/2/library/email.html) for details.
This method must return *True* when the email was processed normally. When this methd returns *False*, then no further email processing happens and the currently processed email is discarded (ie. not send).

## License

The *smtpproxy* is available under the MIT license, with the exception of the *smtps.py* script that comes with its own license.

---

The MIT License (MIT)

Copyright (c) 2007 - 2018 Andreas Kraft

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

repository: acelandlead/smtpproxy

repo_name: acelandlead/smtpproxy


text:
Bitcoin Floating Fee Statistics
===============================

This project is collecting data around the new floating fees and analyzing it statistically.

License
-------

[MIT](http://opensource.org/licenses/MIT)


text:
# FullStack Conference using Bootstrap

Fictitious javaScript conferences called full stack conf to how to use bootstrap

<img width="1423" alt="Screen Shot 2019-07-20 at 9 48 55 AM" src="https://user-images.githubusercontent.com/25851867/61580105-aedc3800-aad3-11e9-94e5-37364aadf134.png">

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.

### Prerequisites

What things you need to install the software and how to install them

```
<!-- bootstrap css -->
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0-alpha.2/css/bootstrap.min.css" integrity="sha384-y3tfxAZXuh4HwSYylfB+J125MxIs6mR5FOHamPBG064zB+AFeWH94NdvaCBm8qnd" crossorigin="anonymous">
    <link href="https://afeld.github.io/emoji-css/emoji.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css?family=Open+Sans:400,400i,600,700" rel="stylesheet">
    <link rel="stylesheet" href="css/custom.css">
<!-- jQuery first, then bootstrap js -->
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.4/jquery.min.js"></script>
    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0-alpha.2/js/bootstrap.min.js" integrity="sha384-vZ2WRJMwsjRMW/8U7i6PWi6AlO1L79snBrmgiDpgIWJ82z8eA5lenwvxbMV1PAh7" crossorigin="anonymous"></script>
```

### Installing

A step by step series of examples that tell you have to get a development env running

Say what the step will be

```
Give the example
```

And repeat

```
until finished
```

End with an example of getting some data out of the system or using it for a little demo

## Running the tests

Explain how to run the automated tests for this system

### Break down into end to end tests

Explain what these tests test and why

```
Give an example
```

### And coding style tests

Explain what these tests test and why

```
Give an example
```

## Deployment

Add additional notes about how to deploy this on a live system

## Built With

* [Dropwizard](http://www.dropwizard.io/1.0.2/docs/) - The web framework used
* [Maven](https://maven.apache.org/) - Dependency Management
* [ROME](https://rometools.github.io/rome/) - Used to generate RSS Feeds

## Contributing

Please read [CONTRIBUTING.md](https://gist.github.com/PurpleBooth/b24679402957c63ec426) for details on our code of conduct, and the process for submitting pull requests to us.

## Versioning

We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/your/project/tags).

## Authors

* **Sergio Torres** - *Initial work* - [MileStake](https://github.com/Esteban-Towerz)

See also the list of [contributors](https://github.com/treehouse) who participated in this project.

## License

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

## Acknowledgments

* Hat tip to anyone who's code was used
* Inspiration
* etc

Viewport
Window
1440×759
1440×900
×

repository: sergio-esteban/full-stack-conf

repo_name: sergio-esteban/full-stack-conf


text:
---
layout: default
---

# 1994-12-13 - Re: HTTP security

## Header Data

From: "Perry E. Metzger"<EMAIL_ADDRESS>To<EMAIL_ADDRESS>(Eric Rescorla)

Message Hash: b85278144678077d425cd7509cbb716ea3ca379446a1d144f0f8ed62a183d00c

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1994-12-13 16:44:25 UTC

Raw Date: Tue, 13 Dec 94 08:44:25 PST

## Raw message

```
{% raw  %}From: "Perry E. Metzger"<EMAIL_ADDRESS>Date: Tue, 13 Dec 94 08:44:25 PST
To<EMAIL_ADDRESS>(Eric Rescorla)
Subject: Re: HTTP security
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Eric Rescorla says:
> In the email world, you don't necessarily have any sort of prior
> relationship with the person you're communicating with and that public
> key cryptography is relatively cheap. (When it takes minutes to
> ship mail across the net, who's going to notice a second or two
> of signature verification?) However, in the case of the Web,
> things are very different.

Since one can sign pages just once (they are written once and read
often) and one can pick one's signature algorithm to speed up
verifications relative to the signatures (using small exponents is the
usual trick fo this), I'm not sure its that big a problem.

I'd like these algorithms to support the serving of signed pages from
hosts that do not know the keys that the pages have been signed with
-- offline signature schemes like the one I just described will
support that nicely.

(However, any algorithm that is cognisant of the difference between
securing the pages and just securing the channel is an improvement
over the SSL proposal.)

.pm

{% endraw %}
```

## Thread

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

+ Return to<EMAIL_ADDRESS>(Eric Rescorla)](/authors/ekr_at_eit_com_eric_rescorla_)"
+ Return to "["Perry E. Metzger" <perry@imsi.com>](/authors/perry_e_metzger_perry_at_imsi_com_)"

+ 1994-12-13 (Tue, 13 Dec 94 08:34:10 PST) - [Re: HTTP security](/archive/1994/12/0e5000faac699b3727e129083ca4831e8a5d06881dba220034095be7fc8ccd97) -<EMAIL_ADDRESS>(Eric Rescorla)_
  + 1994-12-13 (Tue, 13 Dec 94 08:44:25 PST) - Re: HTTP security - _"Perry E. Metzger"<EMAIL_ADDRESS>


text:
<!-- =============================
     ABOUT
    ============================== -->

\begin{:section, title="About this Package", name="About"}

\lead{PkgPage.jl is based upon [Franklin.jl](https://github.com/tlienart/Franklin.jl) and makes it easy to create a beautiful landing page for a package in less than 10 minutes.}

PkgPage uses [Bootstrap 4.5](https://getbootstrap.com/docs/4.5/getting-started/introduction/) and is meant to be particularly easy to use with minimal need to tweak HTML or CSS to get a great-looking result.
With it you can:

* easily insert and style figures and tables,
* easily initiate a multi-columns environment,
* easily control the layout, colors, code theme etc from the config file,
* automatic insertion of new sections into the navbar,
* automatic purging of bootstrap css to remove unused rules,
* all the goodies from [Franklin.jl](https://github.com/tlienart/Franklin.jl):
    * live-rendering,
    * support for [KaTeX](https://github.com/KaTeX/KaTeX) and [highlight.js](https://highlightjs.org/) and automatic pre-rendering,
    * and [much more](https://franklinjl.org/).

\end{:section}

<!-- =============================
     GETTING STARTED
     ============================== -->
\begin{:section, title="Getting started"}

In order to get started, just add the package (with **Julia ≥ 1.3**) and

```julia-repl
julia> using PkgPage
julia> newpage()
julia> serve()
```

\\

The `newpage` call will
* generate a `page/` folder in your current directory which contains all the material to generate your site,
* place a `.github/workflows/DeployPage.yml` to enable the github action that will help deploy your page.

The `serve` call will render your page and make it available for live-preview in your browser.

\alert{You can specify another folder name via `newpage(path="page2")` but don't forget to modify this in the `DeployPage.yml` as well (in 2 spots).}

\end{:section}

<!-- =============================
     SPECIAL COMMANDS
     ============================== -->
\begin{:section, title="Commands"}

\lead{PkgPage makes a few commands available to you to simplify the insertion of common useful environments.
}

**Sections**: you can indicate a section as follows:

```plaintext
\begin{:section, opts...}
text
\end{:section}
```

where the available options are:

* `title="..."` to add a heading to the section, this should be provided,
* `name="..."` to add a specific name that will appear in the navbar (if not given, it will use the given title).

**Figures**: you can indicate a figure as follows:

```plaintext
\figure{path="...", opts...}
```

where `path` is a valid path to the image (e.g. `/assets/image.png`) and the other available options are:

* `width="..."` to specify the width of the image (e.g. `100%`),
* `alt="..."` to specify the image `alt`,
* `caption="..."` to specify the figure caption if any,
* `style="..."` to add any specific CSS styling to the image (e.g. `border-radius:5px`).

\center{
  \figure{path="/assets/nice_image.jpg", width="100%", style="border-radius:5px;", caption="Panoramic view of the Tara Cathedrals (taken from Wikimedia)."}
}

**Tables**: you can insert a table as follows:

```plaintext
\table{"""
| Column One | Column Two | Column Three |
|:---------- | ---------- |:------------:|
| Row `1`    | Column `2` |              |
| *Row* 2    | **Row** 2  | Column ``3`` |
""", opts...}
```

where the available options are:

* `caption="..."`: to add a caption to the table,
* `class="..."`: to add specific bootstrap classes to the table (e.g. `table-striped`),
* `style="..."`: for any further styling.

\center{
    \table{"""
    | Column One | Column Two | Column Three |
    |:---------- | ---------- |:------------:|
    | Row `1`    | Column `2` |              |
    | *Row* 2    | **Row** 2  | Column ``3`` |
    """, caption="A simple table", class="table-striped"}
}

**Columns**: you can declare an environment with columns with:

```plaintext
\begin{:columns}
\column{
Content of a first column  here
}
\column{
Content of a second column here
}
\end{:columns}
```

which will look like:

\begin{:columns}
\column{
_Content of a first column here_
}
\column{
_Content of a second column here_
}
\end{:columns}

\\

**Maths**

Just use `$$ ... $$` for display math and  `$ ... $` for inline maths:

$$ w_i = {2 \over (1-x_i^2)[P'_n(x_i)]^2} $$ <!--_-->

where $P_n$ is the $n$-th [Legendre polynomial](https://en.wikipedia.org/wiki/Legendre_polynomials) and $x_i$ is it's $i$-th root.

**Misc**

* you can use `\\` to add some vertical space (skip a line)
* you can use `\center{...}` to center some content
* you can use `\style{color:red;text-transform:capitalize;}{hello}` to get something like \style{color:red;text-transform:uppercase;}{hello},
* you can use `\alert{...}` to draw attention to some text via a coloured box.

You can also define your own commands which can be as complex as you might want, see the [Franklin docs](https://franklinjl.org) for more information.

\end{:section}

<!-- =============================
     Deploying
    ============================== -->

\begin{:section, title="Deployment"}

\lead{Make your page available online easily by leveraging github actions and GitHub pages.}

By following these instructions, the content of the rendered website will be copied to a `gh-pages` branch where it will be deployed by GitHub.
If you would like to deploy the page with your own URL or using something else than GitHub, have a  look at the specific instructions further on.

**Keys**: in order to have your page be built and deployed on GitHub, you will need to generate a keypair and add it to the GitHub repo. To do so:

1. run in your terminal  `ssh-keygen -N "" -f franklin`,
1. copy the entire content of  the `franklin` file and put it as a new secret named `FRANKLIN_PRIV` on <https://github.com/USERNAME/PACKAGE.jl/settings/secrets/new>,
1. copy the entire content of the  `franklin.pub` file and put it as a new deploy key named `FRANKLIN_PUB` on <https://github.com/USERNAME/PACKAGE.jl/settings/keys> with `read/write` access.

Whenever the `master` branch of your package gets updated, the  build process will be triggered and your page updated.
That's it.

**Avoiding clashes with Documenter.jl**: if you already use [Documenter.jl](https://github.com/JuliaDocs/Documenter.jl) you might want your page to be deployed in a specific folder of `gh-pages`.

\alert{Note that this is typically not necessary as the names created by PkgPage and by Documenter don't clash, but you might still prefer to not mix the two (in which case, read on).}

 you can do so in two steps:

1. change the `run` part of `DeployPage.yml` by specifying the `output` keyword argument  in `PkgPage.optimize` for instance: `PkgPage.optimize(input="page", output="page")`,
1. change the `prepath` in `config.md` to reflect that the base URL will contain that additional folder, for instance `@def prepath = "YourPackage.jl/page"`.

**Use your own URL**: you can usually get your host service like netlify to deploy a specific branch, do make sure to set `@def prepath = ""` in your `config.md` though.

\end{:section}

<!-- =============================
     SHOWING CODE
    ============================== -->

\begin{:section, title="Showing Code"}

\lead{
    Franklin can run your Julia code on the fly and show the output.
}

**Setting up the environment**: the first step is to ensure that the folder with your source has the proper environment including your package.
To do so, in the Julia REPL, navigate to the source (e.g. `cd("page/")`), activate the environment (e.g. `using Pkg; Pkg.activate()`) and add the package(s) that you need (e.g. `Pkg.add("DataFrames")`).
If you check the status or the Project.toml, you will see that `Franklin` is already in there on top of whatever packages you might have chosen to add.
In our current case:

```
Status `~/.julia/dev/PkgPage/page/Project.toml`
  [a93c6f00] DataFrames v0.21.2
  [713c75ef] Franklin v0.8.2
```

Also add the package in the `DeployPage.yml` e.g. in our case there is:

```julia
Pkg.add(["NodeJS", "DataFrames"]);
```

Once that's set up, you can use "named" code blocks i.e. code blocks that look like

`````
```julia:ex
using DataFrames
df = DataFrame(A = 1:4, B = ["M", "F", "F", "M"])
first(df, 3)
```
`````

where `:ex` is the "named part" (`ex` being the name, which should be unique on the page).

```julia:ex
using DataFrames
df = DataFrame(A = 1:4, B = ["M", "F", "F", "M"])
first(df, 3)
```

You can control the indentation and appearance of the output block in the `config.md` too.

\end{:section}