text:
---
layout: post
title: Find Smith
modified:
categories: blog
excerpt:
tags: [SoS, Summers]
author : sachin
comments: true
image:
  feature:
date: 2020-05-20T10:19:07+00:00
---

Howdy Fellas!
“If the little grey cells are not exercised, they grow the rust.”
-Agatha Christie

### Brainbusters
With a halt in the normal routine has come endless free time and with that, sheer boredom which has engulfed all of us by now and dulled our brains.

Figure out how to solve these and mail us your solution to<EMAIL_ADDRESS>Cheers!
![Brainbusters](/images/brainbusters.jpg)

### Find Smith
There is a corridor with 20 rooms
 and Smith is hiding in one of them.
Each day, Smith moves to an adjacent room. John can open only one door
in  a day. John has to find Smith as soon as possible.
What is the minimum number of days that John require to guarantee that he catches Smith?
![Image of Yaktocat](/images/findsmith1.jpg)

### Who ate my cookies?
Steve, Tony, and Bruce have a plate of 1,000 cookies to share. They decide to share them in the following way: beginning with Steve, each of them in turn takes as many cookies as he likes (they must take an integer amount, greater than or equal to 1), and then passes the plate clockwise (with Tony sitting to Steve's left, and Bruce sitting to Tony's left). Nobody wants to feel like he hogged too many cookies, so they all want to avoid being the player at the end who has taken the most cookies. Additionally, nobody wants to feel cheated by finishing with the fewest cookies. Finally, given that the previous two conditions are definitely met, or definitely cannot be met, each player would like to maximize the number of cookies he eats. The players' objectives can be summarized as follows:
![Image of Yaktocat](/images/findsmith2.jpg)
Objectives:
A) Have one player who has eaten more cookies than you, and one player who has eaten fewer cookies than you.
B) Eat as many cookies as possible.
Objective 1 takes infinite priority over Objective 2.
Assuming that all players are perfectly rational, that they are all aware of each other's rationality and objectives, and that they cannot communicate with each other in any way, how many cookies should Steve take to ensure he meets both objectives and how many cookies will Tony and Bruce take if Steve takes the winning amount?
![Image of Yaktocat](/images/findsmith3.jpg)


text:
## Creating your own model and testing the PyTorch server.

