text:
# github-stats
example how to get various stats out of github

## What does it do ?
The script queries for all public repositories of given user/project. Next it iterates over each repository and lists number of contributors and repository properties. At the end it writes the data to the csv files. It supports pagination now.

## Prerequisites

We need to generate user oauth token:
https://help.github.com/en/github/authenticating-to-github/creating-a-personal-access-token-for-the-command-line

You don't need to select anything for permissions. Make sure you copy the token since it is displayed only once.

By using oauth toke we increase the query limits on API.

After the token is generated it needs to be added to auth.properties

# Usage

`groovy ghstats.groovy <user/project>`

# Example run

## Command line
```
groovy ghstats.groovy deepres
Querying: http://api.github.com/users/deepres/repos

Repo: 30breaksaver contributors: 1
Repo: 30breaksaver-ng contributors: 1
Repo: dotfiles contributors: 1
Repo: github-stats contributors: 1
Repo: grails-doc contributors: 30
Repo: OffsetDateTime-with-RestTemplate contributors: 1

For deepres 6 repositories queried

Data succesfully exported to:

data/2020-06-05-deepres-repos.csv file
data/2020-06-05-deepres-contributors.csv file

You have 4669 free requests left for next 60 minutes
```

## CSV file contents

### <>-repos.csv

```
cat data/2020-06-05-deepres-repos.csv

date, repo, language, contributors, forks, stars
2020-06-05,30breaksaver,JavaScript,1,0,0
2020-06-05,30breaksaver-ng,JavaScript,1,0,0
2020-06-05,dotfiles,Shell,1,0,0
2020-06-05,github-stats,Groovy,1,0,0
2020-06-05,grails-doc,Groovy,30,0,0
2020-06-05,OffsetDateTime-with-RestTemplate,Java,1,0,0
```

### <>-contributors.csv

```
cat data/2020-06-05-deepres-contributors.csv

login, html-link
deepres,https://github.com/deepres
graemerocher,https://github.com/graemerocher
jeffbrown,https://github.com/jeffbrown
pledbrook,https://github.com/pledbrook
burtbeckwith,https://github.com/burtbeckwith
bobbywarner,https://github.com/bobbywarner
anshbansal,https://github.com/anshbansal
lhotari,https://github.com/lhotari
jameskleeh,https://github.com/jameskleeh
fordguo,https://github.com/fordguo
ldaley,https://github.com/ldaley
rlovtangen,https://github.com/rlovtangen
lucastex,https://github.com/lucastex
jccorp,https://github.com/jccorp
doelleri,https://github.com/doelleri
and-dmitry,https://github.com/and-dmitry
B5A7,https://github.com/B5A7
yamkazu,https://github.com/yamkazu
marcpalmer,https://github.com/marcpalmer
jbwmcarter,https://github.com/jbwmcarter
mjcmatrix,https://github.com/mjcmatrix
micfra,https://github.com/micfra
jmurciego,https://github.com/jmurciego
pap,https://github.com/pap
alexanderzeillinger,https://github.com/alexanderzeillinger
tomaslin,https://github.com/tomaslin
joelwreed,https://github.com/joelwreed
juarezmax,https://github.com/juarezmax
rosenfeld,https://github.com/rosenfeld
kgeis,https://github.com/kgeis
ZacharyKlein,https://github.com/ZacharyKlein
```

repository: piotr-dziubecki/github-stats

repo_name: piotr-dziubecki/github-stats


text:
# CashFlowApp

Income & Expense tracking application

