text:
# nnUNet baseline model

We chose [nnUNet](https://www.nature.com/articles/s41592-020-01008-z) as a model baseline for KiTS 2021 Challenge since
it is well known as a framework for fast and effective
development of segmentation methods. Users with various backgrounds and expertise can use nnUNet out-of-the-box for
their custom 3D segmentation problem without much need for manual intervention. It's publicly available and can be
accessed via [MIC-DKFZ/nnUNet](https://github.com/MIC-DKFZ/nnUNet).

We do not expect the participants to use nnUNet for model development but strongly encourage to compare the performance of
their developed model to the nnUNet baseline.

A documentation on how to run nnUNet on a new dataset is
given [here](https://github.com/MIC-DKFZ/nnUNet#how-to-run-nnu-net-on-a-new-dataset). To simplify a number of the steps
for the participants of KiTS 2021 Challenge, here we highlight the steps needed to train nnUNet on the KiTS 2021 dataset.

**IMPORTANT: nnU-Net only works on Linux-based operating systems!**

Note that our nnU-Net baseline uses the majority voted segmentations as ground truth for training and does not make
use of the sampled segmentations.

### nnUNet setup

Please follow the installation instructions [here](https://github.com/MIC-DKFZ/nnUNet#installation). Please install
nnU-Net as an integrative framework (not via `pip install nnunet`).

Remember that all nnU-Net commands support the `-h` argument for displaying usage instructions!

### Dataset preparation

This section requires you to have downloaded the KiTS2021 dataset.

As nnUNet expects datasets in a structured format, you need to convert the dataset to be compatible with nnUNet. We
provide a script to do this as part of the nnU-Net repository: [Task135_KiTS2021.py](https://github.com/MIC-DKFZ/nnUNet/blob/master/nnunet/dataset_conversion/Task135_KiTS2021.py)

Please adapt this script to your system and simply execute it with python. This will convert the KiTS dataset into
nnU-Net's data format.

### Experiment planning and preprocessing
In order to train the nnU-Net models all you need to do is run the standard nnU-Net steps:

The following command will extract the dataset fingerprint and based on that configure nnU-Net.
```console
nnUNet_plan_and_preprocess -t 135 -pl2d None -tl 4 -tf 2
```

`-pl2d None` makes nnU-Net ignore the 2D configuration which is unlikely to perform well on the KiTS task. You can
remove this part if you would like to use the 2D model.

 The provided numbers work
well with 64GB RAM. If you find yourself running out of memory or if the preprocessing gets stuck, consider setting
these lower. If you have more RAM (and CPU cores), set them higher.

Running preprocessing will take a while - so sit back and relax!

### Model training
Once preprocessing is completed you can run the nnU-net configurations you would like to use as baselines. Note that
we will be providing pretrained model weights shortly after the dataset freeze so that you don't have to train nnU-Net
yourself! (TODO)

In nnU-Net, the default is to train each configuration via cross-validation. This is the setting we recommend you use
as well, regardless of whether you use nnU-Net for your submission or not. Running cross-validation gives you the most
stable estimate of model performance on the training set. To run training with nnU-Net, use the following command:

```console
nnUNet_train CONFIGURATION nnUNetTrainerV2 135 FOLD
```

`CONFIGURATION` is hereby the nnU-Net configuration you would like to use (`2d`, `3d_lowres`, `3d_fullres`,
`3d_cascade_fullres`; remember that we do not have preprocessed data for `2d` because we used `-pl2d None` in
`nnUNet_plan_and_preprocess`). Run this command 5 times for `FOLD` 0, 1, 2, 3 and 4. If have multiple GPUs you can run
these simultaneously BUT you need to start one of the folds first and wait till it utilizes the GPU before starting
the others (this has to do with unpacking the data for training).

The trained models will be writen to the RESULTS_FOLDER/nnUNet folder. Each training obtains an automatically generated
output folder name. Here we give an example of output folder for 3d_fullres:

    RESULTS_FOLDER/nnUNet/
    ├── 3d_cascade_fullres
    ├── 3d_fullres
    │   └── Task135_KiTS2021
    │       └── nnUNetTrainerV2__nnUNetPlansv2.1
    │           ├── fold_0
    │           │   ├── debug.json
    │           │   ├── model_best.model
    │           │   ├── model_best.model.pkl
    │           │   ├── model_final_checkpoint.model
    │           │   ├── model_final_checkpoint.model.pkl
    │           │   ├── progress.png
    │           │   └── validation_raw
    │           │       ├── case_00002.nii.gz
    │           │       ├── case_00008.nii.gz
    │           │       ├── case_00012.nii.gz
    │           │       ├── case_00021.nii.gz
    │           │       ├── case_00022.nii.gz
    │           │       ├── case_00031.nii.gz
    │           │       ├── case_00034.nii.gz
    │           │       ├── case_00036.nii.gz
    │           │       ├── summary.json
    │           │       └── validation_args.json
    │           ├── fold_1
    │           ├── fold_2
    │           ├── fold_3
    │           └── fold_4
    └── 3d_lowres

Exactly this structure of those three folders (3d_fullres, 3d_lowres and 3d_cascade_fullres) is required for running
inference script presented in the example
of [nnUNet docker submission](../submission/nnUNet_submission).

### Choosing the best configuration

Once the models are trained, you can either choose manually which one you would like to use, or use the
`nnUNet_find_best_configuration` command to automatically determine the best configuration. Since this command does not
understand the KiTS2021 HECs, we recommend evaluating the different configurations manually with the
evaluation scripts provided in the kits21 repository and selecting the best performing model based on that.

In order to evaluate a nnU-Net model with the kits21 repository you first need to gather the validation set
predictions from the five folds into a single folder. These are located here:
`${RESULTS_FOLDER}/nnUNet/CONFIGURATION/Task135_KiTS21/TRAINERCLASS__PLANSIDENTIFIER/fold_X/validation_raw`
Note that we are using the `validation_raw` and not the `validation_raw_postprocessed` folder. That is because
a) nnU-Net prostprocessing needs to be executed for the entire cross validation using `nnUNet_determine_postprocessing`
(`validation_raw_postprocessed` is for development purposes only) and b) the nnU-Net postprocessing is not useful for
KiTS2021 anyways so it can safely be omitted.

Once you have all validation set predictions of the desired nnU-Net run in one folder, double check that all 300 KiTS21
training cases are present. Then run

`python kits21/evaluation/evaluate_predictions.py FOLDER -num_processes XX`

(note that you need to have generated the sampled segmentations first, see [here](../../kits21/evaluation))

Once that is completed there will be a file in `FOLDER` with the kits metrics.

### Inference

For running inference on all images in a specific folder you can either make use of the scripts
prepared for docker submission or run `nnUNet_predict` command:
```console
nnUNet_predict -i INPUT_FOLDER -o OUTPUT_FOLDER -t 135 -m 3d_fullres
```

IMPORTANT: When using `nnUNet_predict`, nnU-Net expects the filenames in the input folder to end with _XXXX.nii.gz
where _XXXX is a modality
identifier. For KiTS there is just one modality (CT) so the files need to end with _0000.nii.gz
(example: case_00036_0000.nii.gz). This is not needed when using the scripts in the nnU-Net docker examples!

## Updating the KiTS21 dataset within nnU-Net

The datset will be finalized by July 15th 2021. In order to update the dataset within nnU-Net you HAVE TO delete not
only the content of `${nnUNet_raw_data_base}/nnUNet_raw_data` but also `${nnUNet_raw_data_base}/nnUNet_cropped_data`
and `${nnUNet_preprocessed}/Task135_KiTS2021`. Then rerun the conversion script again, followed by
[experiment planning and preprocessing](#experiment-planning-and-preprocessing).

# nnU-Net baseline results
Pretrained model weights and predicted segmentation masks from the training set are provided here: https://zenodo.org/record/5126443
If you would like to use the pretrained weights, download the [Task135_KiTS21.zip](https://zenodo.org/record/5126443/files/Task135_KiTS2021.zip?download=1)
file and import it with `nnUNet_install_pretrained_model_from_zip Task135_KiTS21.zip`.

Here are the results obtained with our nnU-Net baseline on the 300 training cases (5-fold cross-validation):

|                    | Dice_kidney | Dice_masses | Dice_tumor | Dice_average |   | SurfDice_kidney | SurfDice_masses | SurfDice_tumor | SurfDice_average |
|--------------------|-------------|-------------|------------|--------------|---|-----------------|-----------------|----------------|------------------|
| 3d_fullres         | 0.9666      | 0.8618      | 0.8493     | 0.8926       |   | 0.9336          | 0.7532          | 0.7371         | 0.8080           |
| 3d_lowres          | 0.9683      | 0.8702      | 0.8508     | 0.8964       |   | 0.9272          | 0.7507          | 0.7347         | 0.8042           |
| 3d_cascade_fullres | 0.9747      | 0.8799      | 0.8491     | 0.9012       |   | 0.9453          | 0.7714          | 0.7393         | 0.8187           |

As you can see, the `3d_cascade_fullres` configuration performed best, both in thers of average Dice score and average Surface Dice.

# Extending nnU-Net for KiTS2021

[Here](https://github.com/MIC-DKFZ/nnUNet/blob/master/documentation/extending_nnunet.md) are instructions on how to
change and adapt nnU-Net. In order to keep things fair between participants **WE WILL NOT PROVIDE SUPPORT FOR IMPROVING
nnU-Net FOR KITS2021**.

gha_language: Python


text:
# Terminus\Models\Workflow

### getFetchUrl
##### Description:
    Give the URL for collection data fetching

##### Return:
    [string] $url URL to use in fetch query

---

### fetchWithLogs
##### Description:
    Re-fetches workflow data hydrated with logs

##### Return:
    [Workflow]

---

### isFinished
##### Description:
    Detects if the workflow has finished

##### Return:
    [bool] True if workflow has finished

---

### isSuccessful
##### Description:
    Detects if the workflow was successful

##### Return:
    [bool] True if workflow succeeded

---

### operations
##### Description:
    Returns a list of WorkflowOperations for this workflow

##### Return:
    [WorkflowOperation[]]

---

### serialize
##### Description:
    Formats workflow object into an associative array for output

##### Return:
    [array] Associative array of data for output

---

### wait
##### Description:
    Waits on this workflow to finish

##### Return:
    [Workflow|void]

---

license: MIT

repository: Deleriumdoll/cli

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: Deleriumdoll/cli


text:
---
layout: doc
title: decor/schedule
---

# decor/schedule

`decor/schedule` is a utility function that tries to run the given callback (the first argument)
at the end of [micro-task](http://www.whatwg.org/specs/web-apps/current-work/multipage/webappapis.html#microtask),
which happens with IE11+ as well as latest Firefox/Chrome/Safari.
For other browsers, notably ones not supporting [MutationObserver](https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver),
`decor/schedule` attempts to take the quickest way reasonably possible to run the given callback
after [micro-task](http://www.whatwg.org/specs/web-apps/current-work/multipage/webappapis.html#microtask) ends.

`decor/schedule` returns a handle with `.remove()` method. If `.remove()` is called before the callback runs, running the callback will be cancelled.

repository: ibm-js/decor

gha_language: JavaScript

gha_license_id: NOASSERTION

repo_name: ibm-js/decor


text:
---
layout: post
title: "Adding Author tag to RSS Feed using Hugo static site generator"
date: 2019-03-14 01:34:15Z
description: How to include the author tag in the generated RSS feed for a Hugo-generated site.

list_image: /images/rss-icon.png
images:
- /images/rss-icon.png

permalink: 2019/03/adding-author-tag-to-rss-feed-using-hugo-static-site-generator/
---

*This post details how to include the author tag in the generated RSS feed for a Hugo-generated site.*

## Default RSS Template
Hugo comes equipped with a template by default. In fact you might be pleasantly surprised to discover your site has an RSS feed already. You can try it out by visiting your site and adding `/index.xml` on the end of either of your home page, or your section containing your blog posts. e.g.,

  - [https://craigrussell.io/index.xml](https://craigrussell.io/index.xml)
  - [https://craigrussell.io/posts/index.xml](https://craigrussell.io/posts/index.xml)

## Customising The Template
While the default template might be enough for some, others are going to want to customise it. For me, I found that I wanted to include an `<author>` tag in my posts.

You can either grab the default template and add the `<author>` tag into it (recommended approach) or just skip ahead and grab my one from the gist below. I would recommend using the default one as it may contain newer changes from Hugo that my gist won't have over time.

To do this, we must start by grabbing a copy of the embedded RSS template. We'll drop that into your project and customise it to include the author tag.

1. Get the [default Hugo RSS template](https://gohugo.io/templates/rss/#the-embedded-rss-xml)
2. Save the template into your Hugo directory as `layouts/_default/rss.xml`
3. Add the `<author>` tag in. You'll probably want to add it under the `<item>` tag, and you may additionally want to add it at the top level.
4. Ensure you have your name detailed in the site config (i.e.,  `config.yaml`, `config.toml` or `config.json` file)

When you're done, it should look like this 👇
{% gist 55a019f576eb10802543e5d1dcc65743 %}

```
// config.yaml

author:
  name: Craig Russell
```

## Final RSS
Now when you publish the site and access the RSS XML, you'll see the `<author>` is now included.

![RSS XML showing the included author tag](/images/author-tag-in-rss-xml.png)

url: https://raw.githubusercontent.com/CDRussell/cdrussell.github.io/3c8f25425d5001290415714b42174d26a313acb7/_posts/2019-03-14-Adding Author to XML feed in Hugo.md

branch_name: refs/heads/main


text:
# Contributing

For a step by step walk through of how to contribute a new sampling sequence or a new sample sequence test, give this page a read:
[Contributing a Sequence or Test](contributesampletest.md)

For all other code changes, either submit a pull request, or drop me a line to chat details before you do work if you want a better chance of making sure your changes are accepted.

## Crediting Work

Everyone who contributes code or non code contributions of any size are elligable to be included in the [Credits](credits.md) page.

Feel free to add your own name to the appropriate section with your pull request.

If you are making a code change, also feel free to add your name as a contributor to whatever files you modify.

## Non Code Contributions

Both code and non code contributions are valued by this project.

Non code contributions include things like the below:
* Terminology corrections.
* Editorial corrections to documentation.
* Improving explanations about sampling or tests types, including adding links to relevant resources.
* supplying links and/or information about testing and/or sampling types to be included.

## Source Code Header (Strongly Suggested)

It's strongly suggested that all files submitted have a header like the below.  All fields are optional however and there are no specific rules about date format, order of fields, or similar.

If you make a change to a file, feel free to add your name to the contributors section, regardless of the size of the change.

You can specify a license as part of this header as shown below.  If no license is supplied, the file will fall under the default license of this repo, which is the [MIT License](LICENSE).

```cpp
/*
FILE: ProgProjBlueNoise.cpp
AUTHOR: Alan Wolfe<EMAIL_ADDRESS>DATE: 2/8/2019
LICENSE: MIT (see license.md next to this file)

CONTRIBUTORS:
Jim Bean
Jack Daniels

LOG:
2/8/19 - Created the file (Alan Wolfe)
*/
```
## Work Needed

A list of specific things the project needs.

### Infrastructure
* a better way to find files in codegen.lua than using ls since some systems won't have it. os.matchdirs:  https://github.com/premake/premake-core/wiki/os.matchdirs
* centralize random number (white noise) generation, also make it seedable for deterministic results.
* clang tidy for style guidelines? Or google C++ style guide? or clang-format? "clang-format -style=google"
* also an editor config? https://editorconfig.org/
* improve the look of graphing in general, all graphs.
* Do super sampling of graphs to help aliasing problems: render at a larger resolution and downside. Possibly render stochastically?
* This seems possibly useful for automatically putting ticks on graphs: http://vis.stanford.edu/files/2010-TickLabels-InfoVis.pdf
* I think you can set up CI as well as code tidying in github. Need to figure those things out.
* Make a way to cache data, since some of it takes a long time to generate (eg large counts of blue noise)
* probably should modify best candidate blue noise generation to use a (1d) grid acceleration structure. Or sort the points and use binary search to calculate distances or something.
* graph: make axis labels instead of using footer text
* make datacache use file compression (zlib?). The data makes this a very poor proposition. a 30MB data cache file compressed to 27MB for me.
* look into multithreading the tests & sample generation. data cache would need to be made safe for this.
 * maybe making the discrepancy test a fork and join operation could be useful.
 * could also be nice to have things threaded more at the macro level instead of micro.
* pcg variant or splitmix instead of mersenne twister, says Marc Reynolds.  Faster and higher quality.
* can we hash samples and test version or something somehow to know when we don't need to re-run a test if the target file already exists?
* add profile information to the output. We can instrument the autogen'd code to time sample functions and test functions and see where the time is going. Maybe also some custom markers if we want more specific information.
* save different caches to different files so they aren't such large binary diffs when anything changes.
* look into using markdeep (html w/ a header to use some javascript) instead of markdown for all this documentation.  Main readme might be markdown but the rest could be html? http://casual-effects.com/markdeep/#templates
* we should probably have something that lists the sampling types / functions per progressive vs not and randomized vs not, in a sample family specific document.
* figure out how to decrease compile times.
 * I think part of it is that auto gen'd code is in headers.  I think if we had more things in .cpp's with .h's that don't change as details change, that compile times would be faster.
* if the data cache gets too large, a way to get some space back is to not save lists of samples that are smaller than some threshold. 1d blue noise generates a lot for the dft for instance, that would be fairly quick to regenerate.
* whenever autogend docs label a test or sample, make a hyperlink to click to go to the page for it

### 1D Sampling Patterns & Tests
* more irrational numbers such as the silver ratio and the plastic constant. Just meaningful irrational numbers though.
* low discrepancy sequences (basic, more exotic, scrambled, etc!)
* other 1d blue noise methods including: dart throwing, relaxation.
* blue noise from eigenvectors: https://twitter.com/TechSparx/status/1093902404867760129
* jittered grid
* other 1d sampling patterns not listed here!
* frequency analysis (DFT)
* regular sampling and some others are not progressive. for integration graphing, it's useful to show what that means when tested the same way progressive samples are tested, but i think non progressive sampling types should be graphed such that at sample count N, it's showing the error for an N count sequence.
* on the integration error graph, the actual graph being integrated could be shown in the lower left
* look into making a power spectrum test: https://cs.dartmouth.edu/wjarosz/publications/subr16fourier.html
* From paniq - could try a triangle or gaussian distribution on jittered grid.
* another number line test: graph sum of samples divided by count of samples.  Good #s of sample counts will have this value being near 0.5. It's the "expected value" of the sample set at that sample count.
* there is a 2d space of anti aliasing vs discrepancy for sampling types.  I know how to quantify discrepancy but not aliasing. maybe figure that out and plot the sequences on a graph showing where they lay here?
* for the integration graph, could show the actual function graphed in the lower left.
* silver ratio etc: http://extremelearning.com.au/going-beyond-golden-ratio/
* is blue noise more predictable than white noise? if in scope it could be interesting to make a test to show this.
* shuffle test for sequences.  graph histogram max-min to show balance of shuffle.  find some way to show how random a shuffle is. I thought graphing actual sample value would help but it's not easy to read.  awolfe/shuffletest has a partial implementation here.
* show how regular 1d sampling has aliasing problems. Also show how random samples trade the aliasing for noise.
* discrepancy and integration tests should really do multiple tests for randomized samples.
* probably should do some rational samples to go with the irrational ones. easy enough to do and can show some interesting things.
* subrandom numbers? from your blog post.
* for 1d mitchells best candidate blue noise, instead of a binary search, since the samples are roughly even, could probably just find what % the sample is from 0-1 and linearly search from that % through the number list.  Maybe check and see if it's faster.
* regular sampling is different if you are considering a wrap around domain or not: https://twitter.com/proceduralguy/status/1106275593719558144

### 2d Sampling Patterns and tests
* best candidate.  Erin suggested kd tree with branch and bounds to find nearest point as an optimization. This would work better for 2d and beyond.
* progressive multijittered sequences (PMJ) - https://graphics.pixar.com/library/ProgressiveMultiJitteredSampling/pmj_slides.pdf
* correlated multi jittering: https://graphics.pixar.com/library/MultiJitteredSampling/paper.pdf
* Martin's R2 sequence for 2d (and higher dimensions) http://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences/
* basic 2d LDS
* sampling on spheres and hemispheres
* making pmj02 more quickly: http://www.jcgt.org/published/0008/01/04/paper.pdf
* deterministic point process: https://arxiv.org/pdf/1207.6083.pdf and https://arxiv.org/pdf/1609.06840.pdf
* orthogonal array sampling (esp for higher dims) https://cs.dartmouth.edu/~wjarosz/publications/jarosz19orthogonal.html
* https://eheitzresearch.wordpress.com/762-2/
* https://eheitzresearch.wordpress.com/772-2/

### Circle / disk sampling patterns
* when someone requests regular sampling of 17 samples, what should we do? right now it does 4x4 and adds zero samples for the rest.
 * we should maybe find the most equal pair of factors that go into whatever number they asked for? not sure.
* dart throwing and other 2d blue noise sample point generation strategies.
* subrandom numbers? from your blog post.
* 2d "plot average" test? could have "average distance from center". Could also just draw a line showing how it moves around the center.. unknown. like the 1d numberline average test but for 2d.
* we could do (selected?) 1d tests on the projections of the 2d sampling patterns.
* latin squares? quincunx?, n queens?
* should randomized sequences go through multiple tests and report avg, min, max?
* projective blue noise
* your progressive projective blue noise
* this O(N) non progressive blue noise technique from Robert Bridson: https://www.jasondavies.com/poisson-disc/  (https://www.cs.ubc.ca/~rbridson/docs/bridson-siggraph07-poissondisk.pdf)
* reread this for sources of 2d patterns: http://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences/
* blue noise through optimal transport.
 * optimal transport: https://mathematical-tours.github.io/book-basics-sources/ot-sources/TransportEN.pdf
 * blue noise through optimal transport: http://www.geometry.caltech.edu/pubs/dGBOD12.pdf
* Vogel Disk: https://www.gamedev.net/articles/programming/graphics/contact-hardening-soft-shadows-made-fast-r4906/
* to dft, try this? Reverse the random point in disk thing.  Polar but squared distances.  Dft the resulting points in square!
* sampling on disks and spheres: https://github.com/matt77hias/fibpy
* square to disk transforms: http://jcgt.org/published/0005/02/01/
* iq square to circle transform: https://twitter.com/iquilezles/status/1106127681974747136?s=03

### Sphere sampling patterns
* http://extremelearning.com.au/how-to-generate-uniformly-random-points-on-n-spheres-and-n-balls/
* fib on spheres and caps: http://marc-b-reynolds.github.io/math/2018/06/21/SFPoints4ET.html
* points on a sphere: https://www.cmu.edu/biolphys/deserno/pdf/sphere_equi.pdf

### hemisphere sampling patterns
* square to hemisphere: https://twitter.com/paniq/status/1106558922566062080

### Triangle sampling patterns
* https://pharr.org/matt/blog/2019/02/27/triangle-sampling-1.html
* https://pharr.org/matt/blog/2019/03/13/triangle-sampling-1.5.html
* uniform point in triangle: https://twitter.com/TechSparx/status/1093193006440726529?s=03
* https://twitter.com/eric_heitz/status/1105097492964741120?s=03
* can do blue noise and white noise via rejection sampling

### 1d dithering patterns
* as a gateway to 2d dithering patterns.
* 1d dithering is like dice rolls over time (could look at blue vs white noise dice rolls!)
* explain relationship between dithering and integration (temporal integration)

### 2d Dithering Patterns
* ign
* void and cluster
* gpu void and cluster https://github.com/jdupuy/BlueNoiseDitherMaskTiles
* bayer
* from paniq for blue noise: basically: fill a square image with uniform noise, stencil out a center circle with feathering, take an inverse FFT and tada, blue noise
* gpu void and cluster algorithm: https://github.com/jdupuy/BlueNoiseDitherMaskTiles
* Cover dithering and triangle distributed noise? and the things here: http://bartwronski.com/2016/10/30/dithering-part-three-real-world-2d-quantization-dithering/
* Animated dithering is something different than static dithering. Then can do taa and not, etc.
* Talk about how dithering relates to sample points.
* 2d sample points: (x,y)=f(x)
* 2d do: z=f(x,y)
* ?how does 1d dithering differ from 1d sample points? An important question to answer to clear some things up.
* 2d sample points: when you have a 2d region you need to take samples of.
* 2d dithering: when you have 2d data that you need to decrease precision on.
* Integration comes up in dithering when you animate it.
* Fewer bits to represent a higher bit depth. Either Integrate it explicitly (actually, or with taa), or let display / eyes integrate it.
* Talk about ordered dithering and thresholding.
* https://github.com/Atrix256/BlueNoiseDitherPatternGeneration

### Documentation
* mention how sampling is like convolution in frequency space somewhere?
* explain progressive vs non progressive sequences
* maybe an overview page for 1d sampling, saying what is best at what?
* maybe a 1d page explaining a good order to read things in to best understand them?

### Research (read these, turn them into todos)
* look into this for rank 1 lattices: http://simul.iro.umontreal.ca/latbuilder/
* sobol with a small table? from marc b reynolds. https://github.com/Marc-B-Reynolds/Stand-alone-junk/blob/master/src/SFH/Sobol.h  includes stratified sobol sampling?
* irrational numbers with integers instead. https://twitter.com/marc_b_reynolds/status/1101608307217842176
* Stochastic Sampling in Computer Graphics (Pixar) http://www.cs.cmu.edu/afs/cs/academic/class/15462-s15/www/lec_slides/p51-cook.pdf
* correlated multi jittered sampling: https://graphics.pixar.com/library/MultiJitteredSampling/paper.pdf
* bilateral blue noise: https://www.liyiwei.org/papers/noise-siga13/
* multiclass blue noise sampling: https://www.liyiwei.org/papers/noise-sig10/
* a survey of blue noise sampling: http://archive.ymsc.tsinghua.edu.cn/pacm_download/38/276-2015_JCST_BNSurvey.pdf
* links at https://www.jasondavies.com/poisson-disc/
* find the electrostatic half toning paper
* Blue noise sampling using an N-body simulation-based method.  https://link.springer.com/article/10.1007/s00371-017-1382-9
* sample transformation zoo from http://www.realtimerendering.com/raytracinggems/

## Alan Specific TODOs
* progressive projective blue noise
* try and think about random projection blue noise
* gather papers linked from progressive projective blue noise project
* James has a bluenoise type sampling he wants to contribute called dpp. Hit him up when you are ready to open things up!
* check out UTK (a sample comparison toolkit) for inspiration etc. https://utk-team.github.io/utk/
* check out these from Martin
 * "Aliasing-Free Blue Noise Sampling" https://kops.uni-konstanz.de/handle/123456789/20250
 * "Stair Blue Noise Sampling" https://www.researchgate.net/publication/308797027_Stair_Blue_Noise_Sampling

repository: follower/SampleZoo

gha_license_id: MIT

repo_name: follower/SampleZoo


text:
# Laravel LMS Application

This project is a project of [Saiful Alam](https://github.com/msa-rakib) build for [DevTravelers](https://www.facebook.com/groups/DevTravelers/).

## Installation

Clone the repository-
```
git clone https://github.com/msa-rakib/DT-lms.git LMS
```

Then cd into the folder with this command-
```
cd LMS
```

##### Then do a composer install
```
composer install
```

Then create a environment file using this command-
```
cp .env.example .env
```

Then edit `.env` file with appropriate credential for your database server.
Just edit these three parameter(`DB_DATABASE`, `DB_USERNAME`, `DB_PASSWORD`).

Then create a database named `lms` and then do a database migration using this command-
```
php artisan migrate
```

Then change permission of storage folder using thins command-
```
(sudo) chmod 777 -R storage
```

At last generate application key, which will be used for password hashing, session and cookie encryption etc.
```
php artisan key:generate
```

## Run server

Run server using this command-
```
php artisan serve
```

Then go to `http://localhost:8000` from your browser and see the app.

## Ask a question?

If you have any query please contact at<EMAIL_ADDRESS>


text:
valid [![GoDoc](https://godoc.org/github.com/vladvelici/valid?status.svg)](https://godoc.org/github.com/vladvelici/valid)
=====

Simple input validation for Go. This package does not deal with any form of input processing.

This package is all about checking if values satisfy different validation rules. It is outside the goals of this
package to deal with web form input processing. There are already plenty of librbaries doing that.

Usage
=====

    ```go
    // A variable to validate.
    var input string

    // ... input processing (e.g. from web forms) ...

    // Validation
    errs := valid.String(input, Nonempty("This field is required."), MaxLen(20, "Input is too long."))

    // errs is an []error containing errors with the relevant error messages.
    ```

Current validators
==================

### Strings

- **Len** - Length in closed interval `[min, max]`.
- **LenStrict** - Length in open interval `(min, max)`.
- **MinLen** - Length at least `min`.
- **MinLenStrict** - Length at least `min+1`.
- **MaxLen** - Length at most `max`.
- **MaxLenStrict** - Length at most `max-1`.
- **Nonempty** - string must not be empty.
- **EmailRFC** - e-mail address validation using the `net/mail` package.
- **Email** - e-mail address validation using the HTML5 Email field regexp.
- **Regex** - Validate using regular expression, given as string.
- **RegexCompiled** - Validate using regular expression, given as `*regexp.Regexp`.

Create custom validators
========================

Validators are different for each type, but they all have similar interfaces.

### Strings

The interface `StringValidator` has one method `Validate(string) error`. Any struct that
implements this interface can be used as a string validator.

A convenience type is also defined: `type StringFunc func(val string) error`. This type implements the
`StringValidator` interface, so any function with the above signature can be used as a validator.

### Example

You can see code for a custom validator here https://gist.github.com/vladvelici/00679f8dff9e205cc157.

repository: vladvelici/valid

repo_name: vladvelici/valid


text:
# Backtrace error submission gem

# Installation

Add `gem 'backtraceio'` to your Gemfile. Alternatively, install it yourself:
```
gem install backtraceio
```

# Usage

```ruby
require 'backtraceio'
```

## Global crash handler

Pass your custom token and upload url from your Backtrace
account.

```ruby
BacktraceIO.register_error_handler(TOKEN, URL)
```

## Reporting custom errors

Create a new `Report` object.

```ruby
report = BacktraceIO::Report
```

(Optional) Add custom attributes/annotations/exception objects:

```ruby
report.attributes['cpu.cores'] = 8
report.annotations['Current User'] = { name: 'John', uid: 42 }
# if we're in an exception handler
report.add_exception_data current_exception
```

The format for attributes and annotations can be found in
[Backtrace I/O api docs][1].

Submit the crash. Pass your custom token and upload url from your Backtrace
account.

```ruby
st = BacktraceIO::SubmissionTarget.new TOKEN, URL
st.submit report.to_hash
```

[1]: https://api.backtrace.io/#tag/submit-crash

repository: backtrace-labs/backtrace-ruby

repo_name: backtrace-labs/backtrace-ruby


text:
kiku
==
A Simple WordPress Theme. (for myself)

![Theme kiku screenshot](screenshot.png)

## Theme Features
* WordPress Starter Theme
 * based on [Sage - WordPress Starter Theme](https://roots.io/sage/)
* Simple Design (Material Design)
* Ready
 * Search Engine Optimization (SEO)
    * OGP, Twitter Cards
 * Table of Contents
    * use [Mokuji.js](https://github.com/hiro0218/mokuji.js)
 * Syntax Highlighter
    * use [Prism.js](http://prismjs.com/)
 * Share Button
    * Twitter
    * Facebook
    * Hatena
    * LINE
 * Amazon Product Link
    ASIN code to Amazon Product Link
* Don't use jQuery (use pure JavaScript)
* Remove WordPress Comments function
* Fit to Japanese Language

## Requirements
Installation notes:
* [PHP](http://php.net/manual/en/install.php) >= 7.1.x
* [Composer](https://getcomposer.org/download/)
* [Node.js](http://nodejs.org/) >= 7.x
* [WordPress](https://wordpress.org/) >= 4.7.x (latest)
* [Yarn](https://yarnpkg.com/en/docs/install)

### Browser Support
Supported browsers: (latest)
* Chrome
* Edge
* Firefox
* Safari

branch_name: refs/heads/develop

gha_language: PHP


text:
# [wildstring](https://www.youtube.com/watch?v=4qHX493bB3U)

Simple String Wildcard Handling

[![build status](https://secure.travis-ci.org/deltreey/wildstring.png)](http://travis-ci.org/deltreey/wildstring)
[![npm version](https://badge.fury.io/js/wildstring.svg)](https://www.npmjs.com/package/wildstring)
[![Codacy Badge](https://www.codacy.com/project/badge/8436bfefb89345d0933bb91f59ed3b22)](https://www.codacy.com/app/suicidolt/wildstring)
[![Code Climate](https://codeclimate.com/github/deltreey/wildstring/badges/gpa.svg)](https://codeclimate.com/github/deltreey/wildstring)
[![bitHound Score](https://www.bithound.io/github/deltreey/wildstring/badges/score.svg?)](https://www.bithound.io/github/deltreey/wildstring)
[![Join the chat at https://gitter.im/deltreey/wildstring](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/deltreey/wildstring?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

## Shake it shake it

Installing wildstring is a snap.  wildstring has no dependencies, so you don't need anything else to run it. If you want to use tools though, here's some tips on how to install it with popular installers.

#### node.js
``` bash
npm install wildstring
```
then:
``` js
var wildstring = require('wildstring');
```

#### bower
``` bash
bower install wildstring
```

#### html

``` html
<script src="wildstring.js"></script>
```

## Hold me tight

Especially with something that does something new, it's important to see how it works.  Below are some examples, but here's a brief explanation as well.

In this explanation, I'll use `*` as my wildcard for simplicity.  If you put a wildcard at the beginning, for example `*Thing` then you can match anything or nothing before your string.  So your string could be `Wild Thing` or just `Thing` and it would match fine.  The same is true for the end.  `Wild*` would match `Wild Thing` or just `Wild`.  If you want to match text in the middle of the string, it works the same way. `Wild*Thing` matches both `WildThing` and `Wild and crazy Thing`.
``` js
wildstring.match('Test*', 'Testing');                 // true, wildcard matches 'ing'
wildstring.match('*ing', 'testing');                  // true, wildcard matches 'test'
wildstring.match('Test*', 'Test');                    // true, wildcard can match empty strings
wildstring.match('*ing', 'Testing it');               // false, no wildcard do match ' it'
wildstring.match('Test', 'Testing');                  // false, no wildcard to match 'ing'
wildstring.match('Test*ing', 'Testing this thing');   // true, matches 'Test' and the end of 'thing', the rest is wildcard matched
wildstring.match('*))))))*', ')))))');                // false, not enough parenthesis
```

### You make my heart string

You can use wildstring for string interpolation, which makes for an easier interface to parse data from users who maybe don't know regular expressions.
``` js
wildstring.replace('I * node.*', [ 'love', 'js' ]);   // 'I love node.js'
wildstring.replace('I * node.*', 'script');           // 'I script node.script' * this behavior is the same as "I * node.*".replace("*", "script") and actually uses that method
wildstring.replace('I * node.*', [ 'love' ]);         // THROWS AN ERROR, wildcard count and number of strings to insert must match
wildstring.replace('*/*/*', [ new Date.getMonth() + 1, new Date.getDate(), new Date.getFullYear]);
// 7/15/2015 (or whatever day it is), probably better to learn the js date parser though
```

### You make everything, groovy

You can use your own wildcards with wildstring, so you can wildstring everything.  You can even turn off case sensitive matching if you want.
``` js
wildstring.wildcard = 'stuff';
wildstring.match('Test stuff', 'Test wild');            // true, wildcard 'stuff' matches 'wild'
wildstring.replace('stuff and stuffthings', [ 'WILD', 'thing' ]); // 'WILD and thingthings'
// turn off case sensitive matching
wildstring.caseSensitive = false;
wildstring.match('tEsT', 'TeSt');                       // true, 'test' matches 'test'
```

## I think I love you

If you want to contribute to wildstring, it's really easy.  Just make sure you have [nodejs](https://nodejs.org/) installed and do the following.
``` bash
git clone https://github.com/deltreey/wildstring
# npm install -g grunt-cli # if you don't have it
npm install
grunt
```

grunt will run all the tests and jshint, so just make sure it passes before submitting a pull request

## But I wanna know for sure

Documentation: [http://deltreey.github.io/wildstring](http://deltreey.github.io/wildstring)

Repository: [https://github.com/deltreey/wildstring](https://github.com/deltreey/wildstring)

repository: LeRegulus/Dekuwayy

repo_name: LeRegulus/Dekuwayy


text:
# Quick Bot API

QuickBot is a mobile robot built as part of the Coursera "Control of the Mobile Robots" class offered by
Georgia Tech. For more information on the QuickBot platform see http://o-botics.org

This package provides high-level API to control QuickBot. Includes utilities to calibrate wheel encoders
and IR sensors. Example code implements a simple "intelligent" behavior:
[YouTube show-off](http://youtu.be/5rOYVlgJui8).

## API overview

QB class encapsulates the API. This class can only be used at the robot side (it operates motors and reads
sensors).

QBServer - run this code on the robot side to delegate control to the base station. Communication protocol is
compatible with the one used in the class, see http://github.com/o-botics/quickbot_bbb . This means that you should be
able to run MatLab code developed in the class. This code can be used at the robot side only.

QBClient implements the QB API by sending commands to QBServer over UDP protocol. This class is meant to
be used at the base station to control robot remotely. Since API is identical to the QB one, you can develop
and test controllers on your base computer (desktop or laptop) and then deploy the same code on QuickBot to
run autonomously.

## Features

1. Uses hardware ADC capture, which provides high capture speed and reliable tick values with no load on CPU.

2. Unlike original robot, speed is stabilized with PID controller. This removes the need to manually adjust
torque - robot runs reliably on any surface: hardwood, carpet, asphalt.

3. Uses predictor/corrector to detect tick sign change (thus emulates quadrature encoder functionality in software).

## Configuration

All configurable parameters are in config.py file.

## Prerequisites

1. QuickBot

2. Install [beaglebone_pru_adc](http://github.com/pgmmpk/beaglebone_pru_adc)
    ```
    git clone http://github.com/pgmmpk/beaglebone_pru_adc
    cd beaglebone_pru_adc/
    python setup.py install
    ```

## Calibrating sensors

You need to calibrate wheel encoders and IR sensors. Calibration means running some simple experiments,
measuring sensor output, then entering these values into `config.py`.

### Calibrating wheel encoders

Use `tools/calibrate_wheel_encoders.py`. Just run it - it will run motors for about 2 seconds to determine
best threshold for each wheel encoder. Use these threshold values to update your `config.py`

### Calibrating IR sensors

Use `tools/calibrate_ir_sensors.py` to capture mean value of an IR sensor. You need to capture
value for 3 different distances to an obstacle: 3in, 6in, and 12in. Do this for each sensor, then
input resulting numbers into `tools/fit.py` and it will print `IR_CALIBRATION` array. Copy it and paste
into your config.py

### Other configuration

Set correct values for `ROBOT_IP`, `BASE_IP`, and `PORT` in `config.py`.

## Running simple "intelligent" behavior

On the robot side, start `qb_server.py`

On the base station, run `qb_simple_behavior.py`

Simple behavior switches between three controllers:

1. "Go straight" controller - robot travels straight until it "sees" an obstacle. Then it yields to
2. "Avoid collision" controller - robot just "jumps" back a little (this helps avoiding it getting stuck
   when too close to a wall). Then it switches to
3. "Find clear direction" controller - robot rotates on a spot, trying to find a "clear" direction. When
   found, switches to "Go straight".

## Programming API

### QB(config)
Constructs new QB object. Takes a single parameter - configuration file.

### QB.start()
Initialises all sub-systems. Call this once before entering main loop.

### QB.on_timer()
Performs necessary periodic tasks (mostly reading sensors and maintaining encoder sign). You must call
this function at 100Hz (every 0.01 sec) in the main loop.

### QB.stop()
Cleanup of all resources.

### QB.set_speed(speed_left, speed_right)
Sets robot speed. The speed parameter is a signed float value that is desired speed of the corresponding wheel.

Speed is measured in ticks/sec. Since there are 16 encoder teeth, the speed is scaled by 16 desired number of rotations
per second. Reasonable speed range is 20-120. Range between -20 and +20 is unstable (robot physically can not move that
slow because of the mechanical limitations).

### QB.get_speed()
Returns tuple of _actual_ speed readings, not the values set with `QB.set_speed`.

### QB.get_ticks()
Returns tuple of the wheel encoder ticks. These are signed values.

### QB.reset_ticks()
Resets ticks values to zero.

### QB.get_ir()
Returns 5-tuple of raw IR readings

### QB.get_ir_distances()
Returns 5-tuple of IR readings converted to distance (in inches)

## Credits
This project started as a fork of official software http://github.com/o-botics/quickbot_bbb by Rowland O'Flaherty.

## License
MIT


text:
## Rack Attack
_______
DOS/DDOS Attacks are extremly had to mitigate. It may be next to impossilbe to deter a determined hacker. That being said we
have a gem called [Rack Attack] (https://github.com/kickstarter/rack-attack) that can be used to mitigate small scale attacks.

Rack Attack supports various types of blocking. If you know an IP Address you can configure rack attack to block it or
you can configre it to block access to a specific route.

You can also configure rack attack to look up IPs from [rails cache] (https://github.com/kickstarter/rack-attack/wiki/Advanced-Configuration). To store an IP for blacklist in the rails cache do the following

``````````
ttmscalr rails_c -f FARM-NAME
Rails.cache.write('block PUT.IP.ADDRESS.HERE', true, expires_in: 3.days)
``````````

Rack Attack also supports throttling. Sometimes a throttle might be more effective than a block.

The configuration is stored in `config/initializers/rack_attack.rb`.

A deploy is required to make the changes active.

## We got some ones old IP
_________
Sometimes when we scale up webservers we might get an IP that was previously used for some service or API. For whatever
reason that IP is still being used by clients of said service even though its now a TTM IP. This might create a flood of unwanted traffic at a particular server.

The easisest way to deal with this is to terminate the server in scalr and let it respawn with a new IP.

repository: ex-ttmers/meta

repo_name: ex-ttmers/meta


text:
#UIViewController-Localization

This category expands the UIViewController behavior to translate automatically the controller main view and its subviews after being loaded from the nib file.

It helps speeding up the process of translating nibs. With this category, you just need to use the localizable key for your views and it will be replaced by the translation if itcan be found on the app strings file. There's no more need to add IBOutlets for translating purposes!

##Installation and usage

1. Add [`UIViewController+Localization.h`](https://github.com/mobilejazz/UIViewController-Localization/blob/master/UIViewController%2BLocalization.h) and [`UIViewController+Localization.m`](https://github.com/mobilejazz/UIViewController-Localization/blob/master/UIViewController%2BLocalization.m)
2. Add this line to your Prefix.pch file

  ```objective-c
  #import "UIViewController+Localization.h"
  ```

3. That's it, you can now start using keys from your strings file on Interface Builder.

##Currently supported UIKit classes

- **UILabel**: It translates the `text` property.
- **UIButton**: It translates the `text` property of the `titleLabel` property.
- **UITextField**: It translates the `placeholder` property.


text:
# Dynamics Crm DevKit contains:
* [26 projects/items template.](https://github.com/phuocle/Dynamics-Crm-DevKit/wiki/Projects-and-Items-Template)
* [Integrated with Visual Studio](https://github.com/phuocle/Dynamics-Crm-DevKit/wiki/Integrated-with-Visual-Studio) that easy deploy WebResource.
* [CLI program](https://github.com/phuocle/Dynamics-Crm-DevKit/wiki/CLI) easy deploy plugins, workflows, custom actions, webresources.

Please [Install Dynamics Crm DevKit](https://github.com/phuocle/Dynamics-Crm-DevKit/wiki/Install) and check our [tutorials](https://github.com/phuocle/Dynamics-Crm-DevKit/wiki/Tutorials).

# Thanks
* [Florian Krönert](https://github.com/DigitalFlow/Xrm-WebApi-Client)
* [Scott Durow](https://github.com/scottdurow/SparkleXrm/tree/master/spkl)
* [Jordi](https://github.com/jordimontana82/fake-xrm-easy)
* [Jason Lattimer](https://github.com/jlattimer/CRMDeveloperExtensions)
* [Alex Parker](https://github.com/zanders3/json)
* [Facebook SDK for .NET](https://github.com/facebook-csharp-sdk/simple-json)
* [requirejs](https://github.com/requirejs/requirejs)
* [Mihir Maruti Kadam](https://github.com/mihirkadam/FormScriptGenerator)

repository: gasyleiss/Dynamics-Crm-DevKit

repo_name: gasyleiss/Dynamics-Crm-DevKit


text:
# Interface: ResolvedKey

## Table of contents

### Properties

- [key](types.ResolvedKey.md#key)

## Properties

### key

• **key**: [`KeyLike`](../types/types.KeyLike.md) \| `Uint8Array`

Key resolved from the key resolver function.

repository: identity-com/jose

repo_name: identity-com/jose


text:
# Chapter 4 - Quarkus Panache (Repository Pattern)
This is an example using Quarkus Panache and the repository pattern.

This project uses Quarkus, the Supersonic Subatomic Java Framework.

If you want to learn more about Quarkus, please visit its website: https://quarkus.io/ .

## Start up Database
This application expects a PostgreSQL database running on localhost. When running `quarkus:dev` (dev mode), the database will be automatically bootstrapped through [Quarkus DevServices](https://quarkus.io/guides/datasource#devservices-configuration-free-databases). When running in `prod` mode (i.e. via `java -jar` or running the native image) you can use Docker to start the database:

```shell
docker run --ulimit memlock=-1:-1 -it --rm=true --memory-swappiness=0 --name chapter4 -p 5432:5432 quay.io/edeandrea/postgres-13-fruits:latest
```

## Running the application in dev mode

You can run your application in dev mode that enables live coding using:
```shell script
./mvnw compile quarkus:dev
```

> **_NOTE:_**  Quarkus now ships with a Dev UI, which is available in dev mode only at http://localhost:8080/q/dev/.

## Packaging and running the application

The application can be packaged using:
```shell script
./mvnw package
```
It produces the `quarkus-run.jar` file in the `target/quarkus-app/` directory.
Be aware that it’s not an _über-jar_ as the dependencies are copied into the `target/quarkus-app/lib/` directory.

If you want to build an _über-jar_, execute the following command:
```shell script
./mvnw package -Dquarkus.package.type=uber-jar
```

The application is now runnable using `java -jar target/quarkus-app/quarkus-run.jar`.

## Creating a native executable

You can create a native executable using:
```shell script
./mvnw package -Pnative
```

Or, if you don't have GraalVM installed, you can run the native executable build in a container using:
```shell script
./mvnw package -Pnative -Dquarkus.native.container-build=true
```

You can then execute your native executable with: `./target/chapter-4-quarkus-panache-repository-1.0.0-SNAPSHOT-runner`

If you want to learn more about building native executables, please consult https://quarkus.io/guides/maven-tooling.html.

## Related guides

- Hibernate ORM with Panache ([guide](https://quarkus.io/guides/hibernate-orm-panache)): Simplify your persistence code for Hibernate ORM via the active record or the repository pattern

## Provided examples

### RESTEasy Reactive example

Rest is easy peasy & reactive with this Hello World RESTEasy Reactive resource.

[Related guide section...](https://quarkus.io/guides/getting-started-reactive#reactive-jax-rs-resources)

repository: sansow/examples

repo_name: sansow/examples


text:
moderator-keys
==============

Keyboard Support for [Google Moderator](http://www.google.com/moderator)™, as a chrome extension.

Use j, k, & space to vote up, down, & skip.

[Install on the Chrome Web Store](https://chrome.google.com/webstore/detail/keyboard-shortcuts-for-go/jeefnmjkejemongllefiekgehpapepji)
----------

Screenshot
----------

![Screenshot](https://raw.github.com/scheib/moderator-keys/master/images/screenshot-640x400.png "Screenshot")

repository: scheib/moderator-keys

repo_name: scheib/moderator-keys


text:
# Library for order the fields in JSON

This Library is a modification of the original library JSON.Simple that let you order the fields that cames from an array or xml...

	Change the data structure: HasMap to LinkedHasMap

## Getting Started

You need to add the library to your project and the select in your IDE.

### Prerequisites

You need to download the library json-simple-order.jar and then add to the folder of lib in you project.

### Installing

1/Download the library json-simple-order.jar

2/Add to the folder Lib in your project

```
\src\main\java\Lib
```

3/In the case of Intellij, open the Project Structure > Project Settings > Libraries

	3.1/There press the simbol "+" and navagate to the folder path and select the json-simple-order.jar

4/add the import sentence to the class.

```
import org.json.simple.JSONObject;
```

## Running the tests

I add a little program example to test the library. In the follow steps I show the output of the program.

### Break down into end to end tests

1/Initial order of the array that we wants to parse in order into an JSON

```
	String[] header={"Name","Surname","Country","State","City", "Address","PostalCode"};
	String[] content={"Alex","Alexiades","Tazmania","Taz","DiabloCity", "Crazy Avenue","9999"};
```

2/Bad result of the maven json-simple librery example:

 2.1/Maven dependencie

```
	<dependencies>
		<dependency>
			<groupId>com.googlecode.json-simple</groupId>
			<artifactId>json-simple</artifactId>
			<version>1.1.1</version>
		</dependency>
	</dependencies>

```
 2.2/Result of JSON with the maven library

 ```
	{
	   "Address":"Crazy Avenue",
	   "State":"Taz",
	   "Country":"Tazmania",
	   "PostalCode":"9999",
	   "City":"DiabloCity",
	   "Surname":"Alexiades",
	   "Name":"Alex"
	}

```

3/Delete the maven dependencie and add the json-simple-order.jar

 2.2/Result of the JSON with the json-simple-order.jar library

```
{
   "Name":"Alex",
   "Surname":"Alexiades",
   "Country":"Tazmania",
   "State":"Taz",
   "City":"DiabloCity",
   "Address":"Crazy Avenue",
   "PostalCode":"9999"
}
```

## Built With

* [Java](https://maven.apache.org/) - Dependency Management

## Contributing

Please read [CONTRIBUTING.md] for details on our code of conduct, and the process for submitting pull requests to us.

## Authors

* **Alejandro Alexiades**

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

## Acknowledgments

* Based in the Json-simple library : https://github.com/fangyidong/json-simple


text:
---
title: Analysis, Design, and Engineering
galleryid: engineer
layout: course
syllabus: http://engineeryourworld.org/
img: engineering/cad1.png
description: This course is based on the Engineer Your World curriculum developed by UT Austin's Engineering Department. Students work on project-based, collaborative projects to explore engineering mindsets and disciplines.
links:
Engineer Your World Curriculum
---

{::options parse_block_html="true" /}

{% for project in site.data.engineer %}

[![alt text]({{ project.imagefolder }}/{{ project.images[0].thumb }}){:.img-responsive}]({{ project.imagefolder }}/{{ image.name }})

[{{project.title}}]({{project.url}})

{{project.description}}

{% endfor %}

{::options parse_block_html="false" /}

extension: markdown


text:
# Changelog

All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.

## [0.8.0](https://github.com/jsalis/solaire/compare/v0.7.0...v0.8.0) (2020-12-21)

### Bug Fixes

-   potential issue with arrays in the config ([11b2b6e](https://github.com/jsalis/solaire/commit/11b2b6e))

### Build System

-   replace merge dependency ([34d55d4](https://github.com/jsalis/solaire/commit/34d55d4))

### Features

-   export function randomWithSeed ([68b644e](https://github.com/jsalis/solaire/commit/68b644e))

## [0.7.0](https://github.com/jsalis/solaire/compare/v0.6.0...v0.7.0) (2020-07-06)

### Bug Fixes

-   mutate regions in given area ([d37d047](https://github.com/jsalis/solaire/commit/d37d047))

### Features

-   allow initial mutations to be passed on init ([479b835](https://github.com/jsalis/solaire/commit/479b835))

## [0.6.0](https://github.com/jsalis/solaire/compare/v0.5.0...v0.6.0) (2020-06-28)

### Features

-   add wip effect for dungeon rooms ([b42ee7e](https://github.com/jsalis/solaire/commit/b42ee7e))

## [0.5.0](https://github.com/jsalis/solaire/compare/v0.4.0...v0.5.0) (2020-06-21)

### Build System

-   update dependencies ([4d89912](https://github.com/jsalis/solaire/commit/4d89912))

### Features

-   always init regions before generating and add more flexible area options ([f1e0a7d](https://github.com/jsalis/solaire/commit/f1e0a7d))
-   use region position as default seed ([4184ba8](https://github.com/jsalis/solaire/commit/4184ba8))

## [0.4.0](https://github.com/jsalis/solaire/compare/v0.3.0...v0.4.0) (2020-06-20)

### Features

-   add function to generate seeds ([a5c1706](https://github.com/jsalis/solaire/commit/a5c1706))
-   add remove method to world ([e778026](https://github.com/jsalis/solaire/commit/e778026))
-   add seed to regions ([5959324](https://github.com/jsalis/solaire/commit/5959324))

## [0.3.0](https://github.com/jsalis/solaire/compare/v0.2.0...v0.3.0) (2020-06-16)

### Features

-   add separate init method to run generation on custom region areas ([e34c36f](https://github.com/jsalis/solaire/commit/e34c36f))
-   add world serialize function and option to set initial data ([28f0927](https://github.com/jsalis/solaire/commit/28f0927))

## [0.2.0](https://github.com/jsalis/solaire/compare/v0.1.0...v0.2.0) (2020-04-27)

### Bug Fixes

-   do not throw when moving in a direction of zero length ([b4ecb5e](https://github.com/jsalis/solaire/commit/b4ecb5e))

### Build System

-   **deps-dev:** bump acorn from 6.2.0 to 6.4.1 ([#4](https://github.com/jsalis/solaire/issues/4)) ([89f32d9](https://github.com/jsalis/solaire/commit/89f32d9))
-   **deps-dev:** bump codecov from 3.5.0 to 3.6.5 ([#3](https://github.com/jsalis/solaire/issues/3)) ([e54ffcb](https://github.com/jsalis/solaire/commit/e54ffcb))
-   run linter on commit ([b7524c6](https://github.com/jsalis/solaire/commit/b7524c6))
-   **deps:** bump eslint-utils from 1.4.0 to 1.4.3 ([17b537e](https://github.com/jsalis/solaire/commit/17b537e))
-   **deps:** bump handlebars from 4.1.2 to 4.5.3 ([6a667a4](https://github.com/jsalis/solaire/commit/6a667a4))

### Features

-   region generator must throw if an invalid region type is selected ([6b183e0](https://github.com/jsalis/solaire/commit/6b183e0))
-   support persistent mutations to data segment ([ab430d1](https://github.com/jsalis/solaire/commit/ab430d1))

## 0.1.0 (2019-07-15)

### Build System

-   update seedrandom dependency ([7589f34](https://github.com/jsalis/solaire/commit/7589f34))
-   **karma:** replace phantomjs with headless chrome ([4fc905a](https://github.com/jsalis/solaire/commit/4fc905a))
-   migrate to jest and babel 7 ([7e1ee17](https://github.com/jsalis/solaire/commit/7e1ee17))
-   more security fixes ugh ([c21ee82](https://github.com/jsalis/solaire/commit/c21ee82))
-   **package:** audit and update dependencies ([918ecd4](https://github.com/jsalis/solaire/commit/918ecd4))
-   **package:** update dependencies ([fe483ad](https://github.com/jsalis/solaire/commit/fe483ad))
-   **package:** update dependencies ([f3da1a4](https://github.com/jsalis/solaire/commit/f3da1a4))
-   **package:** update dependencies ([a3ea611](https://github.com/jsalis/solaire/commit/a3ea611))
-   **package:** update dependencies ([09b9bac](https://github.com/jsalis/solaire/commit/09b9bac))
-   update standard-version to fix security warning ([22bfdf4](https://github.com/jsalis/solaire/commit/22bfdf4))
-   use commitlint ([9b56d1f](https://github.com/jsalis/solaire/commit/9b56d1f))

### Features

-   add `areaStamp` effect ([ef05782](https://github.com/jsalis/solaire/commit/ef05782))
-   add `cellularAutomata` effect ([40aa8a2](https://github.com/jsalis/solaire/commit/40aa8a2))
-   add `floodFill` effect ([a9496ac](https://github.com/jsalis/solaire/commit/a9496ac))
-   add `majorityRules` effect ([6c3e9c9](https://github.com/jsalis/solaire/commit/6c3e9c9))
-   add `mazeGrowth` effect ([0887d4f](https://github.com/jsalis/solaire/commit/0887d4f))
-   add data segment method `hasElementAt` ([742ef6f](https://github.com/jsalis/solaire/commit/742ef6f))
-   add data segment method `match` ([0ccab0f](https://github.com/jsalis/solaire/commit/0ccab0f))
-   add default region chooser ([dd856d9](https://github.com/jsalis/solaire/commit/dd856d9))
-   add method to randomize data with a weighted distribution ([3c561e1](https://github.com/jsalis/solaire/commit/3c561e1))
-   add method to select regions by type ([fcb4f48](https://github.com/jsalis/solaire/commit/fcb4f48))
-   add methods to the data accessor ([3ed595f](https://github.com/jsalis/solaire/commit/3ed595f))
-   add option to choose region type with a weighted distribution ([6ae80cf](https://github.com/jsalis/solaire/commit/6ae80cf))
-   add options to wrap x and y bounds ([37a5d5e](https://github.com/jsalis/solaire/commit/37a5d5e))
-   add pattern matcher ([f35069e](https://github.com/jsalis/solaire/commit/f35069e))
-   add random number generator for region initializer ([369d239](https://github.com/jsalis/solaire/commit/369d239))
-   add region generator object ([c99240e](https://github.com/jsalis/solaire/commit/c99240e))
-   add region init function ([503ab45](https://github.com/jsalis/solaire/commit/503ab45))
-   add region size ([28dc29c](https://github.com/jsalis/solaire/commit/28dc29c))
-   add region types ([d159aa4](https://github.com/jsalis/solaire/commit/d159aa4))
-   add sanity check for world bounds ([ea8fa4d](https://github.com/jsalis/solaire/commit/ea8fa4d))
-   add support for passing x and y values as two arguments ([23e8b10](https://github.com/jsalis/solaire/commit/23e8b10))
-   add world bounds ([bfbab8a](https://github.com/jsalis/solaire/commit/bfbab8a))
-   add world generate function ([d152bf9](https://github.com/jsalis/solaire/commit/d152bf9))
-   add world movement ([a2ac949](https://github.com/jsalis/solaire/commit/a2ac949))
-   add world renderer ([46ceb28](https://github.com/jsalis/solaire/commit/46ceb28))
-   add world seed and random number generator for region chooser ([511a894](https://github.com/jsalis/solaire/commit/511a894))
-   allow a value to be passed to `fill` and `duplicate` ([74476b9](https://github.com/jsalis/solaire/commit/74476b9))
-   create empty data set and pass to region initializer ([811b5de](https://github.com/jsalis/solaire/commit/811b5de))
-   pass random number generator to region effects instead of the world generate function ([f3dd9cd](https://github.com/jsalis/solaire/commit/f3dd9cd))
-   remove methods to move in cardinal directions ([60c0522](https://github.com/jsalis/solaire/commit/60c0522))
-   use random seed by default ([a229ce1](https://github.com/jsalis/solaire/commit/a229ce1))

### Tests

-   add data segment test cases ([46fa3b6](https://github.com/jsalis/solaire/commit/46fa3b6))
-   add test case for `areaStamp` effect ([6854e40](https://github.com/jsalis/solaire/commit/6854e40))
-   add test case for world seed ([ac96c07](https://github.com/jsalis/solaire/commit/ac96c07))

repository: jsalis/solaire

repo_name: jsalis/solaire


text:
### [CVE-2020-25705](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-25705)
![](https://img.shields.io/static/v1?label=Product&message=Siemens%20Lunux%20Based%20Products&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=USE%20OF%20INSUFFICIENTLY%20RANDOM%20VALUES%20CWE-330&color=brighgreen)

### Description

A flaw in ICMP packets in the Linux kernel may allow an attacker to quickly scan open UDP ports. This flaw allows an off-path remote attacker to effectively bypass source port UDP randomization. Software that relies on UDP source port randomization are indirectly affected as well on the Linux Based Products (RUGGEDCOM RM1224: All versions between v5.0 and v6.4, SCALANCE M-800: All versions between v5.0 and v6.4, SCALANCE S615: All versions between v5.0 and v6.4, SCALANCE SC-600: All versions prior to v2.1.3, SCALANCE W1750D: v<IP_ADDRESS>, v8.6.0, and v8.7.0, SIMATIC Cloud Connect 7: All versions, SIMATIC MV500 Family: All versions, SIMATIC NET CP 1243-1 (incl. SIPLUS variants): Versions 3.1.39 and later, SIMATIC NET CP 1243-7 LTE EU: Version

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/developer3000S/PoC-in-GitHub
- https://github.com/hectorgie/PoC-in-GitHub
- https://github.com/nanopathi/linux-4.19.72_CVE-2020-25705
- https://github.com/nomi-sec/PoC-in-GitHub
- https://github.com/tdwyer/CVE-2020-25705

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
# Security Policy

## Reporting a Vulnerability

Please report security issues to:

* Chris Boden [cboden<EMAIL_ADDRESS>* Matt Bonneau [matt<EMAIL_ADDRESS>

repository: tsugiproject/tsugi

repo_name: tsugiproject/tsugi


text:
# CMU Clubs
Rapidly onboard new members at the Activities Fair with CMU Clubs. Given an Andrew ID, the system scrapes the CMU Directory to fetch the corresponding member's name, major, and graduation year. The information is inserted into a structured table and can be exported for use in other roster management applications.

This web application was developed for student organizations at Carnegie Mellon University.

Brought to you by the [CMU Business Technology Group](https://cmubtg.com).

Directory Lookup: Dylan Chou, Juan Diego Meza
UX Design: Matthew Guo
CSV Export: Jenny Zhu

## Development
Start the Django REST API server:
```
pipenv install
pipenv run python manage.py migrate
pipenv run python manage.py createsuperuser
pipenv run python manage.py runserver
```

Start the React.js client server:
```
cd TheClub/clubClient
npm install
npm start
```

## Usage
1) Create a club via the admin portal: http://localhost:8000/admin
2) Login to the application: http://localhost:3000

repository: calvinhklui/CMUClubs

repo_name: calvinhklui/CMUClubs


text:
# Introduction

Architectural patterns describe “[…] a fundamental structural organization or scheme for software systems and provide a set of predefined subsystems, specify their responsibilities, and include rules and guidelines for organizing the relationships between them” [1, p. 12].

## Overview of Architectural Patterns

* [Façade Pattern](Façade%20Pattern/README.md)
* [Name-Service Pattern](Name-Service%20Pattern/README.md)
* [Observer Pattern](Observer%20Pattern/README.md)
* [Oracle Pattern](Oracle%20Pattern/README.md)
* [Proxy Pattern](Proxy%20Pattern/README.md)

# References
[1] F. Buschmann, Ed., Pattern-oriented software architecture: a system of patterns. Chichester; New York: Wiley, 1996.

repository: hasebrook/smart-contract-dev-support

repo_name: hasebrook/smart-contract-dev-support


text:
# Web Hosting Stack

When I first began working with Web hosting, Apache was the only tool I knew. While it's incredibly powerful for a wide range of hosting configurations, the compromise is performance.

I created these scripts to help automate setup of a Centos 6.6-based system for hosting both Python Django apps as well as Wordpress. You'll notice that sometimes I use the pre-built packages (via yum), and sometimes I elect to compile from source. Sometimes the EPEL is a bit behind in the current releases (for stability). Where appropriate, I've compiled the most recent stable version that hasn't made it in yet. It sets up this stack:

<center>![Web Hosting Stack](WebDevStack.png)</center>

| Service | Port | Firewall | Note |
| ------- | ---- | -------- | ---- |
| **Varnish** | 80 | Public | Acts as the primary page cache, and should catch a majority of requests. |
| **nginx** | 8080 | Blocked | Handles serving up static content to Varnish. |
| **gunicorn** | 8000 | Blocked | Handles dynamic content for Python. |
| **Python** | - | - | My current favorite development language. The **Django** framework runs under Python. |
| **php-fpm** | 9000 | Blocked | Handles dynamic content for PHP. |
| **MariaDB** | 3306 | Blocked | Next-generation database. Fully MySQL compliant. |
| **ssh** | 22 | Public | Secure terminal shell service for managing the server through the CLI. We also use fail2ban for additional protection. |

## Server Setup
Sign in **as root** to your freshly-installed Centos 6.6 server (either at the console or via ssh), and issue the following command:

```bash
curl -s https://raw.githubusercontent.com/andrewmarconi/sysadmin-tools/master/centos-6.6/setup.sh | bash
```

## Adding the 'wheel' Group to Sudoers
The script automates the creation of a non-root user, and adds this account to the 'wheel' group. You need to manually enable the rule in the /etc/sudoers file to allow members of the 'wheel' group to run administrative commands. I've attempted to automate this, but it's currently broken (and commented out). Until this is fixed, as root, you need to type ```visudo``` from the command prompt, and uncomment out the following line:

```bash
# %wheel	ALL=(ALL)	ALL
```

## Configuring rmate and SSH Port Forwarding
If you have [TextMate 2](https://github.com/textmate/textmate) or GitHub's [Atom](https://github.com/atom/atom) installed locally as your text editor, you can enable "port forwarding" so that you can easily edit remote files on your local machine.

First, you need to install [rmate](https://github.com/textmate/rmate) on your remote server:

```bash
curl -Lo /usr/local/bin/rmate https://raw.githubusercontent.com/textmate/rmate/master/bin/rmate
chmod o+a /usr/local/bin/rmate
```

Next, you need to add the remote server to your *~/.ssh/config* file locally (this is for Mac OSX -- I've no idea how this is handled on Windows). If the file doesn't exist, create it, and then add this:

```bash
Host xxx.xxx.xxx.xxx
    RemoteForward 52698 localhost:52698
    User uuuuu
```
Of course, replace 'xxx.xxx.xxx.xxx' with your remote server's IP address. You may also use wildcards -- so, for instance if your server network segment is <IP_ADDRESS> through <IP_ADDRESS>, then you can simply use 192.168.5. I use this frequently for servers on my local network, and use only the specific IP address for remote servers.

Also replace the 'uuuuu' with your **remote** user's name. I'd recommend this not be 'root' for security reasons.

## Additional Tools
This script installs and configures Solr, Tomcat, Java, and Postgresql. Not really important for the basic stack, but included here in case I need it.

```bash
curl -s https://raw.githubusercontent.com/andrewmarconi/sysadmin-tools/master/centos-6.6/additional-services.sh | bash
```

repository: andrewmarconi/sysadmin-tools

repo_name: andrewmarconi/sysadmin-tools


text:
# py-simulitis
Python Virus Spread Simulator for Kids

Works well in Visual Studio Code, standard python libraries

Code inspired by
https://www.youtube.com/watch?v=HHQV3ifJopo
and by
https://www.washingtonpost.com/graphics/2020/world/corona-simulator/

TODOS:
1. Show live statistics
2. Implement virus vectors with no symptoms
3. Implement infection via trails
4.  Implement confinement

![Alt text](images/distribution.png?raw=true "Distribution")
![Alt text](images/simulation.png?raw=true "Simulation")

repository: pimajor/py-simulitis

repo_name: pimajor/py-simulitis


text:
# RWXLightReplace
For replacing Surface, Ambient, and Diffuse script tags on bulk RWX objects.

* Point it at a directory of RWX files, zipped or unipped
* Will scan each file for Surface, Ambient, or Diffuse tags and change their values
* Option to re-zip the files after processing

# Caveats
RWXLightReplace won't unzip a file if another file with the same name is in the processing directory. For example, if you have a file named test.zip that contains a file called test.rwx, then it will not extract if there is already a test.rwx file in the directory. Will be fixed in a later version.

Will not process password protected zips. Unzip those first with a program like multizip.

license: Unlicense

repository: locodarwin/RWXLightReplace

repo_name: locodarwin/RWXLightReplace


text:
# Research Project: Group Movement

## Small summary

[The web page](https://tomascarreras1000.github.io/Research-Project-Group-Movement/) and the [GitHub repository](https://github.com/tomascarreras1000/Research-Project-Group-Movement) where it is created from are dedicated to how to generate Group Movement for an RTS game.

###### For the full research, please take a look at the [web page](https://tomascarreras1000.github.io/Research-Project-Group-Movement/).

## About the Author

I am [Tomás Carreras](https://www.linkedin.com/in/tom%C3%A1s-carreras-a96a99177/) (GitHub username [*tomascarreras1000*](https://github.com/tomascarreras1000)), student of the [Bachelor's Degree in Video Games by UPC at CITM-TTC](https://www.citm.upc.edu/ing/estudis/grau-videojocs-bcn/). This content is generated for the second year's subject Project 2, under supervision of lecturer [Ramon Santamaria](https://www.linkedin.com/in/raysan/).

## Relevant Links

+ [Links to documentation in the web page](https://tomascarreras1000.github.io/Research-Project-Group-Movement/#links-to-documentation)


text:
+++
toc = true
next = ""
prev = "/faqs-borrowable-books"
title = "Accounts"
date = "2017-03-14T14:07:12-04:00"
chapter = true
icon = "> "

+++

# Using Scholars Portal Books Accounts

Creating a Scholars Portal Books account allows you to make and save book lists, and to annotate, highlight, and take notes as you read. You can log in to your Books account from the top right-hand side of every page:

Queens, Guelph, Toronto, Ottawa, Windsor, and York currently support Shibboleth one step login for Books:

This means that your SP Books account is linked to your library credentials, and signing in to your account will also allow you to access subscribed content.

If you're at a school that does not yet support this process, you can create an account using your Google, Facebook, Twitter, or OpenID credentials. If you're off-campus you will also have to sign in with your library credentials to access content.

An account's library contains marked and saved records, as well as all annotations made to a text:

repository: kaitlinnewson/hugo-guides-demo

repo_name: kaitlinnewson/hugo-guides-demo


text:
---
title: Organizing Obsidian for D&D | The Big Picture on Vaults
external: false
date: 2023-06-11
draft: false
---

[Getting started](/blog/getting-started-with-obsidian-dnd/) with Obsidian for D&D is easy. Organizing rules, campaigns, and worlds is not. The possibilities are endless. Your needs might simplify or complicate this further. In this series, we'll break down what you need to think about and why. We'll look at strategies to help you get the most out of using Obsidian to organize your D&D life.

## Enter the Vault
The first decision we need to make is regarding our vault or vaults. You can use a single vault for everything. You can use one vault for each campaign, world, or game system. You could use one vault for D&D and another for everything else in your life. There's no wrong way to approach this. But some of these strategies will make it harder for you in the long run.

## One Vault to Rule Them All
You can make good arguments for or against using a single vault but experience has taught me it's the best way to use Obsidian *when done well*.

Multiple vaults might lead to duplicated notes (for example if each vault needed to reference the same location or SRD). It also requires multiple Obsidian windows if you need to work in both.

One vault allows you to discover connections and generate more ideas. But it also presents challenges.

![Sauron reaching for the Obsidian logo](/images/OneVaultRuleAll.png)

With one vault, organization and strategy are key. Here are some of the main considerations:

**File Structure**. We want a structure that makes sense to our brain and the content.

**Tags/Frontmatter**. We want data to organize and understand what we have across our notes.

**Search**. We want to protect search functionality from getting convoluted.

**Future Proof**. We want a vault that can grow with new systems—adding a new campaign, world, or rule system shouldn't be painful. Adopting a new plugin or dropping an old one shouldn't break our notes or create a mess.

When your notes are organized well in a single vault, it introduces the opportunity for simple workflows and emergent ideas. Keeping in mind the points above, you can ensure that your vault becomes a source of inspiration—not just an archive. Don't sweat any of this too much yet. Just set up a single vault with a `TTRPG` folder to sit alongside any other important areas of your life (mine includes other folders for this blog, cooking, engineering, wellness, etc.).

We'll cover it all in this series so be sure to subscribe below to get notified when the next article drops.

Game on.


text:
# Paddle Operator

## Overview

Paddle Operator makes it easy to run [paddle](https://www.paddlepaddle.org.cn/)
distributed training job on kubernetes by providing PaddleJob custom resource etc.

## Quick Start
### Prerequisites

* Kubernetes >= 1.8
* kubectl

### Installation

With kubernetes ready, you can install paddle operator with configuration in *deploy* folder
(use *deploy/v1* for kubernetes v1.16+ or *deploy/v1beta1* for kubernetes 1.15-).

Create PaddleJob crd,
```shell
$ kubectl apply -f https://raw.githubusercontent.com/PaddleFlow/paddle-operator/main/deploy/v1/crd.yaml
```

A succeed creation leads to result as follows,
```shell
$ kubectl get crd
NAME                                    CREATED AT
paddlejobs.batch.paddlepaddle.org       2021-02-08T07:43:24Z
```

Then deploy controller,

```shell
$ kubectl apply -f https://raw.githubusercontent.com/PaddleFlow/paddle-operator/main/deploy/v1/operator.yaml
```

the ready state of controller would be as follow,
```shell
$ kubectl -n paddle-system get pods
NAME                                         READY   STATUS    RESTARTS   AGE
paddle-controller-manager-698dd7b855-n65jr   1/1     Running   0          1m
```

By default, paddle controller runs in namespace *paddle-system* and only controll jobs in that namespace.
To run controller in a different namespace or controll jobs in other namespaces, you can edit `charts/paddle-operator/values.yaml` and install the helm chart.
You can also edit kustomization files or edit `deploy/v1/operator.yaml` directly for that purpose.

If you have any questions or concerns about the usage, please do not hesitate to contact us.

## More Information

Please refer to the
[中文文档](https://fleet-x.readthedocs.io/en/latest/paddle_fleet_rst/paddle_on_k8s.html)
for more information about paddle configuration.

repository: renhuanyu/paddle-operator

repo_name: renhuanyu/paddle-operator


text:
Mac OS X Build Instructions and Notes
====================================
This guide will show you how to build unigridd (headless client) for OSX.

Notes
-----

* Tested on OS X 10.7 through 10.10 on 64-bit Intel processors only.

* All of the commands should be executed in a Terminal application. The
built-in one is located in `/Applications/Utilities`.

Preparation
-----------

You need to install XCode with all the options checked so that the compiler
and everything is available in /usr not just /Developer. XCode should be
available on your OS X installation media, but if not, you can get the
current version from https://developer.apple.com/xcode/. If you install
Xcode 4.3 or later, you'll need to install its command line tools. This can
be done in `Xcode > Preferences > Downloads > Components` and generally must
be re-done or updated every time Xcode is updated.

There's also an assumption that you already have `git` installed. If
not, it's the path of least resistance to install [Github for Mac](https://mac.github.com/)
(OS X 10.7+) or
[Git for OS X](https://code.google.com/p/git-osx-installer/). It is also
available via Homebrew.

You will also need to install [Homebrew](http://brew.sh) in order to install library
dependencies.

The installation of the actual dependencies is covered in the Instructions
sections below.

Instructions: Homebrew
----------------------

#### Install dependencies using Homebrew

        brew install autoconf automake berkeley-db4 libtool boost miniupnpc openssl pkg-config protobuf qt5 zmq libevent

### Building `unigridd`

1. Clone the github tree to get the source code and go into the directory.

        git clone https://github.com/unigrid-project/daemon.git
        cd UNIGRID

2.  Make the Homebrew OpenSSL headers visible to the configure script  (do ```brew info openssl``` to find out why this is necessary, or if you use Homebrew with installation folders different from the default).

        export LDFLAGS+=-L/usr/local/opt/openssl/lib
        export CPPFLAGS+=-I/usr/local/opt/openssl/include

3.  Build unigridd:

        ./autogen.sh
        ./configure --with-gui=qt5
        make

4.  It is also a good idea to build and run the unit tests:

        make check

5.  (Optional) You can also install unigridd to your path:

        make install

Creating a release build
------------------------
You can ignore this section if you are building `unigridd` for your own use.

unigridd/unigrid-cli binaries are not included in the unigrid-Qt.app bundle.

If you are building `unigridd` for others, your build machine should be set up
as follows for maximum compatibility:

All dependencies should be compiled with these flags:

 -mmacosx-version-min=10.7
 -arch x86_64
 -isysroot $(xcode-select --print-path)/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.7.sdk

Once dependencies are compiled, see release-process.md for how the UNIGRID-Qt.app
bundle is packaged and signed to create the .dmg disk image that is distributed.

Running
-------

It's now available at `./unigridd`, provided that you are still in the `src`
directory. We have to first create the RPC configuration file, though.

Run `./unigridd` to get the filename where it should be put, or just try these
commands:

    echo -e "rpcuser=unigridrpc\nrpcpassword=$(xxd -l 16 -p /dev/urandom)" > "/Users/${USER}/Library/Application Support/UNIGRID/unigrid.conf"
    chmod 600 "/Users/${USER}/Library/Application Support/UNIGRID/unigrid.conf"

The next time you run it, it will start downloading the blockchain, but it won't
output anything while it's doing this. This process may take several hours;
you can monitor its process by looking at the debug.log file, like this:

    tail -f $HOME/Library/Application\ Support/UNIGRID/debug.log

Other commands:
-------

    ./unigridd -daemon # to start the unigrid daemon.
    ./unigrid-cli --help  # for a list of command-line options.
    ./unigrid-cli help    # When the daemon is running, to get a list of RPC commands

repository: HUZU-Project/HUZU

repo_name: HUZU-Project/HUZU


text:
# pySearchPassDB_SQLite
Write data to the database and search for a password by email on this database. **SQLite** is used as a database.
## How to use
First you need to create a database.
```
python pySearchPassDB_SQLite.py --create
```
Search for passwords by email.
```
python pySearchPassDB_SQLite.py -s<EMAIL_ADDRESS>python pySearchPassDB_SQLite.py --search<EMAIL_ADDRESS>```
Add fields to the database from files. The lines in the file must be in the format *email:password*. Specifies the path to the folder where these files are with passwords. All files and subdirectories are parsed.
```
python pySearchPassDB_SQLite.py -a "path/to/dir"
python pySearchPassDB_SQLite.py --add "path/to/dir"
```
Show count fileds of db.
```
python pySearchPassDB_SQLite.py -c
python pySearchPassDB_SQLite.py --count
```
Clear all db fields.
```
python pySearchPassDB_SQLite.py --clear
```
## Delimiters
There can be different separators in the lists. These delimiters can be changed in the script itself in the tuple *PATTERN_SPLIT*. The default is 2 delimiters (":" and ";").


text:
# LockfreeSPSCQueue

[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/p-id/spscq/master/LICENSE)

This is header only, C implementation of a lockfree single producer single consumer bounded queue for concurrent programming.

This implementation is best suited for heavy data movement between single producer and single consumer, typical application scenarios are video streaming pipeline and for sharing data across CPUs. The implementation ensures there are no additional memory copies while sharing the data between threads.

The code has been battle tested in production for quite sometime, but do report issues if observed.
# Example

```c
#define ELEMENT_TYPE payload_t*
#define SPSC_QUEUE_SIZE 8192

spsc_queue_t queue;

// producer thread
payload_t* payload_in = NULL;
payload_in = malloc(sizeof(payload_t)); // alternatively get payload blob from object-pool
load_data(payload_in);
enqueue(&queue, payload_in);

// consumer thread
payload_t* payload_out = NULL;
dequeue(&queue, &payload_out);
consume_func(payload_out);
free(payload_out); // alternatively return payload_out back to object-pool
```

Only a single writer thread can perform enqueue operations and only a single reader thread can perform dequeue operations. Any other usage is invalid.

However, one can bundle the SPSC queue implementation with provided spin-lock implementation.
As a note of caution the current spin-lock implementation uses a lot of assembly code which might need a bit of porting effort [Ran in production handling ~100k requests per second on Intel x86_64 Dell hardware]

# Implementation

The underlying implementation uses [ring buffer](https://en.wikipedia.org/wiki/Circular_buffer).

Care has been taken to make sure to avoid any issues with [false sharing](https://en.wikipedia.org/wiki/False_sharing).

The algorithm is optimized further to use an adaptive [B-Tree style] lookahead for queue head/tail indexes to avoid cache-line faults.

References:

- *Intel*. [Avoiding and Identifying False Sharing Among Threads](https://software.intel.com/en-us/articles/avoiding-and-identifying-false-sharing-among-threads).
- *B-Queue*. [B-Queue: Efficient and Practical Queuing for Fast Core-to-Core Communication](http://staff.ustc.edu.cn/~bhua/publications/IJPP_draft.pdf)

## See Also
* [Folly MPMC Queue](https://github.com/facebook/folly/blob/master/folly/MPMCQueue.h) Open source by Facebook
* [Elle](https://github.com/infinit/elle) C++14 asynchronous/coroutine framework used by Infiniti distributed-encrypted filesystem
* [SeaStar](https://github.com/scylladb/seastar) non-blocking asynchronous event-driven C++14 framework used by NOSQL ScyllaDB (see [tutorial](https://github.com/scylladb/seastar/blob/master/doc/tutorial.md))
* [Boson](https://github.com/duckie/boson) C++14 asynchronous/coroutine framework similar to Go channels
* [MC FastFlow](http://sourceforge.net/projects/mc-fastflow/) **M**ulti-**C**ore friendly framework in old C++98 (published in 2009) and still maintained

# About

This project was created by [Piyush<EMAIL_ADDRESS>

repository: tianfengfrank/spscq

repo_name: tianfengfrank/spscq


text:
# BlockTrain

A private blockchain based, trusted key-value store.

# Installation

```
go get -v -u github.com/PiMaker/BlockTrain/choo
```

Then execute `choo` and follow the on screen instructions.

# License

(C) Stefan Reiter 2017

See the file LICENSE in this projects root for more information.

repository: PiMaker/BlockTrain

repo_name: PiMaker/BlockTrain


text:
# Diphloeis candida (Weber) Clem. SPECIES

#### Status
SYNONYM

#### According to
Index Fungorum

#### Published in
Gen. fung. (Minneapolis) (1909)

#### Original name
Lichen candidus Weber

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Lecanoromycetes/Lecanorales/Ramalinaceae/Toninia/Toninia candida/ Syn. Diphloeis candida/README.md

repo_name: mdoering/backbone


text:
The Hyperscale Programming Language [![Build Status](https://img.shields.io/travis/hyperscale/hyperscale/master.svg)](https://travis-ci.org/hyperscale/hyperscale)
===================================

![Hyperscale logo](https://cdn.rawgit.com/hyperscale/hyperscale/master/_resources/logo/hyperscale-logo-color.svg "Hyperscale logo")

This is the main source code repository for Hyperscale. It contains the compiler, standard library, and documentation.

This project is EXPERIMENTAL. The behaviour of this project, its name, and surrounding documentation may change without notice in a future release.

Building from Source
--------------------

### Building on *nix

1. Make sure you have installed the dependencies:

   * `g++` 4.7 or later or `clang++` 5.x or later
   * GNU `make` 3.81 or later
   * `cmake` 3.8.2 or later
   * `boost` 1.66.0 or later
   * `llvm` 5.0.1 or later
   * `curl`
   * `git`
   * `lcov`

2. Clone the [source] with `git`:

   ```sh
   $ git clone https://github.com/hyperscale/hyperscale.git
   $ cd hyperscale
   ```

[source]: https://github.com/hyperscale/hyperscale

3. Build and install:

    ```sh
    $ mkdir build
    $ cd build/
    $ cmake ../
    $ make
    ```

Example
-------

### Debug Pretty Print (format text)

simple.hyper
```
var i = (12 + 8 * 5);

print(i);

```

```sh
$ ./build/bin/hyperscale debug pretty-print ./dev/simple.hyper
```

```
>  SourceFile
>  >  VarDecl <line:1, col:1> used i
>  >  >  ParenExpr <line:1, col:9>
>  >  >  >  BinaryOperator <line:1, col:13> '+'
>  >  >  >  >  IntegerLiteral <line:1, col:10> 'int' 12
>  >  >  >  >  BinaryOperator <line:1, col:17> '*'
>  >  >  >  >  >  IntegerLiteral <line:1, col:15> 'int' 8
>  >  >  >  >  >  IntegerLiteral <line:1, col:19> 'int' 5
>  >  CallExpr <line:3, col:1> 'print'
>  >  >  DeclRefExpr <line:3, col:7> 'i'
```

### Debug pretty Print (format dot)

simple.hyper
```
var i = (12 + 8 * 5);

print(i);

```

```sh
$ ./build/bin/hyperscale debug pretty-print --format dot ./dev/simple.hyper
```

```dot
digraph astgraph {
  node [shape=plaintext, fontsize=12, fontname="Courier", height=.1];
  ranksep=.3;
  edge [arrowsize=.5]
  node0x7f8d89f05580 [label="file"];
  node0x7f8d89f055b0 [label="i"];
  node0x7f8d89f055f0 [label="factor"];
  node0x7f8d89f055f0_open [label="("];
  node0x7f8d89f05610 [label="+"];
  node0x7f8d89f05640 [label="12"];
  node0x7f8d89f05660 [label="*"];
  node0x7f8d89f05690 [label="8"];
  node0x7f8d89f056b0 [label="5"];
  node0x7f8d89f05660 -> node0x7f8d89f05690;
  node0x7f8d89f05660 -> node0x7f8d89f056b0;
  node0x7f8d89f05610 -> node0x7f8d89f05640;
  node0x7f8d89f05610 -> node0x7f8d89f05660;
  node0x7f8d89f055f0_close [label=")"];
  node0x7f8d89f055f0 -> node0x7f8d89f055f0_open;
  node0x7f8d89f055f0 -> node0x7f8d89f05610;
  node0x7f8d89f055f0 -> node0x7f8d89f055f0_close;
  node0x7f8d89f055b0 -> node0x7f8d89f055f0;
  node0x7f8d89f05580 -> node0x7f8d89f055b0;
  node0x7f8d89f056d0 [label="print"];
  node0x7f8d89f05720 [label="i"];
  node0x7f8d89f056d0 -> node0x7f8d89f05720;
  node0x7f8d89f05580 -> node0x7f8d89f056d0;
}
```

![AST Graph](https://cdn.rawgit.com/hyperscale/hyperscale/master/_resources/ast-graph.png "AST Graph")

Features and roadmap
--------------------

- [ ] Command Line
    - [ ] Debug : Command for debugging compiler during development
        - [x] Lexer
        - [ ] Parser
    - [ ] Build : Command for build project written in hyperscale
    - [ ] Test : Command for test project written in hyperscale
    - [ ] Bench : Command for benchmark project written in hyperscale
    - [ ] Lint : Command for linting project written in hyperscale
    - [ ] Package : Command for manage package in project written in hyperscale
- [ ] Compiler
    - [x] Lexer
    - [ ] Parser
    - [ ] AST
    - [ ] Code Generator (LLVM)
- [ ] Standard Library
    - [ ] Spec
- [ ] Documentation
    - [ ] Grammar/Lexical Structure
    - [ ] Command Line
    - [ ] Standard Library

License
-------

See the [LICENSE](LICENSE.md) file for license rights and limitations (MIT).

repository: hyperscale/hyperscale

repo_name: hyperscale/hyperscale


text:
### 09. Rolling

![logo](./09.Rolling.jpg)

There's a hill that I know

Where we all love to go, When the days are clear and blue.

We **climb** right to the top

And down we all flop, Then here is what we do.

We lie flat as flat in the soft green grass, Our hands down by our sides,

And we roll like round, fat **barrels**

Down the slope of that green hill side.

And the **whole** world turns around us

As we all roll round and round,

And the sky spins above our heads

As we **bounce** along the **ground**.

And who'll get to the bottom first?

Will it be Ann or Lee?

Or maybe Tome or Sean or Jane,

Or maybe even me?

And yes it's me, I got there first,

So I shout to Tome and Jane,

And shout to Sean and Lee and Ann,

"Let's do it over again."

So we all **climb** back

To the top of our hill

And go rolling down again.

Yes, over and over and over and over

And over and over

AGAIN.

#### New Words

> barrel, flat, side, bottom, flop, slope, bounce, ground, soft, clear, lie, spin, climb, right, whole

repository: KleeTaurus/Collins-BIGCAT

repo_name: KleeTaurus/Collins-BIGCAT


text:
* Author : Jeewon Park
* Description : Generate static variables of Addressable Labels to manage it EASY.
* How to use :
```
     1. just put the script in /Assets/Editor/
     2. make Labels in Addressable
     3. assign labels to your addressable assets
     4. Hit Deckard Utils / Get All Labels in menu bar
     5. then you can see the AutoGenLabels.cs in Scripts/AllLabels folder
     6. it is private static variables,
        6-1. however, you can access in anywhere with AutoGenLabels.GetLabels() to get all labels
        6-2. return type is List<String>
     7. It should be handy, if you make a downloader.
```
* Worked in :
```
     1. Unity 2019.3.0f
     2. Addressable 1.5
```

repository: coldmine/AddressableLabelGenerator

repo_name: coldmine/AddressableLabelGenerator


text:
---
title: MikroTik Firmware
aliases: ["/software/mikrotikfirmware"]
weight: 999
---

MikroTik routerOS 6 firmware is generally stable. We are currently using 6.49.6.

**Do not use version 7 (not yet supported) or version 6.47/6.48/6.49.2 (occasional hangs) **

**routerOS 6**

Download 6.49.6 [OmniTik (mipsbe) here](https://download.mikrotik.com/routeros/6.49.6/routeros-mipsbe-6.49.6.npk) and [SXTsq (arm) here](https://download.mikrotik.com/routeros/6.49.6/routeros-arm-6.49.6.npk)

Remember that OmniTiks use the "mipsbe" firmware and SXT's use the "arm" firmware due to different processors.

We have documented issues with 6.47/6.48/6.49.2 so don't use them.

We have many omnitiks running 6.49.6 without any problem.

**routerOS 7**

Don't use it yet - it won't work!

This has finally been released but it doesn't work with our configuration yet. We keep testing it as we are eager to deploy the newly added WireGuard.
If you are interested in beta-testing the WG setup, post in the #software-firmware channel on Slack.

If you need to downgrade, read the [instructions here](../../hardware/mikrotikomnitik5ac/)

---

Mikrotik devices come in a variety of architectures and form-factors. Fortunately the firmware versioning and built levels are the same across all platforms. The main variant is the architecture, which might be a different chip for each device model.

We currently use the stable version of RouterOS 6 (__6.49.6__)

Below is a table of the 6.49.6 firmware for Mikrotik devices that are in the mesh:

|Model|Architecture|Firmware link|
|---|---|---|
| OmniTik 5ac | MIPSBE | [Download](https://download.mikrotik.com/routeros/6.49.6/routeros-mipsbe-6.49.6.npk) |
| SXTsq ac | ARM | [Download](https://download.mikrotik.com/routeros/6.49.6/routeros-arm-6.49.6.npk) |
| hAP ac^2 | ARM | [Download](https://download.mikrotik.com/routeros/6.49.6/routeros-arm-6.49.6.npk) |
| CCR Series | TILE | [Download](https://download.mikrotik.com/routeros/6.49.6/routeros-tile-6.49.6.npk) |
| hAP mini | SMIPS | [Download](https://download.mikrotik.com/routeros/6.49.6/routeros-smips-6.49.6.npk) |
| hAP lite | SMIPS | [Download](https://download.mikrotik.com/routeros/6.49.6/routeros-smips-6.49.6.npk) |

## Installing firmware
*   Login to your Mikrotik box Web UI ( CLI if you know how )
*   Go to WebFig > Files section, upload the firmware file
*   Reboot the router
*   The firmware version is visible at the top of the Web UI, watch for the new version

repository: nycmeshnet/docs

repo_name: nycmeshnet/docs


text:
# [Computer Facts](http://alexa.amazon.com/#skills/amzn1.ask.skill.f093a3e2-61b8-4ced-a761-83b4533f0417)
![3.6 stars](../../images/ic_star_black_18dp_1x.png)![3.6 stars](../../images/ic_star_black_18dp_1x.png)![3.6 stars](../../images/ic_star_black_18dp_1x.png)![3.6 stars](../../images/ic_star_half_black_18dp_1x.png)![3.6 stars](../../images/ic_star_border_black_18dp_1x.png) 4

To use the Computer Facts skill, try saying...

* *Alexa, open Computer Facts*

* *Alexa, give me a fact from Computer Facts*

* *Alexa, ask Computer Facts for a fact*

Using this skill, Alexa is able to give you some fun and interesting facts about computer and technologies.

***

### Skill Details

* **Invocation Name:** computer facts
* **Category:** null
* **ID:** amzn1.ask.skill.f093a3e2-61b8-4ced-a761-83b4533f0417
* **ASIN:** B01M1E2ADJ
* **Author:** jjeannin
* **Release Date:** September 20, 2016 @ 01:12:28
* **In-App Purchasing:** No


text:
# ansible-server-provisioning

This playbook installs and configures the following on Ubuntu:

Graylog sidecar (Graylog)
Node exporter (prometheus)
Filebeats (for Graylog)

Usage:
Enter Required variables in `provisioning-variables.yml` and hosts in `provisioning-hosts.yaml`. Use `ansible-playbook -i provision-hosts.yaml provision-servers.yml -K`