text:
# Defining the Character-level CNN Imperative Model

This section provides information on defining the character-level convolutional neural network imperative model by using the Deep Java Library block API.

The model architecture is as follows:

```
  (0): Conv1D(None -> 256, kernel_size=(7,), stride=(1,))
  (1): MaxPool1D(size=(3,), stride=(3,), padding=(0,), ceil_mode=False)
  (2): Conv1D(None -> 256, kernel_size=(7,), stride=(1,))
  (3): MaxPool1D(size=(3,), stride=(3,), padding=(0,), ceil_mode=False)
  (4): Conv1D(None -> 256, kernel_size=(3,), stride=(1,))
  (5): Conv1D(None -> 256, kernel_size=(3,), stride=(1,))
  (6): Conv1D(None -> 256, kernel_size=(3,), stride=(1,))
  (7): Conv1D(None -> 256, kernel_size=(3,), stride=(1,))
  (8): MaxPool1D(size=(3,), stride=(3,), padding=(0,), ceil_mode=False)
  (9): Flatten
  (10): Dense(None -> 1024, Activation(relu))
  (11): Dropout(p = 0.5)
  (12): Dense(None -> 1024, Activation(relu))
  (13): Dropout(p = 0.5)
  (14): Dense(None -> 2, linear)

```

The input shape is (69,1014), where 69 is the total number of characters and 1014 is the maximum string length. The NDArray is one-hot encoded per character.

The output layer represents two possible classifications, malicious or benign. The convolutional layers have 256 single-dimensional filters of varying kernel sizes. They feed into FullyConnected layers after pooling.

## Defining the model in DJL

DJL uses a block level definition of various operators. Each block can have sub-blocks. Individual blocks have their own parameters defined. The model consists of a single block that contains many sub-blocks.

```java
// Declare a model
Model model = model.newInstance();

// Define primary block

SequentialBlock mainBlock = new SequentialBlock();
        float dropoutProbability = (float) 0.5;
        int fullyConnected = 1024;
        int numberOfFilters = 256;
        /**
        * Every block returns a NDList which feeds into the consecutive Block
        * 1D Pooling is defined as a LambdaBlock
        */
        mainblock.add(
                        new Conv1D.Builder()
                                .setKernel(new Shape(7))
                                .setNumFilters(numberOfFilters)
                                .build())
                .add(Activation.reluBlock())
                .add(
                        ndList ->
                                new NDList(
                                        Pool.maxPool(
                                                ndList.singletonOrThrow(),
                                                new Shape(3),
                                                new Shape(3),
                                                new Shape(0))))
                .add(
                        new Conv1D.Builder()
                                .setKernel(new Shape(7))
                                .setNumFilters(numberOfFilters)
                                .build())
                .add(Activation.reluBlock())
                .add(
                        ndList ->
                                new NDList(
                                        Pool.maxPool(
                                                ndList.singletonOrThrow(),
                                                new Shape(3),
                                                new Shape(3),
                                                new Shape(0))))
                .add(
                        new Conv1D.Builder()
                                .setKernel(new Shape(3))
                                .setNumFilters(numberOfFilters)
                                .build())
                .add(Activation.reluBlock())
                .add(
                        new Conv1D.Builder()
                                .setKernel(new Shape(3))
                                .setNumFilters(numberOfFilters)
                                .build())
                .add(Activation.reluBlock())
                .add(
                        new Conv1D.Builder()
                                .setKernel(new Shape(3))
                                .setNumFilters(numberOfFilters)
                                .build())
                .add(Activation.reluBlock())
                .add(
                        new Conv1D.Builder()
                                .setKernel(new Shape(3))
                                .setNumFilters(numberOfFilters)
                                .build())
                .add(Activation.reluBlock())
                .add(
                        ndList ->
                                new NDList(
                                        Pool.maxPool(
                                                ndList.singletonOrThrow(),
                                                new Shape(3),
                                                new Shape(3),
                                                new Shape(0))))
                .add(Blocks.batchFlattenBlock())
                .add(new Linear.Builder().setOutChannels(fullyConnected).build())
                .add(Activation.reluBlock())
                .add(new Dropout.Builder().optProbability(dropoutProbability).build())
                .add(new Linear.Builder().setOutChannels(fullyConnected).build())
                .add(Activation.reluBlock())
                .add(new Dropout.Builder().optProbability(dropoutProbability).build())
                .add(new Linear.Builder().setOutChannels(2).build());

//Set the mainblock as model's starting point

model.setBlock(mainBlock);

```

repository: Geeksongs/djl-demo

repo_name: Geeksongs/djl-demo


text:
# EPD-JTAC
JTAC script for ARMA 3

More information on the forums here: https://forums.bohemia.net/forums/topic/218512-standalone-jtac-script

# How to use
1. Copy the EPD folder to your Mission Folder
2. In the server's init.sqf, add the following: ```call compile preprocessFileLineNumbers "EPD\VirtualJTAC\init.sqf";```
3. On the players you want to have JTAC abilities, add the following: ```this setVariable ["JTAC",true];```
4. Copy the following into your description.ext
```
class CfgNotifications
{
	class JtacReloadNotification
	{
		title = "JTAC";
		iconPicture = "a3\ui_f\data\gui\cfg\communicationmenu\call_ca.paa";
		iconText = "1";
		description = "%1";
		color[] = {0.153, 0.933, 0.122, 1};
		duration = 5;
		priority = 0;
		difficulty[] = {};
	};
};
```

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
Flag: CTF{game_genie_killed_the_nintendo_star}

For my solution, I create `sh;` in-memory using blocks, then jump to it by
modifying `memset()` to point to `system()` and adding an offset to the
argument.

# Game Genius codes

This requires two bytes of changes with the "Game Genius".

The first one changes `call memset` to `call system`:

    0x08048622 (or 0x622 on disk) 0x30 -> 0x20

    Code: AZZAZT

The second one changes the memset argument from the start of the board to the
offset where our code starts (0x15 in):

    0x0804954c (or 0x154c) 0xA0 -> 0xB5

    Code: SLGOGI

# The game

Once those two changes are made, all you have to do is spell out "sh;" at the
offset of 0x15 bytes into the gameboard. Easy, right?

Here is the solution is in 16 moves:

* as
* qaas
* eddds
* qdddds
* ds
* ddddds
* qaas
* eaaaas
* as
* ddddds
* edddds
* aaaaas
* eas
* s
* s
* s
* s
* s

That'll create the following grid after 13 moves (numbering the pieces in hex):

     C      B
     C      BB
    CC      BA
    8 99    AA
    8899    A6
    877     66
      77D   64
      22D    4
     22 DD 344
      1155 33
      1155 3

The important part is:

           <64
      22D    4
     22 DD 344
      >

or

           <11
<PHONE_NUMBER>
<PHONE_NUMBER>
    00>

If you take those as bytes, left to right and top to bottom, you get:

    11001110 00010110 11011100

We have to reverse each byte, because of how it's encoded in-memory:

    01110011 01101000 00111011

And that converts to:

    73 68 3B -> 'sh;'

Once that's done, just play out the game by repeatedly playing `s` till it's
over, at which point a shell should pop!

gha_language: C

gha_license_id: MIT


text:
# Encoding and Error Code Correction

## Error Types

### Burst Error
* contiguous errors
* most likely type of error

## Error Code Correction

* could ask user to repeat

### checksum/hash function
* Damn
* Luhn
* Verhoeff

### parity bits

* Only handle 1 bit error

### Cyclic redundancy checks

* good for burst errors

### Repitition code (repeat 3 times)
* takes up space

### Reed-Solomon codes

### Turbo codes

### Low-density Parity-check Codes

### Hamming Codes
- (7,4), 3 parity bits
- Not good at burst errors
- Detects and corrects all hamming distance 1 errors

## Sources
- http://en.wikipedia.org/wiki/Error_detection_and_correction

## TODO
- Make no error correction
- Look at types of error
- Calculate channel capacity


text:
## ThreeFold Grid Presentation Material:

The ThreeFold Grid is where three elements of the ThreeFold come toether, 3Nodes, 3Bots and the ThreeFold Token.  Several presentations have been created to explain the various components. These presentations will open in another tab on your browser.

