text:
---
id: 3967
title: A blessing of dimensionality often observed in high-dimensional data sets
date: 2015-04-09T15:19:13+00:00
author: Jeff Leek
pe_theme_meta:
  - 'O:8:"stdClass":2:{s:7:"gallery";O:8:"stdClass":3:{s:2:"id";s:2:"-1";s:5:"width";s:0:"";s:6:"height";s:0:"";}s:5:"video";O:8:"stdClass":1:{s:2:"id";s:2:"-1";}}'
al2fb_facebook_link_id:
  -<PHONE_NUMBER>05421_792919457430579
al2fb_facebook_link_time:
  - 2015-04-09T19:19:20+00:00
al2fb_facebook_link_picture:
  - post=http://simplystatistics.org/?al2fb_image=1
dsq_thread_id:
  -<PHONE_NUMBER>
categories:
  - Uncategorized
slug: "a-blessing-of-dimensionality-often-observed-in-high-dimensional-data-sets"
---
[](http://www.jstatsoft.org/v59/i10/paper) have one observation per row and one variable per column.  Using this definition, big data sets can be either:

  1. **Wide** - a wide data set has a large number of measurements per observation, but fewer observations. This type of data set is typical in neuroimaging, genomics, and other biomedical applications.
  2. **Tall** - a tall data set has a large number of observations, but fewer measurements. This is the typical setting in a large clinical trial or in a basic social network analysis.

The [curse of dimensionality](http://en.wikipedia.org/wiki/Curse_of_dimensionality) tells us that estimating some quantities gets harder as the number of dimensions of a data set increases - as the data gets taller or wider. An example of this was [nicely illustrated](http://simplystatistics.org/2014/10/24/an-interactive-visualization-to-teach-about-the-curse-of-dimensionality/) by my student Prasad (although it looks like his quota may be up on Rstudio).

For wide data sets there is also a blessing of dimensionality. The basic reason for the blessing of dimensionality is that:

> No matter how many new measurements you take on a small set of observations, the number of observations and all of their characteristics are fixed.

As an example, suppose that we make measurements on 10 people. We start out by making one measurement (blood pressure), then another (height), then another (hair color) and we keep going and going until we have one million measurements on those same 10 people. The blessing occurs because the measurements on those 10 people will all be related to each other. If 5 of the people are women and 5 or men, then any measurement that has a relationship with sex will be highly correlated with any other measurement that has a relationship with sex. So by knowing one small bit of information, you can learn a lot about many of the different measurements.

This blessing of dimensionality is the key idea behind many of the statistical approaches to wide data sets whether it is stated explicitly or not. I thought I'd make a very short list of some of these ideas:

**1. Idea: **[De-convolving mixed observations from high-dimensional data. ](http://www.ncbi.nlm.nih.gov/pmc/articles/PMC3841439/)

**How the blessing plays a role: **The measurements for each observation are assumed to be a mixture of values measured from different observation types. The proportion of each observation type is assumed to be fixed across measurements, so you can take advantage of the multiple measurements to estimate the mixing percentage and perform the deconvolution. ([Wenyi Wang](http://odin.mdacc.tmc.edu/~wwang7/) came and gave an excellent seminar on this idea at JHU a couple of days ago, which inspired this post).

**2. Idea:** [The two groups model for false discovery rates](http://biostatistics.oxfordjournals.org/content/5/2/155.short).

**How the blessing plays a role: ** The models assume that a hypothesis test is performed for each observation and that the probability any observation is drawn from the null, the null distribution, and the alternative distributions are common across observations. If the null is assumed known, then it is possible to use the known null distribution to estimate the common probability that an observation is drawn from the null.

**3. Idea: **[Empirical Bayes variance shrinkage for linear models](http://www.degruyter.com/view/j/sagmb.2004.3.issue-1/sagmb.2<IP_ADDRESS>7/sagmb.2<IP_ADDRESS>7.xml)

**How the blessing plays a role: ** A linear model is fit for each observation and the means and variances of the log ratios calculated from the model are assumed to follow a common distribution across observations. The method estimates the hyper-parameters of these common distributions and uses them to adjust any individual measurement's estimates.

**4. Idea: **[Surrogate variable analysis](http://journals.plos.org/plosgenetics/article?id=10.1371/journal.pgen.0030161)

**How the blessing plays a role: ** Each observation is assumed to be influenced by a single variable of interest (a primary variable) and multiple unmeasured confounders. Since the observations are fixed, the values of the unmeasured confounders are the same for each measurement and a supervised PCA can be used to estimate surrogates for the confounders. ([see my JHU job talk for more on the blessing](http://www.slideshare.net/jtleek/jhu-feb2009))

The blessing of dimensionality I'm describing here is related to the idea that [Andrew Gelman refers to in this 2004 post.](http://andrewgelman.com/2004/10/27/the_blessing_of/)  Basically, since increasingly large number of measurements are made on the same observations there is an inherent structure to those observations. If you take advantage of that structure, then as the dimensionality of your problem increases you actually get **better estimates** of the structure in your high-dimensional data - a nice blessing!

repository: rbind/simplystats

repo_name: rbind/simplystats


text:
# Consensus

Crypto.com Chain prototype uses Tendermint Core as its consensus algorithm. It utilizes the ABCI interface. The details of this interface can be found on: https://tendermint.com/docs/spec/abci/abci.html#overview

To query a blockchain or submit a transaction, one can use the Tendermint RPC for that. The details of the RPC mechanism can be found on: https://tendermint.com/rpc/#introduction

repository: tomtau/chain-docs

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: tomtau/chain-docs


text:
# Keras.NET

Keras.NET is a high-level neural networks API, written in C# with Python Binding and capable of running on top of TensorFlow, CNTK, or Theano. It was developed with a focus on enabling fast experimentation. Being able to go from idea to result with the least possible delay is key to doing good research.

Use Keras if you need a deep learning library that:

Allows for easy and fast prototyping (through user friendliness, modularity, and extensibility).
Supports both convolutional networks and recurrent networks, as well as combinations of the two.
Runs seamlessly on CPU and GPU.

## Keras.NET is using:

* [Numpy.NET](https://github.com/SciSharp/Numpy.NET)
* [Python.Included](https://github.com/henon/Python.Included)

license: MIT


text:
## tags-item
An Oracle APEX plugin for a tags item, based on jQuery plugin [itemTags.js](http://betaweb.github.io/inputTags-jQuery-plugin/).
The main difference is that a tag is not editable, but a tag can optionally have a link to another page.

### Preview

![Preview](https://github.com/Inolau/tags-item/blob/main/tagsitem.gif)

### Demo

[TagsItem demo](https://apex.oracle.com/pls/apex/ino/r/share/products)

### Custom Attributes

**Maximum number of tags** Maximum number of tags you can enter in a tag item.\
**Tag link** Optional link to another page when clicking on a tag. Use !TAG! to pass the value of tag.\
**Tags LOV query** Optionally, a one column query that retuns a list of tags to choose from.\
**Allow other values** In case of a Tags LOV query, can you enter a value that is not in the LOV?

### Versions

The plugin was built in APEX 20.2, but the code can be used in lower versions to create a plugin for older APEX applications.

### Installation

Download item_type_plugin_com_ilaurensse_tagsitem.sql from the sourrce directoy.

Import this plugin into your APEX applications.

repository: Inolau/tags-item

branch_name: refs/heads/main

repo_name: Inolau/tags-item


text:
---
layout: default
title: DEC Command Reference
---

# DEC

Decrement by one the given key.

* * *

#### Syntax

        DEC <key>

#### Arguments

* **key** ( string ) The key to decrement.

#### Example

       SET 0 foo 10 // foo encoding is GB_ENC_PLAIN now

       DEC foo // Now foo is 9 encoded as GB_ENC_NUMBER

#### Notes

* DEC will change internal value encoding from GB_ENC_PLAIN to GB_ENC_NUMBER
* Return the new decremented value in case of success, otherwise an error.
* If the value is not a parsable number, REPL_ERR_NAN will be returned.

extension: markdown


text:
# _Bodoh Lah!_ Trivia Game App #

## Overview
The _Bodoh Lah!_ Trivia Game App will allow players to answer Trivia questions, earn points and save their high scores.

There are different difficulty levels to the game - Easy, Medium, Hard and Random - and players can choose which level they would like to play the game.

This Trivia Game App utilizes the Open Trivia DB API to obtain Trivia Questions.

## Technologies
* HTML5
* CSS
* JavaScript
* JQuery

## APIs Used
The [Open Trivia DB API](https://opentdb.com/) was used for this app.

## Project Demo
_Bodoh Lah!_ Trivia Game App is available to try via this link: http://ryanjho.github.io/trivia-app/

## User Stories and Wireframes
### 1. Home Page ###
As a player, I want to access the Home Page and start playing the game.
![Bodoh Lah Home Page](./img/Bodoh-Lah-Home-Page.jpg "Bodoh Lah! Home Page")

### 2. Choose Difficulty Level ###
As a player, I want to choose the difficulty level of the game before starting.
![Bodoh Lah! Difficulty Levels](./img/Bodoh-Lah-Difficulty-Levels.jpg "Bodoh Lah! Difficulty Levels")

### 3. Play Game ###
As a player, I want to start playing the game and click to select my answer to the question.
![Bodoh Lah! Game Page](./img/Bodoh-Lah-Game-Page.jpg "Bodoh Lah! Game Page")

### 4. Highlight Correct Answer If Wrong Answer Selected ###
As a player, I would like to know the correct answer to the question if I have selected the wrong answer.
![Bodoh Lah! Wrong Answer](./img/Bodoh-Lah-Wrong-Answer.jpg "Bodoh Lah! Wrong Answer")

### 5. Result Page ##
As a player, I would like to check out my final score after the game is played. I would also like to save my score with my username.
![Bodoh Lah! Result Page](./img/Bodoh-Lah-Result-Page.jpg "Bodoh Lah! Result Page")

## Additional Features To Add With More Time ##
* Sign in Feature
* Countdown Timer
* Pop-up GIPHY for every wrong answer selected
* Additional CSS Styling

gha_language: HTML

gha_license_id: MIT


text:
Back is the new Front
=====================

The crazy mechanical mentor got really obsessed with the idea that "every side is the front of a swerve drive" and got the freshmen
to build a second identical front on the back of the robot so we only need to do at most a 90 degree turn.

To aid her slightly ridiculous plan, we've been tasked with changing the Field Oriented Pointing code to rotate the robot the minimum amount
required to make one of the two fronts of the robot point in the required direction.

Basically, we need to prevent the desired robot's heading from changing more than 90 degrees. At that point, it would be faster
and easier to spin in the opposite direction and use the other 'front' of the robot.

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

Rather ridiculous and convoluted scenario aside, this is actually one of the more interesting problems all good swerve code needs to solve.
In reality, this comes up when controlling the individual swerve modules:
We need to know when it's faster to reverse the direction of the drive wheels! Just like our robot, swerve modules take
a relatively significant amount of time to turn, and mechanical yells at us when spinning modules cause belts to slip...

url: https://raw.githubusercontent.com/Bobobalink/Swerve-Simulator/0356bea57c67e9880b3529b66d16f946c13d4462/tasks/8. Back is the new Front.md

repository: Bobobalink/Swerve-Simulator

path: /tasks/8. Back is the new Front.md

filename: 8. Back is the new Front.md

gha_language: JavaScript

repo_name: Bobobalink/Swerve-Simulator


text:
# EU cookie law

Modified version of [Fu****g EU cookies](https://github.com/jakubboucek/fucking-eu-cookies).

Word `fu****g` was replaced by `smart`.

repository: smartsupp/eu-cookie-law

repo_name: smartsupp/eu-cookie-law


text:
mining_plus
=============

This Minetest mod adds a few fresh mining tools to your world.

 Autominer
-----------

Acts like a pickaxe: Processes all items in the input slot and puts the
dropped items into the 2x3 slots. It will stop mining when all output slots
are filled. In case there are multiple drops, it would also use the eject
slot to prevent a loss of items. Make sure to empty that to make the
autominer work again.

This node should not be used on skyblock servers!

 Bridge Builder
----------------

Allows to build bridges over lava lakes easily but it also can be used
to change the floor nodes. It disallows the use of cobble as that node
is already overused everywhere.

Activate this node by punching it with a torch.

 Grinder
---------

Uses coal or bitchange's mineninths to grind nodes. It only contains 6
supported default nodes to grind. To be extended somewhen...

 Tunnel Bomb
-------------

This strange explosive node somehow manages to dig a 3x6x3 hole into
almost everything. It can be used to build corridors (for railways?)
underground or just to remove the annoying cobble around you.

Activate this node by punching it with a torch.

 More Information
------------------

Forum link: https://forum.minetest.net/viewtopic.php?id=8095

License: CC0 (for everything)

repository: TechNolaByte/Skyfactory-for-mt

repo_name: TechNolaByte/Skyfactory-for-mt


text:
#openfl-gpg

OpenFL extension for "Google Play Games" on Android.

###Main Features

* Achievements (complete, send progress, reveal/unhide, display achievements screen).
* Scoreboards (submit scores, display scoreboard).
* Login / Init.
* Cloud Storage support (for storing progress / scores on google cloud - up to 4KB of data).
* Callback events for onCloudComplete (read from cloud) and onCloudConflict (version conflict on cloud).
* Callback event for login / init
* Automatic conflict resolution (by keeping the newest version by default). You can change that by implementing the onCloudConflict method.
* XML Parser to load the ID's from Google's XML resources file.

###Simple use Example

```haxe
// This example show a simple use case.

import extension.gpg.GooglePlayGames;

class MainClass {

	function new() {
		// first of all... call init on the main method passing the main stage as parameter.
		// the second parameter is to enable cloud storage service.
		GooglePlayGames.init(mainStage,true);
	}

	function login() {
		// to force a login request to the user. This is optional and you may not even call this function
		// at all. Call this just if you want to force the user to login (instead of waiting the user to
		// call displayAchievements or displayScoreboard ...
		GooglePlayGames.login();
	}

	function displayScoreboard() {
		GooglePlayGames.displayScoreboard("your-scoreboard-id"); // to open one specific scoreboard.
		//GooglePlayGames.displayAllScoreboards(); // to show all scoreboards.
	}

	function displayAchievements() {
		GooglePlayGames.displayAchievements(); // to display the achievements.
	}

	function submitScoresAndAchievements() {
		GooglePlayGames.setScore("scoreboard-id",234); // to set 234 points on scoreboard.
		GooglePlayGames.reveal("achievement-id"); // to make one achievement visible
		GooglePlayGames.setSteps("achievement-id",30); // to set one achievement to progress to 30.
		GooglePlayGames.increment("achievement-id"); // to increment the progress of one achievement.
		GooglePlayGames.unlock("achievement-id"); // to unlock / complete one achievement.

		// Please note that all this functions returns false if the user is not logged into the game.
		// In that case you may want to call "GooglePlayGames.login();"
	}

}

```

###Cloud Storage use Example

```haxe
// This example show a simple use case.

import extension.gpg.GooglePlayGames;

class SomeClass {

	function new() {
		GooglePlayGames.onCloudComplete=onCloudComplete;
		GooglePlayGames.onCloudConflict=onCloudConflict;
	}

	function saveToCloud(id:Int, data:String) {
		GooglePlayGames.cloudSet(id,data);
	}

	function loadFromCloud(id:Int) {
		GooglePlayGames.cloudGet(id);
	}

	function onCloudComplete(id:Int, data:String) {
		trace("Data on record: "+id+" is: "+data);
	}

	function onCloudConflict(id:Int, localValue:String, serverValue:String) {
		trace("Conflict on record: "+id);
	}

}

```

###Login event example

```haxe
// This example show a simple use case.

import extension.gpg.GooglePlayGames;

class MainClass {

	function new() {
		// first of all... call init on the main method passing the main stage as parameter.
		// the second parameter is to enable cloud storage service.
		// Set up the login result event callback first, always before init()
		GooglePlayGames.onLoginResult = loginCallback;
		GooglePlayGames.init(mainStage,true);
	}

	function login() {
		// to force a login request to the user. This is optional and you may not even call this function
		// at all. Call this just if you want to force the user to login (instead of waiting the user to
		// call displayAchievements or displayScoreboard ...
		GooglePlayGames.login();
	}

	function loginCallback(result:Int):Void {
		// The possible returned values are:
		// -1 = failed login
		//  0 = trying to log in
		//  1 = logged in
		// this event is fired several times on differents situations, results vary and must be tested
		// and adapted to your game logic. for example, if you execute init() and login() but the user 				// doesn't login, cancel the operation, it will return: 0 -1 0 -1 , same as if the user is 			// not connected to the internet.
		Lib.trace("Login result = "+result);
	}

}
```

###XML Resources parsing example

```haxe
// This example show a simple use case.

import extension.gpg.GooglePlayGames;

class MainClass {

	function new() {
		// first of all... call init on the main method passing the main stage as parameter.
		// the second parameter is to enable cloud storage service.
		GooglePlayGames.init(mainStage,true);

		// Google allows you to download an XML file with you IDs related to some alias name.
		// It's a good practice to match your alias from google play games with your alias on game center, to simplify your code.
		var xmlText='......
			     <resources>
				<string name="complete stage 1">CgkI-7SKzbALA2IQAQ</string>
				<string name="kill 100 enemies">CgkI-7SKzbALA2IQBw</string>
				<string name="complete stage 2">CgkI-7SKzbALA2IQAg</string>
			     </resources>';

		GooglePlayGames.loadResourcesFromXML(xmlText);
	}

	function doSomething() {
		GooglePlayGames.reveal( GooglePlayGames.getID("kill 100 enemies") ); // to use an alias name instead of the ugly ID
	}

}

```

###How to Install

To install this library, you can simply get the library from haxelib like this:
```bash
haxelib install openfl-gpg
```

Also, you'll need to download the google-play-services_lib from your Android SDK Manager. To do that, you need to execute the android tool from:
```bash
$ANDROID_SDK/tools/android
```

Then select *Google Play Services* under the "Extras" section.

Once this is done, you just need to add this to your project.xml
```xml
<haxelib name="openfl-gpg" />
<setenv name="GOOGLE_PLAY_GAMES_ID" value="32180581421" /> <!--

repository: ipsilondev/openfl-gpg

repo_name: ipsilondev/openfl-gpg


text:
## CLI Commands

### Cluster Management
```shell
    docker swarm init --advertise-addr <ip>   # Set up master
    docker swarm init --force-new-cluster -advertise-addr <ip>   # Force manager on broken cluster

    docker swarm join-token worker            # Get token to join workers
    docker swarm join-token manager           # Get token to join new manager

    docker swarm join <server> worker         # Join host as a worker

    docker swarm leave

    docker swarm unlock                       # Unlock a manager host after docker
                                              # daemon restart when autolock is on

    docker swarm unlock-key                   # Print key needed for 'unlock'

    docker node ls                            # Print swarm node list
    docker node rm <node id>
    docker node inspect --pretty <node id>

    docker node promote <node id>             # Promote node to manager
    docker node demote <node id>
```
### Rebalancing

Forced rebalance (dangerous)
```shell
    docker service ls -q > dkr_svcs && for i in `cat dkr_svcs`; do docker service update "$i" --detach=false --force ; done
```
Draining a node
```shell
    docker node update --availability drain <node id>
```
Undrain
```shell
    docker node update --availability active <node id>
```
### Managing Services
```shell
    docker stack ls
    docker stack rm <name>

    docker service create <image>
    docker service create --name <name> --replicas <number of replicas> <image>
    docker service scale <name>=<number of replicas>
    docker service rm <service id>
    docker service ls
    docker service ps <service id>

    docker service logs
```


text:
---
templateKey: blog-post
title: An a11y extension coming to a browser near you
devto_link: >-
  https://dev.to/nickytonline/an-a11y-extension-coming-to-a-browser-near-you-1mg2
date: 2019-04-01T01:02:21.470Z
description: PR I'm working on to get tota11y deployed as a browser extension.
tags:
  - a11y
  - javascript
  - browserextension
---
Last year when I was looking to take on a new role somewhere, one of the places I interviewed at was Khan Academy. TLDR, I wasn’t hired 😉. However, as a candidate, I wanted to stand out (relevant post [Take chances and standout](https://www.iamdeveloper.com/blog/2019-01-05-take-chances-and-standout/)). In a nutshell, I [put up a PR](https://github.com/Khan/tota11y/pull/131) to Khan’s [tota11y](https://github.com/Khan/tota11y) repository to convert their a11y tool to a browser extension.

The goal of the PR was, aside from standing out, was to make it an extension without interfering with how their tool works when loaded as a [bookmarklet](https://khan.github.io/tota11y/#Try-it).

I’ll be up front, I’m not an a11y expert, so this tool was actually really good for me to learn a few things. Here’s a shot of it in action.

https://twitter.com/nickytonline/status/1040818193911173120

One of the coolest features is the screen reader wand (Khan's work, not mine).

![t0ta11y screen reader wand in action](/img/tota11y-in-action.gif "t0ta11y screen reader wand in action")

The PR isn’t merged yet, but will hopefully be in the next month or so. Regardless, you can try it out today as an unpacked extension in Chrome, FireFox, Brave or any browser that lets you load Chrome Webstore extensions. All you need to do is [clone my branch](https://github.com/nickytonline/tota11y/tree/poc/tota11y-as-chrome-extension) and build it locally. See the [README](https://github.com/nickytonline/tota11y/tree/poc/tota11y-as-chrome-extension#loading-tota11y-as-an-unpacked-chrome-extension) for instructions for loading it as an unpacked extension.

I hope you find it useful and shoutout to the devs at Khan for making this great tool.


text:
# Devpleno - Full Stack Master
This repository contains all my own programming project files, notes, and associated files for the [Devpleno - Full Stack Master](https://devpleno.com/cursos-premium-de-desenvolvimento-de-software-devpleno/fullstack-master-3/) course with [Devpleno](https://www.devpleno.com/).

None of the provided course example files, or content are provided in this repository. To get access to these files, please sign up to the course via the above link.

All rights for the original files used and provided with this course go to
[Devpleno](https://www.devpleno.com/).
## Installation & Usage
To install and run this locally on your computer, you will need a local web to open the files in this repository with a text editor, or preview them on a browser.

You may also clone this locally to your computer, using the following line of code:
```
$git clone https://github.com/efcjunior/devpleno-full-stack-master.git
```

More usage instructions on the Cat Clicker application coming in the near future.
## Contribution
Feel free to contribute to any and all of the files within this repository as you see fit. These files are mainly for personal use, but my goal is to help others better understand Full Stack programming with my software and helpful commentary.
## License
As of October 31st, 2016, these files are open for all to use and contribute to. This repository is protected under the [MIT License](http://choosealicense.com/licenses/mit/).

repository: efcjunior/devpleno-full-stack-master

repo_name: efcjunior/devpleno-full-stack-master


text:
---
id: 146
title: RDF::RDFa update with vocabulary expansion, RDF collections and more
date: 2011-09-06T06:37:48+00:00
author: gregg
layout: post
guid: http://wp.greggkellogg.railsplayground.net/wordpress/?p=146
permalink: /2011/09/rdfrdfa-update-with-vocabulary-expansion-rdf-collections-and-more/
categories:
  - Ruby
  - Semantic Web
---
I've updated [RDF::RDFa](http://rubygems.org/gems/rdf-rdfa) with updates from recent changes to RDF Core:

  * Deprecate explicit use of @profile
  * Add rdfa:hasVocabulary when encountering @vocab
  * Implemented Reader#expand to perform vocabulary expansion using RDFS rules 5, 7, 9 and 11.

Additionally, experimental support for RDF Collections (lists) has been added, based on [RDF Webapps working group Wiki notes](http://www.w3.org/2010/02/rdfa/wiki/Lists).

#### Remove RDFa Profiles

RDFa Profiles were a mechanism added to allow groups of terms and prefixes to be defined in an external resource and loaded to affect the processing of an RDFa document. This introduced a problem for some implementations needing to perform a cross-origin GET in order to retrieve the profiles. The working group elected to drop support for user-defined RDFa Profiles (the default profiles defined by RDFa Core and host languages still apply) and replace it with an inference regime using vocabularies. Parsing of @profile has been removed from this version.

#### Vocabulary Expansion

One of the issues with vocabularies was that they discourage re-use of existing vocabularies when terms from several vocabularies are used at the same time. As it is common (encouraged) for RDF vocabularies to form sub-class and/or sub-property relationships with well defined vocabularies, the RDFa vocabulary expansion mechanism takes advantage of this.

As an optional part of RDFa processing, an RDFa processor will perform limited [RDFS entailment](http://www.w3.org/TR/rdf-mt/#rules), specifically rules rdfs5, 7, 9 and 11. This causes sub-classes and sub-properties of type and property IRIs to be added to the output graph.

RDF::RDFa::Reader implements this using the `#expand` method, which looks for `rdfa:hasVocabulary` properties within the output graph and performs such expansion. See an example in the usage section.

#### RDF Collections (lists)

One significant RDF feature missing from RDFa was support for ordered collections, or lists. RDF supports this with special properties `rdf:first`, `rdf:rest`, and `rdf:nil`, but other RDF languages have first-class support for this concept. For example, in [Turtle](http://www.w3.org/TR/2011/WD-turtle-20110809/), a list can be defined as follows:

    [ a schema:MusicPlayList;
      schema:name "Classic Rock Playlist";
      schema:numTracks 5;
      schema:tracks (
        [ a schema:MusicRecording; schema:name "Sweet Home Alabama";       schema:byArtist "Lynard Skynard"]
        [ a schema:MusicRecording; schema:name "Shook you all Night Long"; schema:byArtist "AC/DC"]
        [ a schema:MusicRecording; schema:name "Sharp Dressed Man";        schema:byArtist "ZZ Top"]
        [ a schema:MusicRecording; schema:name "Old Time Rock and Roll";   schema:byArtist "Bob Seger"]
        [ a schema:MusicRecording; schema:name "Hurt So Good";             schema:byArtist "John Cougar"]
      )
    ]

defines a playlist with an ordered set of tracks. RDFa adds the @member attribute, which is used to identify values (object or literal) that are to be placed in a list. The same playlist might be defined in RDFa as follows:

      Classic Rock Playlist
      <meta property="numTracks" content="5"/>

          1.Sweet Home Alabama -
          Lynard Skynard

          2.Shook you all Night Long -
          AC/DC

          3.Sharp Dressed Man -
          ZZ Top

          4.Old Time Rock and Roll
          Bob Seger

          5.Hurt So Good
          John Cougar

This basically does the same thing, but places each track in an rdf:List in the defined order.

You can try both these and other RDF gems a the [distiller](http://rdf.greggkellogg.net/distiller/).

license: Unlicense


text:
    A Proxy Chrome Extension with Vue

    A browser extensions for Chrome, Opera & Firefox.

## Installation
1. Clone the repository `git clone https://github.com/Kat5ura/vue-proxy.git`
2. Run `npm install`
3. Run `npm run build`

Alternately, if you want to try out the sample extension, here are the download links. After you download it, unzip the file and load it in your browser using the steps mentioned below.
 - [**Download Chrome Extension**](https://github.com/EmailThis/extension-boilerplate/releases/download/v1.0/chrome.zip)
 - [**Download Opera Extension**](https://github.com/EmailThis/extension-boilerplate/releases/download/v1.0/opera.zip)
 - [**Download Firefox Extension**](https://github.com/EmailThis/extension-boilerplate/releases/download/v1.0/firefox.zip)

##### Load the extension in Chrome & Opera
1. Open Chrome/Opera browser and navigate to chrome://extensions
2. Select "Developer Mode" and then click "Load unpacked extension..."
3. From the file browser, choose to `extension-boilerplate/build/chrome` or (`extension-boilerplate/build/opera`)

##### Load the extension in Firefox
1. Open Firefox browser and navigate to about:debugging
2. Click "Load Temporary Add-on" and from the file browser, choose `extension-boilerplate/build/firefox`

## Developing
The following tasks can be used when you want to start developing the extension and want to enable live reload -

- `npm run chrome-watch`
- `npm run opera-watch`
- `npm run firefox-watch`

## Packaging
Run `npm run dist` to create a zipped, production-ready extension for each browser. You can then upload that to the appstore.

-----------
This project is licensed under the MIT license.

If you have any questions or comments, please create a new issue. I'd be happy to hear your thoughts.

## Special THANKS TO @Bharani.

repository: unaceg/vue-proxy

repo_name: unaceg/vue-proxy


text:
agra-db-restore
===============

A quick vagrant config for provisioning machines to restore pg backups into.

RailsMachine generates backups with OmniPTR. Vagrantfile automates provisioning machines for restoration. Machines can either be on AWS or VirtualBox.

Requires: http://docs.vagrantup.com/v2/installation/index.html

Spinning up the VM
------------------
We'll spin up the box in AWS, to facilitate retrieving backups from S3.

First, install some things:

    vagrant plugin install vagrant-aws
    vagrant box add dummy https://github.com/mitchellh/vagrant-aws/raw/master/dummy.box

Then, create a .env with appropriate values based on .env.sample.

Load those environment variables:

    source .env

Finally, spin up the box:

    vagrant up --provider=aws

Restoring the DB
----------------
SSH to the new VM:

    vagrant ssh

Go to the directory where Vagrant put the scripts:

    cd /vagrant

Run the restore_db.sh script, specifying a date in ISO 8601 format, like so:

    ./restore_db.sh 2014-03-24

If everything worked, you should now be able to access the database:

    sudo -u postgres psql agra_production

repository: controlshift/agra-db-restore

repo_name: controlshift/agra-db-restore


text:
# D-Weather
![D-Weather](https://user-images.githubusercontent.com/8271958/124655110-660f1c80-de6d-11eb-98ae-661a3506e568.png)

## 🎯 About
Simple weather-app that displays the 7-day forecast upon entering in a location.

## ✨ Features
✔    Utilizes a third party API to retrieve weather information.

✔    Able to convert temperature between Fahrenheit & Celsius.

✔    Can select a specific day to view more weather information for that particular day.

✔    Responsive layout.

## 📸 Screenshots

**Desktop Experience**

https://user-images.githubusercontent.com/8271958/124655824-5fcd7000-de6e-11eb-9fb6-e7dbcd89db38.mp4

**Mobile Experience**

https://user-images.githubusercontent.com/8271958/124656671-7de7a000-de6f-11eb-8094-f81e21b47e4c.mp4

## 🚀 Technologies
- [React](https://reactjs.org/)
- [WeatherbitIO API](https://www.weatherbit.io/)

## 📝 License
[MIT](https://github.com/sir-nutty/D-Weather/blob/main/LICENSE)

repository: sir-nutty/D-Weather

repo_name: sir-nutty/D-Weather


text:
# IMU Web Client Examples

This directory contains example programs, that use the
[imu-tools](https://www.npmjs.com/package/imu-tools) npm package to connect to
an ESP32 that is running either the MicroPython code in
[imu-tools](https://github.com/osteele/imu-tools), or the Arduino (C++) code in
[Arduino-BLE-IMU](https://github.com/osteele/Arduino-BLE-IMU).

## Running these examples

To run these examples, run a server such as:

* (Atom) [atom-live-server package](https://atom.io/packages/atom-live-server)
* (Visual Studio Code) [Live Server
  extension](https://marketplace.visualstudio.com/items?itemName=ritwickdey.LiveServer).
  CLick the Live Server icon in the status bar at the bottom of the window.
* (Command line) `python -m SimpleHTTPServer 5500`. (The inclusion of `5500` is
  not necessary, but makes this compatible with the URLs in the Guide section
  below.)

Click the "Connect BLUE" button to make a Bluetooth connection. This needs to be
repeated each time the page is loaded.

To connect to an MQTT server ("broker"), click "Open Controls" and enter the
hostname of the MQTT broker, and enter the username and password. If several
devices are connected to the same server, the programs will display data from
all of them. Enter a device id to restrict them to only a single device.

## A Guide to the examples

(If you run a server at port 5500, as above, you can click on the example names
below in order to open them in a browser.)

[`index.html`](http://<IP_ADDRESS>:5500) displays a list of examples in this directory.

[`3d-model.html`](http://localhost:5500/3d-model.html) is a p5.js sketch that displays the
[Stanford bunny](https://en.wikipedia.org/wiki/Stanford_bunny). The 3d
orientation of the bunny is yolked to the IMU orientation. The model is red
before the sensor is minimally calibrated, and it fades out when sensor data is
not being received. (With the Gravity BNO055, the model mostly stays red.)

This sketch has a lot of features, that make it useful for interaction but
difficult to read the code. See `3d-example`, below.

The "Calibrate" button resets tells the software that the IMU is currently in
home position (rightside up). It is not related to the IMU's built-in
calibration feature, that synchronizes the IMU's sensors to each other.

[`3d-example.html`](http://localhost:5500/3d-example.html) is a simpler  sketch
that also displays the bunny. It assumes that only a single IMU is connected.

[`sketch.html`](http://localhost:5500/sketch.html) is simple p5.js sketch that
displays the Euler angles. Use it as a starter templtate for writing p5.js
sketches that use the IMU.

[`dashboard.html`](http://<IP_ADDRESS>:5500/dashboard.html) displays a directory of web pages in the
`web` directory directory. It is written in [React](https://reactjs.org), with
[Babel](https://babeljs.io) to process JSX.

[`barchart.html`](http://<IP_ADDRESS>:5500/barchart.html) displays a live bar chart of sensor data.
This is implemented as a [p5.js](https://p5js.org) sketch.

[`chart.html`](http://<IP_ADDRESS>:5500/chart.html) uses [HighCharts](https://www.highcharts.com)
to display another live graph, that automatically scales the *y* axis as data
arrives.

## Additional reading

See the [npm imu-tools README](https://www.npmjs.com/package/imu-tools) for
additional documentation for the IMU connection code.

## License

MIT


text:
The Spectacular Sync Engine
========================

The Spectacular Sync Engine is a standards-compliant, solid MIDI sync engine for iOS.

It is designed to be very easy to work with, and provides precise, jitter-free MIDI clock transmission and robust, error-tolerant MIDI clock reception for your iOS app.

Intensively unit-tested, accompanied by extensive documentation and a complete sample app, and written by one of the pioneers of iOS audio development and developer of [Audiobus](http://audiob.us) Michael Tyson, The Spectacular Sync Engine lets you easily add sync support without needing to worry about the details.

License
-------

Copyright (C) 2015 A Tasty Pixel

This software is provided 'as-is', without any express or implied
warranty.  In no event will the authors be held liable for any damages
arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not
   claim that you wrote the original software. If you use this software
   in a product, an acknowledgment in the product documentation would be
   appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be
   misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

license: Zlib

repository: jaouahbi/TheSpectacularSyncEngine

repo_name: jaouahbi/TheSpectacularSyncEngine


text:
google-music-fuse
=================

Google Music FUSE filesystem

Thanks to vially for his Google Music XBMC addon, which I modified some code from (https://github.com/vially/googlemusic-xbmc)

repository: bigsoftcms/google-music-fuse

repo_name: bigsoftcms/google-music-fuse


text:
---
id: 673
title: 'Chicago’s Single-Largest Order of Ford Interceptor Law Enforcement Vehicles'
date: 2012-03-01T00:00:34-06:00
author: Patrick Mosca
layout: post
guid: http://digital.cityofchicago.org/?p=673
permalink: /index.php/chicagos-single-largest-order-of-ford-interceptor-law-enforcement-vehicles/
image: https://digital.cityofchicago.org/wp-content/uploads/2012/07/ford-order-thumb.jpg
categories:
  - Not Feature
  - Video
tags:
  - Economic and Business Development
  - Public Safety
---

  [iframe width=”560″ height=”315″ src=”http://www.youtube.com/embed/YCCIu9mBcpE” frameborder=”0″ allowfullscreen]

The newest law enforcement vehicles in Chicago are going to be built in Chicago. The Mayor announced an initial purchase of 100 new Ford “Interceptor” sedans and SUVs for its fleet. Last fall, the motor company announced nearly 2,000 new Chicago jobs and a third shift at the Torrence Ave facility, which is the longest continuously-running Ford plant in the US. More info: http://bit.ly/Aho2I8


text:
<a style="float:right;font-size:12px;"<EMAIL_ADDRESS>  Improve this doc
</a>

# Photo Library

```
$ ionic cordova plugin add cordova-plugin-photo-library --variable PHOTO_LIBRARY_USAGE_DESCRIPTION="To choose photos"
$ npm install --save @ionic-native/photo-library
```

## [Usage Documentation](https://ionicframework.com/docs/native/photo-library/)

Plugin Repo: [https://github.com/terikon/cordova-plugin-photo-library](https://github.com/terikon/cordova-plugin-photo-library)

The PhotoLibrary plugin allows access to photos from device by url. So you can use plain img tag to display photos and their thumbnails, and different 3rd party libraries as well.
Saving photos and videos to the library is also supported.
cdvphotolibrary urls should be trusted by Angular. See plugin homepage to learn how.

## Supported platforms
- Android
- Browser
- iOS

repository: tanxujie/AKunZhuBaoZip

repo_name: tanxujie/AKunZhuBaoZip


text:
# ark-swift

[![Language: Swift 4](https://img.shields.io/badge/language-swift%204-f48041.svg?style=flat)](https://developer.apple.com/swift)
![Platform: iOS 8+](https://img.shields.io/badge/platform-iOS-blue.svg?style=flat)
[![Carthage compatible](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](https://github.com/Carthage/Carthage)
[![Build Status](https://www.bitrise.io/app/9c254d1192dee0b6/status.svg?token=LJCBSpGJX4fHNdB4q1NTrQ)](https://www.bitrise.io/app/9c254d1192dee0b6)
[![codebeat badge](https://codebeat.co/badges/82517c1b-d4aa-4e8d-b8dc-fa8d9f6f49ce)](https://codebeat.co/projects/github-com-s4cha-ark-swift-master)
[![License: MIT](http://img.shields.io/badge/license-MIT-lightgrey.svg?style=flat)](https://github.com/s4cha/ark-swift/blob/master/LICENSE)
[![GitHub tag](https://img.shields.io/github/release/s4cha/ark-swift.svg)]()
<!-- [![CocoaPods compatible](https://img.shields.io/badge/Cocoapods-compatible-4BC51D.svg?style=flat)](https://cocoapods.org/pods/PUT_NAME_HERE) -->

```swift
let account = Account(address:"AK3wUpsmyFrWvgytFRoaHatEKj3uxUBZE6")
account.fetchBalance().then { [weak self] balance in
    self?.balanceLabel.text = "\(balance.confirmed.toStandard()) Ark"
}
```
*Displaying an account's balance*

Checkout the example project: https://github.com/s4cha/ark-swift-example

Import `Ark` framework at the top of your file:
```swift
import Ark
```

### Account

```swift
let account = Account(address: "MY_ADDRESS")
```

#### Balance

Get the balance of an account.
```swift
account.fetchBalance().then { balance in
    print(balance)
}

//output: Balance(confirmed: 42, unconfirmed: 200)
```

#### Public key
Get the public key of an account.

```swift
account.fetchPublicKey().then { publicKey in
    print(publicKey)
}

//output: 4fh34jhd34kjdk234jdk5252fkjl4jfaldk324al23r25446
```

#### Information
Get the account information of an address.

```swift
account.fetchInfo().then { account in
    print(account)
}

//output:
Account(
  address: "anAccountAddress",
  balance: Optional(Balance(confirmed: 123, unconfirmed: 456)),
  publicKey: Optional("aPublicKey"),
  secondPublicKey: Optional("aSecondPublicKey"),
  secondSignature: Optional(true),
  unconfirmedSignature: Optional(false)
)
```

#### Delegate fee
Get the delegate fee of an account.

```swift
account.fetchDelegateFee().then { fee in
    print(fee)
}

//output:<PHONE_NUMBER>
```

#### Delegates count
Get the count of delegates.

```swift
account.fetchDelegatesCount().then { delegatesCount in
    print(delegatesCount)
}

//output: 608
```

#### Delegates
Get the delegates of an account.

```swift
account.fetchDelegates().then { delegates in
    print(delegates)
}

//output:
[
  Delegate(
    username: "dr10",
    address: "ANwjGUcVbLXpqbBUWbjUBQWkr4MWVDuJu9",
    publicKey: "031641ff081b93279b669f7771b3fbe48ade13eadb6d5fd85bdd025655e349f008",
    vote: "146519050420810",
    producedBlocks: 35990,
    missedBlocks: 215,
    rate: 13,
    approval: 1.12,
    productivity: 99.4100037
  )
]
```

#### Top Accounts
Get a list of top accounts.
```swift
Account.fetchTopAccounts().then { topAccounts in
  print(topAccounts)
}

//output: [Account1, Account2, Account3 etc ...]
```

### Blockchain

#### Supply
Get the blockchain supply.

```swift
Block.fetchSupply().then { supply in
    print(supply)
}

//output:<PHONE_NUMBER>0000000
```

#### Reward
Get the blockchain reward.

```swift
Block.fetchReward().then { reward in
    print(reward)
}

//output: 200000000
```

#### Milestone
Get the blockchain milestone.

```swift
Block.fetchMilestone().then { milestone in
  print(milestone)
}

//output: 0
```

#### Fee
Get the transaction fee for sending "normal" transactions.

```swift
Block.fetchFee().then { fee in
    print(fee)
}

//output: 10000000
```

#### Nethash
Get the blockchain nethash.

```swift
Block.fetchNethash().then { nethash in
    print(nethash)
}

//output: 6e84d08bd299ed97c212c886c98a57e36545c8f5d645ca7eeae63a8bd62d8988
```

#### Blocks
Get all blocks.

```swift
Block.fetchBlocks().then { blocks in
    print(blocks)
}

//output: [Block1, Block2, Block3 etc ...]
```

#### Block
Get block by id.

```swift
let block = Block(id: "7432845560996079685")
block.fetch().then { block in
  print(block)
}

//output: Block(id: "7432845560996079685", version: Optional(0), timestamp: Optional(22825600), height: Optional(2816164), previousBlock: Optional("11152274710022062224"), numberOfTransactions: Optional(0), totalAmount: Optional(0), totalFee: Optional(0), reward: Optional(200000000), payloadLength: Optional(0), payloadHash: Optional("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"), generatorPublicKey: Optional("0217ff1ec656f2354a899bde097bb3131a9730fe491bb87dedb96489120be9154f"), generatorId: Optional("AXzEMF7TC1aH3ax1Luxk6XdyKXDRxnBj4f"), blockSignature: Optional("3044022023505abfacb6538a0fd8db639dfb3078a34d601c3625533c92a629cb4dd7131c0220658d94e2834668430ee0be70f201820be7fe87574acf3d525f67c662acc7eb03"), confirmations: Optional(1), totalForged: Optional("200000000"))
```

### Signature

#### Fee
Get the fee for a signature.

```swift
Signature.fetchFee().then { fee in
    print(fee)
}

//output: 500000000
```

#### Fee for address
Get the fee for a signature on a specified address.

```swift
Signature.fetchFee(for: "AK3wUpsmyFrWvweRoHaEjuxUBE6").then { fee in
    print(fee)
}

//output: 500000000
```

## More Ѧrk Developer-Language Integrations:

- **Go**
    - [**ark-go**](https://github.com/ArkEcosystem/ark-go): https://github.com/ArkEcosystem/ark-go
- **Java**
    - [**ark-java**](https://github.com/ArkEcosystem/ark-java): https://github.com/ArkEcosystem/ark-java
- **JavaScript**
    - [**ark-js**](https://github.com/ArkEcosystem/ark-js): https://github.com/ArkEcosystem/ark-js
- **Laravel**
    - [**Laravel-Ark**](https://github.com/faustbrian/Laravel-Ark): https://github.com/faustbrian/Laravel-Ark
- **.Net**
    - [**ark-net**](https://github.com/ArkEcosystem/ark-net): https://github.com/ArkEcosystem/ark-net
- **PHP**
    - [**Ark-PHP-Client**](https://github.com/faustbrian/Ark-PHP-Client): https://github.com/faustbrian/Ark-PHP-Client
- **Python**
    - [**Arky**](https://github.com/ArkEcosystem/arky): https://github.com/ArkEcosystem/arky
- **Ruby**
    - [**Ark-Ruby**](https://github.com/faustbrian/Ark-Ruby): https://github.com/faustbrian/Ark-Ruby
- **TypeScript**
    - [**ark-ts**](https://github.com/ArkEcosystem/ark-ts): https://github.com/ArkEcosystem/ark-ts

- **Swift**
    - [**ARKKit**](https://github.com/sleepdefic1t/ARKKit): https://github.com/sleepdefic1t/ARKKit

#### Tip Jar
``ѦRK [Ѧ]:`` ```AK3wUpsmyFrWvgytFRoaHatEKj3uxUBZE6```


text:
```toml
title = "About PuGo"
slug = ""
desc = "some words about pugo"
date = "2018-03-01 00:00"
update_date = "2018-03-06 23:10"
author = "pugo"
hover = "about"
template = "page.html"
lang = ""
sort = 0
draft = false

[meta]
  metadata = "this is meta data"
```

### Introduction

`PuGo` is a simple static site generator by [Golang](https://golang.org). It compiles [markdown](https://help.github.com/articles/markdown-basics/) to site pages with beautiful theme. No dependencies, cross platform and very fast.

![golang](/golang.png)

### Quick start

1. Download from [PuGo](http://pugo.io) and extract zip archive.
2. Run `pugo new site` to create new default site.
2. Run `pugo server`, open `http://localhost:9899` to visit.

### Commands

Run a command when run `pugo` executable file:

- `pugo new` create new site, post or page.
- `pugo build` build static files.
- `pugo server` build and serve static files.

More details in [Documentation](http://pugo.io/en/docs.html).

### Writing

`PuGo` support two kinds of content, `post` and `page`. you can create any `.md` file in proper directories in `source` directory. Read the [wiki](http://pugo.io/en/guide/write-new-post.html) to learn the layout format and more details.

### Compile

After you change your source `.md` files, run

    pugo build

To build static files.

### Customize

- Theme: theme documentation is [Here](http://pugo.io/en/docs/tpl/syntax.html)


text:
# [Kiva Data Science For Good Competitition](https://www.kaggle.com/kiva/data-science-for-good-kiva-crowdfunding)

Kiva.org is an online crowdfunding platform to extend financial services to poor and financially excluded people around the world. Kiva lenders have provided over $1 billion dollars in loans to over 2 million people. In order to set investment priorities, help inform lenders, and understand their target communities, knowing the level of poverty of each borrower is critical. However, this requires inference based on a limited set of information for each borrower.

In Kaggle Datasets' inaugural Data Science for Good challenge, Kiva is inviting the Kaggle community to help them build more localized models to estimate the poverty levels of residents in the regions where Kiva has active loans. Unlike traditional machine learning competitions with rigid evaluation criteria, participants will develop their own creative approaches to addressing the objective. Instead of making a prediction file as in a supervised machine learning problem, submissions in this challenge will take the form of Python and/or R data analyses using Kernels, Kaggle's hosted Jupyter Notebooks-based workbench.

Kiva has provided a dataset of loans issued over the last two years, and participants are invited to use this data as well as source external public datasets to help Kiva build models for assessing borrower welfare levels. Participants will write kernels on this dataset to submit as solutions to this objective and five winners will be selected by Kiva judges at the close of the event. In addition, awards will be made to encourage public code and data sharing. With a stronger understanding of their borrowers and their poverty levels, Kiva will be able to better assess and maximize the impact of their work.

The sections that follow describe in more detail how to participate, win, and use available resources to make a contribution towards helping Kiva better understand and help entrepreneurs around the world.
Problem Statement

For the locations in which Kiva has active loans, your objective is to pair Kiva's data with additional data sources to estimate the welfare level of borrowers in specific regions, based on shared economic and demographic characteristics.

A good solution would connect the features of each loan or product to one of several poverty mapping datasets, which indicate the average level of welfare in a region on as granular a level as possible. Many datasets indicate the poverty rate in a given area, with varying levels of granularity. Kiva would like to be able to disaggregate these regional averages by gender, sector, or borrowing behavior in order to estimate a Kiva borrower’s level of welfare using all of the relevant information about them. Strong submissions will attempt to map vaguely described locations to more accurate geocodes.

# Kernels submitted will be evaluated based on the following criteria:

1. Localization - How well does a submission account for highly localized borrower situations? Leveraging a variety of external datasets and successfully building them into a single submission will be crucial.

2. Execution - Submissions should be efficiently built and clearly explained so that Kiva’s team can readily employ them in their impact calculations.

3. Ingenuity - While there are many best practices to learn from in the field, there is no one way of using data to assess welfare levels. It’s a challenging, nuanced field and participants should experiment with new methods and diverse datasets.
How to Participate and Make a Submission »

To be considered a participant in the Kiva Crowdfunding Data Science for Good Event, there are a few requirements:

    Everyone must register and accept the rules by filling out this form (you'll need to be logged into your Kaggle account to view the form). This ensures you're a participant and also means you'll receive update emails from us about key deadlines and announcements throughout the event.
    To submit a kernel for consideration in the main prize track, make sure it's public and submit it here (you'll need to be logged into your Kaggle account to view the form). Read more details here.
    To submit a kernel or dataset for consideration in the secondary prize track, all you need to do is make sure it's public and be a registered participant before the deadline.

# Prizes and Eligibility »

There is a total prize pool of $30,000 split into two tracks:

    Main prize track for the primary event objective: accurate and localized analyses or methods for assessing poverty levels. ($14,000; five winners total)
    Upvoted kernels and popular datasets to encourage public sharing of code and data ($16,000; 12 winners total)

Main Prize Track

Kiva will award $14,000 in total prizes to five winning authors who submit public kernels effectively tackling the objective by the deadline. These kernels must be submitted for consideration by May 15th, 2018.

Upvoted Kernels and Popular Datasets

There is also a separate prize track for public sharing of code and data to encourage ongoing collaboration. Awards of $1,000 each will also be made to authors of the eight top most upvoted kernels. And four awards of $2,000 each will go to the datasets published with the most upvoted kernels used with the event data.

For more details about the prizes and eligibility click here.
Timeline

All dates are 11:59PM UTC:

    3 April 2018: Kernels Award Announcement (Top 8 upvoted kernels)
    3 April 2018: First Datasets Award Announcement (Top 2 most used data sources published on Kaggle)
    15 May 2018: Challenge Deadline (Kernels for main prize must be submitted and made publicly available to be evaluated for a prize)
    22 May 2018: Winners of the primary prize track will be announced and second datasets award announcement (Second top 2 most used data sources published on Kaggle)

# Rules

To be eligible to win a prize in either of the above prize tracks, you must be:

    a registered account holder at Kaggle.com;
    the older of 18 years old or the age of majority in your jurisdiction of residence;
    not a resident of Crimea, Cuba, Iran, Syria, North Korea, or Sudan; and
    not a person or representative of an entity under U.S. export controls or sanctions.

Your kernels and datasets will only be eligible to win if they have been made public on kaggle.com by the above deadline. All prizes are awarded at the discretion of Kiva, and Kiva reserves the right to cancel or modify prize criteria.

Unfortunately employees, interns, contractors, officers and directors of Kaggle Inc., and their parent companies, are not eligible to win any prizes.


text:
<!-- README.md is generated from README.Rmd. Please edit that file -->

# Paper Template

<!-- badges: start -->

<!-- badges: end -->

I occasionally write papers, I also occasionally write them in R
Markdown, and post code to github. This is an effort to minimise
repetition of dumb set-up tasks.

First steps should be update the licence e.g. using
`usethis::use_ccby_license()`


text:
# Healthy-Glutton

A videogame that represents the consequence of good and bad eating habits in a fun and interactive way.

Download for Mac at [Healthy Glutton](https://sfbarts.itch.io/healthy-glutton)

repository: sfbarts/Healthy-Glutton

repo_name: sfbarts/Healthy-Glutton


text:
# CTF-web-to-system-01

A CTF challenge: Web hacking into the linux system and get R00T!! (created by<EMAIL_ADDRESS>
There are three flags you can discover during the journey.

## How to build yourself and run

```
$ docker build . -t local/ctf01
$ docker run -d -p 9090:9090 local/ctf01
```

## Challenge right away

```
$ docker run -d -p 9090:9090 quay.io/jechoisec/ctf-web-to-system-01
```

Access http://`<ip>`:9090 with your browser.

repository: OWASP/vulnerable-container-hub

repo_name: OWASP/vulnerable-container-hub


text:
---
layout: post
title: March 19th - Extreme Love...is giving.
categories: [Verse of the Day]
alias: [/VerseOfTheDay/2010/03/19/]
---

_Galatians 6:9
And let us not be weary in well doing: for in due season we shall
reap, if we faint not._

This is NOT the day to be weary for doing good! This is the day
which the Lord hath made, and you must keep going! You are given a
promise that if you will stay faithful and keep loving and giving,
you will be rewarded. That's quite a deal! Make up your mind to face
opposition with love and patience, and ask God to give you the
strength to endure!

 --

Jesus Every Day is a ministry of Rodgers Baptist Church in Garland, Texas.


text:
# go-request

![GoVersion](https://img.shields.io/github/go-mod/go-version/gildas/go-request)
[![GoDoc](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/gildas/go-request)
[![License](https://img.shields.io/github/license/gildas/go-request)](https://github.com/gildas/go-request/blob/master/LICENSE)
[![Report](https://goreportcard.com/badge/github.com/gildas/go-request)](https://goreportcard.com/report/github.com/gildas/go-request)

![master](https://img.shields.io/badge/branch-master-informational)
[![Test](https://github.com/gildas/go-request/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/gildas/go-request/actions/workflows/test.yml)
[![codecov](https://codecov.io/gh/gildas/go-request/branch/master/graph/badge.svg?token=gFCzS9b7Mu)](https://codecov.io/gh/gildas/go-request/branch/master)

![dev](https://img.shields.io/badge/branch-dev-informational)
[![Test](https://github.com/gildas/go-request/actions/workflows/test.yml/badge.svg?branch=dev)](https://github.com/gildas/go-request/actions/workflows/test.yml)
[![codecov](https://codecov.io/gh/gildas/go-request/branch/dev/graph/badge.svg?token=gFCzS9b7Mu)](https://codecov.io/gh/gildas/go-request/branch/dev)

A Package to send requests to HTTP/REST services.

## Usage

The main func allows to send HTTP request to REST servers and takes care of payloads, JSON, result collection.

Examples:

```go
res, err := request.Send(&request.Options{
    URL: myURL,
}, nil)
if err != nil {
    return err
}
data := struct{Data string}{}
err := res.UnmarshalContentJSON(&data)
```
Here we send an HTTP GET request and unmarshal the response.

It is also possible to let `request.Send` do the unmarshal for us:

```go
data := struct{Data string}{}
_, err := request.Send(&request.Options{
    URL: myURL,
}, &data)
```
In that case, the returned `Content`'s data is an empty byte array. Its other properties are valid (like the size, mime type, etc)

You can also download data directly to an `io.Writer`:
```go
writer, err := os.Create(filepath.Join("tmp", "data"))
defer writer.Close()
res, err := request.Send(&request.Options{
	URL:    serverURL,
}, writer)
log.Infof("Downloaded %d bytes", res.Length)
```
In that case, the returned `Content`'s data is an empty byte array. Its other properties are valid (like the size, mime type, etc)

Authorization can be stored in the `Options.Authorization`:

```go
payload := struct{Key string}{}
res, err := request.Send(&request.Options{
    URL:           myURL,
    Authorization: request.BasicAuthorization("user", "password"),
}, nil)
```

or, with a Bearer Token:

```go
payload := struct{Key string}{}
res, err := request.Send(&request.Options{
    URL:           myURL,
    Authorization: request.BearerAuthorization("myTokenABCD"),
}, nil)
```

Objects can be sent as payloads:

```go
payload := struct{Key string}{}
res, err := request.Send(&request.Options{
    URL:     myURL,
    Payload: payload,
}, nil)
```

A payload will induce an HTTP POST unless mentioned.

So, to send an `HTTP PUT`, simply write:

```go
payload := struct{Key string}{}
res, err := request.Send(&request.Options{
    Method:  http.MethodPut,
    URL:     myURL,
    Payload: payload,
}, nil)
```

To send an x-www-form, use a `map` in the payload:

```go
res, err := request.Send(&request.Options{
    Method:  http.MethodPut,
    URL:     myURL,
    Payload: map[string]string{
        "ID":   "1234",
        "Kind": "stuff,"
    },
}, nil)
```

To send a multipart form with an attachment, use a `map`, an attachment, and one of the key must start with `>`:

```go
attachment := io.Open("/path/to/file")
res, err := request.Send(&request.Options{
    Method:  http.MethodPut,
    URL:     myURL,
    Payload: map[string]string{
        "ID":    "1234",
        "Kind":  "stuff,"
        ">file": "image.png",
    },
    Attachment: attachment,
}, nil)
```
To send the request again when receiving a Service Unavailable (`Attempts` and `Timeout` are optional):
```go
res, err := request.Send(&request.Options{
    URL:                  myURL,
    RetryableStatusCodes: []int{http.StatusServiceUnavailable},
    Attempts:             10,
    Timeout:              2 * time.Second,
}, nil)
```

**Notes:**
- if the PayloadType is not mentioned, it is calculated when processing the Payload.
- if the payload is a `ContentReader` or a `Content`, it is used directly.
- if the payload is a `map[string]xxx` where *xxx* is not `string`, the `fmt.Stringer` is used whenever possible to get the string version of the values.
- if the payload is a struct or a pointer to struct, the body is sent as `application/json` and marshaled.
- if the payload is an array or a slice, the body is sent as `application/json` and marshaled.
- The option `Logger` can be used to let the `request` library log to a `gildas/go-logger`. By default, it logs to a `NilStream` (see github.com/gildas/go-logger).
- When using a logger, you can control how much of the Request/Response Body is logged with the options `RequestBodyLogSize`/`ResponseBodyLogSize`. By default they are set to 2048 bytes. If you do not want to log them, set the options to *-1*.
- `Send()` makes 5 attempts by default to reach the given URL. If option `RetryableStatusCodes` is given, it will attempt the request again when it receives an HTTP Status Code in the given list.
- The default timeout for `Send()` is 1 second.

**TODO**
- Support other kinds of `map` in the payload, like `map[string]int`, etc.
- Maybe have an interface for the Payload to allow users to provide the logic of building the payload themselves. (`type PayloadBuilder interface { BuildPayload() *ContentReader}`?!?)

repository: gildas/go-request

branch_name: refs/heads/dev

gha_language: Go

repo_name: gildas/go-request


text:
---
description: To scale trust and create a radically fair economy
---

# Welcome

Welcome to the Harmony Docs. This central resource contains an introduction to Harmony, our features and rationale, and resources for developers and network participants. It is divided in three main sections:

* **🎶** General - we describe the basics of Harmony and cover the technical features and our ecosystem, including grants and showcases.
* **🏗** Developers - we share all the tools and documentation for developers to deploy smart contracts and build applications on Harmony.
* **🌏** Network - we provide guides for participating in the Harmony network as a validator, delegator and token holder.

repository: DylanCkawalec/docs-home

repo_name: DylanCkawalec/docs-home


text:
## PlayerGL

The PlayerGL sample shows how to use AVBlocks API to play audio / video streams from a media file.

### Command Line

	.\PlayerGL.x64.exe <file>

###	Examples

The following example plays the `big_buck_bunny_trailer_iphone.m4v` movie trailer:

	.\PlayerGL.x64.exe ..\assets\mov\big_buck_bunny_trailer_iphone.m4v

***

repository: avblocks/avblocks-samples

repo_name: avblocks/avblocks-samples


text:
# SUKU Ethereum Node API Client Lib

[![npm version](https://badge.fury.io/js/%40suku%2Fsuku-ethereum-node-api-client-lib.svg)](https://badge.fury.io/js/%40suku%2Fsuku-ethereum-node-api-client-lib)
![Publish NPM Package](https://github.com/SukuLab/suku-ethereum-node-api-client-lib/workflows/Publish%20NPM%20Package/badge.svg)

This is the SUKU Ethereum Node API Client Lib that can be used to handle REST calls to the [SUKU Ethereum Node API](https://github.com/SukuLab/suku-ethereum-node-api).

## Getting Started
Before using this library you should have a running instance of the Node API. If you do not have a running instance yet, please start by deploying the [SUKU Ethereum Node API](https://github.com/SukuLab/suku-ethereum-node-api).

## Installing the library
Install [@suku/suku-ethereum-node-api-client-lib](https://www.npmjs.com/package/@suku/suku-ethereum-node-api-client-lib) from NPM

```
npm i --save @suku/suku-ethereum-node-api-client-lib
```

## Using the library
```js
import NodeManager from '@suku/suku-ethereum-node-api-client-lib';
const nodeManagerUrl = "http://ethereum-node-api:3000";
const privateKey = "<private key here>";

let nodeManager = new NodeManager(nodeManagerUrl, privateKey);
```

## Sending a transaction
```js
let tx = yourSmartContract.methods.addSomething(parameter);
let txObject = {
    data: tx.encodeABI(),
    to: yourSmartContract.options.address
}
let predictedTxHash = await nodeManager.sendTx(txObject);
```

## Calling a function
```js
let encodedAbi : string = await yourSmartContract.methods.getSomething(parameter).encodeABI();
let tx : Transaction = {
    data: encodedAbi,
    to: yourSmartContract.options.address,
};
let response = await this.nodeManager.callFunction(tx);
```

# Contributing & Community
If you find things that you'd like to improve in this repo feel free to create a PR or an issue. Please read our [Contribution Guidelines](CONTRIBUTING.md) before submitting an issue or a PR.
- [Slack](https://sukudevs.slack.com)
- [Reddit](https://www.reddit.com/r/SUKUecosystem/)

gha_language: TypeScript


text:
# Changelog #

*These logs may be outdated or incomplete.*

## 4.0.0 ##

* Updated to PHP 5.3
* Fixed Composer issues

## 3.1 ##

* Added Composer support
* Replaced errors with exceptions
* Refactored to use strict equality

## 3.0 ##

* Added a basic caching and compression system
* Rewriting checkPath() to work correctly
* Converting private members to protected
* Can now render without a layout
* bind() now accepts an array or string

## 2.0 ##

* Completely rewritten from the ground up; not compatible (at all) with older versions
* Variables are now bound globally instead of per template
* Can configure what ext, layout and path to use
* Uses output buffering to render the templates
* Templates can use the $this variable as it is within the Gears scope
* Removed the cumbersome parent/child hierarchy

## 1.8 ##

* First initial release of Gears

repository: milesj/gears

repo_name: milesj/gears


text:
# OpenCore Updater
Update your OpenCore easily.

## Installation
This app is supported on macOS only.

Download the latest version from [release page](https://github.com/mswgen/oc-updater/releases).

Mount the disk image and copy OpenCore Updater to /Applications.

When launching the first time, a dialog will appear saying that the app cannot be opened. This is because the app is not signed.

Press Cancel, open Finder and go to /Applications.

Right click OpenCore Updater and select "Open". Another dialog will appear saying that macOS cannot verify the developer. Press Open, and the app will open. You don't need to do this the next time. However, when updating(reinstalling) the app, you will need to do this again.

## Usage

When the app opens, press `Get Started`. A dialog will appear asking you to select the EFI directory.

Select your EFI directory. It's usually /Volumes/EFI/EFI. It should have BOOT and OC directories inside.

If your OpenCore version is detect, your OpenCore version and list of kexts you are using will be displayed.

If your OpenCore version is not detected, you will be asked to select the OpenCore version you are using. Select the version you are using and press `Select this version`.

If you are not using the latest version of OpenCore, the app will ask you to update. Press `Update` to update OpenCore.

The app will start to download OpenCore, kexts, and Binary Data. this might take some time and you might see the spinning beach ball.

When the app finishes downloading, it will create a backup of your old EFI and will swap files with the new ones.

Then, it will update config.plist. When it's done, it will display that it's done. It will also display the list of not updated kexts, the backup directory, and that OpenCore Vault is disabled(if it was enabled). You need to reboot your computer to see the changes.

## Troubleshooting

### When the update is done, it displays that OpenCore Vault is disabled

If you were using OpenCore Vault, this message will appear. This is because the app cannot create OpenCore Vault.

So if you want to use OpenCore Vault, you need to create vault again and enable it in the config.plist.

### My OpenCore version is not detected

OpenCore Updater checks your OpenCore version by comparing the SHA-256 hash of your OpenCore.efi and the list of hashes in the app. If the hash is not listed in the app, it can't detect your OpenCore version. You can just manually select the version you are using and press `Select this version`.

If you are using too old version (before 0.6.3), you need to manually update to 0.6.3 first and then use this app to update to the latest version.

Also, if you are using the DEBUG build or 32-Bit version of OpenCore, you can't use the app.

### Some kexts are not updated

OpenCore Updater doesn't update all kexts, but it will update the ones that are listed in the app. The list of kexts that thid app can update is:

* VirtualSMC and plugins
* Lilu
* WhateverGreen
* AppleALC (including AppleALCU)
* VoodooPS2Controller
* VoodooI2C and satelite kexts
* ECEnabler
* BrightnessKeys
* IntelMausi
* RealtekRTL8111
* itlwm
* AirportItlwm
* IntelBluetoothFirmware
* IntelBluetoothInjector
* NVMeFix

all other kexts (including USBInjectAll, XHCI-Unsupported, VoodooRMI, etc.) will not be updated. However, there might be a newer version of those kexts. If this is the case, you should update them manually.

### Auto app update support

Unfortunately, the app cannot automatically update itself. You need to manually update the app. This is because the app is not signed. You can download the latest version from [release page](https://github.com/mswgen/oc-updater/releases) and replace the app in /Applications.

When you launch the updated version, a dialog will appear saying that the app cannot be opened. This is because the app is not signed. Please do the same thing you did when installing the app the first time.

There's no plan to sign the app.

### When updating from 0.6.5 to 0.6.6, I get a warning

In 0.6.6, config.plist - Misc - Security - BootProtect and /EFI/OC/Bootstrap/Bootstrap.efi are changed to config.plist - Misc - Boot - LauncherOption.

If you didn't use Bootstrap, there's no problem with this. However, if you used Bootstrap, the warning will appear.

OpenCore's Bootstrap.efi creates a boot entry in the boot menu and every time it boots, it checks if the boot entry is at the top of the boot menu. If it's not, it will move the boot entry to the top of the boot menu. The BIOS expects to boot from Bootstrap.efi.

However, when updating, Bootstrap.efi will be removed, but the boot entry will not be removed. This is the problem

If you want to update to 0.6.6, you need to manually remove the boot entry. You can do this by following the steps below:

1. Open /EFI/OC/config.plist
2. Set Misc - Security - BootProtect to None
3. Set Misc - Security - AllowNvramReset to True
4. Reboot and from the OpenCore boot picker, select `Reset NVRAM`
5. When your computer reboots, enter BIOS settings and confirm that `UEFI OS` (which is the BOOTx64.efi of OpenCore) is at the top of the boot menu. If it's not, you need to move the boot entry to the top of the boot menu.
6. Save and reboot to macOS.
7. Run OpenCore Updater again.
8. Now, the warning will not appear.

## How to build

1. Install [Node.js](https://nodejs.org/en/download/). Version 16 (Currently LTS) is recommended.

2. Clone or download the source code.

3. Open the terminal and type: `npm i -g yarn` to install yarn.

4. Type `yarn` to install the dependencies.

5. To open the app for development, type `yarn start`.

6. Type `yarn build` to build the app. You need a Mac or Hackintosh to build the app.

7. You can find the DMG file in the `out` directory. This app can run on both Intel Mac (Including Hackintosh) and Apple Silicon Mac.

## Credits

[mswgen](https://github.com/mswgen) for the app.

[acidanthera](https://github.com/acidanthera) for the [OpenCore](https://github.com/acidanthera/OpenCorePkg) project and many kexts.

[InsanelyMac](https://insanelymac.com) for RealtekRTL8111 kext.

[1Revenger1](https://github.com/1Revenger1) for ECEnabler kext.

[OpenIntelWireless](https://github.com/OpenIntelWireless) for AirportItlwm, itlwm, and IntelBluetoothFirmware kext.

[VoodooI2C](https://github.com/VoodooI2C) for VoodooI2C and satelite kexts.

[Apple](https://apple.com) for macOS.

[junepark](https://x86.co.kr/@junepark) for testing.

[exacore39](https://x86.co.kr/@exacore39) for testing.

[JGP](https://x86.co.kr/@JGP) for testing and update guides.

And many people who contributed to the project.

## License

Copyright (c) 2021 mswgen. All rights reserved.

Licensed under the [MIT license](./LICENSE). Please see the LICENSE file for more information.

OpenCore and the OpenCore logo are trademarks of Acidanthera.

Apple and macOS are trademarks of Apple Inc. Apple is not associated with or affiliated with this project.

All other trademarks are the property of their respective owners.


text:
---
title: Domain Driven Design
description: A high level overview of Domain Driven Design
keywords: Domain Driven Design
author: fredrkl
---
# Overview

Eric Evans wrote in 2004 the book [Domain Driven Design - Tackling Complexity in the Heart of Software](https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215/ref=sr_1_1?ie=UTF8&qid=1506262190&sr=8-1&keywords=domain+driven+design). Here he introduces a set of tools and idees on how to keep complex domain logic under control in software. The end goal is to be able to represent the domain in software as close to the way domain experts keep it in their heads. We should be able to read out code and have the domain experts correct us.

Vaughn Vernon followed up in 2013 with the book [Implementing Domain Driven Design](https://www.amazon.com/Implementing-Domain-Driven-Design-Vaughn-Vernon/dp/0321834577/ref=sr_1_4?s=books&ie=UTF8&qid=1506262653&sr=1-4&keywords=domain+driven+design). Here he goes into depth on how to take the tools and ideas and implement them.

For a quick introduction to DDD, you should read [this](https://www.amazon.com/Domain-Driven-Design-Distilled-Vaughn-Vernon/dp/0134434420/ref=pd_sim_14_2?_encoding=UTF8&pd_rd_i=0134434420&pd_rd_r=45FW5DFQNS81CFCYJ981&pd_rd_w=mHc0j&pd_rd_wg=14tZB&psc=1&refRID=45FW5DFQNS81CFCYJ981)

## Implementation

There are many ways to implement an expressive domain model that encapsulate the domain logic. Regardless on how you choose to implement it, there are some principles to follow. Keep the domain model in the center. Developers often has a tendency to focus to much on persistence. A domain model is NOT the same as a database schema. How you choose to persist data is secondary to the domain model.

## Context Map

Keep a Context Map that clearly depict the different [bounded context](./bounded_contexts.md) and there relationships. Each bounded context have there own ubiquitous language.
For an in depth explanation of context map see Eric Evans Book og Vaughn Vernon's. But basically it shows how changes in one context affect another.

### Upstream dependency

If your bounded context have a upstream dependency on another it means that if it changes then our context need to incorporate that change. We take the upstream dependencies terms and use them.

### Downstream dependency

The opposite of upstream. We dictate change and the other contexts must incorporate those.

### Anti-corruption layer

This is when we are in a upstream dependency but we are not willing to take in their terms and and concepts. We create a layer that maps them into our Ubiquitous Language.

### Partnership

When we find us in a relationship with a second team where we share codebase for example, then this could be a sensible relationship. The teams meet up and synchronize.

## Ubiquitous Language

This is basically a list of terms used in a given bounded context with a precise definition as possible. The Ubiquitous Language should then be used throughout the solution.

repository: karolikl/cbs

gha_language: C#

gha_license_id: NOASSERTION

repo_name: karolikl/cbs


text:
---
categories: ["Publications"]
people: ["Alistair E W Johnson", "Jerome Aboab", "Jesse D Raffa", "Tom J Pollard", "Rodrigo O Deliberato", "Leo Anothony Celi", "David J Stone"]
title: A comparative Analysis of Sepsis Identification Methods in an Electronic Database
linktitle: A comparative Analysis of Sepsis Identification Methods in an Electronic Database
date: 2018-04-01
description: >
 To evaluate the relative validity of criteria for the identification of sepsis in an ICU database
---

Critical Care Medicine

## Conclusions

The new organ dysfunction-based Sepsis-3 criteria have been proposed as a clinical method for identifying sepsis. These criteria identified a larger, less severely ill cohort than that identified by previously used administrative definitions. The Sepsis-3 criteria have several advantages over prior methods, including less susceptibility to coding practices changes, provision of temporal context, and possession of high construct validity. However, the Sepsis-3 criteria also present new challenges, especially when calculated retrospectively. Future studies on sepsis should recognize the differences in outcome incidence among identification methods and contextualize their findings according to the different cohorts identified.


text:
Gnieh Diffson [![Build Status](https://travis-ci.org/gnieh/diffson.png)](https://travis-ci.org/gnieh/diffson) [![Code Coverage](https://codecov.io/github/gnieh/diffson/coverage.svg?branch=master)](https://codecov.io/github/gnieh/diffson?branch=master)
=============

A [scala][6] implementation of the [RFC-6901][1] and [RFC-6902][2].
It also provides methods to compute _diffs_ between two Json values that produce valid Json patches.

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

- [Getting Started](#getting-started)
- [Json Library](#json-library)
- [Basic Usage](#basic-usage)
- [Remembering old values](#remembering-old-values)
- [Patches as Collections of Operations](#patches-as-collections-of-operations)
- [Technical Details](#technical-details)

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

Getting Started
---------------

This library is published in the [Maven][7] [Central Repository][8] and is compiled against scala 2.11.
You can add it to your sbt project by putting this line to your build description:
```scala
libraryDependencies += "org.gnieh" %% "diffson" % "2.0.1"
```

If you are using maven, add the following dependency to your `pom.xml`:
```xml
<dependency>
  <groupId>org.gnieh</groupId>
  <artifactId>diffson_${scala.version}</artifactId>
  <version>2.0.1</version>
</dependency>
```

Json Library
------------

Diffson was first developped for [spray-json][3], however, it is possible to use it with any json library of your linking.
The only requirement is to have a `DiffsonInstance` for your json library.

At the moment, diffson provides two instances for [spray-json][3] and [Play! Json][9].
To use these implementations you need to import the correct instance:

```scala
// spray-json
import gnieh.diffson.sprayJson._
// play-json
import gnieh.diffson.playJson._
```

You also need to add the library in your classpath, as they are marked as `provided` by diffson to avoid depending on all json libraries when using diffson.

If you want to add support for your favorite Json library, all you need to do is to implement the `gnieh.diffson.DiffsonInstance` class, which provide the `JsonProvider` for the specific library. Contribution of new Json libraries in this repository are more than welcome.

Basic Usage
-----------

Although the library is quite small and easy to use, here comes a summary of its basic usage.

There are three different entities living in the `gnieh.diffson` package:
 - `JsonPointer` which allows to parse and manipulate Json pointers as defined in [RFC-6901][1],
 - `JsonPatch` which allows to parse, create and apply Json patches as defined in [RFC-6902][2],
 - `JsonDiff` which allows to compute the diff between two Json values and create Json patches.

Basically if one wants to compute the diff between two Json objects, on can execute the following:
```scala
val json1 = """{
              |  "a": 1,
              |  "b": true,
              |  "c": "test"
              |}""".stripMargin

val json2 = """{
              |  "a": 6,
              |  "c": "test2",
              |  "d": false
              |}""".stripMargin

val patch = JsonDiff.diff(json1, json2, false)

println(patch)
```
which will print the following in the console:
```json
[{
  "op":"replace",
  "path":"/a",
  "value":6
},{
  "op":"remove",
  "path":"/b"
},{
  "op":"replace",
  "path":"/c",
  "value":"test2"
},{
  "op":"add",
  "path":"/d",
  "value":false
}]
```
You can then apply the patch to `json1`:
```scala
val json3 = patch(json1)
println(json3)
```

which prints something like:
```json
{
  "d":false,
  "c":"test2",
  "a":6
}
```
which we can easily verify is the same as `json2` modulo reordering of fields.

You may also only want to apply existing patches:
```scala
val raw = """[
            |  {
            |    "op": "test",
            |    "path": "/a",
            |    "value": 4
            |  }
            |]""".stripMargin

val patch = JsonPatch.parse(raw)

val json1 = """{ "a": 4 }"""
val json2 = """{ "a": 7 }"""
patch(json1) // ok json1 is returned unchanched
patch(json2) // throws PatchException
```

Remembering old values
----------------------

The `diff` method takes three parameter. The third one indicates whether the generated patch remembers removed and replaced values.
When set to `true`, the `Replace` and `Remove` operations take an extra field named `old` giving the old value.
The RFC does not define these fields, but it does not fordbid either to add extra fields. Hence, generated patches can still be interpreted by third party implementations.

Patches as Collections of Operations
------------------------------------

Patches may be seen as collections of operations on which you may which to apply some typical collection functions such as `map`, `flatMap`, filtering, folding, ...

```scala
val patch: JsonPatch = ...

val patch2: JsonPatch =
  for(op @ Add("my" :: "prefix" :: _, _) <- patch)
    yield op
```

Technical Details
-----------------

The implementation uses [spray-json][3] to manipulate Json objects.

The _diff_ between two arrays is computed by using the [Patience Diff][4] algorithm to compute the [LCS][5] between both arrays, which is quite simple to implement.

However one can replace the implementation by any other algorithm that implements the `gnieh.diffson.Lcs` trait, e.g.:
```scala
val diff = new JsonDiff(new MyLcsAlgorithm)
```

then use `diff` in lieu of `JsonDiff` in the first usage example.

[1]: http://tools.ietf.org/html/rfc6901
[2]: http://tools.ietf.org/html/rfc6902
[3]: https://github.com/spray/spray-json
[4]: http://alfedenzo.livejournal.com/170301.html
[5]: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
[6]: http://scala-lang.org
[7]: http://maven.apache.org/
[8]: http://search.maven.org/
[9]: https://www.playframework.com/documentation/latest/ScalaJson

repository: aqrcapital/diffson

repo_name: aqrcapital/diffson


text:
---
layout: publication
# The quotes make the : possible, otherwise you can do it without quotes
title: "Proving Termination of Nonlinear Command Sequences"
# YYYY_CONFSHORTNAME_PAPERSHORTNAME
key: 2012_fac_bchr

# conference | journal | poster | workshop
type: journal
redirect_from: /2012/06/proving-termination-of-nonlinear-command-sequences

# The shortname is used for auto-generated titles
shortname: FAC 2012
# add a 2:1 aspect ratio (e.g., width: 400px, height: 200px) to the folder /assets/images/papers/
image: 2012_fac_bchr.png
# add a 2:1 aspect ratio teaser figure (e.g., width: 1200px, height: 600px) to the folder /assets/images/papers/
image_large: 2012_fac_bchr_teaser.png

# Authors in the "database" can be used with just the key (lastname). Others can be written properly.
authors:
- Domagoj Babic
- Byron Cook
- Alan J. Hu
- rakamaric

journal-short: FAC
year: 2012

# bibentry: article | inproceedings | phdthesis | book
bibentry: article
bib:
  journal: Formal Aspects of Computing (FAC)
  series:
  volume: 25
  publisher: Springer
  editor:
  pages: 389--403
  doi: 10.1007/s00165-012-0252-5
  address:
  url:
  number: 3
  month: may
  note:
  issue_date:

# Add things like "Best Paper Award at InfoVis 2099, selected out of 4000 submissions"
award:

# Use if this paper is linked to an internal project. This will link to the project site
# project: upset

# Use this if you have an external project website
external-project:

# The reference to the video entry
video:
# The reference to the preview video entry
#preview-video:

# the preprint
pdf: 2012_fac_bchr.pdf
# A supplement PDF
supplement:

# Extra supplements, such as talk slides, data sets, etc.
supplements:
- name: Conference Version
  abslink: https://soarlab.org/publications/2007_sefm_bchr
  linksym: true
#- name: General UpSet
#  # use link instead of abslink if you want to link to the master directory
#  abslink: http://vials.io/talk/
#  # defaults to a download icon, use this if you want a link-out icon
#  linksym: true

# Link to the repository where the code is hosted
code:

# Link to an official preprint server
preprint_server:
#https://doi.org/10.1101/128579

abstract: "<p>
We describe a simple and efficient algorithm for proving the termination of a
class of loops with nonlinear assignments to variables. The method is based on
divergence testing for each variable in the cone-of-influence of the loop's
condition. The analysis allows us to automatically prove the termination of
loops that cannot be handled using previous techniques. We also describe a
method for integrating our nonlinear termination proving technique into a
larger termination proving framework that depends on linear reasoning.
</p>"

# After the --- you can put information that you want to appear on the website
# using markdown formatting or HTML. A good example are acknowledgements, extra
# references, an erratum, etc.
---
### Acknowledgements

We would like to thank Richard Fateman, Robert Israel, and Daniel Lichtblau for
useful discussions about the complexity of polynomial factorization, divergence
of the update functions, and multivariate limits, and Josh Berdine and Jacopo
Mantovani for their comments on Section 3. We would also like to thank the
anonymous reviewers for many helpful comments and for pointing out the special
case in the computation of safe RGDs.

gha_language: SCSS


text:
---
layout: post
title: "Avalonia Logical Tree Weirdness"
excerpt: "Avalonia has a similar concept of logical and visual trees to other XAML frameworks..."
category: Avalonia
tags: [avalonia, c#, .net]
comments: true
---

Avalonia has a similar concept of logical and visual trees to other XAML frameworks such as WPF,
UWP and Silverlight. However when you take a careful look at the logical tree, it can be seen to
function a little strangely at times!

Take `ItemsControl` as an example and imagine you add two `TextBlock`s to `ItemsControl.Items`:

```xml
<ItemsControl>
  <TextBlock>Hello<TextBlock>
  <TextBlock>World<TextBlock>
</ItemsControl>
```

Here things look pretty simple: the logical tree consists of three controls:

- ItemsControl
  - TextBlock
  - TextBlock

If you look at `ItemsControl.GetLogicalChildren()` you will see that it has two logical children:
the `TextBlock`s we added. If you look at the `TextBlock`'s themselves you will see that their
logical parent is the `ItemsControl`. Simple, right?

Similarly if we do the same with a `StackPanel` we'll see the same:

```xml
<StackPanel>
  <TextBlock>Hello<TextBlock>
  <TextBlock>World<TextBlock>
</StackPanel>
```

- ItemsControl
  - TextBlock
  - TextBlock

Ok, easy! Now lets look deeper into the `ItemsControl` visual tree: the controls created by the
control template. A simplified visual tree might look like this:

- ItemsControl
  - ItemsPresenter
    - StackPanel
      - TextBlock
      - TextBlock

Do you see a problem?

The `StackPanel` in the template has the two `TextBlock`s as its children. But hold on, we've
already determined that the `TextBlock`s are children of the `ItemsControl`, not the `StackPanel`!

In this case we have a `TextBlock` that is the logical child of *two* controls. Ok, that's fine you
say, lets just allow that. But what about the `TextBlock`'s `LogicalParent`? There's only a single
logical parent, it wouldn't make sense to have multiple parents - which one is the actual parent?

The way this works in Avalonia is that as suggested above, the `TextBlock`s are in the
`LogicalChildren` collection of *both* the `ItemsControl` and `StackPanel`, *however* the
`TextBlock`'s logical parent is the `ItemsControl`. This makes sense as if you're only looking at
the logical tree outside the `ItemsControl` template, the `StackPanel` effectively doesn't exist.

What this means is that the logical tree isn't commutative - traversing down the logical tree may
not give the same results as traversing it the other way! The visual tree does have this problem
of course so everything is a lot simpler there.


text:
Optimize
=============

This is very early days for this project.

The intention is to create a flexible Ruby interface for solving numerical optimization problems. The real motivation is to learn about numerical optimization!

Check out the specs for some feel for what this does.

Author: Andrew Berkeley<EMAIL_ADDRESS>
Homepage: https://github.com/spatchcock/optimize

Requirements
============

* The code has only been tested in Ruby 1.9.2
* The math-function library, found at https://github.com/spatchcock/math-function

To do
=====

* More algorithms
* Support for probability density functions
* Support for contraining parameter search space

Contributing
============

If you find a bug or think that you improve on the code, feel free to contribute.

You can:

* Send the author a message<EMAIL_ADDRESS>* Create an issue
* Fork the project and submit a pull request.

License
=======

© Copyright 2012 Andrew Berkeley.

Licensed under the MIT license (See COPYING file for details)

repository: spatchcock/optimize

repo_name: spatchcock/optimize


text:
Prohibit Variable Append Initialization
=======================================

Accessing an undefined variable (a variable that has not been initialized yet) is covered in
[Require Variable Initialization](/documentation/rule/requireVariableInitialization.md) rule.

Append initialization occurs when an append operator is used on against an uninitialized variable.
Strictly speaking append operators require something (already initialized) to append to, and for
that reason using append operator to initialize a variable might be viewed as trying to append to an
uninitialized variable. However this construct is quite common in PHP and the fact that the variable
is being initialized in this way has no negative side effects. For this reason this rule does not point
out broken code but rather a potentially undesired coding style.

Example:

    $a[] = 2;
    // Phlint issue: Variable *$a* initialized using append operator.

Rule configuration:

    // To enable this rule:
    $phlint->addRule('prohibitVariableAppendInitialization');

    // To disable this rule:
    $phlint->removeRule('prohibitVariableAppendInitialization');

Rule source code: [/code/phlint/rule/ProhibitVariableAppendInitialization.php](/code/phlint/rule/ProhibitVariableAppendInitialization.php)


text:
---
noAnchors: true
---

# Taskcluster Documentation

---

Taskcluster is the task execution framework that supports Mozilla's continuous integration and release processes.

---

###  Tutorial

Follow the [tutorial](/tutorial) to learn about Taskcluster, focusing on the parts most relevant to you.

---

###  Manual

[Read the manual](/manual) for a more comprehensive description of Taskcluster's design and operation.

---

###  Reference

Refer to the [reference documentation](/reference) for the technical details of each component.

---

###  Resources

See [resources](/resources) such as presentations, external services, and useful links used by and for Taskcluster.

---

###  People

Find out more about the [people](/people) who make Taskcluster, and get involved yourself!


text:
# Basic log4j2 use
**Small description**

This just show how to create a log file based on date and time and have two different output (console/file).

**Things to do:**

* add dependency from maven
    *  org.apache.logging.log4j:log4j-api:2.11.2
    *  org.apache.logging.log4j:log4j-core:2.11.2

* Create a new "log4j2.xml" in the compiled java directory, copypaste the code below then run.

```
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="MyApp" packages="">
    <Appenders>
        <Console name="ConsoleAppender" target="SYSTEM_OUT" follow="true">
            <PatternLayout>
                <Pattern>%highlight{[%level] %date{dd-MM-yyyy HH:mm:ss.SSS}}{FATAL=bg_red fg_yellow bright} [%file] -> [%method] (%thread) - <%message>%n%throwable{short}</Pattern>
                <disableAnsi>false</disableAnsi>
            </PatternLayout>
        </Console>
        <RollingFile name="MyFile" filePattern="logs/$${date:dd-MM-yyyy}/app-%d{HH-mm-ss}.log" append="true">
            <PatternLayout>
                <Pattern>%date{dd-MM-yyyy HH:mm:ss.SSS} [%file] -> [%method] (%thread) - <%message>%n%throwable{full}</Pattern>
            </PatternLayout>
            <Policies>
                <TimeBasedTriggeringPolicy/>
            </Policies>
        </RollingFile>
    </Appenders>
    <Loggers>
        <Root level="ALL">
            <AppenderRef ref="MyFile"/>
            <AppenderRef ref="ConsoleAppender"/>
        </Root>
    </Loggers>
</Configuration>
```

**THE SHORT HELP VERSION**

`<Console name="ConsoleAppender" target="SYSTEM_OUT" follow="true">`

Basically this means that the output is the same as `System.out.println();`

`<Pattern>%highlight{[%level] %date{dd-MM-yyyy HH:mm:ss.SSS}}{FATAL=bg_red fg_yellow bright} [%file] -> [%method] (%thread) - <%message>%n%throwable{short}</Pattern>`

This will highlight the output in the console (colors), the throwable (stacktrace) is set to short, the full one will be in the log file

`<RollingFile name="MyFile" filePattern="logs/$${date:dd-MM-yyyy}/app-%d{HH-mm-ss}.log" append="true">`

Basically this means that the output goes in a log file.
This will generate a new log file name, the name is based on this `%d{HH-mm-ss}` that means that each second will have a different file name.
Keep in mind that this is only for testing, for example if you delete the `-ss` the file name will change each minute.

**THE LONG HELP VERSION**
Read the [layouts](https://logging.apache.org/log4j/2.x/manual/layouts.html) if you want to change the layout or [the whole help](https://logging.apache.org/log4j/2.x/manual) for all.

gha_language: Java


text:
NoSQL Workshop - Types of NoSQL Databases

## Sections:

* [Types of NoSQL Databases](#types-of-nosql-databases)
* [Bread Crumb Navigation](#bread-crumb-navigation)

## Types of NoSQL Databases

There are 4 main types of NoSQL Databases:

1. Key-Value
    1. A key-value store has a Big Hash Table of keys & values
    2. Examples: Riak, Amazon S3 (Dynamo), Aerospike

2. Document
    1. Document databases store documents made up of tagged elements.
    2. Examples: CouchDB, MongoDb, RethinkDB, Couchbase

3. Column
    1. In a column database, a storage block contains data from only one column.
    2. Examples: Cassandra, Scylla, Druid, HBase, Vertica

4. Graph
    1. A graph database is a network database that uses edges and nodes to represent and store data.
    2. Examples: AllegroGraph, ArangoDB, InfiniteGraph, Apache Giraph, MarkLogic, Neo4J, OrientDB, Virtuoso

## Bread Crumb Navigation
_________________________

Previous | Next
:------- | ---:
← [NoSQL Databases](./nosql-databases.md) | [Key-Value Database](./key-value-database.md) →

repository: The-Hats-Crew/nosql-workshop

repo_name: The-Hats-Crew/nosql-workshop


text:
Note: Our original sprint review disappeared so we restored it a week later
# Sprint Review

## Main problems  Encountered

### Problem 1: Testing is not done enough
We need to improve our testing, since we did not have enough tests for the demo.

### Problem 2: The SCRUM board is not used well
We need to actively use the SCRUM board so everyone knows who is busy doing what.
Everyone needs to make sure they update SCRUM whenever they have started or completed something.

## Adjustments from previous sprints
Since this is the first sprint review we do not have any adjustments

## Adjustments for next sprint
 - Increase testing effort
 - Use the SCRUM board more efficiently

repository: romatallinn/sustainme

repo_name: romatallinn/sustainme


text:
## Google Book Search

### About
This application is a full stack CRUD application built with React and Node Js that allows the user to search the Google Books API for books and save them to a personal saved books list.

### Usage
This application can be found at [this link](https://lit-spire-20524.herokuapp.com/)

### Technologies Used
* React
* Bootstrap
* Express JS
* MongoDB

### License
This application is licensed under the MIT license, which can be found in the project's root directory.

repository: JEmnetu/Google-Book-Search

repo_name: JEmnetu/Google-Book-Search