To test the [PyTorch](https://pytorch.org/) server, first we need to generate a simple cifar10 model using PyTorch.

```shell
python cifar10.py
```
You should see an output similar to this

```shell
Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz
Failed download. Trying https -> http instead. Downloading http://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz
100.0%Files already downloaded and verified
[1,  2000] loss: 2.232
[1,  4000] loss: 1.913
[1,  6000] loss: 1.675
[1,  8000] loss: 1.555
[1, 10000] loss: 1.492
[1, 12000] loss: 1.488
[2,  2000] loss: 1.412
[2,  4000] loss: 1.358
[2,  6000] loss: 1.362
[2,  8000] loss: 1.338
[2, 10000] loss: 1.315
[2, 12000] loss: 1.278
Finished Training
```

Then, we can run the PyTorch server using the trained model and test for predictions. Models can be on local filesystem, S3 compatible object storage, Azure Blob Storage, or Google Cloud Storage.

Note: Currently KFServing supports PyTorch models saved using [state_dict method](https://pytorch.org/tutorials/beginner/saving_loading_models.html#saving-loading-model-for-inference), PyTorch's recommended way of saving models for inference. The KFServing interface for PyTorch expects users to upload the model_class_file in same location as the PyTorch model, and accepts an optional model_class_name to be passed in as a runtime input. If model class name is not specified, we use 'PyTorchModel' as the default class name. The current interface may undergo changes as we evolve this to support PyTorch models saved using other methods as well.

```shell
python -m pytorchserver --model_dir ./ --model_name pytorchmodel --model_class_name Net
```

We can also use the inbuilt PyTorch support for sample datasets and do some simple predictions

```python
import torch
import torchvision
import torchvision.transforms as transforms
import requests

transform = transforms.Compose([transforms.ToTensor(),
                                transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=2)
dataiter = iter(testloader)
images, labels = dataiter.next()
formData = {
    'instances': images[0:1].tolist()
}
res = requests.post('http://localhost:8080/v1/models/pytorchmodel:predict', json=formData)
print(res)
print(res.text)
```

# Predict on a InferenceService using PyTorch

## Setup
1. Your ~/.kube/config should point to a cluster with [KFServing installed](https://github.com/kubeflow/kfserving/blob/master/docs/DEVELOPER_GUIDE.md#deploy-kfserving).
2. Your cluster's Istio Ingress gateway must be network accessible.

## Create the InferenceService

Apply the CRD
```
kubectl apply -f pytorch.yaml
```

Expected Output
```
$ inferenceservice.serving.kubeflow.org/pytorch-cifar10 created
```

## Run a prediction

```
MODEL_NAME=pytorch-cifar10
<EMAIL_ADDRESS>INGRESS_GATEWAY=istio-ingressgateway
CLUSTER_IP=$(kubectl -n istio-system get service $INGRESS_GATEWAY -o jsonpath='{.status.loadBalancer.ingress[0].ip}')

SERVICE_HOSTNAME=$(kubectl get inferenceservice pytorch-cifar10 -o jsonpath='{.status.url}' | cut -d "/" -f 3)

curl -v -H "Host: ${SERVICE_HOSTNAME}" -d $INPUT_PATH http://$CLUSTER_IP/v1/models/$MODEL_NAME:predict
```

You should see an output similar to the one below:

```
> POST /models/pytorch-cifar10:predict HTTP/1.1
> Host: pytorch-cifar10.default.svc.cluster.local
> User-Agent: curl/7.54.0
> Accept: */*
> Content-Length: 110681
> Content-Type: application/x-www-form-urlencoded
> Expect: 100-continue
>
< HTTP/1.1 100 Continue
* We are completely uploaded and fine
< HTTP/1.1 200 OK
< content-length: 221
< content-type: application/json; charset=UTF-8
< date: Fri, 21 Jun 2019 04:05:39 GMT
< server: istio-envoy
< x-envoy-upstream-service-time: 35292
<

{"predictions": [[-0.8955065011978149, -1.4453213214874268, 0.1515328735113144, 2.638284683227539, -1.00240159034729, 2.270702600479126, 0.22645258903503418, -0.880557119846344, 0.08783778548240662, -1.5551214218139648]]
```

repository: maorlipchuk/kfserving

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: maorlipchuk/kfserving


text:
Peel
====

Peel is a small blogging engine designed for simple and quick creation of
content.

Some of its main features include:

* In-place editing with support for rich text formatting.
* All changes are synced to the server as you make them.
* ...

It is built with a lightweight Django backend (powered by
[Tastypie](http://tastypieapi.org/)), and a quick and responsive frontend
built with [React](http://facebook.github.io/react/). The current version
runs on Google App Engine, but through the use of
[django-nonrel](http://django-nonrel.org/) and
[djangoappengine](http://www.allbuttonspressed.com/projects/djangoappengine)
it can easily be adapted to other platforms.

Demo
----

You can view a demo of the app [here](http://peel-demo.appspot.com/). If it's
down, then the free quota has run out, so try again tomorrow.

Usage
-----

To create a new article, click on the center '+' button. This will create a
new empty article that you can edit. Clicking on any of the placeholder
fields (Title, Body or Tags) will allow you to edit them.

When you're done editing, pressing CTRL+Enter will save your changes. For
convenience, in the Title and Tags fields you can also just press Enter.
Rich text formatting is disabled in these fields.

In the Body field, you can additionally press CTRL+B, CTRL+I or CTRL+U to
make the text bold, italic or underlined, respectively.

You can delete or set the visibility of an article via the slide controls that
appear on the right side.

To make changes to already existing fields, press CTRL and click on the field
you wish to edit.

Developing
----------

0. Install [Docker](https://www.docker.io/), [Fig](http://www.fig.sh/),
   [Node.js](http://nodejs.org/) and [Bower](http://bower.io/).

1. Clone this repo:
   ```
   git clone https://github.com/imiric/peel.git
   ```

2. In the project directory build the docker image:
   ```
   fig build web
   ```

3. Install backend dependencies:
   ```
   fig run web ./build.sh
   ```

4. Install frontend dependencies (be patient):
   ```
   npm install && bower install
   ```

5. Compile frontend files (ignore the JSHint errors)
   ```
   gulp
   ```

6. Run:
   ```
   fig up web
   ```
Point your browser to your Docker IP at port 5000.

To continually compile your assets while developing, run `gulp watch`. Also
check out some of the included tasks in `gulpfile.js`.

To deploy to Google App Engine, change the application ID in `app.yaml`, and
run `fig run web ./manage.py deploy`.

License
-------

[MIT](LICENSE)

license: MIT

repository: imiric/peel

repo_name: imiric/peel


text:
# graphql-skip-limit

This library provides helper functions for building Relay-style connections but
with skip/limit style pagination instead of Relay's cursor-based pagination.

It is built and maintained for the
[React.js static site generator Gatsby](https://github.com/gatsbyjs/gatsby) to
drive its GraphQL-based data layer.

It is a port from [graphql-relay](https://github.com/graphql/graphql-relay-js)
so can be used in a similar fashion. See the tests in `src/connection/__tests__`
for an example of using this library.

Connections built with this library can be queried like the following:

```graphql
{
  allFile(skip: 1, limit: 10) {
    edges {
      node {
        id
      }
    }
  }
}
```

In this query, we skip the first result and limit our results to 10.

repository: nubank/gatsby

gha_language: JavaScript

gha_license_id: MIT

repo_name: nubank/gatsby


text:
# cms-laravel-angular
A simple cms with crud in laravel and angular js using token-based authentication

1. Create a database (eg in phpmyadmin)
2. Import the cms_laravel.sql in your new database, which is located in database/assets/
3. Change the configuration (DB name, username, password) according to your settings in .env file (hidden file) and config/database.php file
4. Use the following credentials to login :
<EMAIL_ADDRESS>/ 123456 or
<EMAIL_ADDRESS>/ 654321
5. Go to localhost/cms/public

repository: giannispan/cms-laravel-angular

repo_name: giannispan/cms-laravel-angular


text:
# How to find DP

## Steps to solve a DP

- Identify if it is a DP problem
- Decide a state expression with least parameters
- Formulate state relationship
- Do tabulation (or add memoization)

## Step 1 : How to classify a problem as a Dynamic Programming Problem?

- Typically, all the problems that require to maximize or minimize certain quantity or counting problems that say to count the arrangements under certain condition or certain probability problems can be solved by using Dynamic Programming.
- All dynamic programming problems satisfy the overlapping subproblems property and most of the classic dynamic problems also satisfy the optimal substructure property. Once, we observe these properties in a given problem, be sure that it can be solved using DP.

## Step 2 : Deciding the state

DP problems are all about state and their transition. This is the most basic step which must be done very carefully because the state transition depends on the choice of state definition you make. So, let's see what do we mean by the term "state".

## StateA state can be defined as the set of parameters that can uniquely identify a certain position or standing in the given problem. This set of parameters should be as small as possible to reduce state space

As we know DP is all about using calculated results to formulate the final result.

So, our next step will be to find a relation between previous states to reach the current state.

## Step 3 : Formulating a relation among the states

Let's think dynamically for this problem. So, first of all, we decide a state for the given problem. We will take a parameter n to decide state as it can uniquely identify any subproblem. So, our state dp will look like state(n). Here, state(n) means the total number of arrangements to form n by using {1, 3, 5} as elements.

Now, we need to compute state(n).

## Step 4 : Adding memoization or tabulation for the state

This is the easiest part of a dynamic programming solution. We just need to store the state answer so that next time that state is required, we can directly use it from our memory

## References

<https://www.geeksforgeeks.org/solve-dynamic-programming-problem>


text:
# AS3 library for foursquare

This library was written for [Hail To The Mayor](http://hailtothemayor.com) during the foursquare hackathon, but has since been built out as a more generic Foursquare library.

## Requirements

First of all it seems that this library only works with AIR apps, and SWFs that are hosted via https.

Secondly, I use a library from Ben Rimbey to cast foursquare's JSON results into Actionscript objects (e.g. `Venue`).  This library was enhanced so it can receive nested objects (such as tips for a venue).  An association tree can then be automatically pulled out of the JSON objects.

In enhancing it I use a class introduced in Flash 10, the `Vector`, to provide a "typed collection" for introspection purposes.   So it requires Flash 10 :).

Finally, you need to generate from foursquare an oauth key.  There are several ways to do this, you'll have to pick what works best for you..

## Connecting to foursquare

If you have an OAuth token pass it in to the constructor of the `AuthenticatedFoursquareDelegate` class.

However, if you instead want to use "userless" access (e.g. for the [Venues Project](http://developer.foursquare.com/venues/)), you would need to create a serverside proxy for your foursquare requests.  Ideally this proxy will receive a foursquare request and tack on your application's id and secret.  Then you would create an instance of the `ProxiedFoursquareDelegate`, passing in to the constructor your proxy location.

Either of these delegates, once created, will supply you with methods such as `getCategories`.

## The Goal

I'm trying to take the "fat model, skinny controller" philosophy and apply it to this library.  What I mean by that is I would like the classes to have intelligent enough associations that everything gets pulled in as needed.  Adding a new foursquare endpoint should only require:

* description of the endpoint
* pulling out the main object from the JSON
* determining what class should be instantiated

As an example, this is how a tree of categories is pulled down and wrapped up
    public function getCategories(success:Function, failure:Function = null):void {
        load("venues/categories", function(event:Event):void {
            var categories:Array = jsonResponse(event).categories;
            sendResult(success,instantiate(categories, Category));
        }, failure);
    }

This uses introspection to pull in the entire tree of categories, sub-categories and sub-sub-categories.  This in possible because the `Category` object for venues is listed as:

    public class Category {
        public var name:String;
        public var categories:Vector.<Category> = new Vector.<Category>();
        ...
    }

The `Vector.<Category>` type is what lets introspection work its magic.  As long as the JSON object has an array of the same name, its elements are used to build instances of the appropriate class.

In order to use this code, you need to do nothing more than call getCategories with a callback function:

    getCategories(function(event:ResultEvent):void {
        this.categories = event.result as Array;
    });

Each `Category` object in the array has its inner vector of subcategories automagically populated as well.  Note that you can pass in a failure callback as well.  If you don't do this, the default failure will fire, which is just a popup indicating your error.

The benefits of this approach carry over to all models.  Since the `Venue` class also has a vector of `Category` objects, these get autopopulated too.

## Todo

Some of the things that should be worked on:

* There are some things in the foursquare api making introspection less than smooth.  In the `hereNow` field of a `venue`, for example, the checkin information is a little tricky to draw out.  Therefore we do this manually rather than let associations help us autopopulate the fields.  Some strategy should be established to smooth this out a bit.
* Right now I'm only throwing in the endpoints I use, but if you have your own feel free to add them.
* Similarly the models only have the fields set that I use.  Please add any others that are useful to you, but don't remove any because they could be used for someone else's endpoint!
* If you have any testing strategy to add, please do.  As of now I'm planning to build an AIR app that does live integration testing with the endpoints.
* There needs to be a smoother way to add oauth keys to the app, for both AIR and browser-based Flash applications, maybe a separate project or two is required to handle this.

## License

This code is released under the MIT license.  Do whatever you want with it.

repository: nicothed/foursquare

extension: markdown

repo_name: nicothed/foursquare


text:
# Determination of Soil Damping by  Hydraulic Pendulum

By: Paul Michaels
Created on 02/04/2015 using the [DMPTool](https://dmp.cdlib.org/) Template: NSF-GEN: Generic

You can find the full-text at [https://dmptool.org/api/v1/plans_full/13785.pdf](https://dmptool.org/api/v1/plans_full/13785.pdf)

## Types of data produced

> Types of data, samples, physical collections, software, curriculum materials, and other materials to be produced in the course of the project.

Types of data include:

	Digital signal recordings of pendulum motion
	Spread sheets recording details on soil tested, pendulum settings, frequencies tested.
	Text or PDF files providing observers logs of the experiments
	Spread sheets recording grain size testing and permeability testing.

## Data and metadata standards

> Standards to be used for data and metadata format and content (where existing standards are absent or deemed inadequate, this should be documented along with any proposed solutions or remedies).

	Digital signals will be in either *.wav format or binary integer format. In any case, PDF files specifying the data format details will be provided.
	Grain size testing will be spread sheet format (excel)
	Constant head permeability data will be in spread sheet format (excel)

## Policies for access and sharing

> Policies for access and sharing; Provisions for appropriate protection of privacy, confidentiality, security, intellectual property, or other rights or requirements.

	Initially, there will be a 1 year delay after data are completely collected. There are patent issues that may need to be resolved.
	Data will be hosted on Boise State servers. Access will be by email request to the PI or data manager. Email responding to the request will include instructions on how to download the data.
	Intellectual property rights will be held by Boise State University. This only affects access to the data by a 1 year delay from the date the data have been completely collected.
	Access to data will require proper citations when publishing.

## Policies for re-use, redistribution

> Policies and provisions for re-use, re-distribution, and the production of derivatives.

	The data should not be re-released by 3rd parties. Access to the data should only be by email request to BSU so that Boise State University may maintain a record of those who have had access.
	Access will be permitted to anyone.
	Likely parties interested in the data would be engineers, attorneys, faculty, students.
	Likely use of the data would be in studies of soil dynamics, foundation engineering, geotechnical engineering, earthquake engineering, and claims for damages due to construction vibrations

## Plans for archiving and preservation

> Plans for archiving data, samples, and other research products, and for preservation of access to them.

	Since all the data will be in electronic format, storrage will be on a computer server.
	Initially, the server will be located at Boise State University. It may be at the Center for Geophysical Investigation of the Shallow Subsurface (CGISS). A final solution may include OpenStack or some 3rd party cloud service.
	Meta data will be the spread sheets that capture the details of the testing, including frequency, masses of soil and water, porosity test results, permeability test results, configuration of the pendulum and weights.
	The spread sheets for porosity and permeability testing will be self documenting and follow ASTM or other relevant standards.

Processed 2016-09-28 16:57:08.739181

repository: bulib/dmp

repo_name: bulib/dmp


text:
# LevelDB Curator

The LevelDB Curator gem allows you to manage one or more LevelDB databases from
one or more clients concurrently. It listens on UDP port `9068` on localhost
for `put` and `get` commands.

## Installation ##

```
bundle install
gem build leveldb_curator.gemspec
gem install ./leveldb_curator-0.1.0.gem
```

## Example server implementation ##

```ruby
require "leveldb_curator"

LeveldbCurator.new(
  %w(foobar_database barfoo_database)
)
```

The above example will initialize two leveldb databases: foobar_database
and barfoo_database. It will keep running until the process is terminated.

## Example client implementation

```ruby
require 'socket'
require 'bindata'

class Protocol < BinData::Record
    endian  :big
    stringz :database
    stringz :command_word
    stringz :query_key
    stringz :query_value
end

def get_answer(sock)
    msg, sender = sock.recvfrom(1024)
    msg
end

def send_request(sock, data)
    sock.send(data, 0, "localhost", 9068)
end

def query(database, command, query_key, query_value = "")
    add_request = Protocol.new
    add_request.database = database
    add_request.command_word = command
    add_request.query_key = query_key
    add_request.query_value = query_value
    send_request(@s, add_request.to_binary_s)
    get_answer(@s)
end

@s = UDPSocket.new

query("foobar_database", "put", "foo", "bar")
query("barfoo_database", "put", "bar", "foo")
response = query("foobar_database", "get", "foo")
response2 = query("barfoo_database", "get", "bar")

puts response
puts response2

```

The client code does not depend on this gem nor on leveldb. It only sends out
UDP queries and returns the daemon's response. Therefore you can use this in
multiple projects querying the same database.

### Credits

I've borrowed the UDP client/server code from this gist:

https://gist.github.com/omnisis/3998752

Thanks to [@omnisis] for posting it.

repository: dennisvink/leveldb-curator

repo_name: dennisvink/leveldb-curator


text:
# renovate-test-maven-version-scheme

This is a test setup for showing how to override the `versionScheme`
property of Renovate Bot.

I had the problem that Renovate wanted to update to e.g.
`org.jetbrains.kotlinx:kotlinx-coroutines-core to v1.3.3-1.3.70-eap-42`,
while I wanted to stay on the normal release track (`v1.3.3`).

Some related documentation around this:

- https://github.com/renovatebot/renovate/blob/825c866757a4ab8dd525fd196bd5a3e9bc93445b/docs/usage/docker.md#version-compatibility
- https://docs.renovatebot.com/configuration-options/#versionscheme

gha_language: Java


text:
#The man of peace: or, The glorious appearance of the great God in his people, rising as a man of war, to waste the Assyrian, that is, the mighty oppressor, or enemy to our peace. Being a second olive-leaf, springing 1. To heal the nation, or people of the land. 2. To humble the princes, or people of the Lord. 3. To heighten the spirits of the English, above all the nations about, to break them, or bring them in (with us) to the government of Jesus. By William Erbery.#

##Erbery, William, 1604-1654.##
The man of peace: or, The glorious appearance of the great God in his people, rising as a man of war, to waste the Assyrian, that is, the mighty oppressor, or enemy to our peace. Being a second olive-leaf, springing 1. To heal the nation, or people of the land. 2. To humble the princes, or people of the Lord. 3. To heighten the spirits of the English, above all the nations about, to break them, or bring them in (with us) to the government of Jesus. By William Erbery.
Erbery, William, 1604-1654.

##General Summary##

**Links**

[TCP catalogue](http://www.ota.ox.ac.uk/tcp/)  •
[HTML](http://tei.it.ox.ac.uk/tcp/Texts-HTML/free/A84/A84074.html)  •
[EPUB](http://tei.it.ox.ac.uk/tcp/Texts-EPUB/free/A84/A84074.epub) •
[Page images (Historical Texts)](https://historicaltexts.jisc.ac.uk/eebo-99865947e)

**Availability**

This keyboarded and encoded edition of the work described above is co-owned by the
    institutions providing financial support to the Early English Books Online Text Creation
    Partnership. This text is available for reuse, according to the terms of  Creative Commons 0 1.0 Universal
    licence. The text can be copied, modified, distributed and performed, even for commercial
    purposes, all without asking permission.

**Major revisions**

1. __2013-10 __ __SPi Global__ *Keyed and coded from ProQuest page images *
1. __2014-03 __ __Simon Charles __ *Sampled and proofread *
1. __2014-03 __ __Simon Charles__ *Text and markup reviewed and edited *
1. __2015-03 __ __pfs__ *Batch review (QC) and XML conversion *
1. __2021-05 __ __lb__ *TEI P5 conversion *

##Content Summary##

#####Front#####
The Man of Peace: OR, The Glorious appearance of the great GOD in his People, RISING AS A Man of War
#####Body#####
For Mr. Feak, Mr. Simpson, and all the Members of Christs Church.My Brethren,I Spake last for the pe
    _ For Mr. Feak, Mr. Simpson, and all the Members of Christs Church.
This man shall be the peace, when the Assyrian shall come into our land: and when he shall tread in I Shall not preach, but present in haste a few Proposals to your prudent and pious considerations, iI will encamp about my house, because of the Army, because of him that passeth by, and because of hi
    _ POSTSCRIPT.

#####Back#####
Page 13. line 3. for for, read against.
**Types of content**

  * Oh, Mr. Jourdain, there is **prose** in there!

**Character listing**

|Text|string(s)|codepoint(s)|
|---|---|---|
|Latin Extended-B|Ʋ|434|

##Tag Usage Summary##

###Header Tag Usage###

|No|element name|occ|attributes|
|---|---|---|---|
|1.|__author__|2||
|2.|__availability__|1||
|3.|__biblFull__|1||
|4.|__change__|5||
|5.|__date__|7| @__when__ (1) : 2016-02 (1)|
|6.|__editorialDecl__|1||
|7.|__encodingDesc__|1||
|8.|__extent__|2||
|9.|__fileDesc__|1||
|10.|__idno__|8| @__type__ (8) : DLPS (1), EEBO-CITATION (1), VID (1), EEBO-PROQUEST (1), STC (3), PROQUEST (1)|
|11.|__keywords__|1| @__scheme__ (1) : http://authorities.loc.gov/ (1)|
|12.|__label__|5||
|13.|__langUsage__|1||
|14.|__language__|1| @__ident__ (1) : eng (1)|
|15.|__listPrefixDef__|1||
|16.|__note__|6||
|17.|__notesStmt__|2||
|18.|__p__|11||
|19.|__prefixDef__|2| @__ident__ (2) : tcp (1), char (1)  •  @__matchPattern__ (2) : ([0-9\-]+):([0-9IVX]+) (1), (.+) (1)  •  @__replacementPattern__ (2) : http://eebo.chadwyck.com/downloadtiff?vid=$1&page=$2 (1), https://raw.githubusercontent.com/textcreationpartnership/Texts/master/tcpchars.xml#$1 (1)|
|20.|__profileDesc__|1||
|21.|__projectDesc__|1||
|22.|__pubPlace__|2||
|23.|__publicationStmt__|2||
|24.|__publisher__|2||
|25.|__ref__|4| @__target__ (4) : https://creativecommons.org/publicdomain/zero/1.0/ (1), http://www.textcreationpartnership.org/docs/. (1), https://textcreationpartnership.org/faq/#faq05 (1), https://github.com/textcreationpartnership (1)|
|26.|__relatedItem__|1| @__type__ (1) : facs (1)  •  @__target__ (1) : https://data.historicaltexts.jisc.ac.uk/view?pubId=eebo-99865947e (1)|
|27.|__revisionDesc__|1||
|28.|__seriesStmt__|1||
|29.|__sourceDesc__|1||
|30.|__term__|3| @__type__ (3) : uniform_title (1), topical_term (2)|
|31.|__textClass__|1||
|32.|__title__|3||
|33.|__titleStmt__|2||

###Text Tag Usage###

|No|element name|occ|attributes|
|---|---|---|---|
|1.|__back__|1||
|2.|__bibl__|3||
|3.|__body__|1||
|4.|__div__|8| @__type__ (8) : title_page (1), text (1), dedication (1), epigraph (2), discourse (1), postscript (1), errata (1)|
|5.|__front__|1||
|6.|__g__|82| @__ref__ (82) : char:EOLhyphen (82)|
|7.|__head__|2||
|8.|__hi__|536||
|9.|__item__|3||
|10.|__list__|1||
|11.|__opener__|1||
|12.|__p__|81| @__n__ (13) : 2 (3), 4 (1), 5 (1), 6 (1), 7 (1), 8 (1), 9 (1), 10 (1), 11 (1), 12 (1), 13 (1)|
|13.|__pb__|20| @__facs__ (20) : tcp:118203:1 (1), tcp:118203:2 (2), tcp:118203:3 (2), tcp:118203:4 (2), tcp:118203:5 (2), tcp:118203:6 (2), tcp:118203:7 (2), tcp:118203:8 (2), tcp:118203:9 (2), tcp:118203:10 (2), tcp:118203:11 (1)  •  @__n__ (18) : 1 (1), 2 (1), 3 (1), 4 (1), 5 (1), 6 (1), 7 (1), 8 (1), 9 (1), 10 (1), 11 (1), 12 (1), 13 (1), 14 (1), 15 (1), 16 (1), 17 (1), 18 (1)|
|14.|__q__|3||
|15.|__salute__|1||
|16.|__seg__|1| @__rend__ (1) : decorInit (1)|
|17.|__trailer__|1||


text:
# WaifuStream Reverse Image Search Bot

**WaifuStream** is a simple reverse image search engine built on top of Redis.
It also comes with a Discord bot for performing searches and management.

## Overview

Each image processed by **WaifuStream** is indexed by its perceptual hash value,
and searches are also performed with perceptual hashes as input.

An initial search is performed by dividing the query image hash into byte-sized chunks,
and returning all indexed image hashes that share at least one corresponding chunk with the query hash.

For example:
```
Query Hash:        05 a2 ff b5 ...
Potential Match 1: 05 c6 d2 a2 ... (match in position 0)
Potential Match 2: 2d a2 cc b5 ... (match in position 1 and 3)
```

Afterwards, the full Hamming distance is then computed for every hash matched
by this initial search. Potential matches with a high distance are then filtered out,
and the final result list is returned, sorted by increasing distance.

## Indexer

The Indexer forms the core of this system, and is responsible for:
  - Monitoring source sites (i.e. Danbooru) for images to index
  - Fetching queued images and indexing them within Redis.

Both of these are handled by separate worker processes within the Indexer.

The Indexer is provided with a list of tags to monitor via the `indexed_tags`
Redis key. It will periodically scan source sites for posts with monitored
tags, and add them to per-tag queues. Images will then be fetched and indexed
from each queue in round-robin fashion.

## Client Interface

The main interface for the engine is the `waifustream.index` module.
There, you'll find functions for performing searches and for retrieving indexed
data. Additional functions for working with the Indexer are also provided.

## Discord Bot

Currently, the only extant end-user interface for this engine is via the
included Discord chatbot.

Valid commands for the chatbot include:
```
status [tag]               : Show the status of the indexer, either as a whole or for the provided tag
add / index [tags...]      : Add a set of tags to the indexed tags list.
remove / unindex [tags...] : Remove a set of tags from the indexed tags list.
identify [n]               : Look up a previously posted image within the index.
```

## Config

The following keys can be set within `config.json` to control both the Bot and the Indexer:
```
redis_url           : The URL of the Redis server to connect to.
min_download_delay  : Minimum delay between each fetched image, in seconds.
bot_ua              : The User-Agent string to use for HTTP requests made by the Discord bot.
indexer_ua          : The User-Agent string to use for HTTP requests made by the Indexer.
exclude_tags        : A list of tags that will be excluded from indexing and from bot search results.
tokenfile           : Path to a file containing the bot's login token.
maintenance_mode    : If True, the bot will start in Maintenance Mode, and regular users won't be able to access any bot commands.
authorized_users    : A list of Discord user IDs that are allowed to access privileged commands.
log_channels        : A list of Discord channel IDs to post log messages to.
error_channels      : A list of Discord channel IDs to post error reports to.
command_channels    : A list of Discord channel IDs that will be monitored for commands.
```


text:
---
title: iPhone Debugging
author: rupert
layout: post
permalink: /2009/06/iphone-debugging/
aktt_notify_twitter:
  - no
categories:
  - iphone
tags:
  - iphone
---
As not to forget.. its “obj\_exception\_throw” from debugger -> breakpoints. Very helpful indeed. Note you can click on the image below to get a fullscreen view on my extended Samsung SW2333.. hehe

Other references.. Download “[Lecture 13][1]”
(13. Debugging Tips, Searching, Notifications, KVC_KVO (May 13, 2009)) from Stanford University CS193 Class in iTunes.

 [1]: http://www.stanford.edu/class/cs193p/cgi-bin/index.php


text:
# bcmaps (development version)

# bcmaps 2.0.0

## Removal of `sp` and `raster` support

We've removed support for the `sp` and `raster` packages,
especially those parts that require
the use of the `rgdal` and `rgeos` packages, which will be retired in October 2023. See the [r-spatial blog](https://r-spatial.org/r/2022/04/12/evolution.html) for details of this evolution.

* Removed the `class` argument in all of the data download functions: `get_layer()` and all of the wrapper shortcuts such as `bc_bound()`, `census_tract()`, etc. These functions will now only return `sf` objects.
* The `Spatial` method of `transform_bc_albers()` is removed.
* `fix_geo_problems()` is removed. For `sf` objects simply use `sf::st_make_valid()`
* `self_union()` is removed. Use `raster::union()` for `SpatialPolygonsDataFrame`s, or `sf::st_union()` with `sf` objects instead.
* `get_poly_attribute()` is removed.
* `raster_by_poly()` is retained for now as it does not rely on `rgdal` or `rgeos`,
  just `sp` and `raster`, which are still being maintained.

## Documentation improvements

* Added a `pkgdown` site for `bcmaps` https://bcgov.github.io/bcmaps/ (#63)
* Moved the detailed user documentation from the `README` to a Get Started with `bcmaps` article/vignette (#42)
* Better documentation for `bc_bound_hres()` (#124)

# bcmaps 1.2.0

## Deprecation of `sp` and `raster` support

We've started the process of removing support for the `sp` and `raster` packages,
especially those parts of that require
the use of the `rgdal` and `rgeos` packages, which will be retired in October 2023. See the [r-spatial blog](https://r-spatial.org/r/2022/04/12/evolution.html) for details of this evolution. We will fully remove
support for `Spatial` classes (from package `sp`) in the next release in Summer 2023.

* Added deprecation warnings for the `class` argument in all of the data download functions: `get_layer()` and all of the wrapper shortcuts such as `bc_bound()`, `census_tract()`, etc. This argument will be removed in the next version of `bcmaps` as these functions will only return `sf` objects.
* The `Spatial` method of `transform_bc_albers()` is deprecated.
* `fix_geo_problems()` is deprecated and will be removed completely in Summer 2023.
For `sf` objects simply use `sf::st_make_valid()`
* `self_union()` is deprecated and will be removed in Summer 2023. Use `raster::union()`
for `SpatialPolygonsDataFrame`s, or `sf::st_union()` with `sf` objects instead.
* `get_poly_attribute()` is deprecated because it had a very niche application for calculating attributes on a `SpatialPolygonsDataFrame`, which we are removing support for. It will be removed completely in Summer 2023.

# bcmaps 1.1.0

* `bec` and `tsa` layers are now downloaded directly from the BC Data Catalogue. This ensures that these are up-to-date and means that we do not rely on the manual updating of these layers at  https://github.com/bcgov/bcmapsdata. (#62, #115)
* Package startup message about no longer needing the `bcmapsdata` package has been removed.

# bcmaps 1.0.3

* New behaviour of shortcut functions ensures that all spatial objects (`sf` or `Spatial`) returned
are topologically valid and in the standard CRS of "EPSG:3005" (BC Albers). #96
* More robust behaviour of getting and checking cache of `cded` files.

# bcmaps 1.0.2

* New helper function `show_cached_files()` to show the files that you have cached (and how much space they're taking up on your computer). (#92, #93)

# bcmaps 1.0.1
- When R version is >= 4.0, bcmaps will use `tools::R_user_dir("bcmaps",
"cache")` to determine the cache directory, while when R version is < 4.0, it
will use `rappdirs::user_cache_dir("bcmaps")`. This is to align with CRAN's
storage policy using the `tools` approach while maintaining backwards
compatibility with older R versions. Unfortunately this will require users who
updated to version 1.0 to re-download layers because we are caching layers in a
different location on your file system from that version. Users wishing to clear
the old cache location could run `bcmaps::delete_cache()` before updating to bcmaps 1.0.1.
(#83)
- `cded_raster` and `cded_stars` directly accepts a bounding box generated by `sf::st_bbox` as an aoi. (#87)
- Fixed a bug where bundled datasets (e.g., `mapsheets_50K()`, `mapsheets_250K()`) would not work if `sf` was linked to older GDAL/PROJ libraries due to different formats of coordinate reference systems. (#85)
- Added new census boundary layers: `census_dissemination_area()`, `census_metropolitan_area()`, `census_tract()` (#82).
- Add missing layers to `available_layers`

# bcmaps 1.0

- Drop dependency on {bcmapsdata} in favour of directly retrieving layers (where present)
from the B.C. Data Catalogue (via {bcdata}) and storing in a local cache. Some additional
layers are retrieved from Statistics Canada.
- Some layers may not be identical to what was previously in {bcmaps}. For example `bc_neighbours` previously used data from Natural Earth. The availability of a Hi-Res B.C. boundaries over WFS from the B.C. Data Catalogue means that the layer can now be created directly by {bcmaps}.
- Added forward sortation area (`fsa`), health boundaries (`health_*`) and some census boundaries (`census_*`).
- Added ability to retrieve and cache CDED ([BC Digital Elevation Model](https://catalogue.data.gov.bc.ca/dataset/digital-elevation-model-for-british-columbia-cded-1-250-000) data, returning either `stars` or `raster` objects (#73)
- Use of parallelism in functions that allow it (`raster_by_poly()` &
`summarize_raster_list()`) is now reliant on users setting up their
own `future::plan()` to specify strategy and number of workers, rather than setting
defaults (this is the best practice according to the author of the future package @HenrikBengtsson, #69)
- Fixed bug where errors would occur if a user's system GEOS was a development version (e.g., 3.9.0dev; #71)

# bcmaps 0.18.1

* Fixed an error where `fix_geo_problems()` would fail depending on the version
of `GEOS` upon which `sf` was built.
* `raster_by_poly()` fails informatively when there are `NA` values in
the column on which the polygons are to be split (#48, thanks @j-galloway)
* `raster_by_poly()` (and `summarize_raster_list()`) now uses the
[`future.apply`](https://cran.r-project.org/package=future.apply) package
for parallelism, enabling easy parallelization across platforms (#49)
* `get_layer()` (and in turn, any of the individual layer functions) now sets
the `crs` so the `crs` representation will always be up to date with the user's
`sf` version (#51, https://github.com/r-spatial/sf/issues/1225)

# bcmaps 0.18.0
* Added `bc_neighbours()` function to call layers containing adjacent jurisdictions.
* Ensured the `geometry` column in all layers is consistently named `"geometry"` (Thanks @boshek)
* Moving sf package to Depends to take advantage of sf print methods.
* Added `bc_bbox()` to get a bounding box for British Columbia (#40).
* All references to external data package now point to `bcmapsdata` because of this R bug (https://bugs.r-project.org/bugzilla/show_bug.cgi?id=17520)

# bcmaps v0.17.1
* Fixed an issue where `self_union()` would fail due to a change in the `raster` package (30cef3438)

# bcmaps 0.17.0
* Output of `available_layers()` has changed: `shortcut_function` column is now logical, uses better column names, and has a custom print function that gives more information. (#34)
* Add links to `combine_nr_rd()` function from `regional_districts()` and `municipalities()`. This function combines Regional Districts with the Northern Rockies Regional Municipalities to create a full provincial layer of 'Regional-District-like' polygons.
* Added Timber Supply Areas and BC cities shortcut function and to `available_layers()`
* `bec` (and other large downloadable layers) show up in the output of `available_layers()`, `bec()` works, and `get_layer("bec")` works so that getting downloadable datasets is indistinguishable from getting local datasets. (#32)
* Some utility functions use `sf` functions that have been moved to the `lwgeom` package. They now use the `lwgeom` function (Fixes CRAN CHECK NOTE; #33).
* Added new layer: `bc_cities()` which is a point layer of B.C.'s major cities.

# bcmaps 0.16.0
* First release to CRAN
* Added two new functions: `raster_by_poly` to overlay a SpatialPolygonsDataFrmae or sf polygons layer on a raster layer and clip the raster to each polygon, and `summarize_raster_list` to summarize the results of `raster_to_poly`

# bcmaps 0.15.1
* `get_layer()` now only accepts characters (#31)
* Fixes bug in `check_write_to_data_dir` where it was not creating data directory
* Update README installation instructions so that vignettes aren't built before bcmaps.rdata is installed (#29)

# bcmaps 0.15.0
* Added the ability to download Biogeoclimatic Zone map - as it was too big to
fit in the bcmaps.rdata package, it is hosted as an asset on a GitHub release of bcmaps.rdata,
and downloaded via the function `bec()`, which uses the new function `get_big_data()` (#28).
* Added function `bec_colours()` (and alias `bec_colors()`) to generate a vector of colours
that match the standard colours used to colour Biogeoclimatic Zone maps.

# bcmaps 0.14.0
* Changed the lookup for exported objected to `getNamespaceExports("bcmaps")` so that you can
call layers without loading the package via `bcmaps::`
* Removed `watersheds` layer from package
* Added `ecosections` to package

# bcmaps 0.13.0

This is a major new release with breaking changes.

All data has been removed from the `bcmaps` package and moved to the `bcmaps.rdata`
package, which is hosted on the bcgov drat repository: https://github.com/bcgov/drat.
That package must be installed in order for `bcmaps` to access the data. It can
be installed with: `install.packages('bcmaps.rdata', repos='https://bcgov.github.io/drat/')`

In previous versions of `bcmaps`, data was stored in the package and loaded by
calling `data("layername")` or simply `layername` (e.g., `data("bc_bound")` or `bc_bound`).

Now loading data requires a function call - either using a shortcut function that
is the same name as the dataset (e.g., `bc_bound()` whereas previously one would
simply use `bc_bound`). Alternatively, one can use the `get_layer()` function
(e.g., `get_layer("bc_bound")`).

Another major change is that all the layers are now returned as `sf` classes by
default, rather than `Spatial` classes. `Spatial` versions of the data can still be
obtained by setting the `class` argument to `"sp"` in `get_layer()` and the shortcut
functions (E.g., `bc_bound(class = "sp")` or `get_layer("bc_bound", class = "sp")`).

# bcmaps 0.12.0

* Added `wsc_drainages`

# bcmaps 0.11.0

* Added `hydrozones` dataset.

# bcmaps 0.10.1

* Fixed ring self-intersections in `bc_bound_hres` and `airzones` (#13)

# bcmaps 0.10.0

* Added `water_districts` and `water_precincts` datasets.

# bcmaps 0.9.0

* Added `gw_aquifers` dataset.

# bcmaps 0.8.2

* Added a `tries` argument to `fix_geo_problems` function to set the maximum number of iterations it should go through in attempting to repair topological issues.

# bcmaps 0.8.1

* Set character encoding of `watercourses_15M` and `watercourses_5M` datasets to UTF-8.

# bcmaps 0.8.0

* Added `watercourses_15M` and `watercourses_5M` datasets.

# bcmaps 0.7.1

* `fix_geo_problems` and `transform_bc_albers` are Generic functions with methods for `sf` objects as well as `Spatial` objects
* `fix_self_intersect` is now defunct

# bcmaps 0.6.2

* `fix_self_intersect` has been renamed to `fix_geo_problems` (but kept as an alias for now)
* `fix_geo_problems` can often also fix orphaned holes in addition to self-intersections.

# bcmaps 0.6.0

* Added `watersheds` dataset (#15, @markjohnsonubc)
* Added a `NEWS.md` file to track changes to the package.

# bcmaps 0.5.0

Added two new functions to create and work with SpatailPolygonsDataFrames with nested data frames:

- `self_union` performs a union on a single `SpatialPolygons*` object to take into account overlaps. Polygon attributes are combined in a nested dataframe.
- `get_poly_attribute` allows you to easily parse a nested data frame column (created by `self_union`) to extract or calculate the attributes you want

# bcmaps 0.4.0

Added a couple of convenience functions:

- `transform_bc_albers()` transforms a Spatial object to BC Albers projection
- `fix_self_intersect()` checks for and repairs self-intersecting polygons

# bcmaps 0.3.0

Added 3 Natural Resource layers (areas, regions and districts)

# bcmaps 0.2.0

Added high resolution BC boundaries (`bc_bound_hres`)

# bcmaps 0.1.0

Added `bc_area` function

repository: bcgov/bcmaps

branch_name: refs/heads/main

gha_language: R

repo_name: bcgov/bcmaps


text:
# Android Vulkan Validation Layers

This is a quick guide to get Vulkan validation layers support for a Flutter application. This guide assumes that you've created the application with `flutter create`, otherwise the locations might vary.

1. Download the validation layers from this [GitHub](https://github.com/KhronosGroup/Vulkan-ValidationLayers/releases) releases. Typically named `android-binaries-<IP_ADDRESS>.zip`.
2. When you unzip the file, you will see: `arm64-v8a  armeabi-v7a  x86  x86_64`
3. Copy these directories to `${FLUTTER_APP}/android/app/src/main/vklibs`. The layout should look similar to:

```
src/main/vklibs/
  arm64-v8a/
    libVkLayer_khronos_validation.so
  armeabi-v7a/
    libVkLayer_khronos_validation.so
  x86/
    libVkLayer_khronos_validation.so
  x86-64/
    libVkLayer_khronos_validation.so
```

4. Add the following line to `${FLUTTER_APP}/android/app/build.gradle`, `android > sourceSets` section: `main.jniLibs.srcDirs += 'src/main/vklibs'`.

5. This should enable Vulkan validation layers on your Android application.

repository: jnschulze/flutter-engine

repo_name: jnschulze/flutter-engine


text:
# Notero

A [Zotero plugin](https://www.zotero.org/support/plugins) that syncs items into
a [Notion database](https://www.notion.so/Intro-to-databases-fd8cd2d212f74c50954c11086d85997e)
when added to a specific collection.

Scaffolded with [generator-zotero-plugin](https://github.com/retorquere/generator-zotero-plugin)
and built with [zotero-plugin-webpack](https://github.com/retorquere/zotero-plugin-webpack).

![Notero in action](docs/notero.gif)

## Why use Notero?

- Allows you to integrate your reference manager, task list, reading notes,
  analytical tables, and drafts in one location.
- The name of database entries is the in-text citation, which allows you to
  easily link to references when writing in Notion.
- Create custom views to filter and sort large reference lists by project,
  tag, author, etc.
- Backlinks make it easy to locate any of the notes and drafts that mention
  a reference.
- Link references to entries in other databases, such as projects, tasks,
  manuscripts in your publication pipeline, publishing outlets, etc.

## Installation and Setup

The [latest release](https://github.com/dvanoni/notero/releases/latest) of the
plugin is available on GitHub.

Detailed setup instructions are below.

### Configure Notion

1.  Obtain a Notion internal integration token from https://www.notion.com/my-integrations.

    - See [Notion developer docs](https://developers.notion.com/docs/getting-started#step-1-create-an-integration)
      for detailed instructions.

1.  Create the database that you would like to sync Zotero items into.

    - See [examples](#example-notion-databases) below that you can duplicate
      into your Notion workspace.

1.  Share the database with the integration you created in step 1.

    - See [Notion developer docs](https://developers.notion.com/docs/getting-started#step-2-share-a-database-with-your-integration)
      for detailed instructions.

1.  Ensure the database has the following required properties:

    | Property Name      | Property Type |
    | ------------------ | ------------- |
    | `Name`\*           | Title         |
    | `Item Type`        | Select        |
    | `Title`            | Text          |
    | `Authors`          | Text          |
    | `Year`             | Number        |
    | `DOI`              | URL           |
    | `URL`              | URL           |
    | `Zotero URI`       | URL           |
    | `Full Citation`    | Text          |
    | `In-Text Citation` | Text          |

    \* The title property can be named something other than `Name` as long as
    it does not conflict with any of the other property names.

1.  Take note of the database ID.

    - From the [Notion developer docs](https://developers.notion.com/docs/working-with-databases#adding-pages-to-a-database),
      here's a quick procedure to find the database ID:

      > Open the database as a full page in Notion. Use the **Share** menu to
      > **Copy link**. Now paste the link in your text editor so you can take a
      > closer look. The URL uses the following format:
      >
      >     https://www.notion.so/{workspace_name}/{database_id}?v={view_id}
      >
      > Find the part that corresponds to `{database_id}` in the URL you pasted.
      > It is a 36 character long string. This value is your database ID.

### Install Notero Plugin

1. Download the [latest version](https://github.com/dvanoni/notero/releases/latest)
   of the `.xpi` file.
1. Open the Zotero Add-ons Manager via the **Tools → Add-ons** menu item.
1. Install the `.xpi` file by either:
   - dragging and dropping it into the Add-ons Manager window _or_
   - selecting it using the **Install Add-on From File...** option in the
     gear menu in the top-right corner of the window
1. Restart Zotero to activate the plugin.

### Configure Notero Preferences

1.  Open the Notero preferences from the **Tools → Notero Preferences...** menu item.
1.  Enter the required preferences:

    | Field                    | Description                                            |
    | ------------------------ | ------------------------------------------------------ |
    | Collection Name          | Name of the Zotero collection to monitor for new items |
    | Notion Integration Token | Your personal Notion internal integration token        |
    | Notion Database ID       | ID of the Notion database to sync items into           |

## Example Notion Databases

We provide some example Notion databases that have been configured with all the
properties required by Notero.

Once you've opened one of the examples, click the **Duplicate** button in the
top-right corner of the page to duplicate it into your Notion workspace.

### [Basic Example](https://dvanoni.notion.site/5ba9956716ac4218be77d2b4655911f5)

An empty database that contains only the required properties.
Useful if you want to start from scratch and customize it yourself.

### [Advanced Example](https://dvanoni.notion.site/79b17005bc374209b0f373b1a3cde0ae)

A database with multiple views and some sample entries.
See below for descriptions of how you can use the different views.

#### Bibliographic Info Table View

- Table view enables easy editing of entries.
- Easily navigate to the original source by clicking on the `DOI` or `URL` property.
  - DOIs for books may need to be copy & pasted manually from the `Extra`
    field in Zotero.
- Click on the `Zotero URI` property to view/edit the entry in Zotero or to
  export the bibliography entry in a different citation style.

#### Reading Status Board View

- Keep track of promising references you need to locate, books and articles you
  requested via interlibrary loan, and works that are relevant enough to warrant
  taking in-depth notes or writing a memo.

#### Literature Review Table View

- Quickly analyze and compare attributes of literature you are reviewing
  (e.g., theoretical framework, sample, methods used, key findings, etc.)
- Easily link to other works using the `Related References` property
  (e.g., articles in the same special issue, book chapters in the same edited
  book, studies and commentary that respond to or extend other works).

#### Books Gallery View

- Add a cover image (e.g., right click → copy image address from Amazon).
- Keep track of which books you own, borrow, and lend to others.
  - Add due dates and reminders for library books and interlibrary loans.

## Developer Setup

The steps below should allow you to build and run Notero yourself.

1.  To avoid any potential damage to your default Zotero profile, you can
    [create a new profile](https://www.zotero.org/support/kb/multiple_profiles)
    for development purposes.

1.  [Configure Zotero](https://www.zotero.org/support/dev/client_coding/plugin_development)
    to run the plugin directly from source. Because the `start` script already
    handles most of the steps, you only need to ensure your
    [Zotero profile directory](https://www.zotero.org/support/kb/profile_directory)
    has a directory named `extensions`.

    - **Note:** The `start` script does not currently support Windows.
      If developing on Windows, you will need to follow all the configuration
      steps in the Zotero docs.

1.  Create a `profile.json` file by copying [`profile.json.example`](profile.json.example).
    This file is used by the [`zotero-start`](https://github.com/retorquere/zotero-plugin-webpack/blob/bc5532000c8b395792ab82e381b5493a8ebd9cfd/bin/start.ts)
    command to determine where to install the extension when running a
    development build.

    - `dir` is the absolute path to your [Zotero profile directory](https://www.zotero.org/support/kb/profile_directory)
    - `log` is the name of the file that Zotero debug output will be written to
    - `name` is the name of your Zotero profile (e.g. `default`)

1.  Install dependencies:

        npm ci

1.  Build the plugin and start Zotero with it installed:

        npm start

    The `start` script runs [`zotero-start`](https://github.com/retorquere/zotero-plugin-webpack/blob/bc5532000c8b395792ab82e381b5493a8ebd9cfd/bin/start.ts)
    which performs a number of steps:

    1.  Executes `npm run build` to build the plugin into the `build/` directory.
    1.  Removes the `extensions.json` file and Notero `.xpi` file from your
        Zotero profile directory.
    1.  Writes a new `.xpi` file containing the absolute path to the `build/` directory.
    1.  Starts Zotero with the profile specified in `profile.json` and the
        following command line arguments:

            -purgecaches -jsconsole -ZoteroDebugText

    If you would like to see the commands without executing them, you can run:

        npm start -- --dryRun


text:
# Boring Political Project!

This project lets the user search for a current issue that they want to learn more about. The user is given information about upcoming bills relevant to their search and contact information for their state's congress members.

<!-- 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**  *generated with [DocToc](https://github.com/thlorenz/doctoc)*

- [Tech Used](#tech-used)
- [API Reference](#api-reference)
- [Installation](#installation)
- [Functionality](#functionality)
- [License](#license)
- [In Retrospect](#in-retrospect)
- [Next Steps](#next-steps)
- [Group Members Responsibilities](#Group-Members'-Responsibilities)

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

## Tech Used

- less.js
- Bootstrap
- Firebase
- interact.js
- jQuery

### API

- ProPublica Congress
- Google Civic Information
- Geolocation
- Mapquest Reverse Geocode

## Installation

* Copy the remote URL of this repo
![alt text](https://lh3.googleusercontent.com/DIjmHnofZp2YCO6VsG5mdSe-uHXwAbO9m7XdVEMSZH8nwhNZFXYUiOZiloiO2uPlKEQQN2Cbc30CR_CXMXKOj_gDOnlydnZOJS_G4a4145iHxHPnZZqqEXR0ML2NnIK88i5LHJGFXQ=w2400)

* Open Git Bash
* cd Desktop
* 'git clone + URL'
![alt text](https://lh3.googleusercontent.com/7pbUSRtNFW88br-mFMZSH0uRVYR8ftJbhTvg8NqdggxJC6Rbvn-ep86q2EN1HXJhHJCOEtk25NapszE7hjPjs4Sbfpv001mGVsaYtjBOPld-_3wtY9Osb_bE_KZnfn2vZYndoM-IZQ=w2400)

## Functionality
* User searches for topic
* User can drag and drop bills to learn more about them
* If they choose, user can click get involved button
* 'Get Involved' button asks for user's location
* Based on user's location, representatives will be shown

## License

[MIT License](https://github.com/scoslo5512/Project1/blob/geolocation-work/LICENSE)

## In Retrospect
* Start think about accessibility early on!!
* Use ESLint, Gulp - other task runners

## Next Steps

* When congressional people are shown - we would like to show how these people have previously voted on issues
* Breaking data down to show more local representatives
* Incorporate Tweets from politicians (able to obtain twitter handles from Google Civic API)

## Group Members' Responsibilities

* Project Management & Information Architecture: Maddy
* Interface/Experience Design: Majid
* Web Content and Technology: Cavan
* Web Development and Production: Robert and Dan
* Quality Assurance and Editing: Group

## Link to Deployed App
Heroku version (from branch "heroku_ready"):
https://boringpoliticalapp.herokuapp.com/

repository: Danielthweatt/Boring-Political-App

repo_name: Danielthweatt/Boring-Political-App


text:
# RExtension
Frequently used extension classes which include some convenience methods and manipulations.

# How to use
Just add Extensions folder into your project.

# Extensions
* UIView
* UIImage
* UIImageView
* UITableView
* UITextField
* UIViewController
* UIWindow
* UIButton
* UINavigationController
* String
* UISlider
* Dictionary
* Array

# TODO
Date extensions and other enhancements.

# Author

* [Raj Sharma](https://github.com/rheyansh)
* [Web](http://rajsharma.online/)

## Communication

* If you **want to contribute**, submit a pull request.

# License
RExtension is available under the MIT license. See the LICENSE file for more info.

repository: rheyansh/RExtension

repo_name: rheyansh/RExtension


text:
# Vault with legacy application

A Vagrant project that demonstrates how to use Vault with an application which reads its configuration information from environment variables.

Upon start the Vagrant VM has a mysql database and vault installed as well as an application that uses a mysql database and reads its access credentials from environment variables.

Vault is configured with a database secret engine so that it can generate ephemeral credentials for access to mysql.

We use a tool - `envconsul` to launch the application. What it does is read secrets from Vault and then launch an application in a sub process where the secrets are set in environment variables. This way applications that get their configuration from environment variables can be used with Vault with minimum to no code changes.

## Prerequisites

* Install VirtualBox - [instructions](https://www.virtualbox.org/wiki/Downloads)
* Install Vagrant - [instructions](https://www.vagrantup.com/downloads.html)

## Running the project

* Start the Vagrant VM - `vagrant up`
* Login to the VM - `vagrant ssh`
* Launch the application with `envconsul` - `/vagrant/app_launcher.sh`

The application itself - `/vagrant/app.sh` - is not aware of Vault. It reads its database access credentials form environment variables.

Every time that the application is launched it will be provided with a different set of credentials.

This demonstrates how Vault can solve the problems presented by static credentials set in configuration files. They have a much higher chance to be leaked and are usually difficult and slow to be replaced.

Instead we have every application instance use different set of temporary credentials every time it is launched. This provides multiple advantages:

* Even if credentials are leaked they will expire
* Disabling a set of credentials will affect a single application instance as opposed to all instances of multiple applications
* Every action taken on the database can be traced to a specific application instance based on the credentials used to perform it

repository: slavrd/vault-legacy-app

repo_name: slavrd/vault-legacy-app


text:
# BotLuisHelper
Helper utilities for Bot Framework projects with LUIS utterances.

Replace placeholder info in the following files. Make sure you move config info to config files.

Better yet: Here's an old blog post that talks about how to move config info out of config files to easily avoid committing config info to source control
http://wakeupandcode.com/all-your-database-are-belong-to-us

# Project: LuisConsoleApp
## File: Program.cs

```
static string appID = "<APP_ID>";
static string appVersion = "0.1";
static string key = "<APP_KEY>";
```

# Project: CosmosUtteranceHelper
## File: Program.cs

```
private const string EndpointUrl = "https://<COSMOS_DB>.documents.azure.com:443/";
private const string PrimaryKey = "<COSMOS_KEY>";
private string dbName = "<COSMOS_DB>";
private string collName = "<COSMOS_COLL>";
```

# Project: LuisWebApi
## File: TrainController.cs

```
static string appID = "<APP_ID>";
static string appVersion = "0.1";
static string key = "<APP_KEY>";
```

repository: shahedc/BotLuisHelper

repo_name: shahedc/BotLuisHelper


text:
# Authservice

An implementation of [Envoy](https://envoyproxy.io) [External Authorization](https://www.envoyproxy.io/docs/envoy/latest/configuration/http/http_filters/ext_authz_filter),
focused on delivering authN/Z solutions for [Istio](https://istio.io) and [Kubernetes](https://kubernetes.io).

## Overview

`authservice` helps delegate the [OIDC Authorization Code Grant Flow](https://openid.net/specs/openid-connect-core-1_0.html#CodeFlowAuth)
to the Istio mesh. `authservice` is compatible with any standard OIDC Provider as well as other Istio End-user Auth features,
including [Authentication Policy](https://istio.io/docs/tasks/security/authn-policy/) and [RBAC](https://istio.io/docs/tasks/security/rbac-groups/).
Together, they allow developers to protect their APIs and web apps without any application code required.

```mermaid
graph LR
  pod("URL") --> authservice
  envoyfilter --> |redirect| pod2("IdP")
  pod2 --> |token| apppods

  subgraph "Authservice"
    subgraph "Any Namespace"
      apppods("Application Pod(s)")
    end

    subgraph "istio-system Namespace"
      envoyfilter{{"Envoy Filter"}}
    end

    subgraph "Authservice Namespace"
      authservice{{"Authservice Service"}} --> envoyfilter
    end

  end

  subgraph "Session Storage (Redis)"
    authservice --> database3[("Authservice DB")]
  end

  subgraph "Logging"
    authservice --> fluent(Fluentbit) --> logging-ek-es-http
    logging-ek-es-http{{Elastic Service<br />logging-ek-es-http}} --> elastic[(Elastic Storage)]
  end
```

## Big Bang Touch Points

### Licensing

[Authservice](https://github.com/istio-ecosystem/authservice) utilizes an Apache-2.0 License. The Iron Bank repo for the hardened authservice image can be found [here](https://repo1.dso.mil/dsop/istio-ecosystem/authservice) and the Big Bang repo for the authservice Helm Chart can be found [here](https://repo1.dso.mil/platform-one/big-bang/apps/core/authservice).

### Single Sign On

Authservice provides OIDC Single Sign On capabilities for apps that don't have native support.

Pods just need to have istio-injection, a single label which by default is `protect=keycloak` applied to the pods, and a corresponding chain to load into authservice.

```yaml
spec:
  template:
    metadata:
      labels:
        protect: keycloak
```

If you need to guarantee that authservice protects everything behind istio-ingressgateway, you can label ingressgateway instead of individual applications.

```yaml
istio:
  ingressGateways:
    public-ingressgateway:
      extraLabels:
        protect: keycloak
```

This label can be adjusted via following values in the Big Bang chart:

```yaml
addons:
  authservice:
    values:
      selector:
        key: protect
        value: keycloak
```

The corresponding chain loaded in to authservice via the values in the Big Bang chart:
For more information see the [README.md](https://repo1.dso.mil/platform-one/big-bang/apps/core/authservice/-/blob/main/README.md) in the Authservice package.

```yaml
addons:
  authservice:
    chains:
      example:
        callback_uri: ...
        match: ...
        client_id: ...
        client_secret: ...
```

### Storage

Authservice can be configured to use a redis server for distributed state storage. This Redis instance is used for OIDC token storage/retrieval.

```yaml
addons:
  authservice:
    redis:
      host: "redis.mydomain.com"
      port: "6379"
      password: "password"
```

### High Availability

When setting `replicaCount` above `1`, Authservice will utilize an HA redis deployment, but it can also be configured to use an external redis such as Elasticache.

Authservice also utilizes a horizontal pod autoscaler, which can be configured with min & max replicas and target CPU & memory utilization:

```yaml
addons:
  authservice:
    values:
      replicaCount: 2
      autoscaling:
        enabled: false
        minReplicas: 1
        maxReplicas: 3
        targetCPUUtilizationPercentage: 80
        targetMemoryUtilizationPercentage: 80
```

### UI

There is no UI feature for authservice.

### Logging

Within Big Bang, logs are captured by fluentbit and shipped to elastic by default.

### Health Checks

The authservice Dockerfile includes a [healthcheck](https://repo1.dso.mil/dsop/istio-ecosystem/authservice/-/blob/master/Dockerfile#L23-24) and the authservice Helm Chart includes [liveness & readiness probes](https://repo1.dso.mil/platform-one/big-bang/apps/core/authservice/-/blob/main/chart/templates/deployment.yaml#L42-47) in its deployment:

```yaml
livenessProbe:
  tcpSocket:
    port: 10003
readinessProbe:
  tcpSocket:
    port: 10003
```

### Dependent Packages

When setting `replicaCount` above `1`, a redis configuration is required.


text:
# [Conversion to Python](@id jl2py)

## Conversion Rules

From Julia, one converts Julia objects to Python explicitly using `Py(x)` or implicitly by passing the value to one of the many other functions, such as `pygetattr(x, "append")`.

From Python, calling a Julia function or indexing a Julia object, etc., will convert the result to some Python object.

The following table specifies the conversion rules used whenever converting a Julia object to a Python object.

The user can always explicitly choose a different conversion (e.g. by calling `pylist` or `pydict`).

| From                                                                | To                                                      |
| :------------------------------------------------------------------ | :------------------------------------------------------ |
| Any Python object type (`Py`, `PyList`, etc.)                       | itself                                                  |
| `Nothing`, `Missing`                                                | `None`                                                  |
| `Bool`                                                              | `bool`                                                  |
| Standard integer (`IntXX`, `UIntXX`, `BigInt`)                      | `int`                                                   |
| Standard rational (`Rational{T}`, `T` a standard integer)           | `fractions.Fraction`                                    |
| Standard float (`FloatXX`)                                          | `float`                                                 |
| Standard complex (`Complex{T}`, `T` a standard float)               | `complex`                                               |
| Standard string/char (`String` and `SubString{String}`, `Char`)     | `str`                                                   |
| `Tuple`                                                             | `tuple`                                                 |
| Standard integer range (`AbstractRange{T}`, `T` a standard integer) | `range`                                                 |
| `Date`, `Time`, `DateTime` (from `Dates`)                           | `date`, `time`, `datetime` (from `datetime`)            |
| `Second`, `Millisecond`, `Microsecond`, `Nanosecond` (from `Dates`) | `timedelta` (from `datetime`)                           |
| `Number`                                                            | `juliacall.NumberValue`, `juliacall.ComplexValue`, etc. |
| `AbstractArray`                                                     | `juliacall.ArrayValue`, `juliacall.VectorValue`         |
| `AbstractDict`                                                      | `juliacall.DictValue`                                   |
| `AbstractSet`                                                       | `juliacall.SetValue`                                    |
| `IO`                                                                | `juliacall.BufferedIOValue`                             |
| `Module`                                                            | `juliacall.ModuleValue`                                 |
| `Type`                                                              | `juliacall.TypeValue`                                   |
| Anything else                                                       | `juliacall.AnyValue`                                    |

See below for an explanation of the `juliacall.*Value` types.

## [Wrapper types](@id julia-wrappers)

Apart from a few fundamental immutable types, all Julia values are by default converted into Python to some [`AnyValue`](#juliacall.AnyValue) object, which wraps the original value, but giving it a Pythonic interface.

Some types are converted to a subclass of [`AnyValue`](#juliacall.AnyValue) which provides additional Python semantics --- e.g. Julia vectors are interpreted as Python sequences.

There is also a [`RawValue`](#juliacall.RawValue) object, which gives a stricter "Julia-only" interface, documented below. These types all inherit from `ValueBase`:

- `ValueBase`
  - [`RawValue`](#juliacall.RawValue)
  - [`AnyValue`](#juliacall.AnyValue)
    - [`NumberValue`](#juliacall.NumberValue)
      - `ComplexValue`
      - `RealValue`
        - `RationalValue`
        - `IntegerValue`
    - [`ArrayValue`](#juliacall.ArrayValue)
      - `VectorValue`
    - [`DictValue`](#juliacall.DictValue)
    - [`SetValue`](#juliacall.SetValue)
    - [`IOValue`](#juliacall.IOValue)
      - `BinaryIOValue`
      - `TextIOValue`
    - [`ModuleValue`](#juliacall.ModuleValue)
    - [`TypeValue`](#juliacall.TypeValue)

`````@customdoc
juliacall.AnyValue - Class

Wraps any Julia object, giving it some basic Python semantics. Subtypes provide extra semantics.

Supports `repr(x)`, `str(x)`, attributes (`x.attr`), calling (`x(a,b)`), iteration, comparisons, `len(x)`, `a in x`, `dir(x)`.

Calling, indexing, attribute access, etc. will convert the result to a Python object according to [this table](@ref jl2py). This is typically a builtin Python type (for immutables) or a subtype of `AnyValue`.

Attribute access can be used to access Julia properties as well as normal class members. In the case of a name clash, the class member will take precedence. For convenience with Julia naming conventions, `_b` at the end of an attribute is replaced with `!` and `_bb` is replaced with `!!`.

###### Members
- `_jl_raw()`: Convert to a [`RawValue`](#juliacall.RawValue). (See also [`pyjlraw`](@ref).)
- `_jl_display()`: Display the object using Julia's display mechanism.
- `_jl_help()`: Display help for the object.
`````

`````@customdoc
juliacall.NumberValue - Class

This wraps any Julia `Number` value. It is a subclass of `numbers.Number` and behaves similar to other Python numbers.

There are also subtypes `ComplexValue`, `RealValue`, `RationalValue`, `IntegerValue` which wrap values of the corresponding Julia types, and are subclasses of the corresponding `numbers` ABC.
`````

`````@customdoc
juliacall.ArrayValue - Class

This wraps any Julia `AbstractArray` value. It is a subclass of `collections.abc.Collection`.

It supports zero-up indexing, and can be indexed with integers or slices. Slicing returns a view of the original array.

There is also the subtype `VectorValue` which wraps any `AbstractVector`. It is a subclass of `collections.abc.Sequence` and behaves similar to a Python `list`.

If the array is strided and its eltype is supported (i.e. `Bool`, `IntXX`, `UIntXX`, `FloatXX`, `Complex{FloatXX}`, `Ptr{Cvoid}` or `Tuple` or `NamedTuple` of these) then it supports the buffer protocol and the numpy array interface. This means that `numpy.asarray(this)` will yield a view of the original array, so mutations are visible on the original.

Otherwise, the numpy `__array__` method is supported, and this returns an array of Python objects converted from the contents of the array. In this case, `numpy.asarray(this)` is a copy of the original array.

###### Members
- `ndim`: The number of dimensions.
- `shape`: Tuple of lengths in each dimension.
- `copy()`: A copy of the array.
- `reshape(shape)`: A reshaped view of the array.
`````

`````@customdoc
juliacall.DictValue - Class
This wraps any Julia `AbstractDict` value. It is a subclass of `collections.abc.Mapping` and behaves similar to a Python `dict`.
`````

`````@customdoc
juliacall.SetValue - Class
This wraps any Julia `AbstractSet` value. It is a subclass of `collections.abc.Set` and behaves similar to a Python `set`.
`````

`````@customdoc
juliacall.IOValue - Class

This wraps any Julia `IO` value. It is a subclass of `io.IOBase` and behaves like Python files.

There are also subtypes `BinaryIOValue` and `TextIOValue`, which are subclasses of `io.BufferedIOBase` (buffered bytes) and `io.TextIOBase` (text).
`````

`````@customdoc
juliacall.ModuleValue - Class
This wraps any Julia `Module` value.

It is the same as [`AnyValue`](#juliacall.AnyValue) except for one additional convenience method:
- `seval([module=self], code)`: Evaluates the given code (a string) in the given module.
`````

`````@customdoc
juliacall.TypeValue - Class

This wraps any Julia `Type` value.

It is the same as [`AnyValue`](#juliacall.AnyValue) except that indexing is used to access Julia's "curly" syntax for specifying parametric types:

```python
from juliacall import Main as jl
# equivalent to Vector{Int}() in Julia
jl.Vector[jl.Int]()
```
`````

`````@customdoc
juliacall.RawValue - Class

Wraps any Julia value with a rigid interface suitable for generic programming.

Supports `repr(x)`, `str(x)`, attributes (`x.attr`), calling (`x(a,b)`), `len(x)`, `dir(x)`.

This is very similar to [`AnyValue`](#juliacall.AnyValue) except that indexing, calling, etc. will always return a `RawValue`.

Indexing with a tuple corresponds to indexing in Julia with multiple values. To index with a single tuple, it will need to be wrapped in another tuple.

###### Members
- `_jl_any()`: Convert to a [`AnyValue`](#juliacall.AnyValue) (or subclass). (See also [`pyjl`](@ref).)
`````


text:
# Shared White Board Using Signalling

This app shows how to use `Signalling APIs` to create a shared white board sample in native android.

## Setup

Sign up on Vonage Video API, create an API KEY, then generate a sessionID and token to run Video session. The token should have Publisher role. Add the details under API_KEY, SESSION_ID and TOKEN in OpentokConfig.java

## Demo Video
[![Demo](https://img.youtube.com/vi/Md8qePgqpik/0.jpg)](https://www.youtube.com/watch?v=Md8qePgqpik)

repository: video-ot-samples/OTSharedWhiteBoard

repo_name: video-ot-samples/OTSharedWhiteBoard


text:
# Scalar Product
====

@author Manuel Valle

@date   Febrero 2015

-----

# Problem

You are given two vectors v1=(x1,x2,...,xn) and v2=(y1,y2,...,yn). The scalar product of these vectors is a single number, calculated as x1y1+x2y2+...+xnyn.

Suppose you are allowed to permute the coordinates of each vector as you wish. Choose two permutations such that the scalar product of your two new vectors is the smallest possible, and output that minimum scalar product.

# Input

The first line of the input file contains integer number T - the number of test cases. For each test case, the first line contains integer number n. The next two lines contain n integers each, giving the coordinates of v1 and v2 respectively.

# Output

For each test case, output a line

`Case #X: Y`
where X is the test case number, starting from 1, and Y is the minimum scalar product of all permutations of the two given vectors.

------

Original problem on Google code jam
https://code.google.com/codejam/contest/32016/dashboard

repository: Nearsoft/google-code-jam

repo_name: Nearsoft/google-code-jam


text:
# How to run Minio in FreeNAS [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/minio/minio?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

In this recipe we will learn how to run Minio with FreeNAS.

## 1. Prerequisites

* You have FreeNAS installed and running, if not follow [install instructions](http://doc.freenas.org/9.10/install.html)
* You have a FreeNAS Jail path set, if not follow [jails configuration](http://doc.freenas.org/9.10/jails.html#jails-configuration)

## 2. Installation Steps

### Create a new Jail
Browse to `Jails -> Add Jail` in the FreeNAS UI, click `Advanced` and enter the following settings:

```
Name:         Minio
Template:     --- (unset, defaults to FreeBSD)
VImage:       Unticked
```

Configure relevant network settings for your environment. Click `OK` and wait for Jail to download and install.

### Attach Storage
Browse to `Jails -> View Jails -> Storage`, click `Add Storage` and enter the following settings:

```
Jail:             Minio
Source:           </path/to/your/dataset>
Destination:      </path/to/your/dataset/inside/jail> (usually the same as 'Source' dataset for ease of use)
Read Only:        Unticked
Create Directory: Ticked
```

### Download Minio
Download Minio into the jail:

```
curl -Lo/<jail_root>/Minio/usr/local/bin/minio https://dl.minio.io/server/minio/release/freebsd-amd64/minio
chmod +x /<jail_root>/Minio/usr/local/bin/minio
```

### Create Minio Service
Create a new Minio service file:

```
touch /<jail_root>/Minio/usr/local/etc/rc.d/minio
chmod +x /<jail_root>/Minio/usr/local/etc/rc.d/minio
nano /<jail_root>/Minio/usr/local/etc/rc.d/minio
```

Add the following content:

```
#!/bin/sh

# PROVIDE: minio
# KEYWORD: shutdown

# Define these minio_* variables in one of these files:
#       /etc/rc.conf
#       /etc/rc.conf.local
#       /etc/rc.conf.d/minio
#
# DO NOT CHANGE THESE DEFAULT VALUES HERE
#

# Add the following lines to /etc/rc.conf to enable minio:
#
#minio_enable="YES"
#minio_config="/etc/minio"

minio_enable="${minio_enable-NO}"
minio_config="${minio_config-/etc/minio}"
minio_disks="${minio_disks}"
minio_address="${minio_address-:443}"

. /etc/rc.subr

load_rc_config ${name}

name=minio
rcvar=minio_enable

pidfile="/var/run/${name}.pid"

command="/usr/sbin/daemon"
command_args="-c -f -p ${pidfile} /usr/local/bin/${name} -C \"${minio_config}\" server --address=\"${minio_address}\" ${minio_disks}"

run_rc_command "$1"
```

### Configure Minio Startup
Edit `/<jail_root>/Minio/etc/rc.conf`:

```
nano /<jail_root>/Minio/etc/rc.conf
```

Add the following content:

```
minio_enable="YES"
minio_config="/etc/minio"
minio_disks="</path/to/your/dataset/inside/jail>"
minio_address="<listen address / port>" (Defaults to :443)
```

### Create Minio config directories

```
mkdir -p /<jail_root>/Minio/etc/minio/certs
```

### Create Minio Private and Public Keys (Optional, if HTTPS required and `minio_address` set on port 443)

```
nano /<jail_root>/Minio/etc/minio/certs/public.crt
nano /<jail_root>/Minio/etc/minio/certs/private.key
```

### Start Minio Jail
Browse to `Jails -> View Jails` in the FreeNAS UI, select `Minio` and press the `Start` button (3rd from Left):

### Test Minio
Browse to `http(s)://<ip_address>:<port>` and confirm Minio loads.

repository: cloudberrylab/cookbook

repo_name: cloudberrylab/cookbook


text:
# Dotifles
My dotfiles, using [Parabola Linux](http://https://www.parabola.nu/)  with [sway](http://https://github.com/swaywm/sway).
If you care about the long-term usability of your setup, you should probably consider moving to a wayland-capable environment, it is the [future](https://www.phoronix.com/scan.php?page=news_item&px=X.Org-Maintenance-Mode-Quickly)

Organized using [stow](http://brandon.invergo.net/news/2012-05-26-using-gnu-stow-to-manage-your-dotfiles.html). Run `stow $folder` from inside `~/dotfiles`. This creates symlinks to the configs, and now they can be updated via `git pull`.

Please create backups before trying things out!

| Name           | Stow dir | Dependencies                                         | Details                                          |
| :------------- | :------- | :--------------------------------------------------- | :----------------------------------------------- |
| zsh            | `$HOME`  | zplug                                                | shell                                            |
| vim            | `$HOME`  | vim-plug YouCompleteMe cppman                      | text editing                                     |
| termite        | `$HOME`  |                                                      | terminal                                         |
| sway           | `$HOME`  | rofi grim mako alsa-utils mpc task passmenu clipmenu networkmanager_dmenu udiskie redshift-wlr | wayland compositor
| newsboat       | `$HOME`  | qutebrowser trans wl-clipboard umpv mpv gvim            | RSS reader
| ncmpcpp        | `$HOME`  | mpd                                                  | mpd client
| ranger         | `$HOME`  |                                                      | file browser
| zathura        | `$HOME`  |                                                      | pdf viewer

i3, polybar and xorg are leftovers from an old config, left here because sometimes I need xorg for vidyas.

| Name           | Stow dir | Dependencies                                         | Details                                          |
| :------------- | :------- | :--------------------------------------------------- | :----------------------------------------------- |
| i3             | `$HOME`  | feh, scrot, rofi, wmctrl, i3lock-color, i3lock-fancy, compton | Window manager                             |
| xorg           | `$HOME`  | xinit, colors, xcape, unclutter, numlockx                         | |
| polybar        | `$HOME`  | | |

# Thanks

[SicariusNoctis](http://github.com/SicariusNoctis/dotfiles), whose reddit posts made me aware of this whole i3 thing, a lot of things here are based on his dotfiles
[mohlerm](http://github.com/mohlerm/dotfiles) whose display and scrot setup I adopted
[szorfein](http://github.com/szorfein/dotfiles) current polybar setup is based on his
Any other place that I might have copied scripts and code snippets from, and all the vim plugin creators - you make life hella easy.

repository: Kreest/dotfiles

repo_name: Kreest/dotfiles


text:
Project Name: Pingpong
Project Author: Daniel Muchiri
This program runs on the basis of when >numbers divisible by 3 become ping,numbers divisible by 5 become pong and numbers divisible by 3 and 5 become pingpong as stated on the instructions.
The project is located under the following GITHUB page https://github.com/daydroidmuchiri/pingpong.git
This program runs on all web browsers on all operating systems.
The program was built using atom text editor with inputs from bootstrap and jquery.
The project is licensed under the MIT License.See the LICENSE.md file for details.
The program was built with a little guidance from Moringa school technical mentors.

repository: daydroidmuchiri/pingpong-project

repo_name: daydroidmuchiri/pingpong-project


text:
# Changelog of [exit-process-with-error][repository-github-url]

All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog][keep-a-changelog-spec-url] and this project adheres to [Semantic Versioning][semantic-versioning-spec-url].

## [Unreleased]

### [develop]
#### Added
- chore(*): define brew dependencies [[e440920]]
#### Changed
- style(mate): increase wrap column width [[2225131]]
- style(src): fit code into new line width [[22c4dd4]]
- refactor(lib): finalize ts-node migration [[239b88b]]
- refactor(scripts): finalize rename script ts-node migration [[98f921d]]
- refactor(scripts): finalize provide script ts-node migration [[0ccdcf6]]
- refactor(scripts): migrate start script to ts-node [[0b27d03]]
- refactor(scripts): finalize npm scripts ts-node migration [[72dfe5b]]
#### Fixed
- fix(src): make spec work [[09e5e58]]
- fix(src): reduce stryker runtime errors
#### Security
- chore(*): update dev-deps and engines, again [[bc421f0]]
- chore(scripts): add package.json interface to lib [[9cf9bb4]]
- chore(*): migrate ts-node to strict mode [[a400f24]]
- chore(src): migrate tsc to strict mode [[c64c1dd]]

### [master]
#### Added
- init(*): create project [[3f49e30]]
- chore(*): provide project mvp [POC | [a3450e0]]
- chore(*): improve project infrastructure [POC | [b36daea]]
- chore(*): restructure build output layout [POC | [ef117d7]]
- docs(readme): add getting started section [[4b3e7d4]]
- chore(*): implement production build [[#2] | [c3a485b]]
- docs(readme): add example section [[17f2a4e]]
- chore(*): extend project library [[bdb4e41]]
#### Changed
- docs(readme): link develop branch [[972703a]]
- docs(readme): move bomb emoji [[579b2d4]]
- docs(readme): replace bomb emoji [[51fbd3b]]
- refactor(*): remove npm package scope [[3f0ee43]]
- refactor(mate): remove npm package scope [[49f2ae6]]
- chore(*): update travis configuration [[ae646d5]]
- docs(readme): add badges/shields [[fb5ad3b]]
- docs(readme): switch badges/shields [[db7457e]]
- docs(*): make license a plain file [[63ec1b8]]
- docs(license): refresh template [[4792af8]]
- docs(log): update changelog [[67a7292]]
- docs(log): update changelog, again [[40f0ace]]
- docs(readme): update badges/shields [[c446f09]]
- chore(*): refactor npm scripts [[b71b777]]
- chore(*): softly migrate scripts to ts-node [[0a1db76]]
- docs(log): update changelog once more [[16a5a6b]]
#### Deprecated
- chore(*): drop es5 support [[#1] | [c700b02]]
#### Fixed
- fix(license): use template [[51f4711]]
- fix(*): provide declaration in production build [[8e1d126]]
- fix(*): support node <10 in build process [[c6f979d]]
- fix(ci): increase stryker timeout [[01d3999]]
- fix(ci): increase stryker timeout, again [[08e00a7]]
- fix(code): use template [[8dca1bf]]
#### Security
- chore(*): update dev-deps and excludes [[a9a433b]]
- chore(*): update engines [[08293a1]]
- chore(*): update dev-deps [[8a23c67]]
- chore(*): update dev-deps again [[65d6455]]
- chore(*): implement travis-ci [[a4248db]]
- chore(*): add stable node version [[1f3fbc2]]
- chore(*): add custom travis build script [[d81c3f8]]
- chore(*): define code ownership [[c791b5d]]
- chore(*): update dev-deps and engines [[14c00dc]]

[Unreleased]: https://github.com/ChristianGrete/exit-process-with-error/compare/3f49e305b5453ac6707f81ecde2103bf93e2d2f4...develop
[c64c1dd]: https://github.com/ChristianGrete/exit-process-with-error/commit/c64c1dda66c6db5bf40a8c706daa27885bcda480
[a400f24]: https://github.com/ChristianGrete/exit-process-with-error/commit/a400f24228acc6b7ffa4b5f5405af8ba7e685765
[72dfe5b]: https://github.com/ChristianGrete/exit-process-with-error/commit/72dfe5b6be1f709726af05caa02528fe1f100abd
[0b27d03]: https://github.com/ChristianGrete/exit-process-with-error/commit/0b27d03afee5f7146495fd6b2b93e31237a61515
[0ccdcf6]: https://github.com/ChristianGrete/exit-process-with-error/commit/0ccdcf6f98b7754b8f7959033282c3b5ffade456
[9cf9bb4]: https://github.com/ChristianGrete/exit-process-with-error/commit/9cf9bb4604b4025470da265e729ad664abd65ff4
[e440920]: https://github.com/ChristianGrete/exit-process-with-error/commit/e4409205786cb35b391f6e776475b866d642ffc0
[bc421f0]: https://github.com/ChristianGrete/exit-process-with-error/commit/bc421f0b3e4c43fbee8f69d254a3e98ff08123c3
[98f921d]: https://github.com/ChristianGrete/exit-process-with-error/commit/98f921d480112ca132331319b00755072cbb4dae
[09e5e58]: https://github.com/ChristianGrete/exit-process-with-error/commit/09e5e589ae78da8f559dd0c88b3e0474d0ba5299
[239b88b]: https://github.com/ChristianGrete/exit-process-with-error/commit/239b88b0f5a22d39bd03115e5fa3145210a7171a
[22c4dd4]: https://github.com/ChristianGrete/exit-process-with-error/commit/22c4dd442dfea4b4b6eb23130e3cdd19be6257b5
[2225131]: https://github.com/ChristianGrete/exit-process-with-error/commit/2225131e8c5ae22a875b0eba56eba39e421cc0f7
[16a5a6b]: https://github.com/ChristianGrete/exit-process-with-error/commit/16a5a6bd75e02240c35eff0396ca4b96e7635e65
[0a1db76]: https://github.com/ChristianGrete/exit-process-with-error/commit/0a1db76033640a599f29d312207cdae3b8089744
[14c00dc]: https://github.com/ChristianGrete/exit-process-with-error/commit/14c00dca171260bbce142be1760e6502594bde08
[b71b777]: https://github.com/ChristianGrete/exit-process-with-error/commit/b71b777aabfd587adeadab1c5e2c3d177a6f9207
[bdb4e41]: https://github.com/ChristianGrete/exit-process-with-error/commit/bdb4e41716da2f818686757d72f5fb7015d9e6ee
[c446f09]: https://github.com/ChristianGrete/exit-process-with-error/commit/c446f09d864b28c45085fa9fd7129f861913bf1b
[40f0ace]: https://github.com/ChristianGrete/exit-process-with-error/commit/40f0acebc2b283627329ecafa2f167ba3dda4f31
[8dca1bf]: https://github.com/ChristianGrete/exit-process-with-error/commit/8dca1bfd57cd136333089efc67563dbfc00dd985
[c791b5d]: https://github.com/ChristianGrete/exit-process-with-error/commit/c791b5d2f73a7efdbdfee066b7f5fc53cc80f337
[67a7292]: https://github.com/ChristianGrete/exit-process-with-error/commit/67a7292886bee9b69cc2a41b5be8e5ef90f8e804
[17f2a4e]: https://github.com/ChristianGrete/exit-process-with-error/commit/17f2a4e644443bd69fe26d0faf4036fcdaccf0a8
[4792af8]: https://github.com/ChristianGrete/exit-process-with-error/commit/4792af8d99686c7d266af91c084f43968910d66c
[63ec1b8]: https://github.com/ChristianGrete/exit-process-with-error/commit/63ec1b8da331f30fad34e49fc77387897e9d69de
[db7457e]: https://github.com/ChristianGrete/exit-process-with-error/commit/db7457ed61e072473c43976a45c4dcbac63f54f3
[fb5ad3b]: https://github.com/ChristianGrete/exit-process-with-error/commit/fb5ad3b1ba7200338d614232ed7ce8f291eee4b9
[08e00a7]: https://github.com/ChristianGrete/exit-process-with-error/commit/08e00a78b19166c289705343dc64517f813cee23
[01d3999]: https://github.com/ChristianGrete/exit-process-with-error/commit/01d3999be448a676bf097cf9c5d2d5182cfddbdd
[ae646d5]: https://github.com/ChristianGrete/exit-process-with-error/commit/ae646d55ceec1a82cde4853a61f1054e3f3a6042
[c6f979d]: https://github.com/ChristianGrete/exit-process-with-error/commit/c6f979d022d81fd9ac0e8001fb38f33f5cf90171
[d81c3f8]: https://github.com/ChristianGrete/exit-process-with-error/commit/d81c3f8cb939fc9f1e8077642812f8efbe2b389e
[1f3fbc2]: https://github.com/ChristianGrete/exit-process-with-error/commit/1f3fbc2c58c5d4d671583e4aad0e35f252d745bc
[a4248db]: https://github.com/ChristianGrete/exit-process-with-error/commit/a4248dbd67771e541a2631679f94c4bc896a63e5
[8e1d126]: https://github.com/ChristianGrete/exit-process-with-error/commit/8e1d12609b36c4619f1cff14076fa24562284b33
[c3a485b]: https://github.com/ChristianGrete/exit-process-with-error/commit/c3a485ba40cf52ba987e69899531c2567ff365f9
[#2]: https://github.com/ChristianGrete/exit-process-with-error/issues/2
[65d6455]: https://github.com/ChristianGrete/exit-process-with-error/commit/65d6455df3357f86c14e6d871be3c0d82f1232f6
[49f2ae6]: https://github.com/ChristianGrete/exit-process-with-error/commit/49f2ae62a78dbbb4286ce0cb7a1cd7cf70d80bdf
[3f0ee43]: https://github.com/ChristianGrete/exit-process-with-error/commit/3f0ee437f130aa7b3a40e7954693a166fea67f6d
[51fbd3b]: https://github.com/ChristianGrete/exit-process-with-error/commit/51fbd3b621bb29093c16d25a1407bf01e51f7796
[8a23c67]: https://github.com/ChristianGrete/exit-process-with-error/commit/8a23c67777693109c99ff882fc81de9f738dd9b6
[08293a1]: https://github.com/ChristianGrete/exit-process-with-error/commit/08293a1f2d8dd8cdf5c2f4c81ed5fe3c0f2dd15a
[579b2d4]: https://github.com/ChristianGrete/exit-process-with-error/commit/579b2d4b083624f447241faf4efcf20fab417b07
[4b3e7d4]: https://github.com/ChristianGrete/exit-process-with-error/commit/4b3e7d49666ccbf9df8f58b58d61f24683e63938
[ef117d7]: https://github.com/ChristianGrete/exit-process-with-error/commit/ef117d76560dbe58f1786678e02a392315377c10
[a9a433b]: https://github.com/ChristianGrete/exit-process-with-error/commit/a9a433b963a926281a898e607c64513e3155a4b8
[b36daea]: https://github.com/ChristianGrete/exit-process-with-error/commit/b36daeaae7da6b68e414fc02239c3ec4c81a85ce
[c700b02]: https://github.com/ChristianGrete/exit-process-with-error/commit/c700b029741dcbdd46440ac5cbabf3ee3d0441b0
[#1]: https://github.com/ChristianGrete/exit-process-with-error/issues/1
[a3450e0]: https://github.com/ChristianGrete/exit-process-with-error/commit/a3450e04468fe2a3977e3baa77d177a55409761a
[51f4711]: https://github.com/ChristianGrete/exit-process-with-error/commit/51f4711e0f622b41158fc3c054ce93ec945fa806
[972703a]: https://github.com/ChristianGrete/exit-process-with-error/commit/972703aa8e219b87f38585cbf9631f0c43fd643c
[3f49e30]: https://github.com/ChristianGrete/exit-process-with-error/commit/3f49e305b5453ac6707f81ecde2103bf93e2d2f4
[develop]: https://github.com/ChristianGrete/exit-process-with-error/compare/master...develop
[master]: https://github.com/ChristianGrete/exit-process-with-error/compare/3f49e305b5453ac6707f81ecde2103bf93e2d2f4...master

---

Copyright © 2018 ([MIT][repository-license-url]) [Christian Grete][repository-owner-url]

[keep-a-changelog-spec-url]: https://keepachangelog.com/en/1.0.0/
[repository-github-url]: https://github.com/ChristianGrete/exit-process-with-error
[repository-license-url]: LICENSE
[repository-owner-url]: https://christiangrete.com
[semantic-versioning-spec-url]: https://semver.org/spec/v2.0.0.html

repository: ChristianGrete/exit-process-with-error

repo_name: ChristianGrete/exit-process-with-error


text:
## How to Use

Multiple smaller  automation scripts were consolidated into a single script file.

If you have a database that needs the new card data use it like this:

`$ python scripts/populate_sqlite.py db.sqlite3 tarot_juicer/static/img scripts/thumbnails` where the first argument is the location of the database, second is the directory where to store the images, and last one points to a folder where you have the thumbnail (small) versions of the cards located.

The script will create a directory `tarot_juicer/static/img/thumbnails` and put the files into that folder while updating the database. It also drops the whole table first so generators_generator table which belongs to the generator model gets purged of any current data when the script is done so also beware of that.

The script takes the db.sqlite3 database, drops the contents of the generators_generator table and populates it with data for each tarot card. It also reorders the cards such that the card number matches the id value, thus in sequential order

usage: $ populate_sqlite.py [-h] database media_dir images_dir

FYI:
```
Script to inject images into sqlite3 database field, in additon to csv data

positional arguments:
  database    sqlite3 database file
  media_dir   the location django expects the images to be
  images_dir  folder containing images

optional arguments:
  -h, --help  show this help message and exit
```

gha_language: CSS


text:
# sorting-java
Different kinds of sorting programs in Java

# HOW-TO:

- Make sure JDK is installed.
- After downloading, go into the directory of the sorting program you'd like to use
- Assuming you want to use bubble sort, while in the directory in CLI, type:
    - javac BubbleSort.java
    - java BubbleSort
- Follow the instructions.

# Bubble Sort

- Known as the simplest sorting program
- Array is traversed from first element to last element
- Current element is compared with next element, if the current element is greater than next element, it is swapped

# Selection Sort

- Divides the array into two
	- Sorted array
	- Unsorted array
- Checks the entire array for the minimum element and places it at the beginning of the sorted list and so on

# Insertion Sort

- Only good for smaller arrays, because it takes lots of time
- Transfers one element at a time to the right position