- [ThreeFold Grid: Comparision to Traditional Clouds](https://compare.threefold.me)

More to come.


text:
# hyperloadmore

a simple paginator

The main goal here is to come up with an interface that could
be supported by both an infinite scroller, or a "load more" button.
some interfaces also like to have a "load more" at the top,
but an infinite scroll at the bottom.

The interface used here is CustomEvents, first `hyperloadmore`
is created with a content object. The user emits "hasmore" messages
on the content element when there are new elements ready to display.
this updates the button to show the user it's waiting.
When the user clicks the button, the `hyperloadmore` emits
a `readymore` event - this tells content to add more elements
to that end... The content is responsible for
deciding how many to add, and if/when there are more to come,
to emit another "hasmore" event.

`hasmore` events have a `.detail.top` and `.detail.bottom` boolean
properties to indicate whether the new content is to be added
at the start or end. ("detail" is a feature of [CustomEvents api](https://davidwalsh.name/customevent))

## scrolling

This is also an idea towards a better infinite scroller. We need to decouple the control part from the application.
I want the incoming data to be decoupled from the thing which manages the scrolling.

## example

``` js
var HyperLoadMore = require('hyperloadmore')

var h = require('hyperscript')

var content = h('content')

content.addEventListener('readymore', function (ev) {
  if(ev.detail.bottom) {
    for(var i = 0; i < 10; i++)
      content.appendChild(createElement(...))
  }
})

document.body.appendChild(HyperLoadMore(content))

content.dispatchEvent(
  new CustomEvent('hasmore', {target: content, detail: {bottom: true, count: 10}})
)
```

## example 2: streams helper

``` js
var HyperLoadMore = require('hyperloadmore')
var Streams = require('hyperloadmore/stream')
var h = require('hyperscript')
var content = h('div.content')

document.body.appendChild(HyperLoadMore(content))

pull(
  source,
  pull.map(render), //turn into an html element
  streams.bottom(content) //stream into the loadmore! that's all!
)
```

## events

### readymore

`event.target` is the element to be added to.
`event.detail.top` is true if elements should be added to the top.
`event.detail.bottom` is true if elements should be added to the bottom

### hasmore

when you have new data ready to display, emit the `hasmore` event.
``` js
content.dispatchEvent(new CustomEvent('hasmore', {
  target: content,
  detail: {
    bottom: true, top: false, //bottom should != top
    count: N //optional.
  }
}))
```

## streams

see also, streams helper

``` js

```

## License

MIT

repository: dominictarr/hyperloadmore

repo_name: dominictarr/hyperloadmore


text:
# Bitcoindevkit by Example 😎

[You can check out the website here](https://www.bitcoindevkit-by-example.com/)!

I initially wrote this for myself, but I will gladly merge PRs for more content.

## Build locally
This website uses Jekyll, a static site generator, coupled with the simple yet very clean [just-the-docs theme](https://pmarsceill.github.io/just-the-docs/).

The theme documentation has all the info you need to build locally and customize the theme, but the simple way to build locally for testing and content development is to ensure you have the Ruby toolchain with Jekyll available and simply run
```sh
git clone https://github.com/thunderbiscuit/bitcoindevkit-by-example.git
cd bitcoindevkit-by-example
jekyll serve
```

Changes to the markdown files in the `content` directory will be reflected immediatly on `localhost:4000/`.

repository: thunderbiscuit/bitcoindevkit-by-example

gha_language: Shell

repo_name: thunderbiscuit/bitcoindevkit-by-example


text:
# Complete Results

In the paper, we only show the results for the best algorithm, i.e., the Random Forest Regressor.

In this folder we report the complete results for all the four experimented algorithms.
Therefore, we share 8 different csv files reporting separately the results for the two tools over the four different budgets.

We do not include the `mean_squared_log_error` in the files, since its calculation has not been possible for all the algorithms.

repository: sealuzh/branch-prediction

repo_name: sealuzh/branch-prediction


text:
# angular-tourism-agency

Activity for the Advanced front-end development courses from the [Master's Program in Web App and Website Development](https://estudis.uoc.edu/ca/masters-universitaris/desenvolupament-llocs-aplicacions-web/presentacio) at the [Universitat Oberta de Catalunya](https://www.uoc.edu).

# npm install
Install dependencies

# npm run database
For starting the simulated API

# ng serve
Run the app

repository: cmgdragon/angular-tourism-agency

repo_name: cmgdragon/angular-tourism-agency


text:
JCC Tool
========

This tool downloads the current JCC / JCG / Ku data from the JARL website and outputs a CSV file containing all of the primary and secondary administrative regions for use in amateur radio applications.

You can download the most recent CSV file here: [jcc.csv](jcc.csv)

The easiest way to run this application is like this:
```
cargo run --release > jcc.csv
```

You can also build the application without running it like this:
```
cargo build --release
```

This places the binary at `target/release/jcc`.

repository: vaelen/jcc

branch_name: refs/heads/main

repo_name: vaelen/jcc


text:
# Lab Assignment - Software Engineering
[![Build Status](https://travis-ci.com/ksaketou/maven-project.svg?token=SAbjwsyqTgTceG3agqdc&branch=development)](https://travis-ci.com/ksaketou/maven-project) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

This repository was created in terms of the Software Engineering in Practice class and contains a Maven project written in Java.

## Histogram Generator Module

This module generates a histogram of grades which are given as an input through a file. The input file is provided
to the program as a command line argument. Java's JFreeChart library is being used for the generation of the histogram.

### Jar file Creation and Execution

First of all, download the source code in a zip form. Then, unzip the folder, open it and execute

```
mvn package
```

The target folder has now been created automatically with all the generated files. For the creation of the diagram, execute

```
java -jar gradeshistogram/target/gradeshistogram-0.0.1-SNAPSHOT-jar-with-dependencies.jar [input file absolut path]
```

If you want to execute the jar file with the `grades.txt` file as an input simply run

```
java -jar gradeshistogram/target/gradeshistogram-0.0.1-SNAPSHOT-jar-with-dependencies.jar gradeshistogram\src\main\resources\grades.txt
```
## Unit Testing Module
Details regarding the Unit Testing and Continuous Integration module are available [here](https://github.com/ksaketou/maven-project/tree/development/unittesting/README.md).

## Source Code Analyzer Module
Details and information related to this module and the Design Patterns can be found [here](https://github.com/ksaketou/maven-project/blob/development/SourceCodeAnalyzer/README.md).

repository: ksaketou/maven-project

repo_name: ksaketou/maven-project


text:
PROJECT
=======

## How to run this project?

1. ```git clone REPO_URL```
2. ```cd PROJECT```
3. ```bundle```
4. ```rake db:setup```
5. ```foreman start```
6. Go to http://localhost:3000

## Sanity check!

Is your first time here? Ok, so you should check some stuff. If some of the checks fails, ask any of the contributors.

Checks you have to do:

1. Do ```bundle``` works and install all gems accordingly?
2. Do ```rake db:setup``` works?
3. After run ```foreman start``` if you go to ```http://localhost:3000``` you see something that shows the project is working?
4. Is code coverage 100%?
5. Do ```rake integrate``` works and deploys to production?
6. Do the project have Rollbar or Airbrake configured in production environment?

## Create remote git repository

1. Create git repo.
2. Add remote ```$ git remote add origin REPO_URL```.
3. Push to repo ```$ git push --set-upstream origin```.

## Run specs

```$ rspec .```

## Run rake integrate

The project requires 100% of test coverage.

When you finish an implementation, run:

```$ rake integrate```

This task will run all tasks described on 'jumpup.rake' file, check the file and verify the steps.

## Page title

The project use flutie gem to manage page title.

Add on view files the code above to change the page title:

```content_for(:page_title, 'My title of my page')```

## Configuring domain on Heroku

Check out this [wiki](https://github.com/Helabs/pah/wiki/Configuring-domain-on-Heroku) with detailed instruction of how to use the canonical_host to redirect your naked domain to your real app.

repository: leandrocp/pah

repo_name: leandrocp/pah


text:
# kOmegaSSTCC
OpenFOAM code for rotation/curvature correction for the komegaSST turbulence model.
This is based on the following: https://github.com/cvillescas/TkOmegaSSTCC. which unfortunately is incompatible with the standard distribution from OpenFoam Foundation. Furthermore, from version 3.0 the whole concept of turbulence
modelling was re-written and now is template based. It means that there is only one
formulation of turbulence model for both incompressible and compressible flow.
I have tested it in OpenFOAM 5.
This repository code is not part of the official OpenFOAM distribution.

repository: snaka-dev/kOmegaSSTCC

repo_name: snaka-dev/kOmegaSSTCC


text:
---
layout: post
title: "Think Global, Act Local, Buy From Grocery Stores"
excerpt: "Personal"
categories: personal
comments: false
share: true
---

![](http://nwasianweekly.com/wp-content/uploads/2012/31_34/IMG_2830.JPG)

This weekend I found myself at the neighborhood farmer's market; something that happens every weekend during the spring and summer. If you don't know, farmer's markets are sort of a thing in the PNW; every neighborhood has them and many people like to bump around the kiosks for a few hours.

Anyway, there is something I learned about myself this Sunday; I don't at all about farmer's markets.

 By the way, know what a half gallon of raw goat costs? Before yesterday, I would have said anywhere from $0-$1. Turns out it is $10. Want a dozen duck eggs? Of course not! But for $8, you can get something you don't want at all.

The strangest thing about these markets is the fact there are hundreds of people meandering around.  Again.

Yeah, I understand I may not be the target audience; middle-aged single men do not frequent such things. But I guess I am not sure who the target demographic is.

 However I cannot say that I will never return. I am sure that someday soon I will find myself in the middle of one of these things once again completely by accident.

gha_language: JavaScript


text:
# Development Scripts

* `scripts/clean.sh` : Delete any build artifacts.
* `scripts/install.sh` : Install dependencies in a virtual environment.
* `scripts/publish.sh` : Publish the latest version to PyPI.
* `scripts/create.sh` : Create pipenv environment.

Styled after GitHub's ["Scripts to Rule Them All"](https://github.com/github/scripts-to-rule-them-all).


text:
To Google group:

I've just released an update (0.1.14) to the public prototype of Annalist.

New in this release is initial support for arbitrary binary attachments to Annalist entities, initially usable for adding image files to collections (previously, they must be published separately on the Web and referenced).

This release also contains a number of other enhancements and bug fixes, including:

* Add logic to serve content of attachment in orginally submitted form.
* Add "View" button to edit form.  This makes it possible to show hyperlinks that can be used to access referenced entities.
* Fix some situations causing "500 Server error" messages.
* Update continuation URI if necessary when an entity is renamed, to prevent some surprising "Entity does not exist" messages.
* Added software version to collection, and refuse access if collection version is higher than current software version.
* Don't save URL value in stored data; rather depend on its value being determined when an entity is accessed.  This potentially improves portability of data collections.
* Add documentation of view field descriptions, particularly to cover fields that are used to create entity attachments.
* Added internal support for complex field values that can be partially updated (used to support attachment metadata).
* Quite extensive code refactoring to support attachments.
* Added hooks for file format migration.

More details can be found in the "History" section of the [release notes](https://github.com/gklyne/annalist/blob/master/documents/release-notes/release-v0.1.md), and via the GitHub issues list.

#g

...

To research-object:

I've just released Annalist 0.1.14.

The major new feature in this release is support for arbitrary binary attachments to Annalist entities, initially usable for including image files in collections (previously, they must be published separately on the Web and referenced).

The full announcement is at: https://groups.google.com/d/topic/annalist-discuss/qjvC0nxn5v4/discussion

Release notes (see "history" section for details) at:
https://github.com/gklyne/annalist/blob/master/documents/release-notes/release-v0.1.md

Annalist project on Github:
https://github.com/gklyne/annalist

Live demonstrator:
http://annalist.net/ and http://demo.annalist.net/

#g
--

repository: gklyne/annalist

gha_language: Python

repo_name: gklyne/annalist


text:
# How to Contribute to the Project

## Repository Structure Template for Contributors

All directories and files in this repository should be arranged in the following suggested format for consistency. Users should get familiarized with the structure listed below to find files easily.

    resources/
    |-- [Subject]/
        |-- Mock Paper/
            |-- README.md (record progress)
            |-- mock1/
                |-- main.tex
                |-- fts_[Subject]_mock.cls
                |-- illustration/ (Optional)
                    |-- somefigure.pdf
                    ...
            |-- mock2/
            ...
        |-- Notes/
            |-- README.md (record progress)
            |-- [Topic]/
                |-- main.tex
                |-- fts_[Subject].cls
                |-- ss0/ (Front matter. Optional)
                    |-- intro.tex
                    ...
                |-- ss1/
                    |-- content.tex
                    |-- exercise.tex (Optional)
                    |-- supp.tex (Optional)
                    |-- illustration/ (Optional)
                        |-- somefigure.pdf
                        ...
                |-- ss2/
                ...

NB Please do NOT name the illustration files as main.pdf, since that is agreed to be the name for the temporary builds of the documents and will be ignored by git due to our current .gitignore settings. Also, try not to add any binary files that are subject to changes (since they will be stored in the repository forever).

## LaTeX

### Setup

#### Download

The easiest way to get TeX is to install TeXLive. This works on all platforms and should provide all you need by default.

If you do not want to install all packages (occupying some gigabytes of disk space) from CTAN defaulted by TeXLive, you can try the MiKTeX distribution. It will only install the basic facilities to run TeX, and required packages will be installed on-the-fly. However, due to this quite unique feature, compilation speed is compromised to a certain degree. MiKTeX is also cross-platform now.

On Macintosh, a distribution called MacTeX is also available. It is very much like TeXLive, but its interface is optimized for Macintosh system.

Some other distributions are also out there. But these are the most widely-used ones.

#### Usage

TeX is a markup language. You write tex files and compile them to binary formats like dvi or pdf.

LaTeX is a set of macros equipping on plain TeX. This includes the most important \documentclass and \usepackage， which requires cls and sty files respectively. You may use the existing ones or come up with your own. If you choose the latter, it is recommended that you sync those files through all similar stuff in the same subject. E.g. All M2 notes should use the same cls file, fts_ms.cls.

All the notes in this project are supposed to be written in LaTeX. If you want detailed material to learn it, you may consult the Overleaf/ShareLaTeX tutorial to get a grip of the idea. If you just want to clarify a few usage problems, you may feel free to search/ask them in Stack Overflow.

#### Compile

If you use an LaTeX IDE, you will of course be given compile/view shortcut. Most text editors (like Vim, Emacs, VS Code, etc.) also have plugins that support similar functions.

However, if you insist on managing the command line, there are generally two ways (both require a functioning LaTeX distribution, of course).

Assuming that your main tex file is named main.tex. The play-from-scratch way is to simply use pdflatex main.tex -interaction=nonstopmode. The last argument ensures a similar behaviour of LaTeX compiler to most modern language compilers.

The author (@fivetriplestar) personally recommend using latexmk. It is a perl script which most likely come with most perl distributions. You only need to type latexmk in the working directory and it will take care for the rest.

## Git Workflow

### Setup

#### Download

Several installiation methods work depending on your case.

###### Linux

Use your distribution's package manager to install git. For example, Ubuntu users can use apt-get install git.

###### Native Windows Environment

Install git to your PC from this link.

###### MSYS2 on Windows

Install MSYS2 from here. After all packages have been updated by casting pacman -Syuu over again, input pacman -S git.

Note that in this way you can also get a full POSIX environment on Windows, therefore it is expected to take up more disk space.

###### Macintosh

Most likely your system has already installed git. Try running git --version to find out. If there is no git installed, install it from here.

#### Initialization

Open your favourate terminal (cmd/PowerShell/Git Bash/Msys2 Bash/...) and navigate to the directory you want.

For example, if your want the repository to be at C:/Users/mklprudence/5-triple-star/..., use command cd C:/Users/mklprudence

Clone the repository to establish a local repository copy by running command git clone https://github.com/mklprudence/5-triple-star.git

Move your cmd working directory into the repository directory by running cd 5-triple-star

### Pulling or Fetching a updated copy of file from Github

It is important for you to work on an updated copy both for your own work's sake and for preventing merge conflict. Your current local repository is only a "snapshot" of the online repository at the point of your last git push or git pull.

Open your favourite terminal directly in the 5-triple-star directory.
In Windows, open the directory in File Explorer, right-click any empty space and open cmd/PowerShell/....
Or you can open the terminal and navigate to the suitable directory by running command cd path/to/dir.

Run command git pull origin master to pull updated data from the online repository. You maybe prompted to login Github.
See section Caching Password to avoid having to login every time you git push or pull.

DO NOT conduct a git pull if you have ANY uncommited/unpushed changes to your local repository. This will result in merge conflict. If a merge conflict occurs, the easiest way to resolve is to re-setup the whole local repo.

### Pushing and Committing to Github

#### Committing

After conducting some changes or adding some files, it is important to group those changes and notify the Git system that there are changes, in the action called Committing.

First add the changed file that needed to commit by git add. To add ALL changed file in your working directory to the commit, use git add .. To add only specific file or folder, use git add relative-path-to-file for files and git add relative-path-to-folder/* for folders.

Then conduct the commit by using git commit -m "message-for-the-commit"(with the quotation marks).

If you simply want to commit all the changes, staged or not, in one run, use git commit -a -m "message-for-the-commit"

It is recommended that you do not forget to add the -m "message-for-the-commit" part, otherwise, unless you have configured it, vim will be opened for you to input the commit message, which is painful if you have no existing experience of using it.

#### Pushing to remote repository

Committing only creates commit on a local level. Git Push is required to apply the changes to the online repository.

After committing all required changes, do git push origin master to conduct a git push.

Note : Multiple commits can be pushed at the same time, so feel free to create several commits before applying a final git push.

### Caching Password (Windows)

Password can be cached so that you don't need to login ever time you conduct a git pull or git push.

For detailed instructions, consult Caching your GitHub password in Git


text:
---
title: The Embed Screen & You
layout: post
category: Embedding
description: Our embed builder makes it super easy to customize the look and functionality of your embedded videos.
post_intro:
After clicking the "</> Embed" function under the player window or in the "Media Actions" drop-down menu, the Embed Screen is where you can choose your embed type, customize the player experience, and add social sharing functionality.

Let's take a look at what options are available through the embed screen, and how you can use them for your publicly embedded videos.

---

{% post_image hashed_id: '1856ed5c774555ea40859d6a1bfa1723c96722f5', class: 'center' %}

    There are two main Wistia player embeds types - "inline" and "popovers".  Popovers create a lightbox experience for your viewers (click here for an example ).

The advanced embed types area allows you to customize the dimensions on your player, and gives you access to advanced embed code types.  If you have Video SEO sitemaps created, or require access to the player API, these options will appear here as well.

      Wistia player customization makes it easy to style your video embeds - without it getting in the way of what's most important (it's the content!).  Change the color, pick the controls you want your viewers to see, and set the start and end behavior of your video.  The power is in your hands.

      You might notice there isn't an 'HD button' included in your options.  That's because we don't use one!  In short, when your viewer full-screens the video, your video will switch to HD automatically (if their bandwidth can handle it).  The HD button is a thing of the past.

      The social sharing section allows you to add sharing buttons for your favorite social services.  Let your viewers share links to your content on Facebook and Twitter (and many more), and add a badge (like your logo!) in the lower-right-hand corner.  It's easy, clean, and stays out of the way of your video.

      If you allow your viewers to copy the embed code of the video, the badge and URL will travel with the video, making it a great option for track-back links.

      After your video is finished playing, give your viewers an action to take.  It's a great way to boost engagement and guide your viewers' next steps.  You can use an image or text URL as a call-to-action link, or enter your own HTML (for creating a form, etc.).

      Wistia Interactive Transcripts are excellent for longer-form content and SEO purposes.  Control the layout of your transcript when you embed it with SuperEmbeds ([more on generating transcripts]({{ '/transcripts' | post_url }})).

repository: jordanmunson/wistia-doc

repo_name: jordanmunson/wistia-doc


text:
# T-NOTE and the Bash-UI-Toolkit

T-NOTE is a pure bash script application. It store all notes as separate text files so you can also use it to note scripts of any kind.

I created the toolkit to make my live easier. And I use it for different scripts. The best way to find out what it do you can run it by it self.

## Installation
The easiest way is to copy both scripts in your ${PATH} direction. Then you can run T-Note with `tn` in your Terminal.
( I did a keyboard shortcut <${TERMINAL} -e tn> )

## How to

Most functions are self explaining. However some functions are not full developed yet. For example the TAG management and the Change Notebook.

- Change Notebook: You can use any folder on your system to be your Notebook. But at this time it not change the default Notebook. If you like to do so you need to change line 10 of the script.
- TAG's are at this time just extensions to the title and made by using _tag_anothertag. And you can search them with Search Title.
Functionality for this is in progress.

Use of bash-ui-toolkit:

You just use instead of <echo "blablabla"><print_c "blablabla"> or <print_r "blabla">.
To draw a line <print_c "-" "-"> you can use any symbol or letter.
Use <print_b "some text ....."> for single line box. <print_bc><print_br>
Multi line box <print_mlb "hi" "this is" "some more text" > <print_mlbc><print_mlbr>
and last <banner "#" "your text"><banner_c><banner_r> The first argument set the symbol.

Thanks for the use and I'm happy to get your feed back at:
https://www.reddit.com/user/ToPow1

repository: Thopow/t-note

repo_name: Thopow/t-note


text:
# Changelog

Items starting with `DEPRECATE` are important deprecation notices.

## 4.0.0 (2018-04-29)

### core

- Remove `-u`, `--url` command line option in favor to -u4 and --url-v4.
+ Refactor some functions to permit units tests

### advanced

- Removed support for 'url' config key in config.conf in favor to 'url_v4'
- Renamed error event type T_ERROR_FILE to T_ERROR_NOIP_FILE
- Renamed error event type T_ERROR_NOIP to T_ERROR_NOIP_URLS
- Renamed error event type T_ERROR_PERMS to T_ERROR_FILE
- Remove default value for digcheck nameserver, it allow to use the default nameserver configured in resolv.conf of the running host

### Deprecation

## 3.0.0 (2018-02-11)

### core

+ Rewrite the command line parser to use the argparse module.
+ Re-indent all the main classes
+ Add IPv6 configuration items (note that IPv6 is not fully enabled for now)

### advanced

+ Remove the project config parser, and move all its code into the loader

### Deprecation

- `DEPRECATE` `-u`, `--url` command line options and 'url' config key in config.conf in favor to -u4 and --url-v4.

## 2.2.0 (2015-09-20)

### core

+ Update logging string with new logging defintion

### advanced

+ Add message in mail extension in case when extension error occur

## 2.1.0 (2015-09-20)

### core

+ Improve logging message for all program

### advanced

+ Move Base class for extension into the init file of extension package
+ Add info_mail parameter into mail extension

## 2.0.1 (2015-05-25)

### advanced

+ Fix duplicate message when UPDATE event

## 2.0.0 (2015-04-25)

### core

+ Add ipcheckadvanced feature

### advanced

+ Add mail sender extension
+ Add command extension
+ Add dig checker extension

## 1.0.0 (2015-04-19)

First release of core python script


text:
# Azure Serverless Computing Cookbook Second Edition Java
## Introduction
When using **Java** with **Azure Functions** we don't have the portal support available with **C#**.  Because of this we will need to do the development in **Visual Studio Code** right from the start.  If you have followed along in the **C#** view presented in the mainline of the book, this will be unfamiliar until Chapter 4.
## Getting Started
### Preparing your development workstation
To follow along with the recipes in this book you will need to setup a development workstation and install the following software:
- JDK (version 8 or above)
- Maven
- NodeJS (required for the package manager - npm)
- Azure Functions Core Tools (npm install -g azure-functions-core-tools)
- Visual Studio Code
- Azure Storage Explorer

You will also need to install the following extensions for Visual Studio Code:
- Java Extension Pack
- Debugger for Java
- C#
- Azure Functions
### Your first project
Once all the above is installed you can start your first Azure Functions as follows:
1. In Visual Studio Code, open the Azure Functions explorer
2. Create a new function by clicking on the **Create functions..** icon
3. Click **Browse..**
4. Create a folder to hold your function project and select it
5. When the initialisation dialog pops up click **Yes**
6. Select **Java** as the language for your function project
7. Enter a **Group ID** for the maven project. I used **com.packtpub**
8. Enter an **Artefact ID** for the maven project.  I used **packtpub-functions**
9. Enter a **Version** for the maven project.  I used **1.0-SNAPSHOT**
10. Enter a **Java Package** for the maven project.  I used **com.packtpub**
11. Enter a **Name** for the function.  Based on the first Recipe in **Chapter 1**, I used **RegisterUser**
12. Select **HttpTrigger**
13. Enter a **Java Package** again.  I used **com.packtpub**
14. Enter a **Function Name**.  I used **Register User**
15. Select the **Anonymous** Authorisation Level
16. Select how you would like to open your project.  I used **Open in current window**
17.  Your function project will now initialise and open in the explorer.  All the required configuration files are automatically created.  In addition to your **RegisterUser.java**, a default called **Function.java** will also have been created; you are free to delete that source file and any test source files related to it.

### Deploying your first project
1. In the Azure Functions explorer in Visual Studio Code, click the "**Deploy to Function App…**" icon (The first time you do this you will need to login to Azure)
2. Select the Azure subscription you wish to deploy to
3. Click "**Create New Function App**" or select an existing Azure Function App (if selecting an existing app, you can ignore the following steps)
4. Enter a globally unique name for your function app
5. Click "**Create new resource group**"
6. Enter a name for your resource group
7. Click "**Create new storage account**"
8. Enter a name for your storage account
9. Select a region to deploy into

### Things to check
If you get a class not found exeception when trying to run your new Azure functions then make sure the "**FUNCTIONS_WORKER_RUNTIME**" setting is set to "**java**"

## So, what now?
At this point you will have a completely configured project folder and have deployed it to a new or existing Azure Function Application.  Key files in that structure are:
- **extensions.csproj** Configuration for installing the NuGet packages needed to support bindings that are not core to Azure Functions
- **host.json** Configuration settings for Azure Functions.  Most settings are configured with Annotations when using Java so we generally leave this unchanged
- **pom.xml** The Maven build and deployment configuration.  We will modify this with dependencies as needed

The Chapter directories you will find here contain Recipe folders which are complete project folders and each recipe builds on the previous one, so the above steps are for your information and to help you if you want to start with a fresh project and build up your own functions independently of the recipes.

gha_language: Java


text:
## Adafruit Crickit micro:bit Robot

This is a resorce folder for a micro:bit robot using the Crickit platform from Adafruit.

Link to the full guide.
https://learn.adafruit.com/microbit-crickit-robot

Support open source hardware and software by buying parts at [adafruit.com](https://www.adafruit.com/).


text:
# Examples

## Built-in validator examples

This library provides only two validators out-of-the-box: `isRequired`, which ensures the field isn't empty, and `mustMatch`, which
ensures the field matches the value of another field (useful for value confirmations, such as email or passwords).

In this example we combine them both so that the `password` field is required, and the `passConfirmation` field is both
required and as well as required to match the password field:

```jsx
<input type="password"
    {...useInput('password', 'isRequired')} />

<input type="password"
    {...useInput('passConfirmation', ['isRequired', mustMatch('password')] )} />
```

## Custom validator examples

The following examples illustrate several ways to use this custom validator:

#### Use this custom validator alone (no array needed)

```jsx
<input type="password" {...useInput('password', mustContainZ)} />
```

#### Use this custom validator together with the built-in isRequired validator

```jsx
// then use it while also providing an option to customize behavior
<input
  type="password"
  {...useInput('password', ['isRequired', mustContainZ])}
/>
```

Note that the order the validators are provided is significant: validators will be executed in the order they were provided. The validation will stop on the first validator to reject the input, and its error message will be returned.

In this case, providing the `isRequired` validator first allows for its error message to be displayed when no value is present, and `mustContainZValidator` validator's error message to be displayed if it is not empty but it doesn't contain the letter z.

#### Custom validator that uses an option

```jsx
// then use it while also providing an option to customize behavior
<input
  type="password"
  {...useInput('password', ['isRequired', { options: { ignoreCase: true } }])}
/>
```

#### Override a validator's error message for a particular input

```jsx
// then use it while also providing an option to customize behavior
<input
  type="password"
  {...useInput('password', [
    'isRequired',
    {
      validator: mustContainZ,
      errorMessage: 'Not valid: please make sure it contains the letter z.'
    }
  ])}
/>
```

## Global validator examples

#### Overriding a global validator's error message

Because overriding the error message is such a common use case, you can take a shortcut to do this and assign the new error message directly to the validator:

```jsx
<input
  type="password"
  {...useInput('password', {
    validator: 'mustContainZ',
    errorMessage: 'Must contain the letter z'
  })}
/>
```

#### Overriding a third-party validator's error message

You can also override the error message of a third party validator. To do that, simply specify which validator you are customizing using the `validator` property:

```jsx
<input
  type="password"
  {...useInput('password', {
    validator: 'isEmail',
    errorMessage: 'Please enter a valid email address'
  })}
/>
```

repository: nosachamos/formalizer

repo_name: nosachamos/formalizer


text:
---
title: "User Feedback: Toasts / Snackbars"
---

Good UX is all about being explicit about what's going on the in app when something updates. So the app should give users feedback in two places:
1. When you try to add a new dog but the form is wrong.
2. When you try to update a dogs rating but the form is wrong.

### 1. Feedback when Adding a New Dog

![show snackbar on error screenshot](https://res.cloudinary.com/ericwindmill/image/upload/c_scale,r_5,w_300/v1521398916/flutter_by_example/Simulator_Screen_Shot_-_iPhone_X_-_2018-03-18_at_11.48.20.png)

Only the `submitPup` function needs to be updated in your `new_dog_form` page.

First, some explanation that I glossed over in an earlier lesson:

In the build method on this page, the RaisedButton in the build method is wrapped in a `Builder`.

A builder creates a new scaffold under the hood. It's a new page, a new buildContext, etc.

This new scaffold is necessary to show Snackbars (aka toasts on the web) because they are an element that is on another page, waiting to be called like any page would be.

The *better* way to do this would be to make a whole new stateless widget that's just a Raised Button that shows a snackbar on pressed.

The point is, the space it takes up is already taken up in your pages Scaffold, so it needs a new one.

Anyways, update your `submitPup` method:

```dart
  void submitPup(context) {
    if (nameController.text.isEmpty) {
      Scaffold.of(context).showSnackBar(                                // update start
            new SnackBar(
              backgroundColor: Colors.redAccent,
              content: new Text('Pups neeed names!'),
            ),
          );                                                            // update end
    } else {
      var newDog = new Dog(nameController.text, locationController.text,
          descriptionController.text);
      Navigator.of(context).pop(newDog);
    }
  }

```

Now, try to submit a dog without a name.

### 2. Dialog Feedback when the Rating Form is wrong

Again, this is as easy as writing one method.

This time, you'll implement a Dialog, which on mobile is just a modal.

Dialogs in Flutter give you access to `actions` so you can do things like ask user questions, get ratings, etc.

We're going to use what's called an `AlertDialog`, which alerts the users of something.

This goes in your `dog_detail_page`.

```dart
  // _DogDetailPageState class

  // Just like a route, this needs to be async, because it can return
  // information when the user interacts
  Future<Null> _ratingErrorDialog() async {
    // showDialog is a built in Flutter method
    return showDialog(
      // needs to know its build context
      context: context,
      child: new AlertDialog(
        title: new Text('Error!'),
        content: new Text("They're good dogs, Brant."),
         // This action uses the Navigator to
         // dismiss the dialog
         // This is where you could return information if you
         // wanted to
        actions: [
          new FlatButton(
            child: new Text('Try Again'),
            onPressed: () => Navigator.of(context).pop(),
          )
        ]
      ),
    );
  }
```

Finally, update your `updateRating` method to handle that error:
```dart
  void updateRating() {                                                 // new
    if (_sliderValue < 10) {                                            // new
      _ratingErrorDialog();                                             // new
    } else {                                                            // new
      setState(() => widget.dog.rating = _sliderValue.toInt());
    }
  }
```

Now, when someone tries to give a dog a low rating, we'll stop them.

After all, they're good dogs.

repository: pearlbea/flutter-by-example-www

repo_name: pearlbea/flutter-by-example-www


text:
# Enterobacter Hormaeche & Edwards, 1960 GENUS

#### Status
ACCEPTED

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

#### Published in
Hormaeche, E. , and Edwards, P. R. "A proposed genus Enterobacter. " Int. Bull. Bacteriol. Nomen. Taxon. (1960) 10:71-74.

#### Original name
null

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# Entity, Heap, Node, State

The Cycle ORM architecture separates entity representation (data carrying object), entity data (node) and current data
changes (state). In the simplest form the entity lifecycle can be describe as following:

<img width="826" alt="Entity, Heap, Node, State" src="https://user-images.githubusercontent.com/773481/144865896-a91e9a99-4863-4263-9fc6-4258231a6822.png">

## Entity

The Entity object is, technically, any object used to carry data (including relation data). By default, Cycle relies on
separate classes for each of the entities, however, it is possible to use `stdClass` or the same class for multiple
entities. This can be achieved by associating the entity with custom mappers and giving them different roles.
Upon `persist` operation, the Mapper object must extract entity values and generate the desired State associated with
entity Node.

Since the extraction and hydration of an entity is controlled solely by its associated Mapper, it is possible to use
custom entity implementations, such as ActiveRecord-like classes, or entities in which data is represented using an
internal array structure.

## Node

A node is an internal object used to represent any entity in the system. The node is only used to carry entity
information such as a current set of relations, entity role and it's persisted data. Each entity always has one Node
object associated with it (however, Node might not exist till the first persist operation).

## State

Node State represents changes generated by mappers and is used to represent the desired state of the data. In addition
to that, State links some of the entity fields to the external contexts (for example FK from the relation). The State
exists only during the transaction lifecycle.

If the transaction succeeds the State data will be merged with parent Node object to sync Heap state with persistent
storage. In case of transaction failure the State will be deleted, keeping the Node in its original (pre-transaction)
form.

## Heap

The Heap is used to store all loaded entity Nodes and their current states (if any). By design, heap operates as a hash
table in which the entity is the key and node is the value.

## Entity manager

An Entity manager is used to generate and run a set of operations required to persist or delete given entities. Though
all of the operations are performed within a single Heap the changes are never written to Node directly and only synced
once the transaction is complete.

## Command

Command is a state-changing event applied to the persistence layer. Commands can depend on values in the state which are
provided by other commands (relations). The transaction sorts commands by their dependencies iteratively, executing
every command which does not have any unsatisfied dependency. Command execution might or might not resolve one of the
multiple dependencies.

repository: cycle/docs

repo_name: cycle/docs


text:
---
layout: post
title: magnum.fe, a micromagnetic finite-element code
---

We present [magnum.fe](http://micromagnetics.org/magnum.fe). A finite element code based on [FEnICS](http://fenicsproject.org).
magnum.fe implements state-of-the art algorithms for the solution of dynamical problems.
Due to the use of the high level finite-element package FEniCS, magnum.fe can be easily extended to your needs.

Finite-element codes are well suited for the simulation of complex three-dimensional structures.
By now magnum.fe is able to solve the Landau-Lifshitz-Gilbert equation with the most important effective field contributions, i.e. exchange field, demagnetization field, external field and uniaxial anisotropy field.
The demagnetization-field problem is either solved by a shell-transformation method or a hybrid FEM/BEM method.
Furthermore magnum.fe solves a spin-diffusion model for the simulation of spin torque effects in both multilayer structures and domain walls.

We are planning a number of extensions and improvements in the near future.
Follow this blog to stay up to date.


text:
---
layout: post
title: Kolo mee @ Yun xiang sarawak kolo mee
categories:
- noodles
- bedok
- kopitiam
- sarawak
image: assets/images/kolo-mee-yun-xiang-closed.jpg
featured: false
hidden: false
rating: 4
author: steve
date: 2019-10-24 18:10 +0800
---
**UPDATE:** It seems the hawker wanted a break and she has ceased cooking for a while.

This particular Saturday started with a leisurely cycle around [Bedok Reservoir](https://en.wikipedia.org/wiki/Bedok_Reservoir) - earnestly attempting to work off the calories from that second bottle of wine decision at dinner the night before. It was to be a day of firsts; my first time to bedok reservoir, my first time to see a bird song competition in action, and my first time having **kolo mee** outside of Sarawak.

![Bird song competition](/assets/images/kolo-mee-yun-xiang-2.jpg "Bird song competition")

I found Yu Xiang's **kolo mee** using google maps, trying to find something to eat for lunch. For the uninitiated, **kolo mee** is a signature of the [Sarawakian food scence](http://www.rojakdaily.com/lifestyle/article/7932/5-best-food-to-try-in-sarawak-and-where-to-find-them). I would describe it as a less saucy version of **wanton mee**, with a noodle that is more wavy and chewy in texture (QQQ?). Whenever I am in Kuching I had at last one bowl of **kolo mee** each day, either kosong (best for breakfast), merah (reddened with the sweet sauce used to marinate char siew) or black sauce.

The combination of both minced pork and char siew is what I love about **kolo mee**, especially when tossed with some vinegar. Sarawak style char siew tends to be sweeter than the Singapore counterpart and this char siew was true to that style. The umami of this dish comes when you toss the noodles in all the pork lard.... I'm drooling as I write this. Yu Xiang's **kolo mee** close to what my memory of what **kolo mee** should be, if not quite reaching the standards I was used to in Kuching (although can food ever taste as good outside of the local setting and experience?). However, I will definitely be coming back here to satisfy my cravings, now I know it exists. I will also have to try their Sarawak laksa, a favourite of [Anthony Bourdain](https://www.thestar.com.my/news/nation/2015/05/29/anthony-bourdain-again-tastes-sarawak-laksa), as every local in Kuching will tell you.

There is a promotion on here too, 50c off both laksa and **kolo mee** (I do not know if this is one of those eternal promotions — think rug shops), so I suggest trying this ASAP. Yun xiang also seem to have their own [website](https://yun-xiang-sarawak-kolo-mee-laksa.business.site), which is cool but my mandarin is not that strong.

![Promotion](/assets/images/kolo-mee-yun-xiang-3.jpg "Promotion")

**Price:** $3.50

**Coffee shop:** Block 418 Coffee shop
**Address:** 418 Bedok North Ave 2
**Hours:** 11:00am - 8:00pm

***

![Yu Xiang](/assets/images/kolo-mee-yun-xiang-4.jpg "Yu Xiang")

<iframe src="https://www.google.com/maps/embed?pb=!1m14!1m8!1m3!1d15954.982823734426!2d103.9300227!3d1.328595!3m2!1i1024!2i768!4f13.1!3m3!1m2!1s0x0%3A0x3c3a1bc2dc00e8d6!2sYun%20Xiang%20Sarawak%20Kolo%20Mee!5e0!3m2!1sen!2ssg!4v1571911777514!5m2!1sen!2ssg" width="600" height="350" frameborder="0" style="border:0;" allowfullscreen=""></iframe>

repository: shawes/ang-moh-in-the-east

repo_name: shawes/ang-moh-in-the-east


text:
## Depth Anal Fisting Tools and Guides

#### How to learn Anal Depth Fisting and When to began Anal Depth Fisting  Training? It is easy, Fistfy learners and courses in a flexible way to  learn new things about Depth fisting. We provide online courses on many  topics and books helping you to learn new skills or develop the existing  ones.

####

**Learn Anal Depth Fisting skills** fast and safely. Of  course, Deep Fisting can be practiced by anyone but in most cases the  fear of pain is the responsible of not allowing you to experience a  fisting session as pleasure. Our new Anal Depth Fisting Guide and New  Anal Depth Fisting courses – will guide you [step by step](https://fistfy.com/course/depth-anal-fisting/) on this journey. [Take a Online course now!](https://fistfy.com/course/depth-anal-fisting/)

## What is Anal Depth Fisting?

Anal Fisting in General is the practice of inserting the fingers, a  hand into the anus for sexual Pleasure. Anal Depth Fisting is typically,  We consider depth fisting anything where you get fingers or hand  through the second ring to Sigmoid colon or deeper. The fister can elbow  deep before reaching into the door of the sigmoid. this part of anal  fisting is also known as Deep Fisting.

 The  information you will find on this research will allow you to improve  your penetration skills and facilitate your anus elasticity. Good  fisting skills help you prevent and lower the risks of future damages to  your anus. And on this [Master class learning](https://fistfy.com/course/depth-anal-fisting/)  these fisting skills will bring your enjoyment to a new level of  pleasure and full satisfaction. Anal Stretching tools and guide – **All Anal Stretching** secrets are shared on this [Master Course](https://fistfy.com/course/depth-anal-fisting/).

### **An unique insider’s view**

We have gathered Material and done a great research from **the best fisting** **porn stars**, **the biggest fisting studios** and **the best coaches in the Fisting world**.  These great Actors and Performers have also revealed and shared their  greatest secrets to us. And now we want to share it all with you.

#### **To whom our Anal Depth Fisting** **Guide is intended to**:

- Aspiring fisters wanting to master their skills and have access to a real pro experience
- Anyone who is interested in Anal Depth Fisting secrets
- For beginners and advanced prospects wanting to punch above their weight
- Advanced seeking extra tricks stream from existing skills
- All who need to update their skills of Anal Depth Fisting
- Anyone aspiring to reach new tips and improve fisting
- Anyone looking to develop their Anal depth Fisting skills

## Now We are going to show You how!

![

#### **Hey, We are Fistfy!** We are determined to better your Fisting skills. **Our only question is, will you be up to it?**

## [MASTER CLASS](https://fistfy.com/course/depth-anal-fisting/)

#### [Anal Depth Fisting Course **$28.90**](https://fistfy.com/course/depth-anal-fisting/)

### Get to know Anal Depth Fisting Secrets

ANAL DEPTH FISTING GUIDE | MASTER CLASS COURSE | KNOWLEDGE | PREPARE | TIPS | GLOSSARY | FAQ

ANAL DEPTH FISTING TOOLS AND GUIDE

## Learn Anal Depth Fisting – Safety first

#### Learn Anal Depth fisting skills fast and safely. Well,  We will tell you now why it is important to know an efficient and safe  method. Go Deep and Deeper Anal Depth Fisting safety first. We have the  most accurate information as you begin this journey.

More enjoyment Anal depth fisting know how, where and how. We also tell you all the guides and secrets **How to open Second Ring** more easily and penetrate rectum into Sigmoid Colon. [And beyond](https://fistfy.com/course/depth-anal-fisting/).

Anal Depth Fisting as any other extreme sexual activity must be done  carefully. Fisting is a very powerful physical experience that should be  practiced with moderation and intelligence. When practicing **Anal Depth Fisting**, you should know what you are doing and know the importance of [safety instructions](https://fistfy.com/course/depth-anal-fisting/).

Anal Depth Fisting Guide – Understanding the gross of Anal Depth  fisting anatomy you should know the following basic depth fisting rules.  Learn about the intestines and how it works. Learn where your intestine  is located in your body and what happens where.

## 5 Reasons Why to Take an Anal Depth Fisting Course now

- You will learn a safe way to enjoy anal depth fisting
- Learn the relaxation skills as well as how to relax the hole
- You will learn skills of how to develop your Anal Depth fisting tricks
- Best positions for Anal Depth Fisting
- how to get it in easily and painlessly

So, **learn All The Anal Depth Fisting Guidelines** and,  familiarize yourself with the Depth Fisting basic rules and  Fist-fucking Techniques you need for a safe and enjoyable fisting  session. Make sure you fully comprehend the Anal Depth Fisting guides  and procedures [before moving to the exercises](https://fistfy.com/course/depth-anal-fisting/).

![Successful anal fisting](https://i0.wp.com/fistfy.com/wp-content/uploads/2020/03/successful-anal-fisting.jpg?fit=1280%2C589&ssl=1)

Anal Depth Fisting play is gaining major acceptance and popularity  in our community and it’s important to have the most accurate  information as you begin this journey. Playing Anal Depth Fisting is  like playing an Extreme Sport with risks or injuries. As always, it is  up to you to determine what is good for your own body, the advantage of  using this information will help to you succeed in your journey.

#### Knowing the Anal Depth Fisting Guides and Secrets has many benefits

- Helps you to develop Anal Depth Fisting Skills in a short period of time
- Will guide you to a safe Anal Depth Fisting Secrets and knowledge
- Prevents from harmful and **dangerous injuries**
- By knowing the anatomy, you know what you’re doing
- Guarantees a more enjoyable Anal Depth Fisting session

Anal Depth Fisting Secrets is safe if you do it careful, properly  done, going slowly, listening to your body. These principals help you  make Anal Depth Fisting session [Safe to practice](https://fistfy.com/course/depth-anal-fisting/).

## About Fistfy online learning

#### Fistfy mission is to teach, to train and to share man to man **Fisting information**. Our Goal is to Make it easy, accessible and useful To everyone. **So, You as well will become A fisting expert**.

## Most Powerful Course For Anal Depth Fisting

#### **We will take a look at these many other important parts of Anal Depth Fisting.**  All the necessary information to Depth Anal Fisting How to Prepare for a Depth Fisting Session 3D Interactive Anatomy of Fisting – 3D animation of Anatomy of Depth Fisting Lots of artwork, graphics, videos. Also included Traveling inside the Colon video How to insert the hand into the Sigmoid Colon. Theoretical summaries and assignments with model solutions to support independent Anal Depth Fisting  Plenty of clear instructions and tips to Anal Depth Fisting.

## [MASTER CLASS](https://fistfy.com/course/depth-anal-fisting/)

#### [Anal Depth Fisting Course **$28.90**](https://fistfy.com/course/depth-anal-fisting/)

### Get to know Anal Depth Fisting Secrets

ANAL DEPTH FISTING GUIDE | MASTER CLASS COURSE | KNOWLEDGE | PREPARE | TIPS | GLOSSARY | FAQ

![Look inside the Colon](https://i1.wp.com/fistfy.com/wp-content/uploads/2020/03/rectum-inside-video-1.jpg?fit=1280%2C720&ssl=1)

Look inside the Colon

## Anal Depth Fisting – Physics and Anatomy

##### The fister can elbow deep before reaching into the door of the  sigmoid. This part of anal fisting is also known as Deep Fisting. When  practicing **Anal Depth Fisting**, you should know what you are doing and know the importance of safety instructions.

**Anal Depth Fisting Guide** – Understanding the gross  of Anal Depth fisting anatomy you should know the following basic depth  fisting rules. Learn about the intestines and how it works. Learn where  your intestine is located in your body and [what happens where](https://fistfy.com/course/depth-anal-fisting/).

#### Anal Depht Fisting Course Includes

Access to Definitely the most efficient Anal Stretching Guide and [Course](https://fistfy.com/course/depth-anal-fisting/) material

- All the necessary information to Depth Anal Fisting
- How to Prepare for a Depth Fisting Session
- 3D Interactive Anatomy of Fisting – 3D animation of Anatomy of Depth Fisting
- Lots of artwork, graphics, videos. Also included Traveling inside the Colon video
- How to insert the hand into the Sigmoid Colon.
- Theoretical summaries and assignments with model solutions to support independent Anal Depth Fisting

Just like all of our courses, **we are always available to answer your queries**,  or to explain our research further, usually within 24 hours; We always  love to help. And, just as all of ours other courses, We are always open  to learn from our students and take suggestions of new topics. It’s a  LIVING course that will be used for life.

### **This is how we are different?**

There is lot a of great videos and information on Anal Depth Anal.  Sure. Pity they never get much further than just a scratch. They have  not studied, researched or tested the information these online services  have shared.

Regarding our information, we are committed to focus on a whole range  of Anal Depth Fisting skills and always dig dipper on the subject. Anal  Depth Fisting skills? Sure, in spades. But we also cover things such as  step-by-step Anal Depth Fisting guides. How to learn the secrets of  Anal Depth Fisting and what to DO with them once you have learned them.  Just as getting fisted right way.

We’ll look in detail at how to do Anal Depth Fisting, Best application guidelines on **how to become a master of Anal Depth Fisting**.  Proudly guide and share tips with others. And We’ll introduce you to  the most powerful Anal Depth Fisting secrets of all time. Completed with  real-life examples. That’s something else you get in ours courses,  real-life examples, experiences to study, so you can see for yourself  how the real fisting looks like and how it feels.

  Good Depth Fisting skills help you prevent and lower the risks of future  damages to your anus or colon. And on these Depth fisting skills will  bring your enjoyment to a new level of pleasure and full satisfaction.  All Anal Fisting secrets will be shared.

Understanding the gross of fisting anatomy you should know the  following basic things. Learn about the intestines and how it works.  Let’s see how your intestine is located in your body and what happens  where.

## Most Powerful Course For Anal Depth Fisting

#### **We will take a look at these many other important parts of Anal Depth Fisting.**  All the necessary information to Depth Anal Fisting How to Prepare for a Depth Fisting Session 3D Interactive Anatomy of Fisting – 3D animation of Anatomy of Depth Fisting Lots of artwork, graphics, videos. Also included Traveling inside the Colon video How to insert the hand into the Sigmoid Colon. Theoretical summaries and assignments with model solutions to support independent Anal Depth Fisting  Plenty of clear instructions and tips to Anal Depth Fisting.

## [MASTER CLASS](https://fistfy.com/course/depth-anal-fisting/)

#### [Anal Depth Fisting Course **$28.90**](https://fistfy.com/course/depth-anal-fisting/)

-  						![manuel](https://i1.wp.com/fistfy.com/wp-content/uploads/2015/11/manuel-1.jpg?fit=100%2C100&ssl=1)
-  						![chris](https://i2.wp.com/fistfy.com/wp-content/uploads/2015/11/chris.jpg?fit=100%2C100&ssl=1)
-  						![dan1987](https://i2.wp.com/fistfy.com/wp-content/uploads/2015/11/dan1987.jpg?fit=100%2C100&ssl=1)
-  						![Ahmed](https://i1.wp.com/fistfy.com/wp-content/uploads/2015/11/Ahmed.jpg?fit=100%2C100&ssl=1)
-  						![Fistee_FF](https://i2.wp.com/fistfy.com/wp-content/uploads/2015/11/Fistee_FF.jpg?fit=100%2C100&ssl=1)
-  						![mikesydney](https://i0.wp.com/fistfy.com/wp-content/uploads/2019/02/mikesydney.jpg?fit=100%2C100&ssl=1)
-  						![ff-37](https://i1.wp.com/fistfy.com/wp-content/uploads/2015/11/ff-37.jpg?fit=100%2C100&ssl=1)

“  Hey everybody! I learned a lot of new things with Fistfy, which I  didn't know about fisting hobby even though I had a few years of  experience. ”

### Manuel

Madrid, Spain

### Get to know Anal Depth Fisting Secrets

ANAL DEPTH FISTING GUIDE | MASTER CLASS COURSE | KNOWLEDGE | PREPARE | TIPS | GLOSSARY | FAQ

ANAL DEPTH FISTING TOOLS AND GUIDE

## Improve your Anal Depth Fisting skills and boost your pleasure

### **An unique insider’s view**

We have gathered Material and done great a research from the best  fisting porn stars, the biggest fisting studios and the best coaches in  the Fisting world. These great Actors and Performers have also revealed  and shared their greatest secrets to us. And now we want to share all of  this Anal Fisting Secrets with you.

### **Who’ll benefit?**

Who will benefit? Well, you. And your fisting partners, of course.  And so will any person responsible for their fisting; who wants to  improve their skills and their fisting prospects. And finally, anyone  who’s taken any of our courses. How to Become a Successful fister and  fistee. This is why our courses will really boost your fisting skills.

And remember, this is a Fistfy course, so you have the guarantee you  get the best fisting knowledge. You’ve nothing to lose, so join us right  now as we can promise You will be enrolling a fascinating journey.

#### **To whom our Anal Depth Fisting** **Guide is intended to**:

- Aspiring fisters wanting to master their skills and have access to a real pro experience
- Anyone who is interested in Anal Depth Fisting secrets
- For beginners and advanced prospects wanting to punch above their weight
- Advanced seeking extra tricks stream from existing skills
- All who need to update their skills of Anal Depth Fisting
- Anyone aspiring to reach new tips and improve fisting
- Anyone looking to develop their Anal depth Fisting skills

#### And  remember, this is a Fistfy course. So, you have the guarantee you get  the best fisting knowledge. You’ve nothing to lose, so join us right now  as we can promise You will be enrolling a fascinating journey.

 You will  learn how to go deep – Anal Depth Fisting. All the necessary information  to Depth Anal Fisting.**

 How  to Prepare for a Depth Fisting Session. What are the best positions to  manage Depth Fisting and How to insert the hand into the Sigmoid Colon.

First, This Fistfy Master Class series course comprises of 31 top quality lectures. **Going Deep – Depth Fisting course** you will have the knowledge on all of **the Anal Depth Fisting**  points and its techniques;  also learn to prepare for a Depth Fisting  Session and your body’s Fisting Anatomy. We explain and illustrate The  FF main tools and how to use them. In addition, you get tips, FF  glossary, And much more fisting knowledge.

#### CERTIFICATION – Anal Depth Fisting Course

After completing the course You will receive a certificate. All of  our course material is available around the clock and to your reach.

#### LEARNING INCLUDES

- Access to No. 1 Gay Depth Fisting Guide
- NEW 3D Interactive Anatomy of Fisting – 3D animation of Anatomy of Depth Fisting
- Course material including proffecional eddited videos, pictures and graphics with 3D animations
- 31 A high-quality Lectures and illustrations study material on Depth Fisting
- Plenty of clear instructions and tips to Depth Fisting and exercises
- Theoretical summaries and assignments with model solutions to support independent FF training
- At the end of the course you can give a feedback on the course and rate it
- You can also send questions directly to the author of the course
- direct access and communication to our desk manager
- After completing the course you will be certified

All of our communications in the web service take place in an private [encrypted](https://en.wikipedia.org/wiki/HTTPS) environment.

 It is  easy.

repository: catwken/hellobook

repo_name: catwken/hellobook


text:
# LINK Token Bridge v0.7

- `./token/LinkTokenChild.sol`: A generalized mintable & burnable child LinkToken contract to be used on child networks.

NOTICE: Current implementation of LinkTokenChild contract requires some additional consideration:

- Supporting more than one gateway (multiple bridges minting the same token) leaves room for accounting issues.
  If we have more than one gateway supported, an additional check needs to exist that limits withdrawals per
  gateway to an amount locked on L1, for the specific gateway. Otherwise one can accidentally "burn" tokens
  by withdrawing more than locked in L1 (tx will fail on L1). When there is a 1:1 relationship between the
  gateway and token, the token itself is an accounting mechanism. For a potential N:1 relationship, a more
  sophisticated type of accounting needs to exist.
- Every bridge is unique in the amount of risk it bears, so tokens bridged by different bridges are not 1:1
  the same token, and shouldn't be forced as such.
- Bridges often require an unique interface to be supported by the child network tokens
  (e.g. `mint` vs. `deposit`, `burn` vs. `withdraw/unwrap`, etc.).
- Bridges often assume that the child contract they are bridging to is the ERC20 token itself, not a gateway
  (intermediate contract) that could help us map from the specific bridge interface to our standard
  LinkTokenChild interface.
- Chainlink often needs to launch on a new network before the native bridge interface is defined.
- To support early (before the bridge is defined) Chainlink network launch, we could make an upgradeable
  LinkTokenChild contract which would enable us to slightly update the contract interface after the bridge
  gets defined, and once online transfer the ownership (bridge gateway role) to the new bridge.

TODO: Potentially create an upgradeable `LinkTokenChild.sol` and limit gateway support to only one (owner)!

- `./token/optimism/`: Documentation and token implementation for the Optimism bridge v2.

repository: forkkit/LinkToken

repo_name: forkkit/LinkToken


text:
# Remark

Allows easy prototyping of new talks using [Remark][remark].

Run:

    python3 -m http.server 8091

Then open: http://localhost:8091/

## Development

Get a new version of Remark:

    curl -L https://remarkjs.com/downloads/remark-latest.min.js > remark-latest.min.js

[remark]: https://github.com/gnab/remark

repository: brandur/sorg

gha_language: Go

repo_name: brandur/sorg


text:
# Kubernetes Workshop
A hands-on Kubernetes workshop for learning purposes.

## Table of Contents

* Introduction
  * What is Kubernetes?
  * Docker and Kubernetes
* Concepts
  *
* Architecture
* Installation and Configuration
  * Docker Desktop
  * Minikube
  * Others
    * kind (Kubernetes in Docker)
    * Minishift
    * MicroK8s
    * K3s
* Cluster Administration
* Networking
  * Default Networking
  * Calico Networking
  * Policies
* Security
* Storage
* Application Development
  * Orchestration/Scheduling
  * Stateful apps
  * Stateless apps
  * Deploying apps
    * Deploy using kubectl
    * Deploy using kubernetes yaml
    * Deploy using compose yaml
  * Secrets and Configuration
  * Healthchecks
* Ingress Routing
* Load Balancing
* Observability
  * Monitoring
  * Logging
* Backup/Restore and Disaster Recovery
* Resources
  * [Kubernetes Playground](https://www.katacoda.com/courses/kubernetes/playground)

repository: rupakg/kubernetes-workshop

repo_name: rupakg/kubernetes-workshop


text:
# BAM

To build: Download repo and open BAM_Solution/BAM_Solution.sln in Visual Studio (2017). Start up project ppmtest to create image similar to:
![gif](https://raw.githubusercontent.com/doreiss/BAM/master/testRender_0_result.gif)

Plans for this project:

Want to create a built-from-ground-up physics engine and raytracer for simple 3D objects to help myself better understand the simulation side of animation pipeline.

So far:
  - Some barebones math classes for vector algebra.
  - Some barebones ray tracing built following tutorial by Philip Shirley (http://in1weekend.blogspot.com/2016/01/ray-tracing-in-one-weekend.html).
  - Started basic physics engine following Millington.
  - Added some very basic interface between physics and graphics.

Next up:
  - Implement triangular mesh scattering so can view more complex objects than spheres.
  - Implement directional and object lights.
  - Implement collision detection and correction.

repository: doreiss/BAM

repo_name: doreiss/BAM


text:
# hour

 * [One Hour Shrimp Paella](../../index/o/one-hour-shrimp-paella-237899.json)
 * [6 Hour Chili](../../index/6/6-hour-chili.json)
 * [8 Hour Smoked Brisket](../../index/8/8-hour-smoked-brisket.json)
 * [6 Hour Tri Tip Marinade Recipe](../../index/6/6-hour-tri-tip-marinade-recipe.json)
 * [24 Hour Ham Casserole](../../index/2/24-hour-ham-casserole.json)
 * [5 Hour Beef Stew](../../index/5/5-hour-beef-stew.json)
 * [Five Hour Stew](../../index/f/five-hour-stew.json)
 * [Half Hour Pudding Cake Montreal Pudd](../../index/h/half-hour-pudding-cake-montreal-pudd.json)
 * [Lamb Stew In An Hour](../../index/l/lamb-stew-in-an-hour.json)
 * [Merritt Family Two Hour Turkey](../../index/m/merritt-family-two-hour-turkey.json)
 * [Miss Bettys 24 Hour Lettuce Salad](../../index/m/miss-bettys-24-hour-lettuce-salad.json)
 * [Ninety Six Hour Cake](../../index/n/ninety-six-hour-cake.json)
 * [Rush Hour Refried Beans](../../index/r/rush-hour-refried-beans.json)
 * [Twenty Four Hour Fruit Salad](../../index/t/twenty-four-hour-fruit-salad.json)
 * [Twenty Four Hour Layered Salad](../../index/t/twenty-four-hour-layered-salad.json)
 * [Twenty Four Hour Salad](../../index/t/twenty-four-hour-salad.json)
 * [One Hour Shrimp Paella 237899](../../index/o/one-hour-shrimp-paella-237899.json)


text:
---
layout: post
title: Eigen-vesting II. Optimize Your Portfolio With Optimization
tags:
- Math
- Finance
- Theory
- Practical
summary: Part Two in a Series on How Math Fits in Modern Portfolio Theory
---

In the last [post](../Eigenvesting-I-Linear-Algebra-Can-Help-You-Choose-Your-Stock-Portfolio), we talked about using eigenportfolios for investing. To continue the series, we are going to present more of Markowitz Portfolio Theory. In particular, we will demonstrate how optimization yields the Minimum Variance Portfolio.

# Minimum Variance Portfolio

We are going to use the notation from the last post. For a universe of $$N$$ stocks, let $$\Sigma$$ be the covariance matrix and $$w$$ the corresponding allocation weight for each stock arranged as a vector. Then, the Minimum Variance Portfolio is the solution to the following problem:
    \begin{equation} \min_{w} w^T \Sigma w \end{equation}
    subject to \begin{equation} w^T \mathbb{1} = 1\end{equation}

where $$\mathbb{1}$$ is a vector of 1's. This problem has the unique solution
\begin{equation}
 w =  \frac{ \Sigma^{-1}\mathbb{1} }{ (\Sigma^{-1}\mathbb{1})^T \mathbb{1}  }.
\end{equation}

This solution depends on the covariance matrix, which is of course estimated from data. Even if we had access to the true covariance matrix, the covariance matrix changes over time. This means that your estimate of the true Minimum Variance Portfolio will change as well, and you will have to alter your investments occasionally with this technique. Occasionally, you should rebalance your portfolio, and at that time you could update the covariance matrix.

## Proof

If you define the function
\begin{equation}
 \mathcal{L}(w,\lambda) := w^T\Sigma w + \lambda (w^T \mathbb{1} - 1),
\end{equation}
then since $$\Sigma$$ is symmetric, the quadratic part is positive definite and a unique minimizer exists and occurs at $$(w,\lambda)$$ such that $$\nabla \mathcal{L}(w,\lambda) = (0,\dots,0)^T.$$ Solving this equation gives two equations that are satisfied: from the $$\lambda$$ component of the gradient we recovery the constraint $$w^T \mathbb{1} = 1$$. From the top $$N$$ components associated with $$w$$, we have the equation (after some algebra)
\begin{equation}
\Sigma w = -\lambda \mathbb{1}.
\end{equation}
If $$\Sigma$$ is invertible, then the unique solution is
\begin{equation}
 w = -\lambda  \Sigma^{-1}\mathbb{1} = \frac{ -\lambda  \Sigma^{-1}\mathbb{1} }{1}.
\end{equation}
By substituting the constraint in for the denominator, we eliminate $$-\lambda$$ to have the solution:
\begin{equation}
 w = \frac{ -\lambda  \Sigma^{-1}\mathbb{1} }{w^T \mathbb{1} } = \frac{ -\lambda  \Sigma^{-1}\mathbb{1} }{ (-\lambda  \Sigma^{-1}\mathbb{1})^T \mathbb{1}  } =  \frac{ \Sigma^{-1}\mathbb{1} }{ (\Sigma^{-1}\mathbb{1})^T \mathbb{1}  }.
\end{equation}

# Example

We're going to use the code from the last post and expand upon it with our new analytical tool. First, we get the data as we did before:

{% highlight python linenos %}
    import pandas as pd
    import datetime as dt
    from pandas.io.data import DataReader

    start, end = dt.datetime(2012, 1, 1), dt.datetime(2013, 12, 31)
    tickers = ['AAPL', 'YHOO','GOOG', 'MSFT','ALTR','WDC','KLAC']
    prices = pd.DataFrame()
    for ticker in tickers:
        prices[ticker] = DataReader(ticker,'yahoo', start, end).loc[:,'Close'] #S&P 500
    returns = prices.pct_change()
    returns = returns.iloc[1:, :] # Remove first row of NA's
    training_period = 30
    in_sample = returns.iloc[:(returns.shape[0]-training_period), :].copy()
    tickers = returns.columns.copy() # Save the tickers
{% endhighlight %}

Now, we're going to calculate the inverse of the covariance matrix using a pseudo-inverse (incase it is ill-conditioned or singular) and then construct the minimum variance strategy weights.

{% highlight python linenos %}
    import numpy as np

    covariance_matrix = in_sample.cov().values
    inv_cov_mat = np.linalg.pinv(covariance_matrix) # Use pseudo-inverse incase matrix is singular / ill-conditioned

    # Construct minimum variance weights
    ones = np.ones(len(inv_cov_mat))
    inv_dot_ones = np.dot(inv_cov_mat, ones)
    min_var_weights = inv_dot_ones/ np.dot( inv_dot_ones , ones)

    min_var_portfolio = pd.DataFrame(data= min_var_weights, columns = ['Investment Weight'], index = tickers)
    min_var_portfolio
{% endhighlight %}

      Investment Weight

      AAPL
      0.133215

      YHOO
      0.196214

      GOOG
      0.260885

      MSFT
      0.261103

      ALTR
      0.023642

      WDC
      0.006199

      KLAC
      0.118743

We will also compare it to the largest eigenvalue's eigenportfolio:

{% highlight python linenos %}
    # Largest eigenvalue eigenportfolio
    D, S = np.linalg.eigh(covariance_matrix)
    eigenportfolio_1 = S[:,-1] / np.sum(S[:,-1]) # Normalize to sum to 1
    eigenportfolio_largest = pd.DataFrame(data= eigenportfolio_1, columns = ['Investment Weight'], index = tickers)

    # Plot
    %matplotlib inline
    import matplotlib.pyplot as plt
    f = plt.figure()
    ax = plt.subplot(121)
    min_var_portfolio.plot(kind='bar', ax=ax, legend=False)
    plt.title("Min Var Portfolio")
    ax = plt.subplot(122)
    eigenportfolio_largest.plot(kind='bar', ax=ax, legend=False)
    plt.title("Max E.V. Eigenportfolio")
    print(min_var_portfolio)
{% endhighlight %}

          Investment Weight
    AAPL           0.133215
    YHOO           0.196214
    GOOG           0.260885
    MSFT           0.261103
    ALTR           0.023642
    WDC            0.006199
    KLAC           0.118743

![png](../images/eigenvesting2/output_5_1.png)

Now let's test the algorithm on returns data and compare it to the eigenprofile related to the largest eigenvalue.

{% highlight python linenos %}
    def get_cumulative_returns_over_time(sample, weights):
        return (((1+sample).cumprod(axis=0))-1).dot(weights)

    in_sample_ind = np.arange(0, (returns.shape[0]-training_period+1))
    out_sample_ind = np.arange((returns.shape[0]-training_period+1), returns.shape[0])

    cumulative_returns = get_cumulative_returns_over_time(returns, min_var_portfolio).values
    cumulative_returns_largest = get_cumulative_returns_over_time(returns, eigenportfolio_largest).values

    f = plt.figure(figsize=(10,4))

    ax = plt.subplot(121)
    ax.plot(cumulative_returns[in_sample_ind], 'black')
    ax.plot(out_sample_ind,cumulative_returns[out_sample_ind], 'r')
    plt.title("Minimum Variance Portfolio")

    ax = plt.subplot(122)
    ax.plot(cumulative_returns_largest[in_sample_ind], 'black')
    ax.plot(out_sample_ind,cumulative_returns_largest[out_sample_ind], 'r')
    plt.title("Eigenportfolio")
{% endhighlight %}

![png](../images/eigenvesting2/output_7_1.png)

The minimum variance portfolio did not beat the eigenportfolio (with the most variance), but it had less variance! Usually, this type of portfolio could be blended with other strategies to try to guarantee some returns in bad times. If we didn't trust our math, we could calculate this variance like so for verification:

{% highlight python linenos %}
    # Variance = w^T Sigma w
    largest_var = np.dot(eigenportfolio_1, np.dot(covariance_matrix, eigenportfolio_1))
    min_var = np.dot(min_var_weights, np.dot(covariance_matrix, min_var_weights))

    print('The eigenportfolio has a variance of %f.\nThe minimum variance portfolio has a variance of %f'
          % (largest_var,min_var))
{% endhighlight %}

    The eigenportfolio has a standard deviation of 0.000139.
    The minimum variance portfolio has a standard deviation of 0.000092

## Additional Modeling Constraints

You can extend this problem by adding more constraints or terms to the function we with to optimize.

### "Efficiency" Portfolios

Let $$\mu$$ be a vector of expected (linear) returns for each stock. Then you can calculate the minimum variance portfolio according to a given return $$\gamma$$ for a period
    \begin{equation} \min_{w} w^T \Sigma w \end{equation}
    subject to \begin{equation} w^T \mathbb{1} = 1\end{equation}
    \begin{equation} w^T \mu = \gamma. \end{equation}
Notice, this approach gives you the minimum variance for a set return over a period... hence, "efficiency". This formulation also has an exact solution that can be solved via Lagrange multipliers.

### No Short Sales

Adding the constraints $$w_i \geq 0$$ for all stocks $$i$$ to any portfolio optimization problem will give us a solution with no short sales. This already would make life much easier for a basic backtesting algorithm, and for the common investor to implement as an investing strategy. However, this problem would typically be solved with a quadratic programming solver (not analytically like we have done thus far).


text:
# react-router-menu

React Router binding for Ant.Design's Menu.

[![npm](https://img.shields.io/npm/dm/react-router-menu.svg)](https://www.npmjs.com/package/react-router-menu)
[![npm](https://img.shields.io/npm/v/react-router-menu.svg)](https://www.npmjs.com/package/react-router-menu)
[![CircleCI](https://circleci.com/gh/djyde/react-router-menu.svg?style=svg)](https://circleci.com/gh/djyde/react-router-menu)
[![react-router](https://img.shields.io/badge/react--router-v3.x-green.svg)](https://github.com/ReactTraining/react-router/blob/v3/)
[![antd](https://img.shields.io/badge/antd-v2.x-yellowgreen.svg)](https://github.com/ant-design/ant-design)

## Install

```bash
$ yarn add react-router-menu
```

## Basic

Live demo: https://djyde.github.io/react-router-menu/

```tsx
import * as React from 'react'
import { render } from 'react-router'
import { createReactRouterMenu } from 'react-router-menu'
import { Router, hashHistory } from 'react-router'

// Declare the routes
const routes = {
  title: 'App',
  path: '/',
  component: App,
  childRoutes: [
    { title: 'Home', path: '/home', component: () => <div>Home</div> },
    { title: 'About', path: '/about', component: () => <div>About</div> },
    {
      title: 'Help', path: 'help', component: ({ children }) => <div>Help: {children}</div> ,childRoutes: [
        { title: 'FAQ', path: '/faq', component: () => <div>FAQ</div> },
        { title: 'Contact', path: '/contact', component: () => <div>Contact</div> }
      ]
    }
  ]
}

// Create a ReactRouterMenu
function App ({ children }) {
  const ReactRouterMenu = createReactRouterMenu(routes)
  return (
    <div>
      <ReactRouterMenu mode='horizontal' />
      <div>
        {children}
      </div>
    </div>
  )
}

// Render the router
render((
  <Router history={hashHistory} routes={routes}>
  </Router>
), mountNode)
```

![](https://ws1.sinaimg.cn/large/006tKfTcgy1fi1zpbetnaj30dk08gt8v.jpg)

### `<ReactRouterMenu />`

This component is same as Ant Design's [<Menu />](https://ant.design/components/menu)

### routes

`routes` that pass to `Router` has the same property as [`PlainRoute`](https://github.com/ReactTraining/react-router/blob/v3/docs/API.md#plainroute), except these listed property:

- **title: string** Title for Menu Item

## Limitation

- Asynchronous `getComponent(s)`, `getChildRoutes`, `getIndexRoute` are not supported yet.

# License

MIT License


text:
Working through the ["Functional Programming in Scala" by Paul Chiusano and Rúnar Bjarnason](https://www.manning.com/books/functional-programming-in-scala)

Code style and names are chosen in a fashion I consider appropriate for an exercise and not necessarily for production use.

Run with `sbt test`

repository: jartur/gnosis

repo_name: jartur/gnosis


text:
Stratio Morphlines
==================

Stratio Morphlines add some useful transformations to the defaults Kite SDK.

Stratio Morphlines consists of several modules:

* Commons
    - Calculator: Make operations between fields and/or static numbers.
    - FieldFilter: Filter fields including or excluding.
    - ReadXml: Read xml from header or body, and apply XPath expression.
    - RelationalFilter: Drop fields if they don't accomplish a relational condition.
    - Rename: Rename a field.
    - TimeFilter: Filter a time field between specified dates.
    - ContainsAnyOf: Command that succeeds if all field values of the given named fields contains any of the given values and fails otherwise. Multiple fields can be named, in which case a logical AND is applied to the results.
* GeoIP:
* NLP:
* WikipediaCleaner:
* CheckpointFilter: Get the last checkpoint value by parametrized handler and filter records by paramentrized field
too. Periodically update checkpoints values.

repository: jcortejoso/flume-ingestion

repo_name: jcortejoso/flume-ingestion


text:
# Yahoo! Earnings Calendar Scraper
Scrapes Yahoo! Finance earnings calendar to get data for a specific date or a date range.
This is worked on top of the original repo here: https://github.com/wenboyu2/yahoo-earnings-calendar
Adapted to work for Python 3.
Added region parameter to allow retrieval of a specific region. Use two digit country code as
the example below.

## Installation
### Pip
```sh
pip install git+https://github.com/fricative/yahoo-earnings-calendar.git
```

## Usage

### Get earnings date information on a specific date or in a date range
```python
import datetime
from yahoo_earnings_calendar import YahooEarningsCalendar
...
date_from = datetime.datetime(2018,10,28,0,0)
date_to = datetime.datetime(2018,11,2,23,59)
yec = YahooEarningsCalendar()
print (yec.earnings_on(date_from, 'JP'))
print (yec.earnings_between(date_from, date_to, 'JP'))
```

#### Data attributes
- companyshortname: Company Name
  - e.g., 20160606
- ticker: Ticker
  - e.g., AAPL
- startdatetime: Event Start Time
  - e.g., 2017-04-23T21:00:00.000-04:00
- startdatetimetype: Event Start Time Type
  - e.g., TAS (Time Not Supplied), AMC (After Market Close	)
- epsestimate: EPS Estimate
- epsactual: Reported EPS
- epssurprisepct: Surprise (%)
- gmtOffsetMilliSeconds: GMT Offset in MS

### Get the next earnings date of a specific symbol
```python
import datetime
from yahoo_earnings_calendar import YahooEarningsCalendar
# Returns the next earnings date of BOX in Unix timestamp
print(yec.get_next_earnings_date('box'))
#<PHONE_NUMBER>
```

repository: fricative/yahoo-earnings-calendar

repo_name: fricative/yahoo-earnings-calendar


text:
# Base 64 Converter

Quick & dirty Windows Forms app written in .NET Core 3.1 to convert a textarea to/from Base64, encode files to Base64, and prettify JSON and XML after it has been decoded.

I wrote this after finding I need to frequently decode JWTs and SAML assertions, and not always trusting browser extensions to do it securely.

This thing is like 3 classes, only one of which isn't auto-gen, and is less than 200 lines of code. You can easily verify that it won't send your sensitive stuff across the web when you use it. But, ya know, MIT License, so don't sue me if it somehow does.

Cheers.


text:
better_delayed_job_web
===============
[![Build Status](https://travis-ci.org/skcript/better_delayed_job_web.svg?branch=master)](https://travis-ci.org/skcript/better_delayed_job_web)

We wanted this for ourselves, so we forked it and made it better. A neat and tidy dashboard for delayed_job, which gives you a overview about the status of the queues.
Tested and works with Rails 3 and above.

Some features:

* Easily view jobs enqueued, working, pending, and failed.
* Queue any single job. or all pending jobs, to run immediately.
* Remove a failed job, or easily remove all failed jobs.
* Watch delayed_job operation with live ajax polling.
* Filter delayed_jobs by queue name

The interface:

![Screen shot](http://i.imgur.com/eji1Z8s.png)

A beautiful Bootstrap based responsive interface.

Quick Start For Rails 3 and 4 Applications
------------------------------------

Add the dependency to your Gemfile

```ruby
gem “better_delayed_job_web"
```

Install it...

```ruby
bundle
```

Add the following route to your application for accessing the interface,
and retrying failed jobs.

```ruby
match "/delayed_job" => BetterDelayedJobWeb, :anchor => false, via: [:get, :post]
```

You probably want to password protect the interface, an easy way is to add something like this your config.ru file

```ruby
if Rails.env.production?
  BetterDelayedJobWeb.use Rack::Auth::Basic do |username, password|
    username == 'username' && password == 'password'
  end
end
```

`better_delayed_job_web` runs as a Sinatra application within the rails application. Visit it at `/delayed_job`.

## Serving static assets

If you mount the app on another route, you may encounter the CSS not working anymore. To work around this you can leverage a special HTTP header. Install it, activate it and configure it -- see below.

### Apache

    XSendFile On
    XSendFilePath /path/to/shared/bundle

[`XSendFilePath`](https://tn123.org/mod_xsendfile/) white-lists a directory from which static files are allowed to be served. This should be at least the path to where delayed_job_web is installed.

Using Rails you'll have to set `config.action_dispatch.x_sendfile_header = "X-Sendfile"`.

### Nginx

Nginx uses an equivalent that's called `X-Accel-Redirect`, further instructions can be found [in their wiki](http://wiki.nginx.org/XSendfile).

Rails' will need to be configured to `config.action_dispatch.x_sendfile_header = "X-Accel-Redirect"`.

### Lighttpd

Lighty is more `X-Sendfile`, like [outlined](http://redmine.lighttpd.net/projects/1/wiki/X-LIGHTTPD-send-file) in their wiki.

Contributing
------------

1. Fork
2. Hack
3. `rake test`
4. Send a pull request

Releasing a new version
-----------------------

1. Update the version in `better_delayed_job_web.gemspec`
2. `git commit better_delayed_job_web.gemspec` with the following message format:

        Version x.x.x

        Changelog:
        * Some new feature
        * Some new bug fix
3. `rake release`

Credits
------
Erick Schmitt - [@ejschmitt][1]
Karthik K - [@imkarthikk][2]

[1]: http://twitter.com/ejschmitt
[2]: http://twitter.com/imkarthikk

repository: pdvend/better-delayed-job-web

extension: markdown

repo_name: pdvend/better-delayed-job-web