text:
# ORM

--------------------------------------------------------

* [Naming conventions](#naming_conventions)
* [Basic usage](#basic_usage)
	- [CRUD](#basic_usage:crud)
	- [Selecting columns](#basic_usage:selecting_columns)
	- [Joins](#basic_usage:joins)
* [Relations](#relations)
	- [Has one](#relations:has_one)
	- [Has many](#relations:has_many)
	- [Belongs to](#relations:belongs_to)
	- [Many to many](#relations:many_to_many)
	- [Relation criteria](#relations:relation_criteria)
	- [Creating related records](#relations:creating_related_records)
	- [Eager loading](#relations:eager_loading)
	- [Counting related records](#relations:counting_related_records)
	- [Overriding naming conventions](#relations:overriding_naming_conventions)
* [Automatic typecasting](#automatic_typecasting)
	- [Scalars](#automatic_typecasting:scalars)
	- [DateTime](#automatic_typecasting:datetime)
	- [Enums](#automatic_typecasting:enums)
* [Mutators and accessors](#mutators_and_accessors)
* [Scopes](#scopes)
* [Mass assignment](#mass_assignment)
* [Cloning records](#cloning_records)
* [Array and JSON representations of results](#array_and_json_representations)
* [Traits](#traits)
	- [Camel cased data export and interaction](#traits:camel_cased_data_export_and_interaction)
	- [Nullable](#traits:nullable)
	- [Optimistic locking](#traits:optimistic_locking)
	- [Read-only records](#traits:read_only_records)
	- [Timestamped](#traits:timestamped)

--------------------------------------------------------

The ORM lets you map your database tables to objects and create relations between them.

--------------------------------------------------------

### Naming conventions

The Mako ORM does not impose a naming standard on model class names but best practice is to use the camel cased singular form of the table name.

| Table name       | Model name       |
|------------------|------------------|
| articles         | Article          |
| import_jobs      | ImportJob        |

If you want to use the ORM on an existing database and don't want to rename all your tables then you can use the `$tableName` property to define the name of your table.

All tables are also expected to have an auto incrementing primary key column named `id`. The name of the primary key column can be configured using the `$primaryKey` property.

The ORM expects foreign key names to use the following pattern `<model name>_id` (e.g., item_id, user_id). This can be configured when setting up relations and we'll get back to this later on.

--------------------------------------------------------

### Key types

As previously mentioned, the ORM assumes that all your tables have an auto incrementing primary key by default. You can make it generate UUIDs, make your own custom key generator or tell it that your table doesn't have a primary key.

Use the `$primaryKeyType` property to define the key type.

| Key type          | Constant                           |
|-------------------|------------------------------------|
| Auto incrementing | ORM::PRIMARY_KEY_TYPE_INCREMENTING |
| UUID              | ORM::PRIMARY_KEY_TYPE_UUID         |
| Custom            | ORM::PRIMARY_KEY_TYPE_CUSTOM       |
| None              | ORM::PRIMARY_KEY_TYPE_NONE         |

> If you choose to use your own custom key generator then you'll have to implement the `generatePrimaryKey` method in your model class. You must also make sure that the generated value is unique.

--------------------------------------------------------

### Basic usage

#### CRUD

Lets say you have a table called `articles` with three columns (id, title and content). These few lines of code is all you need to interact with the table:

```
<?php

namespace app\models;

use mako\database\midgard\ORM;

class Article extends ORM
{
	protected $tableName = 'articles';
}
```

Creating a new record is as simple as this:

```
$article = new Article;

$article->title   = 'Super awesome stuff';
$article->content = 'This is an article about some super awesome stuff.';

$article->save();
```

You can then fetch the article by its primary key value like this:

```
$article = Article::get(1);
```

> Note that the `get` method will return `null` if nothing is found.

If you want to throw an exception if there isn't a matching article then you can use the `getOrThrow` method.

```
// By default if throws a mako\database\exceptions\NotFoundException

$article = Article::getOrThrow(1);

// But you can make it throw any exception you want
// You can for example throw a mako\http\exceptions\NotFoundException to display a 404 page

$article = Article::getOrThrow(1, exception: NotFoundException::class);
```

The ORM is built on top of the [query builder](:base_url:/docs/:version:/databases-sql:query-builder) so you can also use other criteria to find your record:

```
$article = (new Article)->where('title', '=', 'Super awesome stuff')->first();
```

Modifying an existing record is done like this:

```
$article = Article::get(1);

$article->title = 'New title';

$article->save();
```

And deleting a record is done like this:

```
$article = Article::get(1);

$article->delete();
```

#### Selecting columns

By default the ORM selects all columns from the result set. You can specify the columns you want to select like this:

```
$articles = (new Article)->select(['id', 'title'])->all();
```

#### Joins

You can also use joins when working with the ORM. In the following example we'll select all articles that have at least one comment:

```
$articles = (new Article)->join('comments', 'article.id', '=', 'comments.article_id')->all();
```

The code above will execute the following SQL:

```
SELECT `articles`.* FROM `articles` INNER JOIN `comments` ON `article`.`id` = `comments`.`article_id`
```

It will return duplicates for articles that have more than one comment. This can be solved using a distinct select:

```
$articles = (new Article)->distinct()->join('comments', 'article.id', '=', 'comments.article_id')->all();
```

--------------------------------------------------------

### Relations

Being able to set up relations between tables is important when working with databases. The ORM supports `has one`, `belongs` to, `has many` and `many to many` relations.

#### Has one

Lets create a user model and a profile model and set up a `has one` relation between them.

```
<?php

namespace app\models;

use mako\database\midgard\ORM;

class User extends ORM
{
	protected $tableName = 'users';

	public function profile()
	{
		return $this->hasOne(Profile::class);
	}
}
```

Lets not bother creating a relation in the profile model jus yet.

```
<?php

namespace app\models;

use mako\database\midgard\ORM;

class Profile extends ORM
{
	protected $tableName = 'profiles';
}
```

You can now access a users profile like this:

```
$user = User::get(1);

$profile = $user->profile;
```

#### Has many

We can now add a `has many` relation to our user model.

```
public function articles()
{
	return $this->hasMany(Article::class);
}
```

We can now fetch all the articles that belong to the user like this:

```
$user = User::get(1);

$articles = $user->articles;
```

#### Belongs to

The `belongs` to relation is the opposite of a `has one` or `has many` relation.

We can continue to build on the article model and add a `belongs` to relation. All we need to get this to work is add a foreign key column named `user_id` to the articles table.

```
public function user()
{
	return $this->belongsTo(User::class);
}
```

Fetching the user that owns the article can now be done line this:

```
$article = Article::get(1);

$user = $article->user;
```

#### Many to many

The `many to many` relation requires a [junction table](https://en.wikipedia.org/wiki/Junction_table) between the two related tables. The name of the junction table should be the names of the two tables you want to join in alphabetical order separated by an underscore.

![junction table](:base_url:/assets/img/junctionTable.png)

The relation would then look like this in the user model:

```
public function groups()
{
	return $this->manyToMany(Group::class);
}
```

And like this in the group model:

```
public function users()
{
	return $this->manyToMany(User::class);
}
```

This is how you would use the relations:

```
// Fetch all the groups that the user belongs to

$user = User::get(1);

$groups = $user->groups;

// Fetch all the users that are in the group

$group = Group::get(1);

$users = $group->users;
```

#### Relation criteria

The ORM is built on top of the [query builder](:base_url:/docs/:version:/databases-sql:query-builder) so you can add query criteria to your relations.

```
public function articles()
{
	return $this->hasMany(Article::class)->orderBy('title', 'asc');
}
```

They can be in the relation definition itself or you can add them when you're accessing the related records.

```
$articles = $user->articles()->orderBy('title', 'asc')->all();
```

#### Creating related records

The ORM lets you create related records without having to worry about remembering to set the right foreign key value.

```
$user = User::get(1);

$article = new Article();

$article->title   = 'My article title';
$article->content = 'My article content';

$user->articles()->create($article);
```

The article will now be saved and the value of the `user_id` foreign key will automatically be set to the users id. This method works for both `has one` and `has many` relations.

The `many to many` relation is a bit different since it requires a junction table. You'll have to use the `link` method to create a link between two related records.

```
$user = User::get(1);

$group = Group::get(1);

$user->groups()->link($group);

// This will produce the same result as the example above:

$user = User::get(1);

$group = Group::get(1);

$group->users()->link($user);
```

> You can also pass the primary key value of the record you want to link instead of the object.

Sometimes you'll need to store additional information in your junction table. This can easily be achieved by using the second parameter of the `link` method.

```
// Create a single link with attributes

$user->groups()->link(1, ['foo' => 'data']);

// Create two links with the same attributes

$user->groups()->link([1, 2], ['foo' => 'data']);

// Create two links with different attributes

$user->groups()->link([1, 2], [['foo' => 'data1'], ['foo' => 'data2']]);
```

You can also update the junction attributes by using the `updateLink` method.

```
// Update a single link

$user->groups()->updateLink(1, ['foo' => 'data']);

// Update two links with the same attributes

$user->groups()->updateLink([1, 2], ['foo' => 'data']);

// Update two links with different attributes

$user->groups()->updateLink([1, 2], [['foo' => 'data1'], ['foo' => 'data2']]);
```

Fetching the junction attributes is done using the `alongWith` method.

```
$groups = $user->groups()->alongWith(['foo'])->all();
```

The `unlink` method is used to remove the link between the records:

```
$user->groups()->unlink($group);

// This will produce the same result as the example above:

$group->users()->unlink($user);
```

#### Eager loading

Loading related records can sometimes cause the `1 + N` query problem. This is where eager loading becomes handy.

```
foreach((new Comment)->limit(10)->all() as $comment)
{
	$comment->user->username;
}
```

The code above will execute `1` query to fetch `10` comments and then `1` query per iteration to retrieve the user who wrote the comment. This means that it has to execute `11` queries in total. Using eager loading can solve this problem.

```
foreach((new Comment)->including('users')->limit(10)->all() as $comment)
{
	$comment->user->username;
}
```

The code above will produce the same result as the previous example but it will only execute `2` queries instead of `11`.

You can eager load more relations using an array and nested relations using the dot syntax.

```
$articles = (new Article)->including(['user', 'comments', 'comments.user'])->limit(10)->all();
```

If you need to add query criteria to your relations then you can do so using a closure.

```
$articles = (new Article)->including(['user', 'comments as approved_comments' => function ($query)
{
	$query->where('approved', '=', true);
}, 'comments.user'])->limit(10)->all();
```

You can also define relations to eager load in the model definition using the `$including` property. This is useful if you know that you're going to need to eager load the relations more often than not.

```
protected $including = ['user', 'comments', 'comments.user'];
```

You can then disable eager loading of the relations if needed by using the `excluding` method:

```
$articles = (new Article)->excluding(['user', 'comments'])->limit(10)->all();
```

It is also possible to eager load relations using the `include` method on both model and result set instances. You can check if a model already has loaded a relation using the `includes` method.

```
$article = Article::get(1);

if(!$article->includes('comments'))
{
	$article->include(['comments', 'comments.user']);
}
```

#### Counting related records

Sometimes you'll want to count the number of related records without having to execute a second query. This can easily be achieved using the `withCountOf` method.

```
$articles = (new Article)->withCountOf('comments')->limit(10)->all();
```

Each `Article` object in the `$articles` result set will now have a `comments_count` property containing the number of comments related to each article.

> You can also pass an array of relation names if you want to count the number of related records for multiple relations.

If you want to add custom query criteria when counting related records then you can do so using a closure.

```
$articles = (new Article)->withCountOf(['comments AS approved_comments_count' => function ($query)
{
	$query->where('approved', '=', true);
}])->limit(10)->all();
```

#### Overriding naming conventions

The ORM relations rely on strict naming conventions but they can be overridden using the optional parameters of the relation methods. The first optional parameter lets you set the name of the foreign key. The `many to many` relation method has two additional parameters that let you set the junction table name and the junction key.

In the example below we are telling the relation to use a foreign key named `user` instead of the default, which should have been `user_id`.

```
public function articles()
{
	return $this->hasMany(Article::class, 'user');
}
```

--------------------------------------------------------

### Automatic typecasting

You can configure your model to automatically typecast values on the way in and out of your database. This is done using the `$cast` property where the array key is the column name and the array value is the type you want to cast the column value to.

#### Scalars

```
protected $cast = ['id' => 'int', 'published' => 'bool'];
```

Valid scalar types are `bool`, `int`, `float` and `string`.

> Note that the maximum value for `int` is `PHP_INT_MAX`.

#### DateTime

The ORM and query builder both allow you to save dates as DateTime objects without first having to convert them to the appropriate format. Wouldn't it be nice if you could also automatically retrieve them as DateTime objects when fetching them from the database as well? This is possible thanks to the `date` typecast.

```
protected $cast = ['joined_at' => 'date', 'last_seen' => 'date'];
```

You'll now be able to treat the `joined_at` and `last_seen` values as [DateTime](:base_url:/docs/:version:/learn-more:date-and-time) objects.

```
$user = User::get(1);

$lastSeen = 'The user was last seen on ' . $user->last_seen->format('Y-m-d at H:i');
```

#### Enums

Both the query builder and ORM support enums values. You can automatically cast database values to the appropriate enum using the `enum` typecast.

```
protected $cast = ['transfer_status' => ['enum' => TransferStatus::class]];
```

> Note that the ORM can only cast to so-called [backed enums](https://www.php.net/manual/en/language.enumerations.backed.php) unless you implement your own `from` method.

--------------------------------------------------------

### Mutators and accessors

Mutators and accessors allow you to modify data on the way in and out of the database. Mutators are suffixed with `Mutator` and accessors and suffixed with `Accessor`.

The following mutator will encode the value when its assigned.

```
protected function numbersMutator(array $numbers)
{
	return json_encode($numbers);
}
```

You can assign the value like any normal value and it will be JSON-encoded internally in the model making it possible to store it in the database.

```
$model->numbers = [1, 2, 3, 4];
```

And the following accessor will decode the value when accessing it.

```
protected function numbersAccessor($numbers)
{
	return json_decode($numbers);
}
```

You can now retrieve the value like any normal value and it will automatically be JSON-decoded for you.

```
$arrayOfNumbers = $model->numbers;
```

--------------------------------------------------------

### Scopes

Scopes allow you to specify commonly used query criteria as methods. All scope methods must be suffixed with the `Scope` suffix.

```
public function publishedScope($query)
{
	$query->where('published', '=', 1);
}

public function popularAndPublishedScope($query, $minViewCount = 1000)
{
	$query->where('published', '=', 1)->where('views', '>', $minViewCount);
}
```

You can now retrieve published articles like this:

```
$articles = (new Article)->scope('published')->all();

$articles = (new Article)->scope('popularAndPublished')->all();

// Camel cased scope names can also be written using snake case

$articles = User::get(1)->articles()->scope('popular_and_published')->all();
```

Scopes also work through relations, and you can of course pass parameters to your scopes:

```
$articles = User::get(1)->articles()->scope('published')->all();

$articles = User::get(1)->articles()->scope('popularAndPublished', 2000)->all();
```

--------------------------------------------------------

### Mass assignment

The ORM allows you to use mass assignment when creating or updating records. This can save you a few lines of code since you don't have to set each value individually but it can open attack vectors in your application if you're not careful.

```
// Create a new record using mass assignment

User::create($this->request->getPost()->all());

// Update an existing record using mass assignment

$user = User::get(1);

$user->assign($this->request->getPost()->all());

$user->save();
```

> The code above might seem like a good idea until a hacker adds an `is_admin` field to the POST data and gives himself admin privileges.
{.danger}

> You can make mass assignment a bit more secure by using the `$assignable` property and define a whitelist of fields that can be set through mass assignment. It's better to be safe than sorry so you should really only use this feature with trusted data.

--------------------------------------------------------

### Cloning records

You can clone records using the `clone` keyword:

```
$clone = clone User::get(1);

$clone->save();
```

You can also clone an entire result set:

```
$clones = clone (new User)->all();

foreach($clones as $clone)
{
	$clone->save();
}
```

--------------------------------------------------------

### Array and JSON representations of results

You can convert both your result and result set objects to arrays and JSON when using the ORM [just like you can with plain query builder result and result set objects](:base_url:/docs/:version:/databases-sql:query-builder#array_and_json_representations).

> It is possible to exclude loaded columns and relations from the array and JSON representations by using the `$protected` property. You can also alter protection at runtime using the `protect()` and `expose()` methods.

--------------------------------------------------------

### Traits

#### Camel cased data export and interation

Databases are usually designed with snake cased column and table names so interacting with columns and relations mapped to properties on ORM objects will lead to inconsistency in your code base if you use camel case everywhere else. This can be solved by using the `CamelCasedTrait` trait.

```
<?php

use mako\database\midgard\ORM;
use mako\database\midgard\traits\CamelCasedTrait;

class Upload extends ORM
{
	use CamelCasedTrait;
}

$upload = Upload::get(1);

// The database column is named "transfer_status" but can
// now be accessed on the ORM object using "transferStatus"

$upload->transferStatus;
```

All column and relation names will be transformed to camel case when transforming ORM objects to arrays or JSON.

If you only want to access data using camel cased properties but want to keep your array and json representations snake cased then you can use the `CamelCasedDataInteractionTrait` trait instead. If you prefer it the other way around then you can use the `CamelCasedDataExportTrait` trait.

> Note that all relations as well as accessors and mutators are expected to be defined using camel case when using the `CamelCasedTrait` and `CamelCasedDataInteractionTrait` traits.

#### Nullable

If you have database columns that allow `null` values then you can use the `NullableTrait` to automatically replace empty strings with `null` when inserting or updating records.

All you have to do is to use the trait and configure your nullable columns using the `$nullable` property.

```
<?php

use mako\database\midgard\ORM;
use mako\database\midgard\traits\NullableTrait;

class Article extends ORM
{
	use NullableTrait;

	protected $nullable = ['source'];
}
```

#### Optimistic locking

When two users are attempting to update the same record simultaneously, one of the updates will likely be overwritten. Optimistic locking can solve this problem.

To enable optimistic locking you need to use `OptimisticLockingTrait` trait. The database table also needs an integer column named `lock_version`. The name of the column can be configured using the `$lockingColumn` property.

```
<?php

use mako\database\midgard\ORM;
use mako\database\midgard\traits\OptimisticLockingTrait;

class Article extends ORM
{
	use OptimisticLockingTrait;
}
```

The second save in the example below will throw a `StaleRecordException` since the record is now outdated compared to the one stored in the database.

```
$article1 = Article::get(1);
$article2 = Article::get(1);

$article1->title = 'Foo';

$article1->save();

$article2->title = 'Bar';

$article2->save();
```

 The `reload` method can be used to refresh the outdated record.

```
$article2->reload();
```

The optimistic locking trait will also check for stale records when deleting.

> Note that optimistic locking only works when working with a single record.

### Read-only records

You can make your records read-only by using the `ReadOnlyTrait`.

```
<?php

use mako\database\midgard\ORM;
use mako\database\midgard\traits\ReadOnlyTrait;

class User extends ORM
{
	use ReadOnlyTrait;
}
```

This will make it impossible to update or delete the records and a `ReadOnlyException` will be thrown if attempted.

```
// Load a read-only record

$user = User::get(1);

// Will throw a mako\database\midgard\traits\exceptions\ReadOnlyException

$user->delete();
```

#### Timestamped

You'll often want to track when a record has been created and when it was updated. The `TimestampedTrait` will do this for you automatically.

The trait requires you to add two `DATETIME` columns to your database table, `created_at` and `updated_at`. You can override the column names using the `$createdAtColumn` and `$updatedAtColumn` properties.

```
<?php

use mako\database\midgard\ORM;
use mako\database\midgard\traits\TimestampedTrait;

class Article extends ORM
{
	use TimestampedTrait;
}
```

You can touch the `updated_at` timestamp without having to modify any other data by using the `touch` method.

```
$article = Article::get(1);

$article->touch();
```

You can also make the ORM touch related records upon saving by listing the relations you want to touch in the `$touch` property.

```
protected $touch = ['foo', 'foo.bar']; // Nested relations are also supported
```

You can easily decide which type of changes that should touch related records using the `$shouldTouchOnInsert`, `$shouldTouchOnUpdate` and `$shouldTouchOnDelete` properties. All of them are set to `true` by default.

repository: mako-framework/docs

repo_name: mako-framework/docs


text:
# PRIDIT
*PRIDIT* is an unsupervised, nonparametric risk/fraud/suspiciouness ranking technique and can also be used as an aggregation method
I found this interesting but could not find a ready implementation in python so here is a python implementation of the PRIDIT algorithm

See a brief overview of why its a good option to consider for risk & for aggregation  below
Further down is info on how the algo works

## RISK/FRAUD Scoring
Data backed risk evaluation benefits from two major things
1. **Not being dependent on training data**  - Fraud tends to be relatively rare and having past fraud data is not always possible. This makes classification or NN based techniques impossible to use. PRIDIT being unsupervised does not require any training data or prior fraud information.
2. **Degree of belongingness to the risk group** instead of black & white classification i.e. the degree of suspiciousness. This allows for rank ordering rows based on degree of suspiciousness and also allows for using this for further analysis i.e. correlate with demographic variables

## AGGREGATION
It is an alternative to weighted averages or composite scores and other aggregation techniques and is more accurate in a broader set of cases

3. **Is not strongly tied to an assumed distribution** - It does not make any assumptions of the distribution of data, for example logistic assumes normally distributed data. PRIDIT usually assumes the distribution of the response variable so is effectively a distribution free method
4. **Can handle categorical data** - Since the method converts input data into ordinal data , It works well with categorical and continuous mix of data and can work on all categorical data too. So it does not make any assumptions about the data generating process.
.... For example 2 different territory managers collect data on a process . There is always a risk of difference in the way in which the data is collected.  For example territory 1 reports 83% doctors having prescribed salicylic acid where as territory 2 reports 75% prescribe salicylic acid , PRIDIT method just considers that territory 1 has more prescriptions than territory 2 but ignores the magnitude of the difference.
*Caveat* - So this makes using PRIDIT on larger data sets more robust than on small data sets.
5. **Is robust in handling missing data** - PRIDIT is a relative measure. which means if missing data is present, especially if data missing is similarly missing in many rows,  is not a big challenge as long as the  % is not too high.

## PRIDIT has two parts

1 -- **RIDIT** score calculation -- RIDIT is shorter version to the phrase "Relative to an Identified Distribution". This is a reference to the point made earlier that PRIDIT does not assume a distribution like LOGIT does.

2 -- **P**CA on the RIDIT scores -- PCA is calculated on the RIDIT scores to find the eigen vector/value which captures the biggest variance.

Making the technique's name P(ca) + RIDIT.

A point to note though while interpreting the results is -- In PRIDIT PCA is applied and the first Principle component is picked. The first principle component captures the most variance & usually will be representative of the kind of variables used, if most of the variables used are risk related then the PRIDIT score could be called a risk indicator. If most of the variables are Quality related then the PRIDIT score can be a proxy /composite quality indicator

Credit to Brock for coming up with RIDIT in 1958 https://www.jstor.org/stable/2527727
and to the implementation @ The Journal of Risk and Insurance, 2002, Vol. 69, No. 3, 341-371

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
---
layout: post
title: Employee Indebtedness Was Not Updating - Resolved
date: '2019-03-05T17:00-06:00'
author: Open Data Portal Team
categories:
- Open Data
- Data Portal
tags:
- pasx-mnuv
- employee indebtedness
- tech-headache
---
Our Employee Indebtedness to the City of Chicago [dataset](https://data.cityofchicago.org/d/pasx-mnuv) was not updating properly from 12/15/2018 through 3/2/2019. The update job runs weekly on Saturdays. We discovered the problem today and believe it is fixed for future runs.

There is no way to fill in the missing rows, so there will be a permanent gap in the data. We performed a special run today so there are records dated 3/5/2019, even though it is a Tuesday and therefore somewhat out of sync with most of the dataset.

license: MIT

gha_language: HTML

gha_license_id: MIT


text:
https://d3js.org/
https://github.com/mbostock/d3/wiki
http://www.jeromecukier.net/blog/2012/09/04/getting-to-hello-world-with-d3/
https://www.reddit.com/r/javascript/comments/38hg2s/whats_the_best_beginner_resource_to_learn_d3js/
https://github.com/mbostock/d3/wiki/Tutorials
https://www.quora.com/How-do-I-learn-D3-js
http://www.recursion.org/d3-for-mere-mortals/
http://uwdata.github.io/d3-tutorials/
https://square.github.io/intro-to-d3/

lynda course

gallery:
https://github.com/mbostock/d3/wiki/Gallery

w/ react:
<EMAIL_ADDRESS>http://nicolashery.com/integrating-d3js-visualizations-in-a-react-app/
http://oli.me.uk/2015/09/09/d3-within-react-the-right-way/
http://10consulting.com/2014/02/19/d3-plus-reactjs-for-charting/
https://github.com/esbullington/react-d3
http://www.reactd3.org/
http://swizec.com/reactd3js/
https://medium.com/react-university/playing-with-react-and-d3-6265b4a01f01#.qe9cszgsy

good tutorials:
http://alignedleft.com/tutorials/d3/   http://chimera.labs.oreilly.com/books/1230000000345/index.html
https://github.com/d3/d3/wiki/Tutorials

repository: fraziermork/resources

repo_name: fraziermork/resources


text:
---
layout: post
title: Ian
---

I work for a company with a larger-than-average number of gentlemen named Ian* concentrated into a small area.  It's small-enough that three of the four could reach out and touch the others if they so desired…

Er…

Pretty-much every working day at 10am and 3pm (excluding Fridays) I've been telling Steve* that it's time for his drink: "Steve, brew time!"

Since 2002 that is, with breaks for good (and bad) behaviour.  Steve gets a bit grumpy if brew time is delayed.

I'm kept on my toes by the rest of the office; if I forget the alert I'm reminded (or bypassed entirely!)  It's a good thing, a dry engineer isn't a happy engineer!

And then we got a new guy and another new guy: 2 of our 4 Ians.*

They wanted in.  Obviously, we engineers take brew times seriously.  I modified the alert, which caught on in high circles, often invoked with third-party modifications; performance tuning!

A popular variant: "Brew Time Nuclear Ian, brew time no-nukes Ian!"*

Awesome.

We got a new starter 2 weeks ago, Dave.*  Now Dave has been away this week - the 6-day SolidWorks course.  A course to be completed in 5 days.  Illogical maybe but hey, 'tis one of the most intense things I've ever done…

Anyway, I practised a tiny update to the brew time alert today, a tweak designed to establish a new office order:

"Brew time Steve, brew time Dave (a pause, and dismissive wave) brew time the Ians."

I think it'll work well.  Quite what Dave will think of it I can't really guess at this stage.  Based on what I've seen so far though, I think she'll fit in nicely.

---

*The names have been changed to protect the identities of those involved.  Yes.  As have their engineering specialities.  We have other Ians throughout the building too; not quite an embarrassment of Ians though.


text:
[discussions]: https://github.com/ElMassimo/vite_ruby/discussions
[rails]: https://rubyonrails.org/
[webpacker]: https://github.com/rails/webpacker
[vite rails]: https://github.com/ElMassimo/vite_ruby
[vite]: https://vitejs.dev/
[vite_rails_legacy]: https://github.com/ElMassimo/vite_ruby/tree/main/vite_rails_legacy
[vite_hanami]: https://github.com/ElMassimo/vite_ruby/tree/main/vite_hanami
[vite_padrino]: https://github.com/ElMassimo/vite_ruby/tree/main/vite_padrino
[vite_ruby]: https://github.com/ElMassimo/vite_ruby/tree/main/vite_ruby
[commands]: /guide/development.html#cli-commands-⌨%EF%B8%8F
[vite-templates]: https://github.com/vitejs/vite/tree/main/packages/create-app
[plugins]: https://vitejs.dev/plugins/
[configuration reference]: /config/
[simple app]: https://github.com/ElMassimo/vite_ruby/tree/main/examples/rails
[example app]: https://github.com/ElMassimo/pingcrm-vite
[heroku]: https://pingcrm-vite.herokuapp.com/
[dev options]: /config/#development-options
[json config]: /config/#shared-configuration-file-%F0%9F%93%84
[vite config]: /config/#configuring-vite-%E2%9A%A1
[GitHub Issues]: https://github.com/ElMassimo/vite_ruby/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc
[GitHub Discussions]: https://github.com/ElMassimo/vite_ruby/discussions
[Troubleshooting]: /guide/troubleshooting

# Getting Started

If you are interested to learn more about Vite Ruby before trying it, check out the [Introduction](./introduction).

If you are looking for configuration options, check out the [configuration reference].

::: tip Compatibility Note
[Vite] requires [Node.js](https://nodejs.org/en/) version >= 12.0.0.

If using [Vite Rails], it requires [Rails] version > 5.1.
:::

## Installation 💿

Add this line to your application's Gemfile:

```ruby
gem 'vite_rails'
```

And then run:

    $ bundle install

- If using Hanami, install the [vite_hanami] gem instead.
- If using Padrino, install the [vite_padrino] gem instead.
- If using other Ruby web frameworks, install the [vite_ruby] gem.
- If using Rails 4, install the [vite_rails_legacy] gem.

### Setup 📦

Run bundle exec vite install, which:

- Adds the bin/vite executable to start the dev server and run other [commands]
- Installs vite and vite-plugin-ruby (which is used to configure Vite)
- Adds [`vite.config.ts`][vite config] and [`config/vite.json`][json config] configuration files
- Creates a sample `application.js` entrypoint in your web app

### Running your first example 🏃♂

Run bin/vite dev to start the Vite development server.

When using Rails or Hanami, restart your web server before visiting any page, and you should see a printed console output:

```
Vite ⚡ Ruby
```

You can now start writing modern JavaScript apps with Vite! 😃

Check an [example app] running on [Heroku].

::: tip Not seeing anything?
Check the _[Troubleshooting]_ section for common gotchas.
:::

### Further Configuration 🧩

When working with a framework such as Vue or React, refer to [vite][plugins] to see which [plugins] to add.

If you would like to contribute a framework-specific template, reach out and we might consider adding it to the installation script.

### Contact ✉

Please visit [GitHub Issues] to report bugs you find, and [GitHub Discussions] to make feature requests, or to get help.

Don't hesitate to [⭐ star the project][vite rails] if you find it useful!

Using it in production? Always love to hear about it! 😃

branch_name: refs/heads/main


text:
# VueInterface
Basic interface for Vue components

#### About
This project is a testing-environment for writing modules/components in Vue.
Each component will have a tab in the Apps navigation.

#### Install
```bash
# Get project (Example with git)
git clone https://github.com/ToxicTree/VueInterface.git
cd VueInterface

# Install npm-packages
npm install

# Build JS & CSS
npm run build

# Build on changes while developing
npm run watch
```

#### Running
Open ``index.html``

#### Adding components
You can edit your generated ``main.js`` and ``main.scss`` to require components or importing scss/css

#### Used tools
[node.js & npm](https://nodejs.org/en/), [vue.js](https://vuejs.org/), [bootstrap](http://getbootstrap.com/)

repository: ToxicTree/VueInterface

repo_name: ToxicTree/VueInterface


text:
---
title: A Crash Course on ML Modules
tags: sml, haskell
---

I was having lunch with a couple of Haskell programmers the other day
and the subject of the ML family came up. I've been writing a lot of
ML lately and mentioned that I thought *ML was well worth learning for
the average Haskeller. When pressed why the best answer I could come
up with was "Well.. clean language, Oh! And an awesome module system"
which wasn't my exactly most compelling response.

I'd like to outline a bit of SML module system here to help
substantiate why looking at an ML is A Good Thing. All the code here
should be translatable to OCaml if that's more your taste.

## Concepts

In ML languages modules are a well thought out portion of the
language. They aren't just "Oh we need to separate these
names... modules should work". Like any good language they have
methods for abstraction and composition. Additionally, like any good
part of an ML language, modules have an expressive type language for
mediating how composition and abstraction works.

So to explain how this module system functions as a whole, we'll cover
3 subjects

 1. Structures
 2. Signatures
 3. Functors

Giving a cursory overview of what each thing is and how it might be
used.

## Structures

Structures are the values in the module language. They are how we
actually create a module. The syntax for them is

``` sml
    struct
      fun flip f x y = f y x
      datatype 'a list = Con of ('a * 'a list) | Nil
      ...
    end
```

*A quick note to Haskellers, in ML types are lower case and type
 variables are written with 's. Type constructors are applied
 "backwards" so `List a` is `'a list`.*

So they're just a bunch of a declarations stuffed in between a
`struct` and `end`. This is a bit useless if we can't bind it to a
name. For that there's

``` sml
    structure M = struct val x = 1 end
```

And now we have a new module `M` with a single member, `x : int`. This
is just like binding a variable in the term language except a "level
up" if you like. We can use this just like you would use modules in
any other language.

``` sml
    val x' = M.x + 1
```

Since `struct ... end` can contain any list of declarations we can
nest module bindings.

``` sml
    structure M' =
      struct
        structure NestedM = M
      end
```

And access this using `.`.

``` sml
    val sum = M'.NestedM.x + M.x
```

As you can imagine, it would get a bit tedious if we needed to `.` our
way to every single module access. For that we have `open` which just
dumps a module's exposed contents into our namespace. What's
particularly interesting about `open` is that it is a "normal"
declaration and can be nested with `let`.

``` sml
    fun f y =
      let open M in
        x + y
      end
```

OCaml has gone a step further and added special syntax for small
opens. The "local opens" would turn our code into

``` ocaml
    let f y = M.(x + y)
```

This already gives us a lot more power than your average module
system. Structures basically encapsulate what we'd expect in a module
system, but

 1. Structures =/= files
 2. Structures can be bound to names
 3. Structures can be nested

Up next is a look at what sort of type system we can impose on our
language of structures.

## Signatures

Now for the same reason we love types in the term language (safety,
readability, insert-semireligious-rant) we'd like them in the module
language. Happily ML comes equipped with a feature called
signatures. Signature values look a lot like structures

``` sml
    sig
      val x : int
      datatype 'a list = Cons of ('a * 'a list) | Nil
    end
```

So a signature is a list of declarations *without* any
implementations. We can list algebraic data types, other modules, and
even functions and values but we won't provide any actual code to run
them. I like to think of signatures as what most documentation
rendering tools show for a module.

As we had with structures, signatures can be given names.

``` sml
    signature MSIG = sig val x : int end
```

On their own signatures are quite useless, the whole point is that we
can apply them to modules after all! To do this we use `:` just like
in the term language.

``` sml
    structure M : MSIG = struct val x = 1 end
```

When compiled, this will check that `M` has at least the field
`x : int` inside its structure. We can apply signatures retroactively
to both module variables and structure values themselves.

``` sml
    structure M : MSIG = struct val x = 1 end : MSIG
```

One interesting feature of signatures is the ability to leave certain
types abstract. For example, when implementing a map the actual
implementation of the core data type doesn't belong in the signature.

``` sml
    signature MAP =
      sig
        type key
        type 'a table

        val empty : 'a table
        val insert : key -> 'a -> 'a table -> 'a table
        val lookup : key -> 'a table -> 'a option
      end
```

Notice that the type of keys and tables are left abstract. When
someone applies a signature they can do so in two ways, weak or
strong ascription. Weak ascription (`:`) means that the constructors
of abstract types are still accessible, but the signature *does* hide
all unrelated declarations in the module. Strong ascription (`:>`)
makes the abstract types actually abstract.

Every once in a while we need to modify a signature. We can do this
with the keywords `where type`. For example, we might implement a
specialization of `MAP` for integer keys and want our signature to
express this

``` sml
    structure IntMap :> MAP where type key = int =
      struct ... end
```

This incantation leaves the type of the table abstract but specializes
the keys to an int.

Last but not least, let's talk about abstraction in module land.

## Functors

Last but not least let's talk about the "killer feature" of ML module
systems: functors. Functors are the "lifting" of functions into the
module language. A functor is a function that maps modules with a
certain signature to functions of a different signature.

Jumping back to our earlier example of maps, the equivalent in Haskell
land is `Data.Map`. The big difference is that Haskell gives us maps
for all keys that implement `Ord`. Our signature doesn't give us a
clear way to associate all these different modules, one for each
`Ord`erable key, that are really the same thing. We can represent this
relationship in SML with

``` sml
    signature ORD =
      sig
        type t
        val compare : t * t -> order
      end

    functor RBTree (O : ORD) : MAP where type key = O.t =
      struct
        open O
        ....
      end
```

Which reads as "For any module implementing `Ord`, I can give you a
module implementing `MAP` which keys of type `O.t`". We can then
instantiate these

``` sml
    structure IntOrd =
      struct
        type t = int
        val compare = Int.compare end
      end
    structure IntMap = RBTree(IntOrd)
```

Sadly SML's module language isn't higher order. This means we can't
assign functors a type (there isn't an equivalent of `->`) and we
can't pass functors to functors. Even with this restriction functors
are tremendously useful.

One interesting difference between SML and OCaml is how functors
handle abstract types. Specifically, is it the case that

    F(M).t = F(M).t

In SML the answer is (surprisingly) no! Applying a functor generates
brand new abstract types. This is actually beneficial when you
remember SML and OCaml aren't pure. For example you might write a
functor for handling symbol tables and internally use a mutable symbol
table. One nifty trick would be to keep of type of symbols
abstract. If you only give back a symbol upon registering something in
the table, this would mean that all symbols a user can supply are
guaranteed to correspond to some entry.

This falls apart however if functors are extensional. Consider the
following REPL session

``` sml
    > structure S1 = SymbolTable(WhateverParameters)
    > structure S2 = SymbolTable(WhateverParameters)
    > val key = S1.register "I'm an entry"
    > S2.lookup key
    Error: no such key!
```

This will not work if `S1` and `S2` have separate key types.

To my knowledge, the general conclusion is that generative functors
(ala SML) are good for impure code, but applicative functors (ala
OCaml and BackPack) really shine with pure code.

## Wrap Up

We've covered a lot of ground in this post. This wasn't an exhaustive
tour of every feature of ML module systems, but hopefully I got the
jist across.

If there's one point to take home: In a lot of languages modules are
clearly a bolted on construction. They're something added on later to
fix "that library problem" and generally consist of the same "module
<-> file" and "A module imports others to bring them into scope". In
ML that's simply not the case. The module language is a rich, well
thought out thing with it's own methods of abstraction, composition,
and even a notion of types!

I wholeheartedly recommend messing around a bit with OCaml or SML to
see how having these things impacts your thought process. I think
you'll be pleasantly surprised.

repository: jozefg/blog

repo_name: jozefg/blog


text:
# Docker Notes

[![Build Status](https://travis-ci.org/addisonlynch/Docker-Notes.svg?branch=master)](https://travis-ci.org/addisonlynch/Docker-Notes)

This respository is the source code for addisonlynch.github.io/docker-notes, which are my rudimentary set of usage notes for the [Docker](https://www.docker.com/) containerization platform.

*Warning: these notes have been **in progress** since I began learning Docker. They may contain errors and inconsistencies.*

## Development

These notes are built with the [Sphinx](https://github.com/sphinx-doc/sphinx) documentation engine using [reStructuredText](http://docutils.sourceforge.net/rst.html) as a markup language. With each push to the ``master`` branch of this repository, the documentation is deployed to addisonlynch.github.io/docker-notes using [TravisCI](https://pypi.org/project/doc8/) and the deployment tool [doctr](https://github.com/drdoctr/doctr).

[doc8](https://pypi.org/project/doc8/) is used for linting the RST files. The linter is run with each Travis build.

### Building The Documentation

These notes can be served locally using ``sphinx-autobuild``, using ``make livehtml``.

To build the documentation only, use ``make html``.

### Linting

Use ``doc8 source`` to lint the documentation.

## Dependencies

* ``doc8``
* ``sphinx``
* ``sphinx_rtd_theme``
* ``sphinx-autobuild``

repository: addisonlynch/docker-notes

repo_name: addisonlynch/docker-notes


text:
# Android Programming Assignment

We would like to create an Android native app that would help us browse GitHub Organization
members. One of the biggest use cases we have is to check on how an organisation is doing
nowadays. This means to check the TOP 15 members of the organization based on a different criterias:

- Number of public repositories
- Number of followers
- Number of public gists

On the Android App we are envisioning a screen where the user could type in an Organisation,
select a sorting criteria and they would be shown the top 15 members of that organization. The
user should be able to see the avatar, name and date of joining github of each member. The
user should also be able to view more details for any of the top members by tapping - e.g. Bio,
Company, Location, etc. User should be able to see as much sensible information as possible
about the selected member.

Requirements:

- Native Android app written in Java and/or Kotlin
- Maintainable code base
- Uses only the Allowed GitHub APIs mentioned below
- Implement proper architecture (of your choice)
- Support screen rotation without making new API calls
- Remember last selected criteria for ordering Organization members across app restarts

Optional:

- Great looking UI
- Animations

List of GitHub APIs allowed to be used:

- List members of an organization:

https://developer.github.com/v3/orgs/members/#members-list

GET /orgs/:org/members

- Get information about a user:

https://developer.github.com/v3/users/#get-a-single-user

GET /users/:username

!! ADDITION !!
For the same of offline data persistance one more link is added

- Getting organization details

https://developer.github.com/v3/orgs/#get-an-organization

GET / orgs/:org

license: Unlicense

repository: ranapat/github-browser-example

repo_name: ranapat/github-browser-example


text:
# pymgit

Clone a bunch of Git repositories to your machine to specified directories and
checkout a specific version (branch/tag).  When working with a lot of Git repos
and periodically moving to different machines, it is tedious to manually clone
all of the repositories you want.  It would be easier to have a text file list
the repositories and have a tool clone and checkout the repos in one fell
swoop.

**Note:** This program expects a modified form of an Ansible Galaxy style
requirements file (as this is the inspiration of this program) to contain the
list of repositories to clone, the version to checkout, and the destination
path to clone the repository.  See in examples below.

## Requirements

`python` and `git` installed on the machine that will run `pymgit`

## Optional Requirements

[git-run](https://www.npmjs.com/package/git-run) if you want to take advantage
of `git-run` configuration file (.grconfig.json) generation.

## Assumptions

You have already handled the storage of your repository credentials in some
Git-way (e.g. SSH key, git credential helper, etc.) on the machine that will
run this program.  That is, this program won't be asking you for the location
of your keys (assume default/normal location) nor will it explicitly prompt
you for a password.  If you're checking out via https, the underlying `git`
program will likely prompt you for your password unless you have it stored
via some Git credential helper.

## Installation

pymgit is on [PyPi](https://pypi.python.org/pypi/pymgit)

```bash
pip install pymgit
```

## Command-line Arguments

| Argument | Description | Type | Default Value |
|---|---|---|---|
| `-r`,`--requirements` | The path to the requirements text file containing a list of the Git repos you want to clone | str | no default, this is required |
| `-g`,`--gitrun` |Turn on the mode to produce a git-run .grconfig.json file|bool|false|
| `-p`,`--gitrunconfigdir`|The directory to write .grconfig.json into|str|user home directory|
| `-d`,`--debug` | Turn on more verbose debugging (not much of it really)|bool|false|
| `-c`,`--checkout` | Force existing repos to checkout requirements file tag|bool|false|
| `-f`,`--force` | Force pymgit to overwrite existing directories|bool|false|
| `-s`,`--strip` | Strip git (and git-related) files from cloned repos|bool|false|
| `-v`,`--version` | Display program version | N/A | None |
| `-h`,`--help` | Display program help | N/A | None |

## Dependencies

None

## Examples

### Program Invocation

Run the program to clone all of the repos identified in ~/requirements.yml

    pymgit -r ~/requirements.yml

Run the program to clone all of the repos identified in ~/requirements.yml and
produce a `.grconfig.json` in the default location (user home diretory)

    pymgit -r ~/requirements.yml -g

Run the program to clone all of the repos identified in ~/requirements.yml and
produce a `.grconfig.json` in a specified directory

    pymgit -r ~/requirements.yml -g -p /somewhere/user/can/write

Run the program to clone all of the repositories specified in the requirements file and
force existing repositories to checkout tag specified in requirements file

    pymgit -r ~/requirements.yml -c

Run the program and turn on debugging

    pymgit -r ~/requirements.yml -d

Run the program to display the version

    pymgit -v

Run the program with no arguments or the -h/--help option to display help

    pymgit
    pymgit -h

### Requirements File

See [example_requirements.yml](example_requirements.yml)

#### Standard (no `git-run` support)

```yaml
---

- src: git@github.com:watsonb/pymgit.git
  version: develop
  dest: /workspace/foo

- src: git@github.com:watsonb/pymgit.git
  version: master
  dest: /workspace/bar
```

Given the above, the program will checkout the pymgit source twice:

- First, the develop branch to the path /workspace/foo
- Second, the master branch to the path /workspace/bar

After running the program with the above example, you should have:

- /workspace/foo/pymgit (checked out to develop)
- /workspace/bar/pymgit (checked out to master)

If these directories already exist and you run the program:

- and the directory **IS** a Git repo --> smiply checks out the version
- and the directory is **NOT** a Git repo --> asks you if you want to delete and clone

#### With `git-run` support

```yaml
---

- src: git@github.com:watsonb/pymgit.git
  version: develop
  dest: /workspace/foo
  tags: [python, pymgit, foo]

- src: git@github.com:watsonb/pymgit.git
  version: master
  dest: /workspace/bar
  tags: [pymgit, bar]
```

The above will perform identically to the previous example, but when the program is
run with the "-g" option, it will create a `.grconfig.json` and will setup `git-run`
tags using the tags specified in the requirements file above.

## Other Notes

This program doesn't do any Git fetching, pushing, pulling (sorry).  Once you
have cloned all of your repos, I highly recommend the NodeJS program
[git-run](https://www.npmjs.com/package/git-run) to manage the fetching,
pushing, pulling, etc.

## License

MIT

## Contributing

1. Fork it
1. Create your feature branch (`git checkout -b my-new-feature`)
1. Commit your changes (`git commit -am 'Add some feature'`)
1. Push to the branch (`git push origin my-new-feature`)
1. Create new Pull Request

## Building and Distributing

```bash
virtualenv venv_pymgit
source venv_pymgit/bin/activate
pip install GitPython PyYaml
pip install twine pyOpenSSL ndg-httpsclient pyasn1
pip install colorama termcolor
pip install future six
git clone git@github.com:watsonb/pymgit.git
cd pymgit
python setup.py clean
python setup.py check
python setup.py build
python setup.py sdist
twine upload dist/*
```

## Authors

| Author | E-mail | Note |
|---|---|---|
|Ben<EMAIL_ADDRESS>author|
|Derek<EMAIL_ADDRESS>OG Jinja Ninja|

repository: watsonb/pymgit

repo_name: watsonb/pymgit


text:
### New in 1.2.1

* Build with net5.0
* Update roslyn to a more recent version

### New in 1.1.0

* Make it a dotnet core tool
* Optimize interned strings equality and `GetHashCode`.

  This can be dangerous if the type is extended and a new constructor is added that doesn't
  do interning but the performance gains in access to dictionary and hashtables are worth it.

### New in 1.0.0

* Use FParsec to parse the configuration
* Use BlackFox.ColoredPrintf instead of an internal solution
* Implement `IComparable`
* Add `[DebuggerDisplayAttribute]` to the generated types

### New in 0.5.4
* Added color output to the console
* Display a message on the console when no file is matched and return '-1' as error level.
 [Issue #16](https://github.com/vbfox/stidgen/issues/16)

### New in 0.5.3
* Fix 'Check' methods being unusable.
  [Issue #38](https://github.com/vbfox/stidgen/issues/38)

### New in 0.5.2
* Lift `System.IFormattable`

### New in 0.5.1
* Add an option to enable DataContract serialization.
  [Issue #37](https://github.com/vbfox/stidgen/issues/37)

### New in 0.5.0
* Predefined types like `int` are now compared with their operators instead
  of relying on `Equals`.
  [Issue #36](https://github.com/vbfox/stidgen/issues/36)
* BUGFIX: Correct code is now generated for `!=` on underlying types that
  don't have a `!=` operator.
  [Issue #35](https://github.com/vbfox/stidgen/issues/35)

### New in 0.4.0
* Static methods `Parse` and `TryParse` are lifted.
* A variant of `TryParse` returning a nullable instead of using an out
  parameter is generated if TryParse exists.
* Types can now be placed in the same file and the default is to place them
  all in a file named as the .stidgen file but with a .Generated.cs extension.
  The previous behavior is available by specifying `UseNameAsFileName: true`.
* Added a more complete set of unit tests.
* Multiple files can now be passed to the command line.
* The command line now support globs like `**\*.stidgen`.
* Generated files and types are now shown on the console.
* BUGFIX: Generic underlying types weren't correctly handled, the name was
  the FullName of the Type instead of C# code.
* BUGFIX: Casts to and from nullable were still generated for Nullable<T>
  underlying resulting in invalid code.
* BUGFIX: `EqualsUnderlying: true` generated code for `.Equals` but didn't
  generate the == and != operators.

### New in 0.3.0
* Add casts to and from nullable.
* Add an option to enable protobuf-net serialization.
* BUGFIX: When a value type was used as underlying compiler warning were
  present in the generated code.

### New in 0.2.0
* Generated files are now named with `.Generated.cs` at the end.
* Generated file now start with a `<auto-generated>` comment.
* All methods generated are now marked with `GeneratedCodeAttribute`.
* A partial method named "Check" + propertyName is now generated to validate
  constructor arguments if needed.

### New in 0.1.1
* Remove package dependencies and include all necessary files in the `.nupkg`.

### New in 0.1.0
* First version

repository: vbfox/stidgen

path: /Release Notes.md

filename: Release Notes.md

gha_language: F#

repo_name: vbfox/stidgen


text:
Selfolio

[![GitHub](https://img.shields.io/github/license/cobidev/simplefolio?color=009387)](https://github.com/cobidev/simplefolio/blob/master/LICENSE.md)
[![Netlify Status](https://api.netlify.com/api/v1/badges/91be6d51-ba25-46e9-9844-dca148c6e0ba/deploy-status)](https://app.netlify.com/sites/selfolio/deploys)

A simple web portfolio made for devs

Check it out live by **[clicking here](https://selfolio.netlify.app/)**.
You can also check my own website as a variation of this template **[varallo.me](https://www.varallo.me/)**.

![Selfolio Demo](src/assets/demo.gif)

Achieves the highest* Lighthouse performance score in production.

*It is 99 from 100 performance only due to default images, not relevant to change for the live demo!

![Selfolio Lighthouse](src/assets/lighthouse.png)

## Features

Single page app

Easy to change data & colors

Lightweight with minimum dependecies

Built from scratch entirely with React & TypeScript

Fully responsive - built in pure CSS with Styled Components

## Instalation
```
npm install

npm start
```

## Usage
This template was built with full separation of concerns, so you barely have to
touch the rest of the code.

All you need to do to change the texts and colors is open the data.ts file, found at
**src/source/data.ts**. In this file you have the following fields:

### Profile Picture
```
import profilePicture from '../assets/profile.png';
```
Simply add your own picture in the **src/assets** folder and remove the default one.
IMPORTANT: Name your picture as **profile.png** like the example above.

### Projects Pictures
```
import project1 from '../assets/project1.png';
import project2 from '../assets/project2.png';
import project3 from '../assets/project3.png';
```
Likewise, just add your own project pictures in the **src/assets** folder and remove the default ones.
IMPORTANT: Name your pictures as **project1.png**, **project2.png** and so on.

### Colors
```
first: '#232122',
second: '#b3c100',
third: '#4cb5f5',
fourth: '#dddede',
```
Pretty simple as well - be creative! Do not delete any key here.

### Head Data
```
title: 'Name | Web developer',
description: 'Welcome to my website'
```
Title is what will appear in the browser's tab, and below is just a meta tag
description.

### Main Data
```
title: 'Hi, my name is ',
name: 'Full Name',
subtitle: 'I am a web developer',
cta: 'Know more',
```
The 'cta' key is the 'call to action' button, so you can change its text.

### About Data
```
sectionTitle: 'About',
img: { src: profilePicture },
p1: `Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus blandit
vehicula lectus. Suspendisse potenti. Ut eget odio eget dolor maximus pharetra
eu a risus. Cras elit leo, commodo nec risus in.`,
p2: `Vivamus nec mattis eros, eget gravida mauris. Nam a turpis vel dui fermentum
ultrices. Mauris nec lorem ut nulla placerat bibendum quis et tortor. Phasellus
ac pellentesque leo. Donec eu lorem vehicula, ultrices enim ut, convallis nibh.
Sed blandit ultricies leo, vel porta ante suscipit a.`,
p3: `Integer velit nulla, imperdiet suscipit dui non, sodales tincidunt odio.
In hac habitasse platea dictumst. Cras ornare feugiat odio, at pharetra ante
elementum sit amet. In aliquet purus ut mauris auctor, quis commodo libero
dignissim. In tristique mi ut mi vulputate convallis.`,
```
This section was built to have a maximum of 3 paragraphs on purpose. Be concise to talk
about yourself is an important skill =) If you want less, just leave it as an empty string, but do not delete the key.

### Project Data
```
{
  title: 'Project 1',
  description1: `Lorem ipsum dolor sit amet, consectetur adipiscing elit.
  Suspendisse rhoncus lectus vitae pulvinar scelerisque.`,
  description2: `Lorem ipsum dolor sit amet, consectetur adipiscing elit.
  Suspendisse rhoncus lectus vitae pulvinar scelerisque. Donec sed
  gravida elit. Duis vel placerat sem, ac condimentum orci. Ut
  scelerisque magna sit amet ex condimentum varius.`,
  liveUrl: 'https://selfolio.netlify.app/',
  liveButtonText: 'See it live',
  sourceUrl: 'https://github.com/guvarallo/selfolio',
  sourceText: 'Source Code',
  img: { src: project1 },
},
```
You will notice that this is an array of objects. If you want to display more projects, just keep copying and pasting more objects followed by a comma - don't forget to add the project's picture in the assets folder and update the img field correctly.
IMPORTANT: If you don't have your project live somewhere, simply leave both 'liveUrl' and 'liveButtonText' as an empty string. Do not delete them.

### Contact Data
```
title: 'Contact',
description: 'Send me an e-mail!',
mailTo<EMAIL_ADDRESS>```
Update accordingly.

### Footer Data
```
githubUrl: 'https://github.com/guvarallo',
linkedinUrl: 'https://www.linkedin.com/in/gustavovarallo/',
```
Update accordingly so the icons link correctly to your accounts.

## Special Thanks
Although this template was built from scratch, it was completely inspired in the
portfolio made by [Jacobo Martínez](https://github.com/cobidev). Please check
his profile and give him some love as well.

## License
[MIT License](LICENSE)


text:
# Fritz.StreamTools
Handy tools for managing my a live video stream and outputting video widgets that can be used directly in OBS or other streaming tools.

## Features

The project is intended to be built as a Docker container and configured with a series of environment variables.  It is intended to support a single-user, and not run on the public-facing internet.

The following features are supported by this project:

*  A checklist rundown of segments of the show (/index) that is updated from another page (/admin)
*  A followers count API that reports the total number of followers: GET /api/Followers
*  A followers count page that can be easily styled and formatted at /Followers/Count
*  A followers goal meter that can be sized and have its goal caption and value set: /Followers/Goal/{goalValue}/{goalCaption}?width={meterWidthInPixels}

## Services Supported

The project supports reading stream metrics from the following services:

*  Mixer
*  Twitch


text:
## AWS Media Services Tools

A library of scripts for interacting with AWS Media Services and documentation for working with compatible contribution encoders.

## Contents
#### Library of  scripts for interacting with AWS Media Services:

Each AWS Media Service has a sub-directory, inside it, you'll find scripts for starting and stopping the service written in Python 3.7 and formatted to either run locally or as AWS Lambda functions. You'll also find documentation on what inputs these scripts expect, what outputs they deliver, and examples for using them in conjunction.
- [MediaConnect scripts](https://github.com/aws-samples/aws-media-services-tools/tree/master/MediaConnect/Compatibility/Examples) (work in progress)
- [MediaLive scripts](https://github.com/aws-samples/aws-media-services-tools/tree/master/MediaLive/Compatibility/Examples)
- [MediaPackage scripts](https://github.com/aws-samples/aws-media-services-tools/tree/master/MediaPackage/Compatibility/Examples)

#### Compatibility documentation:

Each AWS Media Service directory has a Compatibility sub-directory, inside you'll find further sub-directories for partner companies and products that we have been determined compatible with that AWS Media Service.  To the best of our ability we attempt to provide comprehensive documentation for reproducing our compatibility testing. This includes example configurations, links to detailed documentation, and scripts for starting the products.
Please see the AWS Media Service Compatibility [website](https://aws.amazon.com/media-services/resources/compatibility/) for full details on the compatibility program and how to become a compatibility partner.

## License

This library is licensed under the Apache 2.0 License.

repository: alexjennings/aws-media-services-tools

repo_name: alexjennings/aws-media-services-tools


text:
---
# This page was generated from the add-on.
title: Payloads dialog
type: userguide
weight: 5
---

# Payloads dialog

This allows you to select the payload generators to use when [fuzzing](/docs/desktop/addons/fuzzer/) a request.

Payload generators generate the raw attacks that the fuzzer submits to the target application.

The following types of generators are provided by default:

* Empty/Null - generates the selected payload multiple times, leaving the message without changes. This payload generator is useful to send multiple messages that are later processed, for example, with a [Fuzzer HTTP Processor (Script)](/docs/desktop/addons/fuzzer/httpmessageprocessors/).
* File - select any local file for one off attacks
* File Fuzzers - select any combination of the fuzzing files registered with ZAP, e.g. via add-ons like fuzzdb
* Numberzz - allows to easily generate a sequence of numbers, with custom increment
* Regex - generate attacks based on regex patterns
* Strings - raw strings, which can be entered manually or pasted in
* Script - custom scripts that can generate any payloads required
* Json - generate attacks by fuzzing the provided json

You can write custom payload generator scripts - these can supply any payloads that you need.

Add-ons can also define additional payload generators.

The 'Processors...' button launches the [Payload Processors dialog](/docs/desktop/addons/fuzzer/processors/) which allows you to configure payload processors that just apply to the payload generator you have selected.

## Accessed via

|   |                                                                        |
|---|------------------------------------------------------------------------|
|   | [Fuzzer dialog](/docs/desktop/addons/fuzzer/dialogue/) 'Add...' button |

## See also

|   |                                                 |
|---|-------------------------------------------------|
|   | [Fuzzer concepts](/docs/desktop/addons/fuzzer/) |

repository: zaproxy/zaproxy-website

repo_name: zaproxy/zaproxy-website


text:
---
layout: page
title: Presskit
header: Presskit
group: Landing
markdown: true
permalink: presskit/
description: "In the press, additional pictures for the press and much more."
keywords: "press, presskit, CES, Consumer Electronics Show, 2018, pictures, Crownstone, history"
---
{% include JB/setup %}

# Presskit

## Company history

Crownstone, founded in 2016, is a company that combines indoor localization with building automation for homes and offices.

Crownstone went through the Rockstart (<http://rockstart.com>) accelerator (demo day July 2016). We acquired a large network of business contacts, have a scrutinized business model and it ranks our company as a potentially disruptive and scalable player.

Crownstone has support from Almende as research company and from Almende Investments as investor. This guarantees that Crownstone can produce beyond state-of-the-art technology and has enough budget to grow organically.

Crownstone's unique selling point is indoor localization. This has not been capitalized upon by any competitor in the home automation market, and only a few in the building automation market.

There are already many people who have bought Crownstones. The Crownstones can be ordered at <https://shop.crownstone.rocks>.

## Product information

The Crownstone smart plugs and connectors save energy automatically when there are no people present and act according to the personal preference of people when individuals are present.

## Online resources

Social media:

* [LinkedIn](https://www.linkedin.com/company/crownstone)
* [Facebook](https://www.facebook.com/crownstones/)
* [Twitter](https://twitter.com/CrownstoneRocks)
* [Youtube](https://www.youtube.com/channel/UCru1PX6P1JyhsI-OEMXnBdg)

## Press releases / in the press

International:

* "Sockets and Light Switches Follow You in House with Crownstone", 2019, [Smarthome Magazine](https://smarthomemagazine.net/sockets-and-light-switches-follow-you-in-house-with-crownstone/)
* "Crownstone Plugs für Indoor Localization und Building Automation", 2018, [Home & Smart](https://www.homeandsmart.de/crownstone-plug-indoor-localisation).
* "Switch to a Smarter Future", 2018, [Hannover Messe](https://www.hannovermesse.de/en/news/news-details_80642-504194.xhtml)
* "CES 2018: Tech Preview of the Show's Coolest New Products", 2018, [BBC News](https://www.bbc.com/news/technology-42574569)
* "Crownstone: Plug-and-play indoor positioning", 2017 [ENGIE](https://innovation.engie.com/en/news/news/smart-buildings/crownstone-plug-and-play-indoor-positioning/8237)
* "Indoor localization with the Internet of Things", 2017, [shared press release together with EnOcean](https://crownstone.rocks/attachments/PressReleaseCrownstoneEnOcean.pdf).
* "Crownstone takes home automation beyond Alexa", Cate Lawrence, 2016, [readwrite.com](https://readwrite.com/2016/05/16/crownstones-go-beyond-voice-home-alexa-vt4/).
* "Crownstone, the Smart Power Outlet that Uses Indoor Location", Ludovic Privat, 2015, [gpsbusinessnews](http://www.gpsbusinessnews.com/Crownstone-the-Smart-Power-Outlet-That-Uses-Indoor-Location_a5668.html).
* "Slim, heel slim, dit stopcontact", 2016, [innovatief.be](https://www.innovatief.be/nl/nieuws//bouwen/slim-heel-slim-dit-stopcontact/191).
* "Smart stuff", Bruce Byfield, 2015, [linux-magazine.com](http://www.linux-magazine.com/Issues/2015/181/DoBots-Crownstone).

National:

* "CES round-up: Wat brengt 2019 op het gebied van smarthome?", 2019, [FWD Magazine](https://www.smarthomemagazine.nl/2019/01/ces-round-up-wat-brengt-2019-op-het-gebied-van-smarthome/)
* "Stopcontacten en lichtschakelaars kunnen je in huis volgen met Crownstone", 2019, [FWD Magazine](https://www.smarthomemagazine.nl/2019/01/stopcontacten-en-lichtschakelaars-kunnen-je-in-huis-volgen-met-crownstone/)
* "Als een smart plug niet smart genoeg is, dan ontwerpen we er zelf maar een", 2017, [FWD Magazine](https://www.ced.group/nl-NL/Nieuws/FWD-Magazine).
* "Nederlandse start-up introduceert module om stopcontacten slim te maken", Olaf van Miltenburg, 2015, [Tweakers](https://tweakers.net/nieuws/105284/nederlandse-start-up-introduceert-module-om-stopcontacten-slim-te-maken.html).
* "Rotterdammers lanceren 'slim' stopcontact Crownstone", 2015, [nu.nl](http://www.nu.nl/gadgets/4126449/rotterdammers-lanceren-slim-stopcontact-crownstone.html).
* "Slimmer huis dankzij een stekker", Samira Himmit, 2016, [NRC](https://www.nrc.nl/nieuws/2016/12/15/slimmer-huis-dankzij-een-stekker-5780952-a1536988).
* "Smart Industry in de praktijk: DoBots lanceert slim stopcontact op Kickstarter", 2015, [smartindustry.nl](https://www.smartindustry.nl/nieuws/smart-industry-in-de-praktijk-dobots-lanceert-slim-stopcontact-op-kickstarter/).
* "Crownstone: slim stopcontact maakt van jouw huis een smart home", Sophie de Kok, 2015, [dutchcowboys.nl](http://www.dutchcowboys.nl/technology/crownstone-slim-stopcontact-maakt-van-jouw-huis-een-smarthome).
* "Crownstone: met dit slimme stopcontact kun je energie besparen in huis", 2015 [businessinsider.nl](https://www.businessinsider.nl/crownstone-met-dit-slimme-stopcontact-kun-je-energie-besparen-in-huis-491717/).
* "Crownstone: een simpele oplossing voor een slimmer huis", 2015 [fme](https://www.fme.nl/en/node/4173).
* "Deze ondernemer ontdekte het grote verschil tussen Kickstarter en Indiegogo", Maarten Keswiel, 2015, [sprout.nl](https://www.sprout.nl/artikel/crowdfunding/deze-ondernemer-ontdekte-het-grote-verschil-tussen-kickstarter-en-indiegogo).
* "Nederlandse Dobots Kickstart Crownstone: iBeacons in je stopcontact", Remco Bron, 2015, [ibeacon-nieuws.nl](https://ibeacon-nieuws.nl/nederlandse-dobots-kickstart-crownstone-ibeacons-in-je-stopcontact/).
* "Crownstone: Nederlanders maken slim stopcontact dat je moet hebben", Milton Broen, 2015, [want.nl](https://www.want.nl/crownstone-nederlanders-maken-slim-stopcontact-dat-je-moet-hebben/).

## Video files

Product demos:

* Demo on Crownstone turning off dangerous devices, 2016, [Youtube]( https://www.youtube.com/watch?v=bJZy1G756oM).
* Demo on Crownstone hardware features, 2015, [Youtube](https://www.youtube.com/watch?v=JS4tf2v2Wg4&t=3s).

Pitches:

* Demo day at Rockstart, 2016, [Youtube](https://www.youtube.com/watch?v=Hdi8aaQ3oM0)
* Crownstone pitch at EcoSummit 2016, [Youtube](https://www.youtube.com/watch?v=AjW-ZXw1NSo).
* Second place in GetInTheRing contest at Mediamarkt, 2016, [article](https://getinthering.co/dutch-startup-flow-ai-starts-pilot-project-at-media-markt/).

Talks:

* "Ontleed het brein van een smarthome" / "Dissect the brain of a smart home", Tweakers Smart Home event, 2017, [Youtube](https://www.youtube.com/watch?v=o-UCFUcDbkM).

## Podcasts

* "Crownstone Interview, Disney+ Update, Lord of the Rings Amazon Update", 2019, [Computer America - Today's Show](https://computeramerica.com/2019/03/07/crownstone-interview/).
* "Open source power outlets", 2015, [Linux Unplugged](http://www.jupiterbroadcasting.com/88416/open-source-power-outlets-lup-112/).

## Webinars

* "ISSO organiseert webinar over indoor locatiebepaling", 2017, [ISSO](https://isso.nl/updates/nieuws/nieuwsitem/news/isso-organiseert-webinar-over-indoor-locatiebepaling/)

## Logo

![Crownstone Default Logo]({{ site.url }}/images/logos/crownstone_logo_text_black.svg "Crownstone Default Logo, a Crown symbol by 5 dots connected through lines"){: style="max-width:40%" .float-right}

The following logos can be downloaded (see styleguide below).

* A **black** logo with text in [Adobe Illustrator format]({{ site.url }}/images/logos/crownstone_logo_text.ai).
* A **black** logo with text as [svg]({{ site.url }}/images/logos/crownstone_logo_text_black.svg).
* A **white** logo with text as [svg]({{ site.url }}/images/logos/crownstone_logo_text_white.svg). Use only when there is a colored background.
* A **black** logo as [svg]({{ site.url }}/images/logos/crownstone_logo_black.svg). Use only when the brand name is already clearly presented.
* A **white** logo as [svg]({{ site.url }}/images/logos/crownstone_logo_white.svg). Use only when the brand name is already clearly presented and there is a colored background.

Do not use a colored logo! The **black** logo should always be the prefered logo. Only use the white logo if its necessary.

## Styleguide

![Crownstone Styleguide]({{ site.url }}/attachments/crownstone_styleguide.png "Crownstone Styleguide"){: style="width:40%" .float-right}

There are the usual considerations, just a few:

* Use a **black** logo on a **white** background, especially on products or material that does not benefit from color.
* Logo is **white** on a blue background in the case where the logo really needs to pop out.
* Do not use the logo in any color. The logo is either **black** or **white**.
* Use **bands** over the full width, do not use a circle around the logo.
* Only use a **few colors** in supporting photographs and use brand colors.
* The brand colors are a shade of blue, **#003e52**, and the complementary shade of orange, **#ff8400**.
* Use the orange shade as an accent, e.g. for line separation, emphasis, not as a primary color.
* Use **Lato medium** as a font.
* Use the blue font on summaries or accentuated text. Use just a **black font** wherever possible for the primary text.
* In case where lighter shades of colors are required. Go to the [Adobe color wheel](https://color.adobe.com/create/color-wheel/?base=0&rule=Analogous&selected=3&name=My%20Color%20Theme&mode=rgb&rgbvalues=1,0.5176470588235295,0,0,0.23631049943210286,0.32156862745098036,0.5321115173241195,1,0.04999999999999993,0.8844330991828997,0.04999999999999993,1,0.050000000000000044,0.7437521349992267,1&swatchOrder=1,0,2,3,4). Click on "HSB" and adjust the second row. This will only adjust the **saturation** of a color, not the hue.

## Brochures

For an example of a brochure that is created using the above styleguide see:

* [Crownstone Brochure Smart Home]({{ site.url }}/attachments/brochures/Crownstone_Brochure_SmartHome.pdf)
* [Crownstone Brochure Green Home]({{ site.url }}/attachments/brochures/Crownstone_Brochure_GreenHome.pdf)

## Presentations

If you need a slide deck for a particular customer, feel free to contact us for your particular needs.

* [Crownstone Real Estate - Commercial & Residential]({{ site.url }}/attachments/presskit/Crownstone Real Estate - Commercial & Residential.pdf)
* [Crownstone Summary]({{ site.url }}/attachments/presskit/Crownstone Summary.pdf)
* [Crownstone Product Deck voor Consumenten (Dutch)]({{ site.url }}/attachments/presskit/Crownstone Product Deck - Consumenten.pdf)

## Presskit ZIP file

The presskit contains the following folders:

* Diagrams: grayscale installation sketches.
* Icons: for dimming, switching, positioning, etc.
* Logo: black, transparent svg.
* Products: pictures of Crownstone plugs, builtin Crownstones, Guidestones, and PCBs.
* Renders: exploded views and renderings in living room setting.

It can be downloaded here: [presskit visuals (zip, 342 MB)](https://github.com/crownstone/website/releases/download/v.0.0.1-alpha/presskit.zip).

## Events, fairs, talks

![Crownstone at CES]({{ site.url }}/attachments/engie-crownstone.jpeg "Crownstone at CES"){: style="width:40%" .float-right}

* [Beurs Eigen Huis](https://www.realiseerjedroomhuis.nl/crownstone/), Mar. 15-17, 2019
* [CES 2019](https://ces19.mapyourshow.com/7_0/exhibitor/exhibitor-details.cfm?ExhID=T0000336), Consumer Electronics Show, Las Vegas, Jan. 8-11, 2019
* [CES Unveiled](https://www.ces.tech/Events-Programs/CES-Unveiled/Amsterdam/Exhibitors.aspx), Amsterdam, Sep. 27, 2018
* Maatschap [The Future Group](https://www.the-future-group.com/), May 22, 2018
* Hannover Messe, Hannover, Apr. 23-27, 2018
* Building Holland, Amsterdam, May 17-19, 2018
* CES 2018, Consumer Electronics Show, Las Vegas, Jan. 8-12, 2018
* Schneider Electric, Amsterdam, Nov. 30, 2017

## Investors

* [Rockstart](https://www.rockstart.com/startups/crownstone/)
* [Almende Investments](https://almende-investments.com/crownstone/)
* Overview at [Crunchbase](https://www.crunchbase.com/organization/crownstone)

## Frequently asked questions

Q. Do I need to be close to a Crownstone to control it?

A. If you have multiple Crownstones they form a mesh network. If there is one Crownstone in your proximity they can forward the information to the entire network. It is also possible to control the Crownstone from online by leaving a smartphone or tablet at home.

Q. How accurate does a Crownstone measure my position?

A. A single Crownstone has an accuracy up to three to eight meters, just like an iBeacon. By using multiple Crownstones, the location becomes more accurate. If also the sensors on the smartphone itself are used, submeter accuracy is feasible. Our current software aims for room-level accuracy (around 1.5 meter or 5 feet).

Q. What devices does the Crownstone recognize?

A. The Crownstone measures both voltage and current. This allows it to measure not only power consumption, but also the type of load. Motors and transformers are reactive. Lights and heaters are resistive. The Crownstone also measures the current at a high frequency. This type of data characterizes a device. The types of devices the Crownstone can distinguish are lamps, fridges, electrical kettles, smartphones, and laptops, for example.

Q. What is the protocol used by the Crownstone?

A. The Crownstone uses Bluetooth Low Energy. This technology is directly available on a contemporary smartphone. The Crownstones can directly be controlled from your smartphone without the need for a hub. Moreover, the location of your smartphone can be used to turn off devices when you leave a room or turn on the lights when you enter a room.

{% include snippets/bottom-margin %}


text:
---
layout: post
title: Visit to Milan
---

## Ah, Milan.
That wonderful place of gelato & fashion & sun tans.
The last stop on PYO's whirlwind Europe tour was in Milan, and I must confess, I was looking forward to it the most.

### The Food

After scarce vegetarian options in Germany and Austria, Italian food definitely lived up to its reputation! I had a cannoli,
spaghetti, and averaged around 2.5 gelatos per day. Flavors: strawberry, mint, grape, butterscotch.

![Ice Cream and the Duomo](/res/IMG_20170625_125454251.jpg)
![Spaghetti](/res/IMG_20170625_121306902.jpg)
![Cannoli](/res/IMG_20170625_122902230.jpg)
![Cappucino](/res/IMG_20170625_115849749.jpg)

### The Language

I've been trying to speak snippets of Italian, since I speak Spanish & Latin & sing opera. It's a naturally musical language,
with many open vowels, so just being surrounded by Italian speakers makes me feel very sunny. (People tend to associate
computer geekiness with an aversion to sunlight. This is not entirely untrue.)

Below are some key phrases I found myself using:

Un gelato fragola, per favore. -> One strawberry ice cream, please. (highly important)

Per favore -> Please

Grazie. (GRAH-zie) -> Thank you.

Prego. (PRAY-go) -> You're welcome!

Mi scusi. -> Pardon me.

Sono vegetariano. -> I'm a vegetarian!

### The Fashion

The shops in Milan are gorgeous and expensive. Some of the storeowners take their clothes very seriously;
we were chased out of a shop! Most of them were very friendly, however. There's a big plaza with designer name stores like
Prada, and Versace. I ended up buying a bright red leather jacket.
![Jacket](/res/IMG_20170625_145451440.jpg)
![Versace Heels](/res/IMG_20170625_132302468.jpg)
![Shop Interior](/res/IMG_20170625_133550354.jpg)


text:
---
layout: default
---

# 1994-03-01 - Re: standard for steganography?

## Header Data

From<EMAIL_ADDRESS>(Plaz)

To<EMAIL_ADDRESS>Message Hash: dbe440b237ac82ee9a28cf6de189630d53b3c27814b70bb39367bd93a478c08f

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-03-01 19:40:57 UTC

Raw Date: Tue, 1 Mar 94 11:40:57 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Plaz)
Date: Tue, 1 Mar 94 11:40:57 PST
To<EMAIL_ADDRESS>Subject: Re: standard for steganography?
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Jim choate<EMAIL_ADDRESS>wrote:
>I have played w/ stego some and w/ the present resolutions of images I dont
>find the images have enough complexity to really hide a message of a useable
>length, unless you break it up into several images.

Present resolutions? What directions do you think it needs to go? Stego
handles 24 bit TrueColor (actually 32 bit, but Romana wisely decided not to
stuff data in the almost always blank alpha channel), and as many DPI as
you have memory for. I don't think there is much call for deeper color
resolution.

It's true that GIF only accepts 8-bit color and the defacto standard
internet transmision format for higher resolutions JPEG is a lossy
compression that annhilates the message. Is this what you are refering to?

>I use a function to measure the complexity of a image based on adjacent bit
>changes. The more complex an image the more bit changes. I measure it thus:
>
># of adjacent bit changes in image/ # of bits in image = complexity
>
>if the complexity is too low or too high (this is counter intuitive) then you
>can't hide a message. Consider an image w/ only a few bit flippings, any
>message that is inserted will cause the visual image to be distorted in a
>noticable way (unless it is truely expressionistic). Now consider a image w/
>every other bit flipped (maximum complexity) which is in effect a
>checkerboard. Any bits that get flipped change the pattern to a less complex
>one (ie the checkerboard is broken up). Also you have to consider the effects
>on edges and the standard deviation inherant in using anti-aliasing. This
>will cause bits on the edge to be switched incorrectly for the algorith in
>use. Since it is a trivial problem to measure the sd for various graphics
>packages this makes a nifty test bed for finding imbedding images. Blank or
>mono-chromatic areas also show the same type of errors.

Scanned or Frame-grabbed are good for this kind of thing.

_______________________________________________________________________
Geoff Dale         -- Cypherpunk/Extropian --         Plastic Beethoven
AnarchyPPL - Anarch (Adjudicator)      ExI-Freegate Virtual Branch Head
<EMAIL_ADDRESS>                                      66 Pyramid Plaza
<EMAIL_ADDRESS>                           Freegate<EMAIL_ADDRESS>7777
                "Subvert the domination paradigm!"

{% endraw %}
```

## Thread

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

+ Return to<EMAIL_ADDRESS>(Plaz)](/authors/plaz_at_netcom_com_plaz_)"

+ 1994-03-01 (Tue, 1 Mar 94 11:40:57 PST) - Re: standard for steganography? -<EMAIL_ADDRESS>(Plaz)_


text:
# restart_router
Restarting my Vodafone Router to make sure the performance is good...
I am assuming you are running this script on a RPi.

# Install
Clone it

# Install Chromium
todo, install it in docker
``

# Run chromium with debugging port
`--remote-debugging-port=9222`

# Install Python Dependencies
`pip3 install -r requirements.txt`

# Run
Replace `abc` with your actual password. Change IP to your router ip address.
`python3 PASSWORD=abc IP=<IP_ADDRESS> restart_router.py`


text:
# Deployment

## New Deployment
Ensure your settings yml file is properly configured as shown in the Quick Start and Configuration sections

Run: `serverless deploy [--stage=dev] [--settings=settings.yml]`

If you need to deploy using a specific AWS profile, you should run:

`AWS_SDK_LOAD_CONFIG=true serverless deploy [--stage=dev] [--settings=settings.yml] --aws-profile PROFILE_NAME `

## Deploying Updates

Keeping your Serverless stacks up to date is critical to ensuring you have the fewest bugs and most secure
 environment. We follow [Semantic Versioning](https://semver.org/) to help users understand compatibility and changes.

### Updating Serverless Sharp
Start by downloading the latest code that's compatible with your previous version (check your package.json file to
 see the current version.)

Once you've downloaded the new version and ensured you've made any necessary configuration changes, you have two
 options:

 1) You can simply run the standard deployment:

 ```shell script
sls deploy --settings ./settings.yml --stage <stage>
```

This will deploy the entire application.

repository: venveo/serverless-sharp

gha_language: JavaScript

repo_name: venveo/serverless-sharp


text:
---
path: '/guides/nicotine-storage'
author: 'duncanyoyo1'
title: 'Guides - Nicotine Storage'
---

With the state of vaping being what it is in the United States and other countries around the world, it's more important than ever to store your nicotine base properly. This guide should help you understand the best practices to store your nicotine long term ( Years ).

### The enemy of nicotine is oxidation.

### What causes oxidation?

**Well firstly**, exposure to oxygen. A lot of manufacturers will have to expose the nicotine to oxygen during the manufacturing process, thus beginning the process of oxidation.
Some vendors will use a supercritical gas to remove the nicotine from the tobacco plant, without exposing it to oxygen. ( There are more steps involved but it is not important for what we are talking about )

Either way, you will eventually need to open and use your nicotine bases. And inevitably expose them to oxygen.

**The second** cause of oxidation is exposure to light, UV light especially.
Exposure to UV light will cause the nicotine to begin to oxidize and break down almost immediately.

**And the final** cause of oxidation is heat. As well as changes in temperature.
Oxidation occurs more rapidly the hotter it is, conversely, the colder it is the slower oxidation happens.
Having constant temperature fluctuations is not great for storage either, ideally you want as little fluctuation in temperature as possible.

The best way to keep nicotine from oxidizing is to keep it in an amber glass bottle, in a freezer (-20C is the preferred temperature for long term storage).
The amber glass will prevent UV light and oxygen from getting to the nicotine in the bottle, and keeping it in the freezer will slow any reaction happening.

Check out [GlassBottleOutlet](https://glassbottleoutlet.com/collections/boston-round) for some decently priced amber glass.

### But what about that pesky oxygen in the bottle?

Well that is where using Argon for preserving nicotine can be beneficial. It is a noble gas and does not react with nicotine, PG or VG, and more importantly it is heavier than air, so it will naturally displace any environmental gasses (By volume, dry air contains 78.09% nitrogen, 20.95% oxygen, 0.93% argon, 0.04% carbon dioxide).
This will help keep the amount of oxygen as low as possible.

The best practice is to decant your nicotine into storage bottles ( For example, use 4x the size of your working bottle, so you only have to open any given bottle 4 times. Smaller is also fine if you have the space. ) and top them with argon.

You can find it frequently sold as a wine preservative, but make sure you get the pure argon one. Not the mixed gas one. ( Nitrogen can turn your nic base pink but otherwise shouldn't affect it )

[ArT Wine Preserver](https://www.amazon.com/gp/product/B01MEHJCQ2)

All you have to do is spray it for a few seconds in your bottle. Since it is heavier than air it will displace the air in the bottle and create a layer of protection from oxygen.

Keep a working bottle of nicotine handy for mixing, like a 60ml amber PET bottle, but you can use a smaller bottle depending on how much you mix and what nic level you use. PET or glass is preferred. Store it in a cool, dark place. Out of direct light.
Then when you need to refill your working bottle, you can fill it and re-top your storage bottle with argon.

You could also choose to store it in smaller amber glass bottles, like a 30ml. That way you can just take one out as you need them.
The down side of this is it takes up much more volume, so you need a lot more space in your freezer.

All of these things will help ensure your nicotine bases are good to use for years and years to come.

repository: diy-ejuice/diy-compendium

repo_name: diy-ejuice/diy-compendium


text:
# Our Stuff

### A Test Driven Developed Rails application for keeping an inventory of items in your home.

This is an app built out of personal necessity. My wife and I were moving to a smaller downtown condo and needed to get rid/give away a lot of big stuff. We wanted a way to easily track the items we were giving away and also allow our friends to claim (or call 'dibs') on those items. This app fit the bill.

The style is very basic, but that is by design. I imagined that we would be adding items via our iPhones vs any other way. So the key here was a super responsive, clean layout that would easily load on our phones.

# Contributions
This isn't something I plan on developing out much further, but if you feel like contributing, feel free to do the fork, contribute, push, MR thing. I'll welcome any additions with open arms.

Some things I want to add, but don't have time for:

1. Email notifications using Mandrill
2. Password resets using Mandrill/Devise (I know, I'm just being lazy, but remember your passwords people - not that hard...)
3. SMS notifications using Twillo (or the like)
4. A few more tests wouldn't hurt
5. Draper (or some view model layer) to clean up the UI a bit

# License

This app is released under the MIT License. Have at it!

### Made with love by: [Alex Spencer](http://www.alexspencer.net)


text:
# SolverComparator

A few scripts to compare optimization solvers from various sources. Comparisons are performed in the NLPModel framework. Also, some additional problems are provided. All solvers are interfaced to use the Stopping Pkg to uniformize the stopping criteria in the comparisons.

For now, only unconstrained optimization is considered. Supported solvers are variants from
- NLopt (7 gradient based variants)
- Ipopt (full hessian and limited memory approximation variants)
- Knitro (untested)
- Optimize (trunk and lbfgs)
- ARCTR (20 variants, 4 more using the MA97 HSL package available)
- LSDescentMethods (various conjugate gradients, modified Newton)

src/ExtSolvers contains wrappers to solvers from
- Ipopt
- NLopt
- LbfgsB (not an official julia Pkg)
- Knitro (not an open source solver)
- Newtrunk  adjustment of trunk to use the Stopping Pkg
- test_ext_solvers: tests the provided wrappers to external solvers on the rosenbrock test function

src/compare_solvers.jl contains useful function to run batches of solvers on batches of problems. Both scripts run several solvers on a set of problems; each the set of solvers need not be distincts and a corresponding set of options is required, one option list per solver.  Both return two performance profiles and the corresponding stats dictionaries, one using function evaluations and the other CPU time.
- compare_solvers_with_options   The results are produced solver by solver.
- compare_solvers_with_options2  The results are produced problem by problem.

src/Ampl_JuMP contains some problems used for testing, both modeled in JuMP and AMPL
- bray and braxy: brachistochrone models
- msqrtals: an instance from the CUTEst collection translated both in JuMP and AMPL
- test script to validate that both models (AMPL and JuMP) are equivalent

src/tests contains several script helpful to compare solvers from any source. They should serve as examples.
- CUTEstUnc.list: list of unconstrained models in CUTEst
- testcompare: test the comparison tools.
- testgeneric:  template to test several solvers on several models (MPB, CUTEst, Ampl)
- AmplProblems.jl: script to load the Ampl test problems
- CUTEstProblems.jl: script to load the CUTEst test problems
- MPBProblems.jl: script to load the MPB test problems

gha_language: Julia


text:
---
title: Floats
parent: Order
nav_order: 4
---

# Floating-Point Order

When `nav_order` fields are floating-point numbers, the pages are ordered in increasing order of the numerical values.

Floats include `0.0` and negative values.

repository: debplana/just-the-docs-lsp

repo_name: debplana/just-the-docs-lsp


text:
---
id: 1
name: 'mysql_debug'
---
Possible options are `Console`, `File`, `FileAndConsole` and `None`.
In case of a file output, the file will be located in the current working directory
on starting the server, named like `/<resourcename>-<timestamp>.log`. The name of the
file can be changed by setting `mysql_log_file_format`.
(Default: `None`)

repository: glifem/fivem-mysql-async

repo_name: glifem/fivem-mysql-async