[![Platform](http://img.shields.io/badge/platform-ios-blue.svg?style=flat
)](https://developer.apple.com/iphone/index.action)
[![Language](http://img.shields.io/badge/language-swift-brightgreen.svg?style=flat
)](https://developer.apple.com/swift)
[![License](http://img.shields.io/badge/license-MIT-lightgrey.svg?style=flat
)](http://mit-license.org)

## Requirements
- iOS 8.0+
- Xcode 8.0+
- Swift 3.0+

## Installation

> **Embedded frameworks require a minimum deployment target of iOS 8.**

### CocoaPods

[CocoaPods](http://cocoapods.org) is a dependency manager for Cocoa projects.

CocoaPods 0.36 adds supports for Swift and embedded frameworks. You can install it with the following command:

```bash
$ gem install cocoapods
```

To integrate [Charts](https://github.com/danielgindi/Charts) and [LGButton](https://github.com/loregr/LGButton) libraries into your Xcode project using CocoaPods, specify it in your `Podfile`:

```ruby
# Uncomment the next line to define a global platform for your project
# platform :ios, '9.0'

target 'CashFlowApp' do
  # Comment the next line if you're not using Swift and don't want to use dynamic frameworks
  use_frameworks!
  pod 'Charts'
  pod 'LGButton'

  # Pods for CashFlowApp

end
```

Then, run the following command:

```bash
$ pod install
```

## Author

Harun Özdemir<EMAIL_ADDRESS>

license: MIT

repository: harunozdemir/CashFlowApp

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: harunozdemir/CashFlowApp


text:
todo
=========

todo is a simple to-do command line application written in C++.

Todo entries are currently stored as json files and parsed with [RapidJSON](https://github.com/miloyip/rapidjson).

Features
---------
- Add/remove todo entries containing title and description
- Assign todo entries to categories
- Add labels to todo entries
- Check off todo items that have been completed

Issues
---------
- Command parsing logic is messy/spaghettio
  - Todo list is always read at the beginning of the program regardless of command entered

- Report an issue in Issues if you find something not listed here

Future Additions
---------
- Add due dates to todo items and implement reminder functionality
- Add ability to switch between different sets of todo lists (currently the current todo list filepath has to be set within config)
- See more in the [example todo database file.](todo.jsondb) :)

repository: Coteh/todo

repo_name: Coteh/todo


text:
UITextFieldLimit
================

This sub-class of the UITextField, written in Objective-C (ARC), provides more features to the UITextField in the iOS SDK, like a text length limit. It also shows the number of left characters inside the TextField.
Use it for multiple TextFields, the number of left characters will only show when relevent. The display label includes a shake animation when no characters left.

Features list:
* Multiple textfields supported
* Set the text length limit
* Paste prevention
* Displays a label of left characters inside the textfield, gets hidden when you stop editing.
* DELEGATE methods to know when the user reaches the limit and more.
* Shake animation when no characters left.

Copy the UITextFieldLimit.h and UITextFieldLimit.m files to your xcode project.

This project is under the Apache License 2.0

See https://github.com/JonathanGurebo/UITextFieldLimit/wiki/License


text:
# sBG model of customer retention

A python implementation of the shifted-beta-geometric (sBG) model from Fader and Hardie's ["How to Project Customer
Retention" (2006)](http://www.brucehardie.com/papers/021/sbg_2006-05-30.pdf).

Important note to modelers: amongst other presumptions, see §3 of the paper, sBG is only applicable to discrete,
contractual customer relationships:

<img src="customer_bases.png" alt="Custer Bases Diagram" width=363 height=321>

Figure Source: ["Probability Models for Customer-Base Analysis" (Fader and Hardie 2009)](https://marketing.wharton.upenn.edu/files/?whdmsaction=public:main.file&fileID=341)

## Example

```python
from shifted_beta_geometric import derl, fit, predicted_survival

# measured percentage of cohort that survives over time
example_data = [.869, .743, .653, .593, .551, .517, .491]

# fit our observed data to the sBG model, which returns the parameters alpha and beta
alpha, beta = fit(example_data)

# predict the next 5 time samples:
future = predicted_survival(alpha, beta, len(example_data) + 5)[-5:]

# future = [0.460, 0.436, 0.414, 0.395, 0.378]

# compute the discounted expected residual lifetime (DERL) for the survivors
# of this cohort at point in time t:
discount = 0.10  # rate at which we discount future revenue
                 # to get value in today's terms, e.g. 10%/year
t = len(example_data)
residual_cohort_lifetime = derl(alpha, beta, discount, t)

# residual_cohort_lifetime = 7.530

# if our average revenue per period per customer is a constant v_avg,
# to get the residual customer lifetime value (CLV) of this cohort
# we simply multiply the residual_cohort_lifetime by v_avg:

v_avg = 10
residual_cohort_clv = residual_cohort_lifetime * v_avg

# thus residual_cohort_clv = $75.30 per customer in this cohort
```

## Requirements
sBG requires `numpy` and `scipy` for fitting and the gauss hypergeometric function.


text:
# Detox Bar

###### Run
```
npm instal
DEBUG=loopback:security:* node .

```

## Project Layout
- `common/models` contains the extended user files. `user.js` contains the logic for sending emails and password reset, while `user.json` contains the model definition.
- `server/boot/authentication.js` enables authentication middleware with the `enableAuth()` method. It's this middleware that finds the access token id string (usually from the query string) and appends entire token instance onto the express request object as `req.accessToken`. From there, you can find the user's ID: `req.accessToken.userId` (used in the `routes.js` file, see directly below).
- `server/boot/routes.js` contains all the routing logic. In this example, we have used [Express](http://expressjs.com/) to configure the routing since each LoopBack app is an extended version of an Express app.
- `server/views`contains all the views (or pages) rendered by Express using the [EJS templating framework](http://www.embeddedjs.com/)
- `server/datasources.json` contains the datasource configurations. Here is where we add an email datasource.
- `server/model-config.json` contains the all the model configurations. Here is where we configure the extended user model (lowercase 'u') and the email model. The rest of the models are all built-in LoopBack models.

###### Note
Node (Loopback), AngularJs, Mongo


text:
---
name: Bug report
about: Create a report to help us improve the quality of VTU Discord Bot
title: Explain the bug there.
labels: bug
assignees: TancsicsGergely

---

**Describe the bug**
A clear and concise description of what the bug is.

**To Reproduce:**
Steps to reproduce the behavior:
1. Check if your command is good.
2. If you are sure that the bot is not good, try to explain the problem. (For eg.: **When I type ``!VTU play despacito`` the bot is not playing the music.**)

**Expected behavior:**
A clear and concise description of what you expected to happen.

**Screenshots:**
If applicable, add screenshots to help explain your problem.

**Command (please complete the following information):**
 - Name: [e.g. play]
 - Error [e.g. not playing music, not joining VC]
 - Times the error was spotted [e.g. 3216]

**Personal Devide Problem (please complete the following information):**
 - Device: [e.g. iPhone6]
 - OS: [e.g. iOS8.1]
 - Browser/App [e.g. stock browser, safari, discord]
 - Version [e.g. v15.45]

**Additional context**
Add any other context about the problem here.

repository: TancsicsGergely/VTU-Discord-Bot

gha_language: Python

gha_license_id: MIT

repo_name: TancsicsGergely/VTU-Discord-Bot


text:
# ES7 and Beyond with Docker

Safely learn new JavaScript features with updated Node.js and Babel versions, and zero risk to your existing projects.

## About This Repository

This is the code repository for [the ES7 and Beyond with Docker webinar](https://sub.watchmecode.net/es7-and-beyond), delivered on May 2nd, 2017.

If you're interested in using this code, understand why it is written in this manner, and what each of the parts are, please [Buy A Copy Of The Webinar](https://sub.watchmecode.net/es7-and-beyond).

### Getting Started

How to get started with this repository:

0. Install Docker on your computer ([Docker for Mac](https://docs.docker.com/docker-for-mac/), [Docker for Windows](https://docs.docker.com/docker-for-windows/), or just play Docker on linux)
0. Make sure you have any version of Node.js with npm installed. Doesn't matter which version, you just need "npm run" capability.
0. Clone the above repository to your computer
0. Run `npm run build` in a console window
0. Run `npm run es7` in the same window

At this point you are at the command line of a shell running within the docker container, and there are a few options for what you can do.

### Run Babel.js v7.0-alpha.9

The container in which you are working has an alpha version of the latest Babel.js installed and configured.

To run Babel.js and use TC-39 Working Group features from stage 0 through 4, use `gulp` - which has also been installed and configured.

0. Run "gulp" to start a watch loop that is used to build the output (i.e., transpile the source files into ES6 code that Node.js can run).
0. Touch one of the source files to trigger a build.

From here, you can either exit the watch loop (Ctrl+C) to get back to the command line, from where you are now able to run any of the transpiled files. Or you can open a new shell instance into the same container (see the section on Shell Into The Container, below).

For example, run `node ./app/build/objectSpread-1.js`.

### Run Node.js v7.9

The container in which you are working has Node.js v7.9 installed giving you access to many features of JavaScript that you may wish to learn.

You can use this version of Node.js like any other version of node. Just call `node` to run a REPL environment, or call `node <script.js>` with your script name
to execute an existing file.

For example, run `node ./app/src/asyncFunctions-2.js`.

### Shell Into The Container

It is often useful to open a second terminal window or command shell into the same Docker container. When you have `gulp` running, as shown above, for example.

To do this, open a new terminal window or command prompt and run:

`npm run es7-shell`

This will create a new shell instance inside of the existing container.

You may call `npm run es7-shell` as many times as you wish, for a given container instance. Just be sure the container is running first, by calling `npm run es7` from a previous window.

## Legal Junk

Copyright © 2017 Muted Solutions, LLC. All Rights Reserved.

Code and configuration found in this repository are distributed under [MIT License](https://mutedsolutions.mit-license.org).

The video and other related content are not redistributable. Please [buy a copy of the webinar](https://sub.watchmecode.net/caching-node-modules-in-docker/) for access to those resources.


text:
# Set up MariaDB on Digital Ocean

## Create server

Create a CentOS server available and don't forget to activate Private Network

## Install MariaDB

1. Get the latest MariaDB version by creating a new file
 ```
 vi /etc/yum.repos.d/MariaDB.repo
 ```
 with
 ```
 # MariaDB 10.1 CentOS repository list - created 2016-08-08 04:26 UTC
 # http://downloads.mariadb.org/mariadb/repositories/
 [mariadb]
 name = MariaDB
 baseurl = http://yum.mariadb.org/10.1/centos7-amd64
 gpgkey=https://yum.mariadb.org/RPM-GPG-KEY-MariaDB
 gpgcheck=1
 ```

1. Install mariadb
 ```
 sudo yum update
 sudo yum install mariadb-server mariadb-client
 ```

1. Start MariaDB as a service and allow to start at reboot
 ```
 sudo systemctl start mariadb.service
 sudo systemctl enable mariadb.service
 ```

## Configure MariaDB

1. Secure the database (yes for all)
 ```
 mysql_secure_installation
 ```

1. Backup the original conf file
 ```
 cp /etc/my.cnf /etc/my.bak
 ```

1. Open my.cnf [mysqld]
 ```
 vi /etc/my.cnf
 ```
and add the following line in (this is for a 8GB memory server):
 ```
#
# The MySQL server
#
[mysqld]

# The maximum amount of concurrent sessions the MySQL server will
# allow. One of these connections will be reserved for a user with
# SUPER privileges to allow the administrator to login even if the
# connection limit has been reached.
max_connections = 100

# The maximum size of a query packet the server can handle as well as
# maximum query size server can process (Important when working with
# large BLOBs).  enlarged dynamically, for each connection.
max_allowed_packet = 16M

# *** Slow Queries Specific options ***

# Log slow queries. Slow queries are queries which take more than the
# amount of time defined in "long_query_time" or which do not use
# indexes well, if log_short_format is not enabled. It is normally good idea
# to have this turned on if you frequently add new queries to the
# system.
slow_query_log

# All queries taking more than this amount of time (in seconds) will be
# trated as slow. Do not use "1" as a value here, as this will result in
# even very fast queries being logged from time to time (as MySQL
# currently measures time with second accuracy only).
long_query_time = 2

# *** Cache Specific options ***

# Query cache is used to cache SELECT results and later return them
# without actual executing the same query once again. Having the query
# cache enabled may result in significant speed improvements, if your
# have a lot of identical queries and rarely changing tables. See the
# "Qcache_lowmem_prunes" status variable to check if the current value
# is high enough for your load.
# Note: In case your tables change very often or if your queries are
# textually different every time, the query cache may result in a
# slowdown instead of a performance improvement.
query_cache_size = 64M

# Only cache result sets that are smaller than this limit. This is to
# protect the query cache of a very large result set overwriting all
# other query results.
query_cache_limit = 2M

# Query cache type is used to define the type of cache activated
# 2 means only for cacheable queries that begin with SELECT SQL_CACHE
query_cache_type=2

# *** INNODB Specific options ***

# Table type which is used by default when creating new tables, if not
# specified differently during the CREATE TABLE statement.
default-storage-engine = INNODB

# InnoDB, unlike MyISAM, uses a buffer pool to cache both indexes and
# row data. The bigger you set this the less disk I/O is needed to
# access data in tables. On a dedicated database server you may set this
# parameter up to 80% of the machine physical memory size. Do not set it
# too large, though, because competition of the physical memory may
# cause paging in the operating system.  Note that on 32bit systems you
# might be limited to 2-3.5G of user level memory per process, so do not
# set it too high.
innodb_buffer_pool_size = 6G

# Size of each log file in a log group. You should set the combined size
# of log files to about 25%-100% of your buffer pool size to avoid
# unneeded buffer pool flush activity on log file overwrite. However,
# note that a larger logfile size will increase the time needed for the
# recovery process.
innodb_log_file_size = 512M

 ```

1. Restart MariaDB
 ```
 sudo systemctl restart mariadb.service
 ```

## Create Users and Schema

1. Connect to MySQL
 ```
 mysql -u root -p
 ```
 1. Create database
 ```
 CREATE DATABASE popety;
 ```
1. Create user
 ```
 CREATE USER 'popety'@'%' IDENTIFIED BY 'USER_PASSWORD';
 ```
1. Give the user full privileges for your new database
 ```
 GRANT ALL PRIVILEGES ON popety.* to popety@'%';
 ```

1. Flush the privileges to make the change take effect.
 ```
 FLUSH PRIVILEGES;
 ```

1. Verify that the privileges were set
 ```
 SHOW GRANTS FOR 'popety'@'%';
 ```

## Annex
https://support.rackspace.com/how-to/installing-mysql-server-on-centos/
https://www.percona.com/blog/2014/01/28/10-mysql-performance-tuning-settings-after-installation/
https://downloads.mariadb.org/mariadb/repositories/

repository: Popety/Raneto

repo_name: Popety/Raneto


text:
# Miracle 1.1.0

[Download latest release](https://github.com/MaximDubrovin/miracle/releases)

or install via Bower

```
bower install miracle
```

Miracle plugin gives you control over appearance of elements. Helps you to turn appearance of elements on page load from stuttering chaos to perfect synchronous performance of the symphony.

Basic example

Long read about problem that Miracle targeted to solve: «Elements animation on initial page render: CSS animations and load event to the rescue from messy page render»

Plugin can wait & show element with effect after:
- element's images dependencies loaded
- other element's show effect ended
- other element's images dependencies loaded
- trigger from your code

Declare with ease right in element attributes:
- built-in customizable show effects
- fully customizable show effects
- complex show order between many elements
- spinner before show
- show timeouts
- properties inheritance between miracles

_Plugin needs jQuery 1.10.2 or later. Earlier versions are not tested with Miracle._

__API navigation__
- Built-in effects
  - [data-m-effect](#data-m-effect--built-in-effect-name)
  - [data-m-duration](#data-m-duration--time-in-ms)
  - [data-m-easing](#data-m-easing--any-valid-transition-timing-function-value)
  - [data-m-scale-init](#data-m-scale-init--value-from-0-to-infinity)
  - [data-m-origin](#data-m-origin--any-valid-transform-origin-value)
  - [data-m-translate](#data-m-translate--any-valid-translate-value)
- Custom effects: CSS classes approach
  - [data-m-style-init](#data-m-style-init--classname)
  - [data-m-style-final](#data-m-style-final--classname)
- Custom effects: Inline CSS approach
  - [data-m-style-init](#data-m-style-init--inline-css-declarations)
  - [data-m-style-final](#data-m-style-final--inline-css-declarations)
- [data-m-opaque](#data-m-opaque--true)
- [data-m-timeout](#data-m-timeout--time-in-ms)
- Spinner
  - [data-m-spinner](#data-m-spinner--true)
  - [data-m-spinner-style](#data-m-spinner-style--your-custom-style-name)
- [data-m-id](#data-m-id--name-it-as-you-like)
- Await
  - [data-m-await-load](#data-m-await-load--m-id-or-prev)
  - [data-m-await-show](#data-m-await-show--m-id-or-prev)
  - [data-m-await-trigger](#data-m-await-trigger--true)
- [data-m-inherit](#data-m-inherit--m-id)
- [If one of miracle's image dependencies was not loaded](#if-one-of-miracles-image-dependencies-was-not-loaded)
  - [data-m-error-style](#data-m-error-style--classname)
- [Dynamic elements rendering and Miracle. Manual initialization.](#dynamic-elements-rendering-and-miracle)

## How to use?

[Download latest release](https://github.com/MaximDubrovin/miracle/releases)

or install via [Bower](http://bower.io/)

```
bower install miracle
```

In your ```<html/>``` add this to ```<head/>```:
```html
<head>
...
<script src="js/jquery-1.11.0.min.js"></script>
<script src="js/spin.js"></script> <!-- optional -->
<script src="js/miracle.min.js"></script>
...
<head/>
```

Assign class «miracle» to element:
```html
<div class="miracle">...</div>
```

Miracle initializes as soon as DOM is ready. Plugin parses for miracles (elements with class «miracle») and prepares them for special appearance behaviour. Then plugin waits when all image dependencies of miracle will be loaded then shows miracle with effect.

If you want to initialize Miracle manually for dynamically added elements — see [here](#dynamic-elements-rendering-and-miracle)

Images dependencies:
- ```<img/> ``` elements
- CSS declarations with ```url("...")``` (shorthands & precise variants):
   - ```background``` (& ```background-image```; multiple backgrounds are handled too)
   - ```list-style``` (& ```list-style-image```)
   - ```border-image``` (& ```border-image-source```)

Without image dependencies miracle shows immediately according to declared properties (effect, custom effect, await, show timeout etc.)

You can customize miracle appearance behavior in declarative way right in html using ```data-``` attributes. You say — plugin works.

_Example:_
```html
<div class="miracle" data-m-effect="from-space"
data-m-duration="444" data-m-await-show="prev"
data-m-timeout="111" data-m-spinner="true">...<div>
```

## API

## Plugin defaults

Some miracles that uses __built-in__ show effects initially hidden using ```opacity: 0```. If you declare [custom effect](#custom-effects) then you need to take care about both initial and final states styles yourself.

Miracles have __implicitly declared properties__ that plugin needs to create basic show effect:
- ```data-m-effect="fade-in"```
- ```data-m-duration="500"```
- ```data-m-easing="ease-in-out"```

## Built-in show effects

Choose one that you like. Built-in effects designed to work without any customization but if you want there all what you need —
[Built-in effects settings](#built-in-effects-settings).

#### data-m-effect = «built-in effect name»
Default: «fade-in»

Built-in effects names:
- __fade-in__: Transition from ```opacity: 0``` to ```opacity: 1```.

- __ease-y__: Transition from ```scaleY(0.9)``` to ```scaleY(1)``` gives elegant presentation effect.

- __ease-x__: Transition from ```scaleX(0.9)``` to ```scaleX(1)``` gives elegant presentation effect.

- __from-space__: Miracle lands from outer space like apps icons on iOS. Transition from ```scale(3)```, ```translate(-200px)``` to ```scale(1)``` and original position.

- __from-hell__:
Miracle comings from hell like a devil. Transition from ```scale(0)```, ```translate(-200px)``` to ```scale(1)``` and original position.

- __scale__: Transition from ```scale(0)``` to ```scaleY(1)```.

- __slide__: Miracle comings from another position. Transition from``` translate(0px,-200px)``` to original position. This effect doesn't make sense without setting [data-m-translate](https://github.com/MaximDubrovin/Miracle#data-m-translate--any-valid-translate-value)

_Example:_
```html
<div class="miracle" data-m-effect="from-space">...</div>
```

## Built-in effects settings
_These properties work only with built-in effects._
### Effect duration

How long effect should lasts.

#### data-m-duration = «time in ms»
Default: «500»

_Example_:
```html
<div class="miracle" data-m-effect="ease-y"
data-m-duration="333">...</div>
```

### Effect easing

You can set your own transition easing for built-in effect.

#### data-m-easing = «any valid ```transition-timing-function``` value»
Default: «ease-in-out»

_Example:_
```html
<div class="miracle" data-m-effect="ease-y"
data-m-easing="cubic-bezier(0.1, 0.7, 1.0, 0.1)">...</div>
<div class="miracle" data-m-effect="ease-y"
data-m-easing="linear">...</div>
```

### Initial scale

You can set initial scale of element for built-in effect.

#### data-m-scale-init = «value from 0 to infinity»
Affected effects:
- __ease-y__: Initial ```scaleY()``` value

Default: «0.9»

- __ease-x__: Initial ```scaleX()``` value

Default: «0.9»

- __from-space__: Initial ```scale()``` value

Default: «3»

- __from-hell__: Initial ```scale()``` value

Default: «0»

- __scale__: Initial ```scale()``` value

Default: «0»

_Example:_
```html
<div class="miracle" data-m-effect="scale" data-m-scale-init="0.2">...</div>
```

### Transform origin

You can set the origin for transformations of an element for built-in effect.

#### data-m-origin = «any valid ```transform-origin``` value»
Affected effects:
- __ease-y__: Origin for ```scaleY()``` transformation

Default: «center»

- __ease-x__: Origin for ```scaleX()``` transformation

Default: «center»

- __from-space__: Origin for ```scale()``` transformation

Default: «center»

- __from-hell__: Origin for ```scale()``` transformation

Default: «center»

- __scale__: Origin for ```scale()``` transformation

Default: «center»

_Example:_
```html
<div class="miracle" data-m-effect="scale" data-m-origin="left top">...</div>
```

_Note:_

If «x-offset» presented, but «y-offset» doesn't then «y» mimics «x».

### Translate
You can set the values for initial state's translate transformations of built-in effect. From that position miracle effect will start.

#### data-m-translate = «any valid ```translate()``` value»

Affected effects:
- __from-space__: Values for initial state's ```translate()```.

Default: «-200px, -200px»

- __from-hell__: Values for initial state's ```translate()```.

Default: «-200px, -200px»

- __slide__: Values for initial state's ```translate()```.

Default: «0px, -200px»

_Example:_
```html
<div class="miracle" data-m-effect="slide" data-m-translate="-400px, -400px">...</div>
```

## Custom effects
You can set your own show effect with CSS classes or inline CSS declarations.

### CSS classes approach
You can use CSS classes from your own stylesheets to create custom show effect.

_Note dot before class name._

Declare initial state style of miracle:

#### data-m-style-init = «.className»

_Example:_
```html
<div class="miracle" data-m-style-init=".initialState">...</div>
```

```css
.initialState {

	opacity: 0;
	transform: scale(0) translateX(-200px) translateY(-200px);

}
```

Declare final state style of miracle. How user should see miracle at the end of effect:

#### data-m-style-final = «.className»

_Example:_
```html
<div class="miracle" data-m-style-final=".finalState">...</div>
```

```css
.finalState {

	opacity: 1;
	transform: scale(1) translateX(0) translateY(0);
	transition-property: opacity, transform;
	transition-duration: 600ms;
	transition-timing-function: ease-in-out;

}
```

It's more powerful and convenient then inline CSS approach. Especially if you are using [Autoprefixer](https://github.com/ai/autoprefixer) that automatically adds prefixes to your CSS declarations.

With classes approach it's easy to create elements that responsive to images dependencies loading by deeply modifying element style from your separately defined css classes.

### Inline CSS approach
You can create custom effect right in HTML attributes with inline CSS declarations.

Declare initial style of miracle:

#### data-m-style-init = «inline CSS declarations»

_Example:_
```html
<div class="miracle"
data-m-style-init="opacity: 0; transform: scale(0) translateX(-200px) translateY(-200px);">...</div>
```

Declare final style of miracle. How user should see miracle at the end of effect:

#### data-m-style-final = «inline CSS declarations»

_Example:_
```html
<div class="miracle"
data-m-style-final="opacity: 1;	transform: scale(1) translateX(0) translateY(0); transition-property: opacity, transform;transition-duration: 600ms; transition-timing-function: ease-in-out;">...</div>
```

_Note:_
- take care about vendor prefixes
- if built-in ```data-m-effect``` presented then custom effect will be ignored.

### Make miracle initially opaque

Some miracles that use built-in show effects initially hidden using ```opacity: 0```. But sometimes you may want to rewrite it or rewrite inherited property of miracle.

#### data-m-opaque = "true"

_Example:_
```html
<div class="miracle" data-m-opaque="true">
```

## Show timeout

Before shows himself miracle can wait some time after all other delays.

#### data-m-timeout = «time in ms»

_Example:_
```html
<div class="miracle" data-m-timeout="1000">...</div>
```

## Spinner

#### data-m-spinner = "true"

Plugin can show spinner at the center of miracle position until miracle show effect begins.

_You should add [spin.js](http://fgnass.github.io/spin.js/) plugin (not included in Miracle plugin) in ```<head/>``` before ```miracle.js```_

_Example:_
```html
<head>
<script src="js/jquery-1.11.0.min.js"></script>
<script src="js/spin.js"></script>
<script src="js/miracle.js"></script>
</head>
<body>
<div class="miracle" data-m-spinner="true">
</body>
```

_Note:_
- Miracle should have ```position: relative```, because spinner will be centered inside miracle with ```position: absolute; width: 0px; left: 50%; top: 50%```.
- If there is no ```spin.js``` in HTML — there won't be a spinner.

#### data-m-spinner-style = «your custom style name»

You can set your own spinner style for miracle and apply this style only to selected miracles.

 Under title «Usage» on this page you will see object ```var opts = {...}``` with spinner's style options.

In your ```<html/>``` in ```<head/>``` add ```<script/>``` tag _after_ miracle.js:
```html
<head>
<script src="js/jquery-1.11.0.min.js"></script>
<script src="js/spin.js"></script>
<script src="js/miracle.min.js"></script>
<script>
	M.settings.spinner.style.customSpinnerStyle = {
            lines: 5,
            length: 10,
            width: 2,
						//... etc.
  }
</script>
</head>
```
In this ```<script/>``` tag create ```M.settings.spinner.style.customSpinnerStyle``` object where ```customSpinnerStyle``` is name of your custom spinner style.

Copy your earlier configured spinner options to this object.

Declare ```data-m-spinner-style``` property for miracle with ```customSpinnerStyle``` as value:
```html
<div class="miracle" data-m-spinner="true"
data-m-style="customSpinnerStyle">...</div>
```

Done. Plugin will use your custom spinner style for this miracle.

## Miracle id («m-id»)

It is utility miracle property. It doesn't affect miracle appearance. Properties like «data-m-await-show» or «data-m-inherit» need it.

#### data-m-id = «name it as you like»

_Example:_
```html
<div class="miracle" data-m-id="godzilla">...</div>
<div class="miracle" data-m-await-show="godzilla">...</div>
```

In case above second miracle will await when miracle with m-id «godzilla» will be shown then it shows himself.

_Example:_
```html
<div class="miracle" data-m-id="godzilla"
data-m-effect="from-space" data-m-duration="444"
data-m-spinner="true">...</div>
<div class="miracle" data-m-inherit="godzilla">...</div>
````

In case above second miracle inherits ```data-m-effect```, ```data-m-duration``` and ```data-m-spinner``` properties from miracle with m-id «godzilla».

## Await another miracle or own trigger

Miracle can await when another miracle will be «loaded» or «shown» before start to show himself or own trigger. You can run complex ordered miracles orchestra. Declare and Conquer.

#### data-m-await-load = «m-id» or "prev"

Miracle waits when miracle with specified m-id or just previous miracle will be loaded then shows himself.

_Example:_
```html
<div class="miracle" data-m-id="first">...</div>
<div class="miracle" data-m-await-load="first">...</div>
```

### Mutual ```data-m-await-load```
Two miracles can await each other «loaded» signal and show synchronously.

```html
<div class="miracle" data-m-id="yellow" data-m-await-load="red">...</div>
<div class="miracle" data-m-id="red" data-m-await-load="yellow">...</div>
```

#### data-m-await-show = «m-id» or "prev"

_This could work with custom effects only if you manually declared overall custom effect duration via ```data-m-duration```. With built-in effects ```data-m-await-show``` works fine without this tuning._

Miracle waits when miracle with specified m-id or just previous miracle will be shown then shows himself

_Example:_
```html
<div class="miracle" data-m-id="first">...</div>
<div class="miracle" data-m-await-show="first">...</div>
```

_Note:_

«m-id» of awaited miracle can't be "prev".

#### data-m-await-trigger = "true"

Miracle doesn't start to show himself until your programmatically command to him from your code.

How to command to show miracle whenever you want:

```javascript
$('#some-id').trigger('m-show');
```

_Example:_
```html
<div id="some-id" class="miracle" data-m-await-trigger="true">...</div>
```
```javascript
$('#some-id').trigger('m-show');
```

## Properties inheritance

One miracle can inherit other miracle properties. You don't need to repeat the similar properties between similar miracles. Especially bad case may be when your need to pollute your code with repeating same custom effect.

One miracle which lend properties called «typical», one which borrow properties called «similar».

#### data-m-inherit = «m-id»

_Example:_
```html
<div class="miracle" data-m-id="typical-miracle"
data-m-effect="ease-y" data-m-duration="333"
data-m-spinner="true">
<div class="miracle" data-m-inherit="typical-miracle">
<div class="miracle" data-m-inherit="typical-miracle">
```

Second and third miracles will have the same properties as «typical-miracle»: ```data-m-effect="ease-y" data-m-duration="333" data-m-spinner="true"```

### Rewrite and extend inherited properties

_Example:_
```html
<div class="miracle" data-m-id="typical-miracle"
data-m-effect="ease-y" data-m-duration="333"
data-m-spinner="true">
<div class="miracle" data-m-inherit="typical-miracle"
data-m-duration="111" data-m-await="typical-miracle">
```

Second miracle inherits all «typical-miracle» properties, rewrites ```data-m-duration``` property and extends his properties with ```data-m-await="typical-miracle"```.

## If one of miracle's image dependencies was not loaded
To not interrupt overall miracles effects order on page, Miracle'll simulate load event for this image, continue to await other image dependencies and finally show miracle. So miracle element will be shown but with gap on not loaded image's place and will look according to your design without this image. Also plugin throws error in console to notify about this case.

«Image dependency was not loaded» example

#### data-m-error-style = «.className»

To apply special style for miracle if one of image dependencies failed to load use ```data-m-error-style=".className"```. Where ```.className``` may be any class from your stylesheets. Note dot before class name.

In future there will functionality to choose which types of images dependencies should case error. For example, ```border-image``` may be not so important as ```<img />``` to cause miracle restyling in failed to load case.

##Dynamic elements rendering and Miracle
By default Miracle initializes as soon as DOM is ready. So plugin can't know about all future miracles you'll render dynamically from your code. Especially it is a problem for templates rendering.

To handle dynamically rendered elements you need to initialize Miracle manually as soon as element appended to the page:

```javascript
/* Create  element, turn it to miracle and append element to the page. */
var p = document.createElement("p");
p.className = 'miracle';
document.body.appendChild(p);

/* Initialize Miracle plugin. But firstly check it's avaliability. */
M ? M.init() : {};
```

Imagine you have a [Meteor](https://www.meteor.com/) template with miracles:

```javascript
/* Meteor can say when template elements are rendered.  */
Template.myTemplate.rendered = function ( ) {
	M ? M.init() : {};
}
```

When you trigger Miracle initialization plugin doesn't touch already parsed miracles. It's convenient and efficient.

## Performance
Plugin uses hardware accelerated
CSS declarations that should please you with silky smooth 60fps animations.

## Browser support
Supported: Modern webkit browsers, Firefox, IE 11.

In other browsers page loads as usual, without any special appearance.

## Warning:
- Plugin occupies ```M``` global variable.

repository: MaximDubrovin/miracle

repo_name: MaximDubrovin/miracle


text:
# Cases directory for Ridgepack

This directory is designed for cases that use the core MATLAB utilities
in Ridgepack for specific models and research papers.  This includes functions
specifically designed for interpreting output from the Regional Arctic System Model
(RASM; http://www.oc.nps.edu/NAME/RASM\_PhaseIII.html) and for development
of the CICE Consortium sea ice model (https://github.com/CICE-Consortium).

All MATLAB scripts within case directories use functions within the adjacent
library directory. Those functions are documented separately from the scripts
that use them in this case directory.

## Cases currently available

### JAMES\_2018\_Variational\_Ridging

Scripts used to demonstrate the functionality of the sea ice morphology library described in:

Roberts, A.F., E.C. Hunke, S.M. Kamal, W.H. Lipscomb, C. Horvat, W. Maslowski (2018),
Variational Method for Sea Ice Ridging in Earth System Models, Part I: Theory, *submitted to J. Adv. Model Earth Sy.*.

## Cases to become available in 2018

### RASM\_Sea_Ice_Toolbox

Scripts used to analyse the dynamics and thermodynamics of the coupled RASM sea ice
component.

## Authors
Andrew Roberts, Naval Postgraduate School, April 2018<EMAIL_ADDRESS>
Reviewer for JAMES\_2018\_Variational\_Ridging: Samy Kamal, Naval Postgraduate School, May 2018

## Required software

Designed to be used with MATLAB 2018a or a newer version


text:
Boids
=====

MPHYG001 Research Software Engineering With Python coursework 2

http://development.rc.ucl.ac.uk/training/engineering/

Refactored clone of:
A deliberately bad implementation of [Boids](http://dl.acm.org/citation.cfm?doid=37401.37406)
for use as an exercise on refactoring.

```
usage: boids [-h] [--config CONFIG]

Boid simulator: Simulates birds flying in flocks using the boids model.

optional arguments:
  -h, --help            show this help message and exit
  --config CONFIG, -c CONFIG
                        Boid simulator YAML configuration file. Defaults are
```

Exemplary YAML configuration file:
```
Boids:
  count: 50
  vxlim: [0, 10]
  vylim: [-20, 20]
  xlim: [-450, 50]
  ylim: [300, 600]
Dynamics:
  alert_distance: 100
  fly_to_middle_strength: 0.01
  formation_flying_strength: 0.125
  formation_flying_distance: 10000
Animation:
  frames: 50
  interval: 50
  xlim: [-500, 1500]
  ylim: [-500, 1500]
```


text:
---
layout: post
title: C++17 Variants
published: true
tags: ["variants","C++17","rough"]
---
When I first heard of the concept of variants, I pondered about why It was needed. Most people I knew anyway didn't find it particularly useful. For most of my programming life, I worked in building game engines. There, Speed and effeciency usually trumps "super safe" code. If I could design something that would get a 50% speedup, with a uber low chance of it breaking, and in the instance that it does break we can patch just the instance that we are using, then we would do it.

Before I go over how I use it (which is likely to be wrong), let's introduce variants.

## Unions
To introduce Variants, we first have to re-visit a langugage feature called unions.

{% highlight cpp %}

union my_union
{
  int i,
  char c,
  float f,
  double d
};

int main()
{
    my_union a;
    a.i = 255;
    return a.c;
}

{% endhighlight %}

A union, unlike a struct, only allocates memory for the largest object in the union. At any one point of time, only 1 sub-object within the union should be used.
1 common use case of unions, is for ip addresses.

{% highlight cpp %}

union ipv4_address
{
  unsigned ints address;
  char octets[4];
};

{% endhighlight %}

This way, we can use ipv4 as eitehr the 32 bit string, or the way we commonly use ipv4 addresses : "XXX.YYY.ZZZ.WWW"

Here in lies in problem. with a union, at no point at time during execution of the program, are we able to check to see which type we are currently using at some point in time. If you knew where the address was being initialized, you might know. But if someone were to pass you this union as input data, there would be no possible way
for you to know which one is in use. Maybe you are smart and can find a way to figure out which one is invalid, given that here we have 2 variables. But what if our
union can have 10-20 different items. How would you know what type is being stored?

## Tagged Unions

In early C++, people used to use what they called tagged unions. Basically, it's just a simple way for you keep track of your unions. A possible implementation is something like this,

{% highlight cpp %}
struct my_union
{
  enum
  {
    type_int,
    type_octet
  } tracker;
  union ipv4_address
  {
    unsigned ints address;
    char octets[4];
  };

  void print_address() const
  {
    if(tracker == type_int)
    {
      std::cout << address;
    }
    else if(tracker == type_octet)
    {
      std::cout << static_cast<int>(octets[0])
                << "." << static_cast<int>(octets[1])
                << "." << static_cast<int>(octets[2])
                << "." << static_cast<int>(octets[3]);
    }
  }
}
{% endhighlight %}

Tagged unions seems like a great solution right? Well there is actually a huge problem. Unions were made during the "C" era, and they do not support custom C++ classes that are not trivial classes. Meaning that, with unions, you are not supposed to place elements in it that has constructors and destructors. There are ways to hack it to work, but It definitly is not the right way to do it.

## Variants

At some point, people in the c++ community decided that they should have a c++ type-safe union, so variants were invented.

Variants can be used in a variety of ways.

{% highlight cpp %}
#include <variant>
int main()
{
  std::variant<int,float,double> test;
  test = 6.5;
  if constexpr (std::holds_alternative<double>(test))
  {
    // do something
  }

  test = 1;
  try
  {
    std::get<int>(test);
  } catch(std::bad_variant_access&){}

  test = 1.5f;

  auto* my_result = std::get_if<float>(&test);
  if(my_result)
  {
    // do something with *my_resutt.
  }
}
{% endhighlight %}

Here you can see a couple of ways that we can extract the data from variant. There are more, but I feel that here are the more useful ones.

On top of writing these code manually, variants also provide you write a custom visitor for the variant.

{% highlight cpp %}
#include <variant>
int main() {
  std::variant<int,float,double> test;
  test = 4;
  auto type = std::visit([](auto&& arg) {
      using T = std::decay_t<decltype(arg)>;
      if constexpr (std::is_same_v<T, int>)
          return 0;
      else if constexpr (std::is_same_v<T, float>)
          return 1;
      else if constexpr (std::is_same_v<T, double>)
          return 2;
      else
          static_assert(always_false<T>::value, "non-exhaustive visitor!");
      return -1;
  }, w);
}
{% endhighlight %}

As you can see, we can pass in a lambda function to ```std::visit```, and we can query for the type of the object, and perform some kind of operation for each type.
I found this especially useful in parsing, but I guess, It can get really handy whenever you have an "xor" operation.

For example, in parsing C code, an expression can be a lot of different small expressions, but never more than 1 expression at a time.

```cpp
// I should probabably add some actual examples here at some point.
```

repository: jonnerloller/blog

repo_name: jonnerloller/blog


text:
# Mercado Test App

Mercado Test App, is a app test for a dev application job in mercado libre.

## Installation

Install all dependencies by executing the next command.

```bash
npm install
```
## Technologies
This app is building in Next JS, a framework for React for production it takes all considerations for SSR, SEO, Scability and Performance in account, use react for the creation of Pages and components, also it comes with a API building with Node, Express and for the Data manipulation use Graphql.
## Usage
Commands for the application.
```
npm run dev: Run the project in dev mode.
npm run test: Run the unit test.
npm run coverage: Run the coverage report.
npm run build: Execute the build command necessary for the start.
npm run start: Run the application for production.
```

## License
[MIT](https://choosealicense.com/licenses/mit/)

repository: reinhearth/testing-nextapp

branch_name: refs/heads/main

repo_name: reinhearth/testing-nextapp


text:
# Neural ConvNets in Haskell

[![Build Status](https://travis-ci.org/kevchn/neural-convnets.svg?branch=master)](https://travis-ci.org/kevchn/neural-convnets)
(for Neural ConvNets, fork of Neural)

[![Build Status](https://travis-ci.org/kevchn/simple-neural.svg?branch=master)](https://travis-ci.org/kevchn/simple-neural)
(for linked Simple Neural, independent project)

### Project Description
**Contributors:** Kevin Chen and Suteerth Vishnu of the University of Maryland, College Park.

**Intention:** Demonstrate that Haskell's powerful abstractions allow for the implementation of sophisticated network architectures which would be difficult to do with standard approaches (i.e Tensorflow/Pytorch).

#### Goals
- [x] Improve upon canonical MNIST example for the **neural** library developed by Lars Brünjes, using convolutional neural networks.
- [x] Optimize convnet MNIST example hyperparameters
- [x] Add tests (for simple-neural)
- [x] Add travis (for simple-neural)
- [ ] Add liquid verification

#### Reach Goals (if time permits)
- [ ] Create further examples for other datasets/architectures
- [x] Create own addons (pooling) to increase library functionality
- [x] Create independent neural net project (simple-neural)

#### Notes
- Examples run extremely slowly, takes a long time to figure out hyperparameters
- Complicated architectures are nearly impossible to run for a 2016 MBP

repository: kevinniechen/neural-convnets

repo_name: kevinniechen/neural-convnets


text:
# Titylnik

Flask App that generates documents from templates and html.

## Installation
Download or clone projects [here](https://github.com/curlyhilfiger/titylnik).

For setup use virtual environment

Also on Windows it's requires to install pandoc manually

Check [requirements.txt](https://github.com/curlyhilfiger/titylnik/blob/master/requirements.txt)

```bash
pip install flask #and other
```

Write next commands:

Windows CMD
```bash
set FLASK_APP=run.py
set FLASK_ENV=development
flask run
```
Linux
```bash
$ export FLASK_APP=run.py
$ export FLASK_ENV=development
$ flask run
```

## Usage

You can use it as you want.
I hope this helps you in your studies.

## Contributing
Pull requests are welcome.

## License
[MIT](https://choosealicense.com/licenses/mit/)

repository: curlyhilfiger/titylnik

gha_language: HTML

repo_name: curlyhilfiger/titylnik


text:
# ViewExtractor

Extract SwiftUI views from ViewBuilder content.

## Installation

Follow the instructions at [Adding Package Dependencies to Your App][1] to find out how to install the Swift package. Use the link of this GitHub repo as the URL (`https://github.com/GeorgeElsham/ViewExtractor`).

## Example

Here is an example which creates a `VStack` with `Divider()`s in between.

### View code

```swift
struct DividedVStack: View {
    private let views: [AnyView]

    // For 2 or more views
    init<Views>(@ViewBuilder content: TupleContent<Views>) {
        views = ViewExtractor.getViews(from: content)
    }

    // For 0 or 1 view
    init<Content: View>(@ViewBuilder content: NormalContent<Content>) {
        views = ViewExtractor.getViews(from: content)
    }

    var body: some View {
        VStack(spacing: 0) {
            ForEach(views.indices) { index in
                if index != 0 {
                    Divider()
                }

                views[index]
            }
        }
    }
}
```

### Usage

```swift
DividedVStack {
    Text("View 1")
    Text("View 2")
    Text("View 3")
    Image(systemName: "circle")
}
```

### Result

<img src="https://user-images.githubusercontent.com/40073010/115965850-f43c5d80-a522-11eb-8113-1f73d07fade0.png" width="25%">

  [1]: https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app#3234996


text:
# Lagom 1.6 Migration Guide

This guide explains how to migrate from Lagom 1.5 to Lagom 1.6. If you are upgrading from an earlier version, be sure to review previous migration guides.

Lagom 1.6 updates to the latest major versions of Play (2.8), Akka (2.6) and Akka HTTP (10.1). We have highlighted the changes that are relevant to most Lagom users, but you may need to change code in your services that uses Play APIs directly. You'll also need to update any Play services in your Lagom project repositories to be compatible with Play 2.8. Please refer to the [Play 2.8 migration guide](https://www.playframework.com/documentation/2.8.0-M1/Migration28), [Akka Migration Guide 2.5.x to 2.6.x](https://doc.akka.io/docs/akka/2.6.0-M1/project/migration-guide-2.5.x-2.6.x.html) and the [Akka HTTP 10.1.x release announcements](https://akka.io/blog/news-archive.html) for more details.

For a detailed list of version upgrades of other libraries Lagom builds on such as for Slick, Kafka and others, refer to the [release notes](https://github.com/lagom/lagom/releases).

## Migrating from Lagom 1.5

To migrate from Lagom 1.5 we recommend first migrating to latest version of Lagom 1.5 before upgrading to Lagom 1.6. Refer to the [release notes](https://github.com/lagom/lagom/releases) for details upgrading to latest version of Lagom 1.5.

## Build changes

### Maven

If you're using a `lagom.version` property in the `properties` section of your root `pom.xml`, then simply update that to `1.6.0`. Otherwise, you'll need to go through every place that a Lagom dependency, including plugins, is used, and set the version there.

> **Note:** Lagom 1.6 requires, at least,  Maven `3.6.0`. Please update your environments.

### sbt

The version of Lagom can be updated by editing the `project/plugins.sbt` file, and updating the version of the Lagom sbt plugin. For example:

```scala
addSbtPlugin("com.lightbend.lagom" % "lagom-sbt-plugin" % "1.6.0")
```

We also recommend upgrading to sbt 1.2.8 or later, by updating the `sbt.version` in `project/build.properties`.

### Jackson serialization

Lagom is now using the Jackson serializer from Akka, which is an improved version of the serializer in Lagom 1.5. You can find more information about the Akka Jackson serializer in the [Akka documentation](https://doc.akka.io/docs/akka/2.6/serialization-jackson.html). It is compatible with Lagom 1.5 in both directions.

#### JacksonJsonMigration

If you have used `JacksonJsonMigration` classes they must be changed to extend `akka.serialization.jackson.JacksonMigration` instead. It has the same method signatures as the deprecated `JacksonJsonMigration`.

The configuration in `lagom.serialization.json.migrations` must be moved to `akka.serialization.jackson.migrations`.
It has the same structure.

#### Service API

The default settings for the `ObjectMapper` that is used for JSON serialization in the Service API now uses `ISO-8601` date formats. The default in previous versions of Lagom was to use Jackson private format which can be more time and/or space efficient. The reason for this change is that the ISO format is a better default for interoperability.

If you want your Service API to produce the same output for types like `java.time.Instant`or `java.time.LocalDateTime` adjust the configuration for the `ObjectMapper` in your `application.conf`:

```
akka.serialization.jackson {
  # Configuration of the ObjectMapper for external service api
  jackson-json-serviceapi {
     WRITE_DATES_AS_TIMESTAMPS = on # Serializes dates using Jackson custom formats
  }
}

#### Configuration changes

* `lagom.serialization.json.compress-larger-than` is now configured with `akka.serialization.jackson.jackson-json-gzip.compress-larger-than`
* `lagom.serialization.json.jackson-modules` is now configured in `akka.serialization.jackson.jackson-modules`

#### JSON Compression threshold

When marking a serializable class with `CompressedJsonable` compression will only kick in when the serialized representation goes past a threshold. The default value for `akka.serialization.jackson.jackson-json-gzip.compress-larger-than` is 32 Kilobytes. As mentioned above, this setting was previously configure by `lagom.serialization.json.compress-larger-than` and defaulted to 1024 bytes. (See [#1983](https://github.com/lagom/lagom/pull/1983))

repository: GabryLig/lagom

repo_name: GabryLig/lagom


text:
# Closing Thoughts #

## Applications ##

So, what else can this be used for other than deformers? Think about things like
Maya MPxCommands; GUI widgets (via hooking the ``QEventLoop`` instead of the
``deform``/``compute`` functions), or even scene callbacks! *The possibilities
are endless*...for abuse, that is. While the overhead of constantly checking of
an updated DLL is not significantly performance-draining, repeated checks across
several DLLs could have an effect.

In my opinion, within the context of Maya, it's best to utilize this technique
as a development aid, rather than something you leave enabled in shipping code,
controlled via a simple preprocessor definition or similar mechanism.

## Current Limitations ##

### State transfer ###

Right now, this little demonstration doesn't do anything to save any static
state across reloads of the DLL, nor does it handle adding new business logic
functions and making those hot-loadable as well; you must maintain a defined set
of entry points beforehand. There are several possible solutions to this;
[``cr.h``](https://fungos.github.io/blog/2017/11/20/cr.h-a-simple-c-hot-reload-header-only-library/#the-problem)
handles this quite elegantly, and I might decide to take a similar approach as
well in the future.

### Single-shot functions ###

Certain functions in Maya, such as ``initialize`` and ``creator`` are called
only once when the node is created; as such, if we wanted to do things like add
attributes to a node dynamically, we cannot utilize this existing approach of
keeping the update in the ``deform`` function; we'd need to find a different way
of not just making sure that the DLL is reloaded for that ``initialize``
function, but also to make sure that all nodes in the scene are updated to point
to that new ``initialize`` function as well, along with making any modifications
to memory that might entail. This is not a trivial problem to solve.

### Crash/Error handling ###

Right now, we don't do any sort of crash handling in the DLL at all; this means
that if we accidentally compile code that executes UB, we could end up crashing
Maya very easily. One thing to look into is to possibly catch such crash
signals, and if so, load a previous known good working version of the DLL and
attempt to continue execution. Again, ``cr.h`` has some implementation of this
work as well; I might take a stab at porting it over to a Maya implementation in
the future.

## Conclusion ##

Even with all the downsides and possible crashes, to me, being able to
continuously work on your code and watch it update live 5 out of 10 times is
better than having to unload/reload 10 out of 10 times; I've been utilizing this
approach recently when writing a deformer on my own project, and I'm definitely
far more productive than when I work conventionally, even with all my build
shortcuts and tests.

In summary, I hope you've learned a little more about memory and how it works
over the course of this tutorial, whether or not you choose to implement this
development technique in production! Feel free to contact me or file questions
on the repository page; I know I'm not the greatest when it comes to explaining stuff.


text:
# EZTip

A repository for the front-end architecture and framework of the EZTip payment processing platform

## Getting Started

- Fork and clone the repository to your local machine
- Ensure that the server is running from other _tippr_ organizational repositories
- Open the repository in your IDE of choice, navigate into the `client` directory, and run `yarn start`

## Author

- [Nathan Thomas](https://github.com/nwthomas)

## Acknowledgements

- The entire _tippr_ team of Lambda School students that worked a whole week to turn out a great product

repository: tippr-application/tippr-frontend-nathan

gha_language: JavaScript

repo_name: tippr-application/tippr-frontend-nathan


text:
#### (Some small repo edits still in progress)

# Measuring and predicting variation in the interestingness of physical structures
[Cogsci 2021 paper](https://github.com/cogtoolslab/curiotower_CogSci2021/blob/master/CogSci2021_final_submission.pdf)

## What makes a tower interesting?
What features of a physical scene make it interesting? In this project we explore both open-ended building behavior in kids, as well as adult ratings of pre-built towers. We find that _interestingness_ is a surprisingly reliable measure between subjects, and that physical configurations that violate expectations are considered more interesting.

## Project Overview:
_Where can I find things?_

The repo is divided into three main sections:
1. ``/stimuli/`` where you can find scripts for generating or viewing the stimuli from the two experiments
2. `/experiments/` where you can find code used for running the two web-based rating tasks
3. `/analysis/` where you can find our scripts for analysis and results.

There are also two additional directories: `models` and `utils` which provide auxiliary support.

#### Experiment 1: What towers do children choose to build?

In this experiment we gave 53 children a set of 9 primitve plastic blocks and asked them to construct a "cool tower". We documented the towers and then asked adults to rate the towers on a scale from 1-5 on how interesting they were. Our key finding was that taller towers were considered more interesting.

`stimuli` We gave each of the kids a set of 9 preimitive plastic blocks and instructions to "build a cool tower". [link to all towers](https://github.com/langcog/curiobaby_drop/tree/master/coolTower)

`analysis` The script generating the dataframe consisting of adult ratings of the child-built towers can be found [here](https://github.com/cogtoolslab/curiotower_CogSci2021/blob/master/analysis/evalTower-cooltower.ipynb).
And you can find the script for generating the key figure [here](https://github.com/cogtoolslab/curiotower_CogSci2021/blob/master/analysis/curiotower_figs.R)

#### Experiment 2: What features of a physical scene make it interesting?

In this experiment we procedurally generated towers using the TDW physics environment. We specififcally varied the height (2,4,8 blocks) and the jitter in the x position (low, med, high jitter). We created 72 towers, rendered from two different viewpoints for a total of 144 towers.

`stimuli` In the second experiment, we procedurally generated towers using the [tdw_physics](https://github.com/cogtoolslab/tdw_physics) virtual 3d physics environment

`analysis`
- The script for the [model comparisons](https://github.com/cogtoolslab/curiotower_CogSci2021/blob/master/analysis/curiotower_lme_analysis.R) in the paper
- Generate key [figures](https://github.com/cogtoolslab/curiotower_CogSci2021/blob/master/analysis/curiotower_figs.R)
- We also include aditional supplemental analyses for the [split-halves reliability](https://github.com/cogtoolslab/curiotower_CogSci2021/blob/master/analysis/Split-halves%20analysis.ipynb) and [correlation](https://github.com/cogtoolslab/curiotower_CogSci2021/blob/master/analysis/Stability-Interesting%20Correlation.ipynb) we conducted while exploring the relationship between interestingness and stability


text:
# Starmera quercuum (Phaff & E.P. Knapp) Kurtzman, Robnett & Basehoar-Powers, 2008 SPECIES

#### Status
ACCEPTED

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

#### Published in
FEMS Yeast Res. 8(6): 951 (2008)

#### Original name
Pichia quercibus Phaff & E.P. Knapp

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
---
layout: post
title: "What to pack: A travel checklist"
excerpt: "Every time I leave for a trip, I find myself running in circles wondering what I forgot. To this end, I've been maintaining a travel checklist of items that are musts and figured I'd share what's in my suitcase when I travel."
cover: "suitcases.jpg"
---

Every time I leave for a trip, I find myself running in circles wondering what I forgot. To this end, I've been maintaining a travel checklist of items that are musts and figured I'd share what's in my suitcase when I travel. Let's get started!

# General

These are items that you're probably going to want to bring on every trip, regardless of where you're going.

* T-Shirts
* Socks
* Underwear
* Sleeping undershirts
* Hat
* Meds
  * Any prescription meds you're taking
  * Medicine for upset stomachs, headaches, allergies
* Towel ("Don't forget to bring a towel!" – Towelie)
* Toiletries
  * Toothbrush & toothpaste
  * Shampoo
  * Body wash
  * Loofa
  * Comb
  * Moisturizer
* Umbrella and/or Rain Jacket
* Camera
* Gadgets and chargers

# Situational

Depending on if you're going on a business trip, a vacation, or something else you may need these

* Formal or dressy clothes
  * Collared shirts
  * Dress pants
* Hiking and/or waterproof shoes

# Warm weather 😎

Heading to the beach or out for long summer hikes? You'll probably want

* Sunglasses
* Flip flops and/or Sandals
* Swim suit
* Shorts

# Cold weather ❄

If instead you're heading for some winter adventures you may want

* Warm clothes
  * Scarf
  * Gloves/mittens
  * Wool socks
  * Underlayers

# Out of the country

* Passport
* Physical itinerary (It's great we have devices, but batteries die and screens crack. Better safe than sorry!)

# Nice-to-haves

* Entertainment (a book or a magazine?)
* Power bank for on-the-go charging
* Snacks

I'll be modifying this list every so often and expanding it as I think of more things that I may have missed. Hope that helps!

repository: podrezo/journeyman

repo_name: podrezo/journeyman


text:
# Publishing your first book #

**easybook** is an application that lets you easily publish books in various
electronic formats. Although it was originally designed to publish programming
books, you can use **easyboook** to publish any kind of book, manual or
documentation website.

![easybook workflow diagram](what_is_easybook.png)

**easybook** is currently designed for authors with advanced computer skills
or companies with IT departments or personnel. For that reason, **easybook**
lacks a GUI interface and it can only be used from the command line.

**easybook** is also a free and open-source application published under the
[MIT license][1]. This means that you can do *almost* anything with it. The
only condition is that if you use **easybook** in your applications, you must
always maintain the original `LICENSE.md` file included in the source code of
**easybook**. This file explains the license of the application and its
original author.

## Installing easybook ##

Before installing **easybook**, make sure that you have PHP 5.3.2 or higher
installed on your computer. This is the only technical requisite to install
and use **easybook**. You can check your installed PHP version executing the
following command on the console:

~~~ .cli
$ php -v
~~~

The recommended method to install **easybook** is to use [Composer][2]:

~~~ .cli
$ php composer.phar create-project easybook/easybook <installation-dir>
~~~

Replace the `<installation-dir>` with the path where you want **easybook**
to be installed and you are done. If Composer isn't installed on your computer,
you can install it executing the following command:

~~~ .cli
$ curl -s http://getcomposer.org/installer | php
~~~

Once installed, check that everything is correct by executing the `./book`
script inside the **easybook** installation directory. If you see the list of
available commands, everything went fine:

~~~ .cli
$ cd <easybook-installation-dir>
$ ./book

                     |              |
 ,---.,---.,---.,   .|---.,---.,---.|__/
 |---',---|`---.|   ||   ||   ||   ||  \
 `---'`---^`---'`---|`---'`---'`---'`   `
                `---'

easybook is the easiest and fastest tool to generate
technical documentation, books, manuals and websites.

Available commands:
  benchmark   Benchmarks the performance of book publishing
  customize   Eases the customization of the book design
  help        Displays help for a command
  list        Lists commands
  new         Creates a new empty book
  publish     Publishes an edition of a book
  version     Shows installed easybook version
~~~

N> If the `./book` script doesn't work, try `php book` or check the execution
N> permissions of the `book` script.

The `./book` script is the unique *entry point* for every **easybook**
command. If you need to know for example the installed version, just run the
`version` command through the `book` script:

~~~ .cli
$ ./book version

                    |              |
,---.,---.,---.,   .|---.,---.,---.|__/
|---',---|`---.|   ||   ||   ||   ||  \
`---'`---^`---'`---|`---'`---'`---'`   `
               `---'

easybook installed version: 5.0
~~~

### Alternative installation methods ###

If you just want to test drive **easybook**, download the [easybook.zip][3]
file, uncompress it somewhere and you are done.

If you are an advanced user that want to *hack* or modify **easybook**, clone its repository with Git and install its dependencies with Composer:

~~~ .cli
$ mkdir easybook
$ git clone http://github.com/javiereguiluz/easybook.git easybook

// download vendors and dependencies
$ cd easybook
$ php composer.phar install
~~~

## Publishing the first book ##

Before creating your first book in [the next section](#creating-a-new-book),
let's dig into book publication using the **easybook** documentation as the
sample book. This book is located at the `doc/easybook-doc-en/` directory and
it's a good resource for learning how to create advanced books with
**easybook**.

In order to transform the original Markdown contents of the documentation into
a real book, execute the following command:

~~~ .cli
$ cd <installation-dir>
$ ./book publish easybook-doc-en web
~~~

The first argument of the `publish` command is the name of the directory where
the book contents are stored (`easybook-doc-en`) and the second argument is the
name of the `edition` to be published. After executing this command, you
should see the following output:

~~~ .cli
$ ./book publish easybook-doc-en web

                     |              |
 ,---.,---.,---.,   .|---.,---.,---.|__/
 |---',---|`---.|   ||   ||   ||   ||  \
 `---'`---^`---'`---|`---'`---'`---'`   `
                `---'

 Publishing 'web' edition of 'easybook documentation' book...

 [ OK ]  You can access the book in the following directory:
 <installation-dir>/doc/easybook-doc-en/Output/web

 The publishing process took 0.5 seconds
~~~

The `publish` command always displays the edition (`web`) and the title
(`easybook documentation`) of the book being published. Editions are one of the
most powerful **easybook** features and they are thoroughly explained in
[their own chapter](#editions). For now, consider that a single book can be
published in a lot of different ways and formats, each of one being an
edition.

In case of error, the output of the `publish` command also displays the error
cause and most of the times,how to solve it. If everything went fine, the
`publish` command displays the path of the directory where that book edition
was published (`<installation-dir>/doc/easybook-doc-en/Output/web`) and the
total time elapsed to publish the book (`0.5 seconds`).

Browse to the `<installation-dir>/doc/easybook-doc-en/Output/web` directory and
you'll find an HTML file called `book.html`. If you open it with a browser,
you'll see the full **easybook** documentation published as a single HTML page.

Books published as single HTML pages aren't very useful, so execute now the
following command to publish the book as a website:

~~~ .cli
$ ./book publish easybook-doc-en website
~~~

If you browse to the `<installation-dir>/doc/easybook-doc-en/Output/website`
directory, you'll find a directory called `book/` with a lot of HTML files
inside it. As you can see, just by publishing another edition (`website`
instead of `web`) the same book is published in a totally different way.

Execute once again the `publish` command but using the `ebook` edition:

~~~ .cli
$ ./book publish easybook-doc-en ebook
~~~

As you surely have guessed, the book is now published as a `book.epub` file
inside the `<installation-dir>/doc/easybook-doc-en/Output/ebook` directory. Now
you can copy this `book.epub` file into any `.ePub` compatible reader (iPad
tablets, iPhone phones, most Android tablets and phones and every e-book
reader except Amazon Kindle) and start reading the **easybook** documentation
as an e-book.

Similarly, you can publish your book as `MOBI` (the format for Kindle-
compatible e-books) and `PDF` files. However, these formats require the
installation of two libraries and they will be explained in the next chapters:

~~~ .cli
// publishes the book as a PDF file
$ ./book publish easybook-doc-en print

// publishes the book as a Kindle-compatible MOBI e-book
$ ./book publish easybook-doc-en kindle
~~~

N> For those impatient readers that cannot wait to try the `MOBI` and `PDF`
N> publication, these are the third-party libraries needed to generate those
N> formats:
N>
N>   * For `MOBI` books: [KindleGen](http://amzn.to/kindlegen)
N>   * For `PDF` books: [PrinceXML](http://www.princexml.com/)

## Creating a new book ## {#creating-a-new-book}

In this section you will create and publish your own book. **easybook**
requires that your books follow a certain structure of files and directories.
To avoid creating this structure by hand, books are bootstrapped with the `new`
command:

~~~ .cli
$ ./book new "My First Book"
~~~

The only argument required by the `new` command is the title of the book
enclosed with quotes. After executing the previous command, **easybook** will
create a new directory called `my-first-book` inside the **easybook** `doc/`
directory, and with the following file and directory structure:

~~~
<easybook>/
    doc/
        my-first-book/
            config.yml
            Contents/
                chapter1.md
                chapter2.md
                images/
            Output/
~~~

These are the files and directories created by **easybook**:

  * `config.yml`, this file contains all the book configuration options.
    We'll cover all of them in the next chapters, but meanwhile you can change
    the `author` option to set your name as the book author's name.
  * `Contents/`, this directory stores all the book contents (both text and
    images). **easybook** creates two sample chapters (`chapter1.md` and
    `chapter2.md`) and an empty `images/` directory.
  * `Output/`, initially this directory is empty, but eventually it will
    contain the published book.

### Writing the book ###

Book contents are written using regular text files with the Markdown syntax.
This format has become the *de facto* standard for writing documentation for
Internet. If you are not familiar with the Markdown syntax, read the
[Markdown reference](#markdown-reference) appendix.

N> Markdown is the only format currently supported by **easybook**. In the
N> future, more formats will be supported, such as reStructuredText and
N> Textile.

Therefore, forget **easybook** for a while and write the contents of your
book in Markdown syntax using your favorite text editor (`vi`, *Notepad*,
*TextMate*, *SublimeText*, etc.)

The `config.yml` file lists all the book items, such as the chapters and
appendices. The sample book created with the `new` command only includes two
chapters. Therefore, whenever you add a new chapter to the book, don't forget
to add it to the `config.yml` file too:

~~~ .yaml
book:
    # ...
    contents:
        - { element: cover }
        - { element: toc   }
        - { element: chapter, number: 1, content: chapter1.md }
        - { element: chapter, number: 2, content: chapter2.md }
        - { element: chapter, number: 3, content: chapter3.md }
        - { element: chapter, number: 4, content: chapter4.md }
        - { element: chapter, number: 5, content: chapter5.md }
        - ...
~~~

The next chapter explains in detail all the configuration options of this file,
and the 21 different [content types](#content-types) that **easybook** books
can include.

As the book publication process is extremely fast (less than 2 seconds for a
400-page book on an average computer), you can publish every edition of the
book periodically to check your progress:

~~~ .cli
$ ./book publish my-first-book web
$ ./book publish my-first-book website
$ ./book publish my-first-book ebook
$ ./book publish my-first-book kindle
$ ./book publish my-first-book print
~~~

[1]: http://opensource.org/licenses/MIT
[2]: http://getcomposer.org/
[3]: https://github.com/javiereguiluz/easybook-package/blob/master/easybook.zip?raw=true

repository: plasmasolutions/easybook

repo_name: plasmasolutions/easybook


text:
[![Build status](https://ci.appveyor.com/api/projects/status/kvde5325bat7e8bu/branch/master?svg=true)](https://ci.appveyor.com/project/NPadrutt/moneyfox/branch/master)

## Money Fox
A way to make budgeting easy. A basic idea for the community, made even better by the community.

### Talk with us
We have a slack team to make communication a bit easier. Write me a mail to<EMAIL_ADDRESS>to get your invitation.

### Try it

There are two versions in the stores available for all devices with Windows 10 or Android:

First there is a stable version who get regular udpates as soon as they are fully tested:

[Windows](https://www.microsoft.com/store/apps/9nblggh6ck9d)

[Android](https://play.google.com/store/apps/details?id=com.applysolutions.moneyfox)

Second there is a beta for all these guys who want get their hands on all the new features who are currently in development. We try to keep this as stable as possible. But nonethless expect some bugs (please report! =) ):

Windows (please send me your Microsoft Account that I can give you access to the beta flights)

[Android](https://play.google.com/apps/testing/com.applysolutions.moneyfox)
(You can also opt-in for the beta in the play store)

### Contribution

Head over [here](https://github.com/Apply-Solutions/MoneyManager/blob/master/CONTRIBUTE.md)

### Translations

Help us translate the money fox to as many languages as possible. Head over [here](https://crowdin.com/project/money-fox) and get involved!

### Code of conduct
We act under the (Contributor Covenant)[http://contributor-covenant.org/version/1/4/)

### Tools
We use Visual Studio 2017 (inkl. xamarin). If you use resharper please ensure you align the formatting to this solution.

Also, please install the SQLite Extension for Visual Studio.

### Contact
Feel free to contact me. Just write me a mail or even better join our slack channel.

### Sponsoring
The development of this app is supported by [Apply Solutions](http://www.apply-solutions.ch/).

license: MS-PL


text:
---
layout: default
---

## Creative Coding

### Touch Designer

* _[Touch Designer](https://derivative.ca/)_: a node based visual programming language for real time interactive multimedia content
* _[Processing](https://processing.org/)_: a flexible software sketchbook and a language for learning how to code within the context of the visual arts
* _[Cinder](https://libcinder.org/)_: a free and open source library for professional-quality creative coding in C++

[back](../)

repository: marcosecchi/resources

repo_name: marcosecchi/resources


text:
# Park
A Python implementation of Spark's Python API, but working on a single machine.

## Motivation
Programming directly on Spark is a hard task:

* The behavior of Spark is hard to understand;
* The error message is hard to decipher;
* There is few debugging tools;
* The test is time consuming.

With this package, you can get rid of all these problems.
Use this package to prototype or experiment on a single machine.
* Your code runs fast.
* The error message is stardard Python error message, and thus easy to understand.
* You have automatically all debugging tools, which you are used to using.
* Any further doubt? Just peek into this package's source code. There are no "magic" inside.

As soon as your program runs correctly, use Spark to deploy it on a cluster.
Your code needs no or little modification.

## Usage
```python
import park as sc
sc.parallelize()
```

## Note
If you ever use the `mapPartitions()` function, you will need to do a mild modification when you pass to Spark.
For every function which you pass to Spark's `mapPartitions()` function, you should add a `[]` around the returned value(s).

repository: WenjieZ/Park

repo_name: WenjieZ/Park


text:
---
layout: page
title: About
id: main
comments: true
---

Supposed to be for productive procrastination, by a graduate student, so as to get into a habit of writing regularly. But it is not. Though I try. If you wish to give me a shout out and know how to get in touch with me, do get in touch with me, with thoughts, suggestions and what not. If you don't know how to get in touch with me, and have made up your mind that you must get in touch with me, you can try contacting me through [G+](https://plus.google.com/100909387498133159339/) or drop a note on the [tweety](https://twitter.com/mehtadushy).

The site is based on [Jekyll](http://jekyllrb.com) and [Hyde](http://mdo.github.io/hyde) and hosted at GitHub. Go check them out if you wish to acquire a similar setup for yourself.


text:
# Build Instructions

In the majority of cases, most Visallo components can be built by simply opening a terminal to the component root directory and running `mvn package`. The two most common components that are a little less straight-forward are the web application and yarn ingest components. Additional instructions for both can be found below.

## Root Module Installation

You'll need to install the Visallo `root` Maven module after you've cloned the [source code](source-code.md) and any time you pull the latest Visallo source code.

        mvn install -f root/pom.xml

## Smoke Test

You should make sure everything compiles and tests pass before going any further. Otherwise, it's hard to reason about what might be wrong when things later fail.

Compile all modules, building the web app resources for development (which is faster):

    mvn compile -Dgrunt.target=development

Run all unit tests, continuing on failures and without failing the build:

    mvn test -fn -Dgrunt.target=development

It is a known issue that some unit tests fail on Windows. The following are expected to fail:
* `org.visallo.core.formula.FormulaEvaluatorTest`
* `org.visallo.tesseract.TesseractGraphPropertyWorkerTest`
* `org.visallo.opencvObjectDetector.OpenCVUtilsTest`
* `org.visallo.opencvObjectDetector.OpenCVObjectDetectorPropertyWorkerTest`

## Web Application

Building the Visallo web application is very similar to running it, as described in the [Running section of the development Docker container](dev-docker-image.md#running) instructions.

From the root directory of the Visallo project, run

        mvn package -pl web/war -am -DskipTests -Dsource.skip=true

The previous command will create a WAR file in the `web/war/target` directory.

## Web Application Plugins

The Visallo web application can be extended with dynamically loaded plugins. You can find some example plugins in `web/plugins`.

To build a web plugin, run:

        mvn package -pl ./web/plugins/<plugin-name>/ -am -DskipTests

Once the plugin JAR file is created, copy it to the `/visallo/lib` directory in HDFS:

        hadoop fs -put <path_to_plugin_jar> /visallo/lib

Or, copy it to the web server's lib directory `/opt/visallo/lib` or for docker `docker/visallo-dev-persistent/opt/visallo/lib`.

This is the easiest way to expose the plugin to all web servers. The Visallo web application will automatically add the JAR file to the classpath.

To learn more about extending Visallo with plugins, please [read this](../extension-points/index.md).

## Graph Property Workers

Each graph property worker can be built independently using the following Maven command:

        mvn package -pl <path_to_plugin_dir> -am

Once the plugin JAR file is created, copy it to the `/visallo/lib` directory in HDFS.

        hadoop fs -put <path_to_plugin_jar> /visallo/lib

As an example, to build and deploy the `tika-mime-type-plugin` one would run the following commands from the root of
the Visallo project:

        mvn package -pl graph-property-worker/plugins/tika-mime-type -am
        hadoop fs -put graph-property-worker/plugins/tika-mime-type/target/visallo-tika-mime-*-jar-with-dependencies.jar /visallo/lib

Visallo's graph property worker YARN application  will automatically detect the plugin in the classpath.

repository: StuartPaton/visallo

repo_name: StuartPaton/visallo


text:
rails-jquery-dateinput
======================

Replaces date selects, created by the rails date form helper, with a [[jQuery tools dateinput](http://flowplayer.org/tools/dateinput/index.html "jQuery tools dateinput")]

Based on [[https://gist.github.com/706187](https://gist.github.com/706187)]

Usage
-----

Require the javascript in `app/assets/javascripts/applications.js`

    //= require rails-jquery-dateinput

this will also load version 1.2.6 of jQuery tools dateinput. If you would like to use another version, load the javascript like this

    //= require rails-jquery-dateinput/without-jquery-tools

don't forget to load your version before.

For the standard CSS require in `app/assets/stylesheets/application.css`

    *= require jquery-tools-1.2.6/index

repository: finchi/rails-jquery-dateinput

repo_name: finchi/rails-jquery-dateinput


text:
---
author: "Margherita Buizza Avanzini"
author_url: ""
date: "2013-03-21 14:00:00 +0000 UTC"
location: "Amphi PASCAL"
title: "Studying the solar core in underground laboratories : Borexino and solar neutrinos"
author_filiation: "Laboratoire APC Paris"
author_filiation_url: ""
type: "spécialisé"
author2: ""
author_url2: ""
author_filiation2: ""
author_filiation_url2: ""
title2: ""
category: "seminar"
layout: "seminar"
---
Solar neutrinos have represented a stimulating research field since more than 40 years. The study of their flux mixes the fundamental Particle Physics, through the phenomenon of neutrino oscillations, with Astrophysics, through the role of neutrinos in the solar models. Borexino is presently the only detector allowing to measure in real time solar neutrinos emitted by three different solar reactions (7Be, 8B and pep) with the lowest energy threshold ever reached. Thanks to the Borexino measurements, our understanding of neutrino oscillations in the solar sector has been extremely improved. I will show how this "magic work" (J. Bachall, arXiv:hep-ex/0106086v1) has been accurately and patiently driven to the success.

repository: aphecetche/gatsby-subatest

repo_name: aphecetche/gatsby-subatest


text:
ASP.NET Core Command Line Tools
===============================

The .NET Core CLI includes some commands that are specific to ASP.NET Core projects.

 - dotnet dev-certs
 - dotnet user-secrets
 - dotnet user-jwts
 - dotnet sql-cache

For more information on these tools, see <https://github.com/aspnet/DotNetTools>.

repository: dotnet/sdk

gha_language: C#

repo_name: dotnet/sdk


text:
---
title: "Kubeflow pipeline"
date: 2019-08-27T00:00:00-08:00
weight: 80
draft: false
---

### Kubeflow Pipelines

Kubeflow Pipeline is one the core components of the toolkit and gets deployed automatically when you install Kubeflow. Kubeflow Pipelines consists of:

* A user interface (UI) for managing and tracking experiments, jobs, and runs.
* An engine for scheduling multi-step ML workflows.
* An SDK for defining and manipulating pipelines and components.
* Notebooks for interacting with the system using the SDK.

[Amazon Sagemaker](https://aws.amazon.com/sagemaker/) is a managed service that enables data scientists and developers to quickly and easily build, train, and deploy machine learning models.

For this exercise, we will build Mnist classification pipeline using Amazon Sagemaker.

#### Assign IAM permissions

In order to run this exercise, we need three levels of IAM permissions. 1) create Kubernetes secrets **aws-secret** with Sagemaker policies. We'll use this during pipeline execution to make calls to AWS API's. 2) create an IAM execution role for Sagemaker so that the job can assume this role in order to perform Sagemaker actions. Typically in a production environment, you would assign fine-grained permissions depending on the nature of actions you take and leverage tools like [IAM Role for Service Account](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) for securing access to AWS resources but for simplicity we will assign AmazonSageMakerFullAccess IAM policy to both. You can read more about granular policies [here](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html). 3) Assign sagemaker:InvokeEndpoint permission to Worker node IAM role so that we can use this to make predictions once Sagemaker creates the endpoint

Run this command from your Cloud9 to create these IAM permissions
```
aws iam create-user --user-name sagemakeruser
aws iam attach-user-policy --user-name sagemakeruser --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
aws iam create-access-key --user-name sagemakeruser > /tmp/create_output.json
```

Next, record the new user's credentials into environment variables:

```
export AWS_ACCESS_KEY_ID_VALUE=$(jq -j .AccessKey.AccessKeyId /tmp/create_output.json | base64)
export AWS_SECRET_ACCESS_KEY_VALUE=$(jq -j .AccessKey.SecretAccessKey /tmp/create_output.json | base64)
```

Apply to EKS cluster:

```
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Secret
metadata:
  name: aws-secret
  namespace: kubeflow
type: Opaque
data:
  AWS_ACCESS_KEY_ID: $AWS_ACCESS_KEY_ID_VALUE
  AWS_SECRET_ACCESS_KEY: $AWS_SECRET_ACCESS_KEY_VALUE
EOF
```

Run this command to create **Sagemaker execution role**
```
TRUST="{ \"Version\": \"2012-10-17\", \"Statement\": [ { \"Effect\": \"Allow\", \"Principal\": { \"Service\": \"sagemaker.amazonaws.com\" }, \"Action\": \"sts:AssumeRole\" } ] }"
aws iam create-role --role-name eksworkshop-sagemaker-kfp-role --assume-role-policy-document "$TRUST"
aws iam attach-role-policy --role-name eksworkshop-sagemaker-kfp-role --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
aws iam attach-role-policy --role-name eksworkshop-sagemaker-kfp-role --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess
aws iam get-role --role-name eksworkshop-sagemaker-kfp-role --output text --query 'Role.Arn'
```

At the end of the script, you will get the arn of IAM role generated. Make a note of this role as you will need it during pipeline creation step

Here is an example of the output
```
TeamRole:~/environment $ aws iam get-role --role-name eksworkshop-sagemaker-kfp-role --output text --query 'Role.Arn'
arn:aws:iam::371348455981:role/eksworkshop-sagemaker-kfp-role
```
Lastly, let's assign sagemaker:InvokeEndpoint permission to Worker node IAM role

```
cat <<EoF > ~/environment/sagemaker-invoke.json
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "sagemaker:InvokeEndpoint"
            ],
            "Resource": "*"
        }
    ]
}
EoF
aws iam put-role-policy --role-name $ROLE_NAME --policy-name sagemaker-invoke-for-worker --policy-document file://~/environment/sagemaker-invoke.json
```

#### Run Sagemaker pipeline notebook

Go to your **eks-kubeflow-workshop** notebook server and browse for Sagemaker pipeline notebook (eks-workshop-notebook/notebooks/05_Kubeflow_Pipeline/05_04_Pipeline_SageMaker.ipynb). If you haven't installed notebook server, review [fairing chapter](/advanced/420_kubeflow/fairing/#create-jupyter-notebook-server) and finish the [clone the repo](/advanced/420_kubeflow/fairing/#clone-the-repo) instructions.

Open Sagemaker pipeline notebook
![dashboard](/images/kubeflow/pipelines-view-sagemaker-notebook.png)

{{% notice info %}}
Starting from here, its important to read notebook instructions carefully. The info provided in the workshop is lightweight and you can use it to ensure desired result. You can complete the exercise by staying in the notebook
{{% /notice %}}

Review the introduction and go through the prerequisites for 1) creating an S3 bucket and 2) copying the pipeline data. You can skip step 3 because you have already created Kubernetes secrets and Sagemaker execution role earlier. Continue with step 4 by installing Kubeflow pipeline SDK

Once all the prerequisites steps are completed, let's go through building our pipeline.

Run step 1 to load Kubeflow pipeline SDK. Once that is complete, run step 2 to load sagemaker components

Before you run step 3 - create pipeline, replace the value of SAGEMAKER_ROLE_ARN with Sagemaker execution role that we created during [Assign IAM permissions](/advanced/420_kubeflow/pipelines/#assign-iam-permissions)
![dashboard](/images/kubeflow/pipelines-sagemaker-execution-role.png)

After this, go and run next two steps to compile and deploy your pipelines

You will receive 2 links, one is for experiments and other is pipeline run.
![dashboard](/images/kubeflow/pipelines-deploy.png)

Click on **here** next to **Experiment link**.
![dashboard](/images/kubeflow/pipelines-sagemaker-experiment.png)

You can click on **View pipeline** to view details of the pipeline
![dashboard](/images/kubeflow/pipelines-sagemaker-overview.png)

You can click on pipeline run to examine each steps in the pipeline. Click on sagemaker training job and then click logs tab to see details
![dashboard](/images/kubeflow/pipelines-run-logs.png)

After few minutes you'll see the training job completes and then creates a model. After this step, batch transformation runs and then finally model is deployed using Sagemaker inference. Make a note of Sagemaker endpoint so that we can run prediction to validate our model
![dashboard](/images/kubeflow/pipelines-sagemaker-endpoint.png)

Now, let's run prediction against this endpoint. You can safely ignore the permissions note because we have already taken care of this earlier. Install boto3 and then change the endpoint name to the name you received in previous step
![dashboard](/images/kubeflow/pipelines-sagemaker-predictions.png)

You'll receive predictions as depicted above

repository: zengelan/eks-workshop

gha_language: CSS

gha_license_id: NOASSERTION

repo_name: zengelan/eks-workshop


text:
# Securing an OpenShift Container Image CI/CD Pipeline with Anchore

The files in this project are related to my writeup on integrating the Anchore container image scanning solution into an OpenShift/Jenkins CI/CD pipeline. I talked about setting up the OpenShift/Jenkins pipeline in this post:

https://blog.osninja.io/building-a-container-image-cicd-pipeline/

I'm following up on that post with this one:

https://blog.osninja.io/p/2c6a2686-a668-434b-8c8c-d45db94c2e48/

# Contents

This repo has three folders:

* **openshift** - this folder has the YAML defintions for the resources I create for the project in OpenShift. Mostly it is the default **NodeJS + MongoDB Persistent** template project, but these YAML files were the result of my configuration
* **jenkins** - this folder has the Jenkinsfile that represents the pipeline that I build
* **anchore** - this folder has the config.yaml and the docker-compose.yaml for the Anchore engine that I ran.


text:
# gke-terraform-recipes
A curated list of Google Kubernetes Engine Terraform Recipes

## Requirements
- [terraform `^0.12.0`](https://www.terraform.io/)

## OAuth scopes used for all node pools
https://developers.google.com/identity/protocols/googlescopes
```
oauth_scopes = [
  "compute-rw",
  "storage-ro",
  "logging-write",
  "monitoring",
  "https://www.googleapis.com/auth/service.management"
]
```

repository: sthlmio/gke-terraform-recipes

repo_name: sthlmio/gke-terraform-recipes


text:
### Capturing calls to `MKDirections` methods

Each of the methods below have spy method equivalents that capture the calls to the method and any parameters, if available.  The properties listed below the method names list the new properties of `MKDirections` that you can use to validate method calls.

`calculateDirectionsWithCompletionHandler:`
- `var calculateDirectionsCalled: Bool`
- `var calculateDirectionsCompletionHandler: MKDirectionsHandler?`

`calculateETAWithCompletionHandler:`
- `var calculateETACalled: Bool`
- `var calculateETACompletionHandler: MKETAHandler?`

`cancel`
- `var cancelCalled: Bool`

> After capturing the call to the method, these spies DO NOT forward the call to the superclass (real) implementation.  If you would like for any of these spies to forward the method call to the superclass implementation, simply insert the following call at the beginning of your test with an appropriate selector:
>
> `directions.setShouldForwardMethodCallWithSelector("calculateDirectionsWithCompletionHandler:", true)`
>
> This can be reversed in your test at any time by another call to the same method with the value `false`.

repository: samodom/TestableMapKit

repo_name: samodom/TestableMapKit


text:
Aeries Mobile
=============

A mobile client for FJUHSD's Aeries gradebook browser interface.

## Table of Contents

* [Project Info] (#project-info)
* [Installation] (#installation)
* [Screenshots] (#screenshots)
* [Team Members](#team-members)
* [Tech Stuff] (#tech-stuff)
* [License] (#license)

## Project Info
Aeries Mobile provides a more mobile-appropriate UI for the Aeries Gradebook site for FJUHSD. Simply use your regular Aeries credentials to log in. We've added several upgrades on top of the regular Aeries functions, inclduing assignments grouped by type and individual assignment grades.

## Team Members
* [Shivam Thapar](http://www.shivamthapar.com)
* [Andy Yu](https://github.com/AndyYu)

## Installation
> **NOTE: As of December 2013, Aeries has changed its UI. We are working on updating the app to work with the new changes. Until then, the app is unfortunately not going to work. We are sorry for the inconvenience.**

Aeries Mobile is a mobile site, so it can be accessed by any web browser on any phone. Simply point your browser to [http://aeries.shivamthapar.com](http://aeries.shivamthapar.com). It can even be used on your computer!

We've also made an Android wrapper app for the site, which can be found [here] (https://github.com/shivamthapar/ABI-Gradebook-Android). Follow the instructions on that page to download the app on your Android phone.

## Screenshots

For full-sized screenshots, click [here](https://github.com/shivamthapar/aeries-mobile/tree/master/screenshots/galaxy%20nexus/skinned).

![Home Screen](http://s13.postimg.org/4t219glbr/framed_home_Copy.png "Home Screen")
![Gradebook Screen](http://s13.postimg.org/q1fpqvzsn/framed_gradebook_Copy.png "Gradebook")
![Class Screen](http://s13.postimg.org/6v2inpjav/framed_class_Copy.png "Class")
![Total Class Grades Screen](http://s13.postimg.org/ooy0p02d3/framed_totalgrades_Copy.png "Total Grades")

## Tech Stuff
Thank you to the following projects for making our development much easier and enjoyable! :)

* [Flask](http://flask.pocoo.org/), our favorite Python Microframework.
* [Beautiful Soup](http://www.crummy.com/software/BeautifulSoup/) for parsing the Aeries website
* [Requests](http://docs.python-requests.org/en/latest/) module to handle form data.
* [Heroku](https://www.heroku.com/), for painlessly hosting our project.

Please look at the Requirements.txt file for other dependencies.

## License
MIT

repository: shivamthapar/aeries-mobile

repo_name: shivamthapar/aeries-mobile