text:
# Changelog
All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).

## [Unreleased]
### Added
- Following sum with `Hasher` and `Digest` implementation ([#3](https://github.com/althonos/pruefung/pull/3)):
    * Crc8 (CCIT variant)
    * Crc16 (XMODEM variant)
    * Crc64 (*???* variant)
- Derived `Debug` implementation for all `Hasher`.
### Changed
- Bumped required `digest` version to `v0.7`.
- Bumped required `generic-array` version to `v0.9`.
### Removed
- [`crypto-test`](https://crates.io/crates/crypto-tests) test dependency
  (replaced by [`digest::dev`](https://docs.rs/crate/digest/0.7.5/source/src/dev.rs)).

## [0.2.1] - 2017-11-23
### Added
- `Digest` and `Hasher` traits are re-exported at root of module.
### Fixed
- `README.md` is now the readme file of the crate.
- Make `BSD` checksum available only since `0.2.1`.

## [0.2.0] - 2017-07-24
### Added
- Following sum with `Hasher` & `Digest` implementations:
    * Unix (UNIX `cksum`)
    * FNV 32 in several variants: `FNV1-32`, `FNV1a-32` and `FNV0-32`
    * FNV 64 in several variants: `FNV1-64`, `FNV1a-64` and `FNV0-64`
- Paper & reference about CRC32, CRC32c, Adler32 and UNIX checksum.
### Fixed
- **CRC32/CRC32C**: Useless NOT operations before/after each block write, replaced by
  a single NOT operation in the `finish` method (and initialisation to `0xFFFFFFFF`).
### Changed
- Implementation of unit tests to use private macros module.
- Names of checksum structs to follow Rust naming conventions (acronyms as single
  CamelCased word): `BSD` -> `Bsd`, `CRC32(C)` -> `Crc32(c)`, `UNIX` -> `Unix`.
- Code using bitwise operations to use Rust primitive methods where applicable.
- Structure of the library to nest the `crc32` module inside a `crc` module.
### Removed
- [`byte-tools`](https://crates.io/crates/byte-tools) and [`block-buffer`](https://crates.io/crates/block-buffers)
  dependencies, *crate is now free of any requirement !*

## 0.1.0 - 2017-07-20
### Added
- Following sums with Hasher & Digest implementations:
    * Adler32
    * Bsd checksum (UNIX `sum`)
    * Crc32 (Ethernet variant)
    * Crc32c (Castagnoli polynomial variant)
    * Fletcher16
    * SysV checksum (UNIX `sum -s`)
- Tests and benchmarks generated with the [`crypto-tests`](https://crates.io/crates/crypto-tests) crate.
- A basic README inspired by the README of the [`hashes`](https://github.com/RustCrypto/hashes) project.
- This CHANGELOG file.

[Unreleased]: https://github.com/althonos/pruefung/compare/0.2.0...HEAD
[0.2.0]: https://github.com/althonos/pruefung/compare/0.1.0...0.2.0
[0.1.0]: https://github.com/althonos/pruefung/compare/8b9ae86...0.1.0

license: MIT

repository: althonos/pruefung

branch_name: refs/heads/master

extension: md

gha_language: Rust

license_type: permissive

repo_name: althonos/pruefung


text:
## Introduction

We see it all of the time on the big screen - a loved one is lost and the living can't
help but fret that they never 'told them I loved them.'  We can't help it when we
ask ourselves 'When was the last time I told my significant other I loved them?'
Worry no more!  ILU is a service for sending and tracking that special message
to the person we care about most.

Base template for creating flask app - borrowed heavily from [flask recipe](https://gitlab.com/patkennedy79/flask_recipe_app)

## How to Run (Development)

With docker, etting started is as easy as `make init_project`.  This
handles:
1. Creating the Dockerfile for the postgres service. The db
configuraitons in web/instance/flask.cfg are copied to postgresql/Dockerfile
1. Building the docker images
1. Starting the docker containers
1. Initializing the database

Go to your favorite web browser and open:
    http://localhost:5000  $ Or check the IP address using 'docker-machine ip'

## How to Run (Production)

The production environment can be started with `make prod`

The production environment uses gunicorn and nginx containers. By
specifying 'docker-compose.yml' in the make command, docker does
not run docker-compose.override.yml, which is run by default

## Key Python Modules Used

- Flask - web framework
- SQLAlchemy - ORM (Object Relational Mapper)
- Flask-Login - support for user management
- Flask-Migrate - database migrations
- Flask-WTF - simplifies forms

This application is written using Python 3.6.3.  The database used is PostgreSQL.

## Unit Testing

In the top-level folder:
    % nose2

For running a specific module:
    % nose2 -v project.tests.test_module.py

## TODO

There's loads of room for improvement:

1. Get `make test` working
1. Create API documentation
1. Add documentation to tests
1. Separate local requirements from production
1. Use class based views
1. Reorganize config files to 'local', 'dev', 'staging', 'production'
1. Use token based authentication
1. Improve routing - separate log in endpoints from message handling

repository: JacksonKontny/ilu

repo_name: JacksonKontny/ilu


text:
# Password-Locker , 12/2/2019
## Author
#### **Naima Niyigena**
## Description

This project is about creating an account and user has to login using username and password, also it can be an existing account.
They have to view the various account credentials and their passwords in the application.

## BDD Specification

| Account     | Username        | Password |
| ------------- |:-------------:| -----:|
| Before you sign up you should create an account.| Now you have an account it must to have a username to use while you are login.| And also you have password for your account|
| An axisting account | Even if it is existing but you also have username to use | Password for better security |
| Delete an account.| If you delete an account, the username also should no longer used.| Even the password it is not used in that time.|

## Setup/Installation Requirements
* git clone: https://github.com/Naimar1/Password-locker.git
* cd Password-locker
* code . (if you are using visual studio)
* atom .
* run : python3 name of the file.py

## Known Bugs
Hope that my codes is clear and understandable,
There are no errors, by mistake if you find them please contact me for the below address.

## Technologies Used
 * Python

 ## Support and contact details

Don't hesitate to contact me if you get a confusion or any other question,suggestion etc
* Tel:0788358969
*<EMAIL_ADDRESS>
### License

* MIT License
* Copyright (c) 2019 NAIMA NIYIGENA


text:
---
sidebar: reference
---

# IIS Central Certificate Store (CSS)
Designed for the [Central Certificate Store](https://blogs.msdn.microsoft.com/kaushal/2012/10/11/central-certificate-store-ccs-with-iis-8-windows-server-2012/)
introduced in Windows 2012. Creates a separate copy of the `.pfx` file for each hostname and places
it in the path provided by the `--centralsslstore` parameter, or the `DefaultCentralSslStore` setting
in [settings.config](/win-acme/reference/settings). Using this store also triggers any created or
updated IIS bindings to get the `CentralSSL` flag.

## Unattended
`--store centralssl [--centralsslstore C:\CentralSSL\] [--pfxpassword *****]`

repository: WouterTinus/win-acme

gha_language: C#

repo_name: WouterTinus/win-acme


text:
# MTMWPhotoBrowser

[![CI Status](https://img.shields.io/travis/1055263815<EMAIL_ADDRESS>[![Version](https://img.shields.io/cocoapods/v/MTMWPhotoBrowser.svg?style=flat)](https://cocoapods.org/pods/MTMWPhotoBrowser)
[![License](https://img.shields.io/cocoapods/l/MTMWPhotoBrowser.svg?style=flat)](https://cocoapods.org/pods/MTMWPhotoBrowser)
[![Platform](https://img.shields.io/cocoapods/p/MTMWPhotoBrowser.svg?style=flat)](https://cocoapods.org/pods/MTMWPhotoBrowser)

## Example

To run the example project, clone the repo, and run `pod install` from the Example directory first.

## Requirements

## Installation

MTMWPhotoBrowser is available through [CocoaPods](https://cocoapods.org). To install
it, simply add the following line to your Podfile:

```ruby
pod 'MTMWPhotoBrowser'
```

## Author

<EMAIL_ADDRESS><EMAIL_ADDRESS>
## License

MTMWPhotoBrowser is available under the MIT license. See the LICENSE file for more info.

repository: qiandashuai/MTMWPhotoBrowser

repo_name: qiandashuai/MTMWPhotoBrowser


text:
# stringy

[![Author](http://img.shields.io/badge/author-@anolilab-blue.svg?style=flat-square)](https://twitter.com/@anolilab)
[![npm](https://img.shields.io/npm/v/growcss-stringy.svg?style=flat-square)](https://www.npmjs.com/package/growcss-stringy)
[![David](https://img.shields.io/david/growcss/stringy.svg?style=flat-square)](https://david-dm.org/growcss/stringy#info=dependencies&view=table)
[![GitHub release](https://img.shields.io/github/release/qubyte/rubidium.svg?style=flat-square)](https://github.com/growcss/stringy/releases)
[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](LICENSE)

## Chat Room on Gitter
[![Join the chat at https://gitter.im/growcss/stringy](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/growcss/stringy?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

## Master
[![Build Status](https://img.shields.io/travis/growcss/stringy.svg?branch=develop&style=flat-square)](https://travis-ci.org/growcss/stringy)

### Bits and Pieces:
* [npm:](https://npmjs.org/) Well... it's a Node.js package manager
* [Grunt:](http://gruntjs.com/) Automates common tasks: test, build, clean
* [Bower:](http://bower.io/) Package manager for browser dependencies
* [Hound:](https://houndci.com/) Hound comments on style violations in GitHub pull requests

## Getting Started:

1. You need to have npm installed (it comes with node)
2. Clone this repository: `git clone git@github.com:anolilab/skeljs.git`
3. Install dependencies: `npm install`

## Install

~~~
npm install
grunt
~~~

## Change log

Please see [CHANGELOG](CHANGELOG.md) for more information what has changed recently.

## Testing

~~~
grunt test
~~~

## Contributing

Please see [CONTRIBUTING](CONTRIBUTING.md) for details.

## Security

If you discover any security related issues, please email<EMAIL_ADDRESS>instead of using the issue tracker.

## Credits

- [Daniel Bannert](https://github.com/growcss)
- [All Contributors](../../contributors)

## License

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

repository: sass-projects/stringy

gha_language: CSS

repo_name: sass-projects/stringy


text:
# puppet-on-coreos-demo

Ever wanted to manage your CoreOS infrastructure with Puppet? These are the files to make it happen locally with Vagrant.

## Install and Apply MOTD Module

You can verify your setup is working by installing the [puppetlabs MOTD](https://forge.puppet.com/puppetlabs/motd) module, which writes a message to `/etc/motd`.

On the puppet master
```
vagrant ssh puppetmaster
puppet module install puppetlabs-motd
```

Then add the following to `/etc/puppetlabs/code/environments/production/manifests/site.pp`
```
node default {
  class { 'motd':
    content => "Hello world!/n",
  }
}
```

Run puppet on the master to make sure it's working
``
puppet agent -t
cat /etc/motd
```
and you should see 'Hello World!' printed.

Then do the same on the CoreOS machine:
```
vagrant ssh coreosagent
docker run -p 443:443 -p 80:80 --rm --privileged --hostname coreos-agent -v /tmp:/tmp -v /etc:/etc -v /var:/var -v /usr:/usr -v /lib64:/lib64 --network host puppet/puppet-agent
cat /etc/motd
```

and you should see the same thing!

repository: scotty-c/puppet-on-coreos-demo

repo_name: scotty-c/puppet-on-coreos-demo


text:
  🌌

portal

craftable nether star portal guns

  Now you can use a Portal Gun to travel around various places in your Minecraft world!

  Based off of the Bukkit reqest forum post made by user Shikishima.

Click to open up demo GIF in high quality

How to Play

---

### Step One: Obtaining a Portal Gun

The actual Portal Gun item is a Nether Star with the destination coordinates displayed below the name. To make one, either issue the command `/portalgun` as an operator, or craft it with:

### Step Two: Fueling the Portal Gun

For a Portal Gun to work, it will use up 1 Ender Pearl from the inventory of the player who opened up the portal.

### Step Three: Setting the Portal Gun destination

Right click anywhere with the Portal Gun in your hand to open the Anvil GUI. Type in the world, x, y, and z coordinates here. The format looks like this:

```
world=world_name,x=1,y=1,z=1
```

Click the completed item to set the destination of your Portal Gun.

### Step Four: Opening up a portal

Once you have set the destination of your Portal Gun, left click anywhere to open up a portal! The portal will immediately appear as green "Happy Villager" particles.

Unlike Nether Portals or End Portals, the Portal Gun openings only last for **five seconds**. Hurry up and jump through, before it closes, to instantly be teleported to the destination programmed into your Portal Gun!

### Step Five: 🎉 Have fun

Store as many Portal Guns as you want in your inventory. Each one will stay linked to its destination forever, so you can grab whichever you need for the adventure at end!

What's included

```
.
├── LICENSE -- License for this repository.
├── makefile -- Makefile which uses simple bash commands to compile and build the JAR without an IDE.
├── README.md -- The file you are currently reading.
├── build -- Build directory generated by the makefile, can be deleted at any time.
│   ├── bin
│   │   ├── me
│   │   │   └── insanj
│   │   │       └── portal
│   │   │           └── *.class
│   │   └── plugin.yml
│   └── portal-version.jar
├── external -- External dependancies directory. You have to download these open source JARs and place them here; or change the PATH in the makefile.
│   └── craftbukkit-1.13.2.jar
├── plugin -- Source code directory, structured as a standard Java package.
│   ├── me
│   │   └── insanj
│   │       └── anvilgui -- Source of GUI, https://github.com/WesJD/AnvilGUI
│   │       └── portal
│   │           ├── Portal.java
│   │           ├── PortalGunClickListener.java
│   │           ├── PortalPlayerMoveListener.java
│   │           ├── PortalCommandExecutor.java
│   │           └── PortalGun.java
│   └── plugin.yml -- Configuration file which also defines current version number (see git tag as well).
└── server -- Optional directory for testing out the plugin on a local server.
```

Authors

```
Julian Weiss
<EMAIL_ADDRESS>github.com/insanj
```

Acknowledgements

---

- [PortalGun](https://github.com/MrDaniel-TX/PortalGun/)
- [AnvilGUI](https://github.com/WesJD/AnvilGUI)
- [Sign GUI](https://bukkit.org/threads/sign-gui-use-the-sign-interface-to-get-user-input.177030/)
- [Renaming an Anvil Inventory](https://www.spigotmc.org/threads/rnaming-a-anvil-inventory-with-nms-in-1-12-2.327481/)
- [Colored Particles](https://www.spigotmc.org/wiki/colored-particles/)
- [Helix Spiral](https://bukkit.org/threads/1-8-particle-lesson-1-helix-spiral.408264/)
- [Location Iterator (Drawing a Line)](https://bukkit.org/threads/drawing-line-of-blocks-between-two-locations.55426/)

License

---

#### portal

```
MIT License

Copyright (c) 2019 Julian Weiss

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```

#### AnvilGUI

```
MIT License

Copyright (c) 2016 Wesley Smith

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```

repository: insanj/portal

gha_language: Java

gha_license_id: MIT

repo_name: insanj/portal


text:
# NLP_Curriculum_Notes
## NLP Natural Language Processing Curriculum, Study Topics and Applications Notes

## Recommended Courses:
https://www.udemy.com/course/nlp-natural-language-processing-with-python

## Recommended Books:
https://www.amazon.com/Natural-Language-Processing-Action-Understanding/dp/B07X37578L

# What is NLP used for? (What is Machine Learning / Data Science / AI used for?)
## Real World Uses/Cases/User-Problems (common tools in parenthesis):
	- topic modeling (Latent Dirichlet Allocation, Non-negative Matrix Factorization)
	- text classification (sklearn, spaCy, NLTK)
		-- e.g. classifying email as spam or legit
- spam filter (Multinomial Naive Bayes Classifier (vs. Gaussian Naive Bayes classification))
	-- example of classification
-- statquest https://www.youtube.com/watch?v=O2L2Uv9pdDA
	- feature extraction (sklearn/spaCy?)
	- flagging offensive / inappropriate content (hate-speech and abuse detection)
	- NER = Named Entity Recognition
- POS = part of speech tagging
- entity extraction (spaCy function)
- recommendation (various)
- fuzzy search (various)
- sentiment analysis (vector-embeddings: NLTK, spaCy, basilica, R)
	-- movie reviews
	-- customer feedback (restaurant, online shop)
	-- e,g, https://www.linkedin.com/learning/integrating-tableau-and-r-for-data-science/where-r-rules
- chatbots / assistants / agents
- text generation (LSTM, GRU, NN)
- Summarizing Long Text Documents (RNN, CNN, Transformers)
- Understanding Commands ("computer, do X!")
	-- Understanding Text Commands
	?
	voice to text
	text to voice
	- fake-news detection

## Tools:
	- python string functions
	- regex https://drive.google.com/file/d/1JVmK-pW4IKHIEj0UUvqLXelcYbbUPhuE/
- sklearn
- Multinomial Naive Bayes Classifier
- NLTK (designed to be adjustable, not for speed)
- spaCy (designed for speed using one-size fits all models)
- basilica
-
- Neural Networks:
- RNN (Recurrent Neural Network)
- CNN (Convolutional Neural Networks)
- Transformers (NN)
- LSTM (Long Short Term Memory, (not forgetting) vs. RNN)
- GRU (Gated Recurrent Unit, a variation on LSTM system)
- Generative Auto-Encoder NN
https://www.udemy.com/course/nlp-natural-language-processing-with-python/learn/lecture/13195724#overview

## General Process:
- tokenization
- stop words
(my blog on this)
https://medium.com/wooden-information/what-are-stopwords-precisely-960590b21548
- Stemmatization (see note below)
- phrase-matching
- lemmatization (see notes below)
- semantics
- vectorizing/embeddings (example:
On how vector-embeddings work:
https://colab.research.google.com/drive/1n0QHVKLmjHhb1J0PVumoxq58-1OevP5b
calculate distance with e.g. "Cosine Distance" https://reference.wolfram.com/language/ref/CosineDistance.html

## Methods, Approaches:
- Bag Of Words (e.g. with high bias, low variance, Multinomial Naive Bayes Classifier)
e.g. Spam Filter
- Vector Space / vectorizing / embeddings
- Lexicon Based Analysis
- Sequence-to-sequence

## Issues, Limitations, Challenges:
	- Apple's notorious problem of making (accurate) calendar appointments based on text from emails and messages (super hard)
	- 'negatives' such as 'not' in sentences (very difficult)
	- understanding from context (very difficult)
	- legal and contract english (very difficult)
	- tools for doctors to process large amounts of research publications  (very difficult)

## Ethics and NLP
	- Exclusion/Discrimination/Bias
- Privacy
- VSD value sensitive design (http://faculty.washington.edu/ebender/2017_575/#vsd)
https://aclweb.org/aclwiki/Ethics_in_NLP
http://faculty.washington.edu/ebender/2017_575/

## Books:
	Discussion of Issues
https://www.amazon.com/Rebooting-AI-Building-Artificial-Intelligence/dp/1524748250

	Teaching Model Use
https://www.amazon.com/Hands-Machine-Learning-Scikit-Learn-TensorFlow/dp/1492032646

## History & Approaches
#### Symbolic vs. Subsymbolic
- heuristic approaches and "knowledge bases"

.......................................................................................................................................................

# On Stemmatize vs Lemmatize

For NLP it is helpful to reduce forms of words to ones that are easily compared.

Two methods for this are
1. stemmatizing (or reducing to clipped 'stem' form of the word)
2. lemmatizing (or using a more general and abstract "lemma" form of a word)
https://en.wikipedia.org/wiki/Lemmatisation

In various languages one 'word' may have different forms that are spelled very differently:
- wolf, wolves
- be, are, was, were, is,

In some languages (such as Japanese) there is a 'dictionary form' separate from the gazillion other word-forms based on that. But in languages such as English, there is no 'dictionary form,' so a new 'meta-word-form' was created for this purpose and this is called a "lemma."

## Stem vs. lemma

In some cases you could use a 'stem' (form of a word) as a proxy for a 'dictionary form' or 'lemma' form of a word.
- e.g. pour poured pouring

The stem of these examples is all the same "pour," which you can get by removing the extra letters in the other forms (the 'ed' and the 'ing')

The problem with 'stems' is that often clipping the end off a word will not give you the same 'root-step'
- fishes -> fish (this is ok)
- wolves -> wolv (this is not ok. 'wolf' and 'wolv' are not the same "root" form)

This is a problem when the stems "wolf" and "wolv" would be treated by the NLP engine as two unrelated words (assumed to have different meanings and uses, which is an error in the model).

The 'lemma' is one standard/root/dictionary/generalized/abstract form which all other forms can be converted to so that different texts can be compared.

.......................................................................................................................................................

## On NLTK vs spaCy
Overall, spaCy is optimized for fast and easy out-of-the-box use.
NLTK is easier to customize.

#### If you want more personal customization -> use NLTK
#### If you want optimized as-is performance -> use spaCy

.......................................................................................................................................................

New Steps (GGA):
Alias Standardization

....
spaCy Notes

Doc Object:  contains "processed text"
Voc Object (vocabulary object)

(see with "nlp.pipeline")
1. Tagger
2. Parser
3. 'ner' Describer

dep = syntactic dependency

ner = named entity recognizer

branch_name: refs/heads/main


text:
---
layout: default
---

# 1993-05-12 - Re:  CALLER ID?

## Header Data

From<EMAIL_ADDRESS>(Jonathan Stigelman)

To<EMAIL_ADDRESS>Message Hash: a5a63ed18c01f1362a7f35c12140f873cd44655e2b44af0c7d0dbb6ff7aa66a9

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1993-05-12 20:14:45 UTC

Raw Date: Wed, 12 May 93 13:14:45 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Jonathan Stigelman)
Date: Wed, 12 May 93 13:14:45 PDT
To<EMAIL_ADDRESS>Subject: Re:  CALLER ID?
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

> From: Satan<EMAIL_ADDRESS>> Subject: Re:  CALLER ID?
>
> and besides.. 800 numbers get your phone number the
> same way your caller gets your number when you call collect
> THEY ARE PAYING FOR THE CALL
> they kinda have a right to know what they are paying for
>

You're confused or you miswrote:  800 number owners pay for your calls,
people with caller ID boxes do not.

So, do you think that the "privacy protecting 900 number" ($2/min) uses
your number (remember that they DO have it) for privacy junk mailing
purposes?

        Stig

>> Jonathan Stigelman<EMAIL_ADDRESS>PGP key on request <<

{% endraw %}
```

## Thread

+ Return to [May 1993](/archive/1993/05)

+ Return to<EMAIL_ADDRESS>(Jonathan Stigelman)](/authors/stig_at_netcom_com_jonathan_stigelman_)"

+ 1993-05-12 (Wed, 12 May 93 13:14:45 PDT) - Re:  CALLER ID? -<EMAIL_ADDRESS>(Jonathan Stigelman)_


text:
---
layout: page
title: About
permalink: /about/
---

I am a graduate fellow working towards a PhD degree in biophysics at the Rockefeller University. My research utilizes machine learning approaches to do 3D reconstrucion of protein structures from cryo-electron microscopic images, as well as biochemical experiments to answer the how the structures we have explain the biological mechanistic working of the proteins. In particular I am interested in proteins that work as molecular machinery controlling import/export of molecules in or out of the cells.

I completed my undegrad in biology at Massachusetts Institute of Technology (MIT) in 2015.

I also enjoy developing practical data solutions to real-world problem using data science tools like NLP, deep learning, computer vision, and interactive web visualizations. These include [tutorials](https://vincentk1991.github.io/tutorial/) on neural network and Bayesian statistics written as blogs, [COVID-19 summarizer](https://vincentk1991.github.io/GPT2-summarizer/) from GPT-2, and a [program](https://vincentk1991.github.io/Hello-World/) analyzing the complicated electoral system change in Thailand General election 2019, what what it might mean for Thai politics.

### Contact me

[vkieuvongngam<EMAIL_ADDRESS>


text:
# Composing with canvas

Canvas class is useful for composing several elements like images, text and figures.

!!! tip "Tip"
    Canvas `append(arr)` function also supports an array of elements.

```php
<?php

use GImage\Text;
use GImage\Image;
use GImage\Figure;
use GImage\Canvas;

$img1 = new Image();
$img1
    ->load('https://i.imgur.com/G5MR088.png')
    ->scale(0.5);

$figure1 = new Figure(300, 150);
$figure1
    ->setBackgroundColor(10, 20, 30)
    ->create();

$text1 = new Text('My awesome text!');
$text1
    ->setSize(18)
    ->setColor(255, 255, 255)
    ->setFontface('/my/path/fonts/times.ttf');

// used as canvas layout
$figure0 = new Figure(400, 250);
$figure0
    ->setBackgroundColor(50, 20, 30)
    ->create();

$canvas = new Canvas($figure0);
$canvas
    // append every element
    ->append($figure1)
    ->append($img1)
    ->append($text1)
    // as PNG format
    ->toPNG()
    // draw the canvas with all elements
    ->draw()
    ->save('text.png');
```

For more details check out [the presentation card](./creating-a-presentation-card.md) example.

repository: joseluisq/gimage

gha_language: PHP

repo_name: joseluisq/gimage


text:
# Socket-Programming
This repository contains one application that serve as a server and another application that server as a client. And these client and server can communicate with each other.

## Features
1. Start server in a port.
2. Start the client that can communicate with the server using that port.
3. Multiple client can run and be connected with the server.
4. Client can register to the server by providing a name.
5. Clients can send message to each other using their name.

repository: nahidsaikat/Socket-Programming

repo_name: nahidsaikat/Socket-Programming


text:
# DMPagerViewController

[![CI Status](http://img.shields.io/travis/Daniele Margutti/DMPagerViewController.svg?style=flat)](https://travis-ci.org/Daniele Margutti/DMPagerViewController)
[![Version](https://img.shields.io/cocoapods/v/DMPagerViewController.svg?style=flat)](http://cocoadocs.org/docsets/DMPagerViewController)
[![License](https://img.shields.io/cocoapods/l/DMPagerViewController.svg?style=flat)](http://cocoadocs.org/docsets/DMPagerViewController)
[![Platform](https://img.shields.io/cocoapods/p/DMPagerViewController.svg?style=flat)](http://cocoadocs.org/docsets/DMPagerViewController)

DMPagerViewController is a UIViewController subclass which mimics the navigation system used in Twitter and Tinder clients for iOS. It also add some special effects like icon tint color fade on scroll and page parallax effect during scroll.
It also offer several configuration options you can easily see in .h file.
Because an image worth more than thousand of words this is a short gif which show you the class.

## A short introduction

To run the example project, clone the repo, and run `pod install` from your project.

Then you can create a new DMPagerViewController which contains your child view controllers like this:

```
UIViewController * vc1 = ...;
UIViewController * vc2 = ...;
UIViewController * vc3 = ...;
self.pagerController = [[DMPagerViewController alloc] initWithViewControllers: @[vc1,vc2,vc3]];

```

Your child view controllers must be conform to `DMPagerViewControllerProtocol` protocol in order to return the appropriate item to show into the navigation bar (used only when `.useNavigationBar` is set to YES).

So each view controller must implement:

```
- (DMPagerNavigationBarItem *)pagerItem {
	 DMPagerNavigationBarItem *item;
	 UIImage *itemIcon = ...;
	 NSAttributedString *itemTitle = ...;
	 item = [DMPagerNavigationBarItem newItemWithText:itemTitle andIcon: itemIcon];
	item.renderingMode = DMPagerNavigationBarItemModeOnlyText;
	return item;
}
```

Using `.renderingMode` you can decide what show for a specified item (the icon, icon and text or only the text).

You can choose between three different transitions to use when moving programmatically between pages using `-setPageIndex:animated:`:

```
typedef NS_ENUM(NSInteger, DMPagerViewControllerAnimation) {
	// Standard UIScrollView animation
	DMPagerViewControllerAnimationStandard,
	// Ease In+Out animation on scroll
	DMPagerViewControllerAnimationEaseInOut,
	// Animation with final bounce
	DMPagerViewControllerAnimationBounceEnd,
	// Animation with initial+final bounce
	DMPagerViewControllerAnimationBounceStartEnd
};
```

Navigation Bar can also be customized (it's an UIView): you can decide what kind of transition (in term of colors) you want to use for navigation bar items: take a look at `.colorizeMode` (`DMPagerNavigationBarItemColorize`).
Also you can decide the layout of the navigation bar itself via `.style` property (`DMPagerNavigationBarStyle`)

You can push it from a navigation stack or put it into the root window.
You can also access to navigationBar configuration via .navigationBar property.

## Requirements
It works fine with iOS 8. Should work in iOS7 but I've not tested it.

## Installation

DMPagerViewController is available through [CocoaPods](http://cocoapods.org). To install
it, simply add the following line to your Podfile:

    pod "DMPagerViewController"

## Author

Daniele Margutti
Mail: [me<EMAIL_ADDRESS>Web: [danielemargutti.com](http://www.danielemargutti.com)

## License

DMPagerViewController is available under the MIT license. See the LICENSE file for more info.


text:
# Dimorphorchis tenomensis (A.L.Lamb) P.J.Cribb SPECIES

#### Status
ACCEPTED

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

#### Published in
null

#### Original name
Dimorphorchis rossii var. tenomensis

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# sauce-connect-tunnel
[![Build Status](https://travis-ci.org/bytbil/sauce-connect-tunnel.svg)](https://travis-ci.org/bytbil/sauce-connect-tunnel)

A Node.js wrapper around the Saucelabs connect proxy binaries.

## Install

```
npm install --save-dev sauce-connect-tunnel
```

## Usage

### Simple Usage
```javascript
var sauceConnectTunnel = require('sauce-connect-tunnel');
var tunnel = new sauceConnectTunnel(process.env.SAUCE_USERNAME, process.env.SAUCE_ACCESSKEY);

tunnel.start(function(status) {
    if (!status) {
        console.error('Something went wrong starting the tunnel');
    }

    console.log('Sauce Connect Tunnel ready');

    tunnel.stop(function() {
        console.log('Sauce Connect Tunnel destroyed');
    });
});
```

## Options

```javascript
new sauceConnectTunnel(username, accessKey, tunnelId, enableTunnel, args);
```

#### `username`
Username to saucelabs

#### `accessKey`
Accesskey for saucelabs

#### `tunnelId`
Unique identifier for the tunnel. It's optional and automatically generated when not specified. Note that the tunnel identifier may have to be passed in with the browsers object as a desired capability to enable traffic to use the tunnel. More details [here](https://saucelabs.com/docs/additional-config#tunnel-identifier)

#### `enableTunnel`
Boolean value to indicate if the tunnel is to be created or not. This value can be set to `false` to mock a tunnel creation if the site tested is publicly accessible. This value is optional and defaults to `true`.

#### `args`
An array of option flags (see [here](https://saucelabs.com/docs/connect)). Example: ``['--debug', '--direct-domains', 'www.google.com']``. It's optional.

## Contribution
Forked from https://github.com/jmreidy/sauce-tunnel

repository: bytbil/sauce-connect-tunnel

repo_name: bytbil/sauce-connect-tunnel


text:
---
title: Reverse Integer
date: "2020-03-09"
type: problem-solving
description: Reverse Integer
tags: csharp
---

Note: This problem was taken from LeetCode - [Reverse Integer](https://leetcode.com/problems/reverse-integer/)

This is a typical reverse a number problem. Simply mod the given number by 10. That gives you the last digit of the number then divide the input number by 10. That will remove the last digit of the number. Keep doing this to get the reversed number. To find if the number overflows, put the output in `long` datatype and check if the number is same as the int datatype.

```csharp
public int Reverse(int x) {
    long output = 0;

    while(x != 0){
        int temp = x % 10;
        output = (output * 10) + temp;
        x /= 10;
    }

    if((int)output != output){
        return 0;
    }

    return (int)output;
}
```

repository: melwinalm/my-gatsby-blog

gha_language: JavaScript

repo_name: melwinalm/my-gatsby-blog


text:
# Oj Modes

Oj uses modes to switch the load and dump behavior. Initially Oj supported on
the :object mode which uses a format that allows Ruby object encoding and
decoding in a manner that lets almost any Ruby object be encoded and decoded
without monkey patching the object classes. From that start other demands were
made the were best met by giving Oj multiple modes of operation. The current
modes are:

 - `:strict`
 - `:null`
 - `:compat` or `:json`
 - `:rails`
 - `:object`
 - `:custom`

Since modes determine what the JSON output will look like and alternatively
what Oj expects when the `Oj.load()` method is called, mixing the output and
input mode formats will most likely not behave as intended. If the object mode
is used for producing JSON then use object mode for reading. The same is true
for each mode. It is possible to mix but only for advanced users.

## :strict Mode

Strict mode follows the JSON specifications and only supports the JSON native
types, Boolean, nil, String, Hash, Array, and Numbers are encoded as
expected. Encountering any other type causes an Exception to be raised. This
is the safest mode as it is just simple translation, no code outside Oj or the
core Ruby is execution on loading. Very few options are supported by this mode
other than formatting options.

## :null Mode

Null mode is similar to the :strict mode except that a JSON null is inserted
if a non-native type is encountered instead of raising an Exception.

## :compat or :json Mode

The `:compat` mode mimics the json gem. The json gem is built around the use
of the `to_json(*)` method defined for a class. Oj attempts to provide the
same functionality by being a drop in replacement with a few
exceptions. To universally replace many `JSON` methods with their faster Oj counterparts,
simply run `Oj.mimic_json`. [{file:JsonGem.md}](JsonGem.md) includes more details on
compatibility and use.

## :rails Mode

The `:rails` mode mimics the ActiveSupport version 5 encoder. Rails and
ActiveSupport are built around the use of the `as_json(*)` method defined for
a class. Oj attempts to provide the same functionality by being a drop in
replacement with a few exceptions. [{file:Rails.md}](Rails.md) includes
more details on compatibility and use.

## :object Mode

Object mode is for fast Ruby object serialization and deserialization. That
was the primary purpose of Oj when it was first developed. As such it is the
default mode unless changed in the Oj default options. In :object mode Oj
generates JSON that follows conventions which allow Class and other
information such as Object IDs for circular reference detection to be encoded
in a JSON document. The formatting follows the rules describe on the
[{file:Encoding.md}](Encoding.md) page.

## :custom Mode

Custom mode honors all options. It provides the most flexibility although it
can not be configured to be exactly like any of the other modes. Each mode has
some special aspect that makes it unique. For example, the `:object` mode has
it's own unique format for object dumping and loading. The `:compat` mode
mimic the json gem including methods called for encoding and inconsistencies
between `JSON.dump()`, `JSON.generate()`, and `JSON()`. More details on the
[{file:Custom.md}](Custom.md) page.

## :wab Mode

WAB mode ignores all options except the indent option. Performance of this
mode is on slightly better than the :strict and :null modes. It is included to
support the [WABuR](https://github.com/ohler55/wabur) project. More details on
the [{file:WAB.md}](WAB.md) page.

## Options Matrix

Not all options are available in all modes. The options matrix identifies the
options available in each mode. An `x` in the matrix indicates the option is
supported in that mode. A number indicates the footnotes describe additional
information.

| Option                 | type    | :null   | :strict | :compat | :rails  | :object | :custom |  :wab   |
| ---------------------- | ------- | ------- | ------- | ------- | ------- | ------- | ------- | ------- |
| :allow_blank           | Boolean |         |         |       1 |       1 |         |       x |         |
| :allow_gc              | Boolean |       x |       x |       x |       x |       x |       x |         |
| :allow_invalid_unicode | Boolean |         |         |         |         |       x |       x |         |
| :allow_nan             | Boolean |         |         |       x |         |       x |       x |         |
| :array_class           | Class   |         |         |       x |       x |         |       x |         |
| :array_nl              | String  |         |         |         |         |         |       x |         |
| :ascii_only            | Boolean |       x |       x |       2 |       2 |       x |       x |         |
| :auto_define           | Boolean |         |         |         |         |       x |       x |         |
| :bigdecimal_as_decimal | Boolean |         |         |         |       3 |       x |       x |         |
| :bigdecimal_load       | Boolean |         |         |         |         |         |       x |         |
| :compat_bigdecimal     | Boolean |         |         |       x |         |         |       x |         |
| :cache_keys            | Boolean |       x |       x |       x |       x |         |       x |         |
| :cache_strings         | Fixnum  |       x |       x |       x |       x |         |       x |         |
| :circular              | Boolean |       x |       x |       x |       x |       x |       x |         |
| :class_cache           | Boolean |         |         |         |         |       x |       x |         |
| :create_additions      | Boolean |         |         |       x |       x |         |       x |         |
| :create_id             | String  |         |         |       x |       x |         |       x |         |
| :empty_string          | Boolean |         |         |         |         |         |       x |         |
| :escape_mode           | Symbol  |         |         |         |         |         |       x |         |
| :float_precision       | Fixnum  |       x |       x |         |         |         |       x |         |
| :hash_class            | Class   |         |         |       x |       x |         |       x |         |
| :ignore                | Array   |         |         |         |         |       x |       x |         |
| :indent                | Integer |       x |       x |       4 |       4 |       x |       x |       x |
| :indent_str            | String  |         |         |       x |       x |         |       x |         |
| :integer_range         | Range   |       x |       x |       x |       x |       x |       x |       x |
| :match_string          | Hash    |         |         |       x |       x |         |       x |         |
| :max_nesting           | Fixnum  |       5 |       5 |       x |         |       5 |       5 |         |
| :mode                  | Symbol  |       - |       - |       - |       - |       - |       - |         |
| :nan                   | Symbol  |         |         |         |         |         |       x |         |
| :nilnil                | Boolean |         |         |         |         |         |       x |         |
| :object_class          | Class   |         |         |       x |         |         |       x |         |
| :object_nl             | String  |         |         |       x |       x |         |       x |         |
| :omit_nil              | Boolean |       x |       x |       x |       x |       x |       x |         |
| :quirks_mode           | Boolean |         |         |       6 |         |         |       x |         |
| :safe                  | String  |         |         |       x |         |         |         |         |
| :second_precision      | Fixnum  |         |         |         |         |       x |       x |         |
| :space                 | String  |         |         |       x |       x |         |       x |         |
| :space_before          | String  |         |         |       x |       x |         |       x |         |
| :symbol_keys           | Boolean |       x |       x |       x |       x |       x |       x |         |
| :trace                 | Boolean |       x |       x |       x |       x |       x |       x |       x |
| :time_format           | Symbol  |         |         |         |         |       x |       x |         |
| :use_as_json           | Boolean |         |         |         |         |         |       x |         |
| :use_raw_json          | Boolean |         |         |       x |       x |       x |       x |         |
| :use_to_hash           | Boolean |         |         |         |         |         |       x |         |
| :use_to_json           | Boolean |         |         |         |         |         |       x |         |
 --------------------------------------------------------------------------------------------------------

 1. :allow_blank an alias for :nilnil.

 2. The :ascii_only options is an undocumented json gem option.

 3. By default the bigdecimal_as decimal is not set and the default encoding
    for Rails is as a string. Setting the value to true will encode a
    BigDecimal as a number which breaks compatibility.
    Note: after version 3.11.3 both `Oj.generate` and `JSON.generate`
    will not honour this option in Rails Mode, detais on https://github.com/ohler55/oj/pull/716.

 4. The integer indent value in the default options will be honored by since
    the json gem expects a String type the indent in calls to 'to_json()',
    'Oj.generate()', or 'Oj.generate_fast()' expect a String and not an
    integer.

 5. The max_nesting option is for the json gem and rails only. It exists for
    compatibility. For other Oj dump modes the maximum nesting is set to over
    1000. If reference loops exist in the object being dumped then using the
    `:circular` option is a far better choice. It adds a slight overhead but
    detects an object that appears more than once in a dump and does not dump
    that object a second time.

 6. The quirks mode option is no longer supported in the most recent json
    gem. It is supported by Oj for backward compatibility with older json gem
    versions.

branch_name: refs/heads/develop

gha_language: C


text:
# Python-Cracks

1.Text to Speech
  Four lines of code, python will speak to you :)

  Dependencies
    pyttsx

  For deep resarch refer https://pypi.python.org/pypi/pyttsx

2. Face recognition using OpenCV
   Simple face recognition code using OpencV

   Reference https://opencv.org

repository: Ansonmathew/Python-Cracks

repo_name: Ansonmathew/Python-Cracks


text:
Marinade:
3 tbsp shallots minced,
1.5 tbsp garlic minced,
1/4 cup sugar,
1 tbsp fish sauce,
1/2 tbsp thick soy sauce,
1/2 tbsp pepper,
3 tbsp neutral cooking oil.
Vegetables:
green leaf lettuce,
mint – rau thơm,
Vietnamese perilla – tiá tô,
Vietnamese balm – kinh giới,
cucumbers sliced.
Garnish:
pickled daikon and carrots (đồ chua),
1/2 tbsp scallion in oil (mở hành),
1/2 tbsp crushed peanuts.
Dipping Sauce:
prepared fish sauce / nước chấm.
'
instructions: '
Mix all seasoning ingredients in a bowl and mix. It will bubble from the baking powder.
After everything is dissolved, add the pork and mix well.
Cover with plastic wrap and refrigerate over night, or freeze for about 1 hour or until slightly firm. The purpose is to thicken it up.
Although the butcher ground it 4 times, blend this one final time in a food processor after marinating so it becomes stickier and easier to form shapes with.
Form into desired shapes--usually balls or logs.
Steam for about 10 minutes so the shape holds
Deep fry or grill to add color and finish cooking.
'

repository: NathanNNguyen/gatsby

repo_name: NathanNNguyen/gatsby


text:
# Tintri REST API #
Tintri REST API documentation version v310.91 and code examples.

API version v310.91 maps to TXOS 4.5 and TGC 4.1 and above.

## REST API Documentation ##
The REST API documentation is located [here](https://tintri.github.io/tintri-rest-api/index.html).

## Questions or Comments ##
For questions and comments, please go to the [Tintri Hub Automation Discussion Group](http://hub.tintri.com/discussions/automation).

repository: Tintri/tintri-rest-api

repo_name: Tintri/tintri-rest-api


text:
# sndEmbedder
sndEmbedder is the command-line tool I use to embed **short mono audio sounds (max about 5 seconds)** into a C/C++ file.

# HOW TO COMPILE
**sndEmbedder.c** is a single C89 file that can be easily compiled this way:

```gcc -O3 -no-pie -fno-pie sndEmbedder.c -o sndEmbedder -lopenal -lm```

(or in a similar way using other compilers: compilation instructions are at the top of [**sndEmbedder.c**](./sndEmbedder.c))

## DEPENDENCIES
* **sndEmbedder.c** requires a version of openal with float samples support (**AL_FORMAT_MONO_FLOAT32**)

# GETTING STARTED
**sndEmbedder** is an interactive console application.

It can capture sound from any supported capture device (e.g. microphone or any PC output, if an audio monitor capture device has been correctly configured).

At the end of the process it should create an **.inl** file (like [bells.inl](./Test/sounds/bells.inl)) that can be included into user code.

# HOW TO USE .INL FILES
In the **Test** subfolder there are two demos:

* [**test_openal.c**](./Test/test_openal.c) (depends on openal)
* [**test_sokol.c**](./Test/test_sokol.c) (depends on -lasound on Linux)

Compilation instructions for Linux, Windows and Emscripten are at the top of each .c file.


text:
# cors-buster
When you need a file, but the headers ain't good, who you gonna call? CORS Buster!

## What is this?

This is the software ~running on https://cors-buster-tbgktfqyku.now.sh~ (Update: I had to shut it down after the bandwidth exceeded the free tier of Now), a free
service for AJAX users struggling to work around the fact that many websites
do not implement CORS headers, even for static content.

## What it does

Say you tried to do this AJAX call and got this lovely error:

```
window.fetch('http://nodejs.org/dist/v6.10.2/node-v6.10.2-linux-x64.tar.gz')

Fetch API cannot load http://nodejs.org/dist/v6.10.2/node-v6.10.2-linux-x64.tar.gz. No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'http://example.org' is therefore not allowed access. If an opaque response serves your needs, set the request's mode to 'no-cors' to fetch the resource with CORS disabled.
Uncaught (in promise) TypeError: Failed to fetch
```

You can do this instead, and now there's no error:

```
window.fetch('https://cors-buster-tbgktfqyku.now.sh/nodejs.org/dist/v6.10.2/node-v6.10.2-linux-x64.tar.gz')
```

## Is this safe?

CORS is designed to prevent a 3rd party (Eve) from doing evil things to Alice
using her browser to make HTTP requests to Bob, essentially impersonating Alice.
Browsers prevent JavaScript from making this kind of Cross-Origin AJAX Request
by default. But if this server is making the request *on behalf* of your
JavaScript, there is no way we could be impersonating Alice. Alice is safe.
Bob was never protected in the first place. Eve has better things to do with
her time.

## But I need to POST/PUT/etc with data?

That works too! Just make an OPTIONS/POST/PUT/DELETE/etc request and it will be forwarded.
If you can only make GET requests, you can provide a `method` query parameter and
the server will make it that kind of request instead.

## Supported headers

If there's a way to whitelist ALL headers, let me know. The one's I've explicitly added
so far are:

#### Request Headers:

- accept-encoding
- accept-language
- accept
- access-control-allow-origin
- authorization
- cache-control
- connection
- content-length
- content-type
- dnt
- pragma
- range
- referer
- user-agent
- x-http-method-override
- x-requested-with

#### Response Headers:

- accept-ranges
- age
- cache-control
- content-length
- content-language
- content-type
- date
- etag
- expires
- last-modified
- pragma
- server
- transfer-encoding
- vary
- x-github-request-id

## That is nice, I want to run my own server

Sure thing, just do:

```
git clone https://github.com/wmhilton/cors-buster
cd cors-buster
npm install
PORT=80 npm start
```

## No, I meant I want to deploy it to zeit.now.sh

Even easier, just do:

```
now wmhilton/cors-buster
```

## License

This work is released under [The MIT License](https://opensource.org/licenses/MIT)

repository: elifsgban/cors-buster

repo_name: elifsgban/cors-buster


text:
DesignPatterns
===================

[![MIT Licence](https://badges.frapsoft.com/os/mit/mit.svg?v=103)](https://opensource.org/licenses/mit-license.php)

Content
----------
> - C#
	- Behavioral (Mediator), Creational (Abstract Factory, Singleton), Structural (Decorator, Flyweight)
> -  Javascript
	- Learning JavaScript Design Patterns - https://addyosmani.com/resources/essentialjsdesignpatterns/book/


text:
# Project Description
Test application for the COMPSs runtime. The application receives as a parameter an integer that indicates the number of tasks to execute on the infrastructure. In the example described in this README, the infrastructure is composed of 2 containers: one playing the role of the master and another one acting as the worker node. The master node receives the _StartApplication_ request, instruments the code of the application and runs it creating as many tasks as indicated in the parameter. These tasks are submitted to the worker node.

## Requirements

Have Docker available.

## Image Building (optional)
Although the application image is publicly available from the public Docker image registry and can be pulled from there, this repository contains the script and Dockerfile used for generating it as an example. Users can create such image locally by executing the _build\_image_ script located within the builder folder. However, it will still require Internet connection to pull the mf2c/compss-agent from the Docker registry if it is not cached yet.

  _git clone https://github.com/mF2C/COMPSs-Test.git_

  _./COMPSs-Test/builder/build\_image_

## COMPSs-Test Execution
### **Execution step 1: Deploying the infrastructure**

  Instantiate a Docker container that plays the role of worker
  _docker run --rm -it --env MF2C_HOST=<IP_ADDRESS>  --env DEBUG=debug --name worker mf2c/compss-test:latest_

  Instantiate a Docker container that plays the role of master. The container is listening on port 46100, it is important to redirect the port of the container host.
  _docker run --rm -it --env MF2C_HOST=<IP_ADDRESS> -p46100:46100 --env DEBUG=debug --name master mf2c/compss-test:latest_

  WARNING: make sure that both, master and worker, IP addresses match the IP address passed as MF2C_HOST

### **Execution step 2: Run the application**

To execute COMPSs you have to send a HTTP PUT request to the _StartApplication_ method. The body of the request has to be in XML format. Please, make sure that the IP addresses of the resources described in the XML match the IP addresses of the containers.

```
curl -X PUT -H "Content-Type: application/xml" -d '<startApplication>
    <ceiClass>es.bsc.compss.test.TestItf</ceiClass>
    <className>es.bsc.compss.test.Test</className>
    <methodName>main</methodName>
    <parameters>
        <params paramId="0">
            <direction>IN</direction>
            <type>OBJECT_T</type>
            <array paramId="0">
                <componentClassname>java.lang.String</componentClassname>
                <values>
                    <element paramId="0">
                        <className>java.lang.String</className>
                        <value xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xs="http://www.w3.org/2001/XMLSchema" xsi:type="xs:string">3</value>
                    </element>
                </values>
            </array>
        </params>
    </parameters>
    <resources>
        <resource name="<IP_ADDRESS>:46100">
            <description>
                <memorySize>4.0</memorySize>
                <memoryType>[unassigned]</memoryType>
                <operatingSystemDistribution>[unassigned]</operatingSystemDistribution>
                <operatingSystemType>[unassigned]</operatingSystemType>
                <operatingSystemVersion>[unassigned]</operatingSystemVersion>
                <pricePerUnit>-1.0</pricePerUnit>
                <priceTimeUnit>-1</priceTimeUnit>
                <processors>
                    <architecture>[unassigned]</architecture>
                    <computingUnits>1</computingUnits>
                    <internalMemory>-1.0</internalMemory>
                    <name>[unassigned]</name>
                    <propName>[unassigned]</propName>
                    <propValue>[unassigned]</propValue>
                    <speed>-1.0</speed>
                    <type>CPU</type>
                </processors>
                <storageSize>-1.0</storageSize>
                <storageType>[unassigned]</storageType>
                <value>0.0</value>
                <wallClockLimit>-1</wallClockLimit>
            </description>
        </resource>
        <resource name="<IP_ADDRESS>:46100">
            <description>
                <memorySize>4.0</memorySize>
                <memoryType>[unassigned]</memoryType>
                <operatingSystemDistribution>[unassigned]</operatingSystemDistribution>
                <operatingSystemType>[unassigned]</operatingSystemType>
                <operatingSystemVersion>[unassigned]</operatingSystemVersion>
                <pricePerUnit>-1.0</pricePerUnit>
                <priceTimeUnit>-1</priceTimeUnit>
                <processors>
                    <architecture>[unassigned]</architecture>
                    <computingUnits>1</computingUnits>
                    <internalMemory>-1.0</internalMemory>
                    <name>[unassigned]</name>
                    <propName>[unassigned]</propName>
                    <propValue>[unassigned]</propValue>
                    <speed>-1.0</speed>
                    <type>CPU</type>
                </processors>
                <storageSize>-1.0</storageSize>
                <storageType>[unassigned]</storageType>
                <value>0.0</value>
                <wallClockLimit>-1</wallClockLimit>
            </description>
        </resource>
    </resources>
    <serviceInstanceId>e47b5928-98c5-417e-9dd5-1593fc6dca5b</serviceInstanceId>
</startApplication>' http://localhost:46100/COMPSs/startApplication
```


text:
---
title: Reactive Extensions
layout: notes
---

backpressure, or flow control, is when the consumer of the data is slower than the producer of the data. This can lead to excess memory usage because if the chain doesn't want to lose data over an asynchronous boundary, it has to queue. That queue may grow out of hand. Backpressure is a form of negotiation about how much items to produce until further notice which allows the bounding of the queue between the producer and the consumer.
Remember the old days when you typed too fast and the computer started beeping? That's backpressure.

repository: glennawatson/ghuntley

repo_name: glennawatson/ghuntley


text:
---
layout: default
---

# 1993-09-23 - Mail outage

## Header Data

From<EMAIL_ADDRESS>(Hal Finney)

To<EMAIL_ADDRESS>Message Hash: e20cd6fccc1cf703dd27ac87b889952809310cc2a8fc9d9aab99e39844dee5ed

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1993-09-23 17:20:32 UTC

Raw Date: Thu, 23 Sep 93 10:20:32 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Hal Finney)
Date: Thu, 23 Sep 93 10:20:32 PDT
To<EMAIL_ADDRESS>Subject: Mail outage
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

My remailer at<EMAIL_ADDRESS>is apparently unable to receive
mail today and last night.  I have complained to customer service about this
and hopefully the problem will be resolved soon.

Hal Finney
<EMAIL_ADDRESS>

{% endraw %}
```

## Thread

+ Return to [September 1993](/archive/1993/09)

+ Return to<EMAIL_ADDRESS>(Hal Finney)](/authors/hfinney_at_shell_portal_com_hal_finney_)"

+ 1993-09-23 (Thu, 23 Sep 93 10:20:32 PDT) - Mail outage -<EMAIL_ADDRESS>(Hal Finney)_


text:
# Notes

## Setup

For the language it has to run on the JVM, so lets use Kotlin since im most confortable with that one.

Since I havent used a web framework in kotlin yet, my choices (from the ones i've heard of) are the following:
* Spring (written in java and uses gradle to build)
* Ktor (written in kotlin by jetbrains)

I'm going to go for ktor since its pure kotlin and still has a good backing. Also i dont know how maven deals with
dependencies using gradle. I'd like to avoid gradle if possible. So for build system we'll use maven.

While IDEA is downloading lets look at this TLE format.
After reading its wikipedia page, it seems like a very strict format, does Orekit provide a parser for it?

[Yes it does!](https://www.orekit.org/site-orekit-10.3/architecture/tle.html)

Good! no custom parsers if i dont need to.

Next what else am I going to need?
* Csv parser
* Open weather api

Hopefully Lat and Long values are in decimal, we'll assume that for now, maybe add different formats for that later.

In the tips theres a website to test our accurary, I wonder if they have an api?

## Planning

Right now that I have a general idea lets plan this out.

The way the challenge is written it sounds like they want a front-end (it being an _Application_ and all).
 So I'm sticking with a
web api.

If we want a correct web api, it should be stateless.
So I have two choices:
1. Take all the possible inputs in a single call (json)
2. deal with a database and have multiple routes.

The first one is less painfull on me, but Im willing to bet they have a script that uploads the files for the TLE's and the csv's. So being able to have dedicated File routes could be nicer on them.

BUT dealing with a database is going to be a pain, especially for the test setups.

So we'll stick with the first choice for now, i'll structure the code so it can be exploded to different routes later.

## Issues encountered

with the kotlinx.serialization plugin there seems to be an issue with the kotlin compiler version even though its configured with the correct compiler... I guess were switching to gradle 🙄
As much as I hate it, at least I know it...

repository: Progdrasil/tech-challenge

repo_name: Progdrasil/tech-challenge


text:
# Legato

Legato provides query access through the official [Google Analytics Reporting API v4](https://developers.google.com/analytics/devguides/reporting/core/v4/)

## Installation

[Available in Hex](https://hex.pm/packages/legato), the package can be installed as:

  1. Add `legato` to your list of dependencies in `mix.exs`:

    ```elixir
    def deps do
      [{:legato, "~> 0.2.0"}]
    end
    ```

  2. Ensure `legato` is started before your application:

    ```elixir
    def application do
      [applications: [:legato]]
    end
    ```

Get an oauth access token from Google

"Authorization: Bearer token_here"

HTTPoison.post "https://analyticsreporting.googleapis.com/v4/reports:batchGet", "{}", [{"Authorization", "Bearer token_here"}]

* [x] Collect data into Query struct
* [x] Convert query into Request JSON, encode with Poison
* [x] Send request to GA
* [x] Decode response
* [x] Parse data into struct
* [x] support metric expression strings
* [x] add filters to Query
* [x] add date ranges to Query
* [x] add order by to Query
* [x] add segment_id to Query
* [x] add Sampling
* [x] put report struct into named struct
* [ ] add segments to Query (long goal)

```elixir
profile = %Legato.Profile{access_token: oauth2_access_token, view_id: view_id}
```

```elixir
defmodule ExitReport do
  defstruct :exits, :pageviews, :country
end
```

```elixir
import Legato.Query

alias Legato.Request
alias Legato.Report

profile |>
  metrics([:exits, :pageviews]) |>
  dimensions([:country]) |>
  filter(:exits, :gt, 10) |>
  between(start_date, end_date) |> # first date range for the query
  between(another_start_date, another_end_date) |> # adds subsequent date ranges
  order_by(:pageviews, :descending) |>
  segment(-3) |>
  sampling(:small) |>
Request.all |>
Report.as(ExitReport)
```

If you'd like to use relative dates, I suggest trying `timex`.
`segment` with an integer will clear any segments, cannot be mixed with dynamic segments.


text:
<!--
 title: Alter Me
 layout: default_layout
-->

## A boilerplate document

The source for this page is a markdown document located in 'src/data/markup.nz/index.md'

The source is **stored** in the xqerl database as a
[cmark](https://github.com/commonmark/cmark) converted XML document.

The frontmatter section is a HTML comment block at the
start of the document

Page 'layout' can be specified in the frontmatter.
If no page layout is specified then a default layout will be used.
Layout refers to xQuery function item **stored** in the xqerl database.
The layout source is 'src/data/markup.nz/default_layout.xq'

The xqerl database can store any XDM item.

gha_language: XQuery


text:
# ursa: bare-metal management daemon

![logo](./docs/image/ursa-logo.png)

ursa is management daemon for bare-metal.

The name "ursa" is derived from a Latin word that means "bear".

## Feature

- manage bare-metal server
  - save to sqlite
- headless boot server using [iPXE](https://ipxe.org/)
  - include a some servers (dhcpd, httpd, tftpd)
- provisioning [cloud-init nocloud-net](https://cloudinit.readthedocs.io/en/latest/topics/datasources/nocloud.html) in bare-metal
  - create linux users
  - insert user authorized keys
  - bonding network interface by ursa-bonder

## Getting Started

prepare a some binaries and put to `./cmd/ursa/static` .

- initrd.img
- kernel
- filesystem.squashfs

### Build

Please use `Makefile`.

```bash
$ make
```

### Put binaries and files to Server

`static` directory is DocuemntRoot in HTTP Server.

```bash
$ tree .
.
├── static
│   ├── filesystem.squashfs
│   ├── initrd.img
│   ├── kernel
│   └── ursa-bonder
└── ursa
```

### Execute ursa!

```bash
$ sudo ./ursa -iface eth0 -dhcp-range "<IP_ADDRESS>:<IP_ADDRESS>" -service-nw "<IP_ADDRESS>/24" -service-gw "<IP_ADDRESS>" -service-range "<IP_ADDRESS>:<IP_ADDRESS>"
# Listen 67/udp (DHCP), 69/udp (TFTP), 80/tcp (HTTP), so need root permission.
```

Next, you boot bare-metal server in same Layer2 Network.

It becomes...

- boot OS from `initrd.img` using iPXE.
- set IP address to bonding interface from one of `-service-range`.
- set IP address to management interface from one of `dhcp-range`.

repository: lovi-cloud/ursa

repo_name: lovi-cloud/ursa


text:
---
date: "2015-04-10T12:27:13+01:00"
title: "Cyclomatic Complexity"
categories: ["Complexity", "OOP", "Programming"]
description: "Imagine you’re having a great day at the office, you’ve got a brand new feature the customer is dying to have, and you’ve completed it in record time. You’re all ready to get it merged and peer reviewed. So you commit it, and push it to your build pipeline, where it’s analyzed. The build fails. Your analytics tool tells you complexity is too high! You’re given a numeric complexity value for your code, and a lower complexity value that you need to get your code’s complexity under."
---

Imagine you're having a great day at the office, you've got a brand new feature the customer is dying to have, and you've completed it in record time. You're all ready to get it merged and peer reviewed.

So you commit it, and push it to your build pipeline, where it's analyzed. The build fails. Your analytics tool tells you complexity is too high!

You're given a numeric complexity value for your code, and a lower complexity value that you need to get your code's complexity under. But what does that exactly does this value mean? And why does high complexity mean you probably need to refactor your code?

Complexity in software development is Cyclomatic Complexity. Cyclomatic Complexity was first described way back in [1976 by Thomas McCabe](https://books.google.ro/books?id=vtNWAAAAMAAJ&pg=PA3&hl=ro), and is in it's essence a numeric value that is the total number of paths an execution through a piece of code could take. The higher this number, the higher the number of routes through a piece of code, and the more behaviors your class will exhibit that you'll need to test for (and opportunities your code has to choose the wrong path).

### How to we work out the number?

Take for example this simple method.

```ruby
def hello
    puts "hello, world!";
end
```

We can represent this using a graph. Using a node to represent the start and the end of the code, and a node for every decision made within the graph. In our example there are none, making the complexity simple to work out.

Now we've built our graph, we apply this formula defined by McCabe that counts the number of routes through the code.

> M = E − N + 2P

What do these letters mean though?

- E = The number of edges of the graph. _Edges are the lines in the graph_
- N = The number of nodes of the graph. _One of the circles is a node_
- P = The number of connected components. _Number of interchangeable components, like classes, we're analysing_

So in this example

- E = 1 _There's 1 line in the graph_
- N = 2 _There's 2 nodes in the graph, Start and End_
- P = 1 _There's a single component we are analyzing, our simple hello world function_

So our formula breaks down like this

1.  1 = 1 - 2 + (2 \* 1)
2.  1 = 1 - 2 + 2
3.  1 = -1 + 2
4.  1 = 1

So this method has a complexity of 1. There is 1 route through the code.

Okay, but what if we start making our method more complex? Lets add in an if statement in there.

```ruby
def hello(name=nil)
    if name.nil?
        puts "hello, world!"; # A
    else
        puts "hello, "+name+"!"; # B
    end
end
```

We can represent this with a graph like this

So lets take our formula again

> M = E − N + 2P

- E = 4 _There's 4 edges in the graph_
- N = 4 _There's 4 nodes in the graph, Start and End and our if name selection_
- P = 1 _There's a single component we are analyzing, our simple hello world function_

So our formula breaks down like this

1.  2 = 4 - 4 + (2 \* 1)
2.  2 = 4 - 4 + 2
3.  2 = 0 + 2
4.  2 = 2

There are 2 routes through the code.

Programs don't just need selection though, they need iteration too! Also known as: Loops. How do we calculate the complexity of this function with a loop in the method?

Here's our updated example with a small loop in it

```ruby
def hello(loops, name=nil)

    loops.times do # A1
        puts "hello,"; # B
    end # A2

    if name.nil?
        puts "hello, world!"; # C
    else
        puts "hello, "+name+"!"; # D
    end
end
```

Now representing loops is a little bit more complicated than if statements

You'll notice that for the loop there are 3 nodes. A1 is the path to the loop, B is the code in the loop, and A2 is the code from the loop till the next statement.

So lets apply our formula again.

> M = E − N + 2P

- E = 8
- N = 7
- P = 1

Which means the complexity is

1.  3 = 8 - 7 + (2 \* 1)
2.  3 = 8 - 7 + 2
3.  3 = 1 + 2
4.  3 = 3

There are 3 paths through the code.

### But why is this number important?

This number is important because there are [3 main types of bugs](http://misko.hevery.com/2008/11/17/unified-theory-of-bugs/) in software:

1.  Logical _If 2 > 3 when it should be if 3 > 4_
2.  Wiring _I injected the queue object when I should have injected the db object_
3.  Rendering _I put the wrong text in this button_

Logical is the most common, Wiring the second most common and Rendering the least common. Logical is also the hardest to identify and resolve, Wiring the second most, and Rendering the least.

The complexity number indicates the number of opportunities there are to create a logical error. The lower the complexity, the higher the probability we haven't got a bug in our code.

This is also part of why SOLID encourages you to never have to go back and change a class. Assuming you're adding new functionality to a class, every time you modify it, you're increasing the complexity of the class, which increases the difficulty of testing it, and increases the likelihood you've made a mistake in the logic.

That's what complexity means, and reducing it in your classes and methods will reduct the amount of bugs in your code. Despite it being created a long time ago, it's still an incredibly useful metric.

gha_language: TypeScript

gha_license_id: NOASSERTION


text:
# BrainF**k Interpreter
A C# interpreter for the esoteric BrainFuck programming language.

The interpreter is very simple and can be found in Interpreter.cs. The WPF GUI project is separate but provides a neat interface to mess around with.

I made this for fun and I think it is a great learning experience to help understand concepts such as parsing and how memory is stored.

The sample project may be slower than if it was ran from the command line (although I haven't made a command line version), as it has events for updating the memory display and output.

The only optimization I have done is added a "pre-parser" that creates a dictionary (aka hashmap) of where loops start and end, so the program execution isn't slowed by searching for loops.

#####Screenshot:

![Image](https://i.pyratron.com/4Tc08I.png)

repository: Cyral/BrainF-Interpreter

repo_name: Cyral/BrainF-Interpreter


text:
Contributing to Vertcoin Core
============================

The Vertcoin Core project operates an open contributor model where anyone is
welcome to contribute towards development in the form of peer review, testing
and patches. This document explains the practical process and guidelines for
contributing.

First, in terms of structure, there is no particular concept of "Bitcoin Core
developers" in the sense of privileged people. Open source often naturally
revolves around a meritocracy where contributors earn trust from the developer
community over time. Nevertheless, some hierarchy is necessary for practical
purposes. As such, there are repository "maintainers" who are responsible for
merging pull requests, as well as a "lead maintainer" who is responsible for the
release cycle as well as overall merging, moderation and appointment of
maintainers.

Communication Channels
----------------------

Most communication about Vertcoin Core development happens onthe #development channel
on [Discord](https://discord.gg/vertcoin).

Issues List
--------------------

Open issues can be found on github in the [issues list](https://github.com/vertcoin-project/vertcoin-core/issues).

Contributor Workflow
--------------------

The codebase is maintained using the "contributor workflow" where everyone
without exception contributes patch proposals using "pull requests" (PRs). This
facilitates social contribution, easy testing and peer review.

To contribute a patch, the workflow is as follows:

  1. Fork repository ([only for the first time](https://help.github.com/en/articles/fork-a-repo))
  1. Create topic branch
  1. Commit patches

For GUI-related issues or pull requests, the https://github.com/bitcoin-core/gui repository should be used.
For all other issues and pull requests, the https://github.com/bitcoin/bitcoin node repository should be used.

The master branch for all monotree repositories is identical.

As a rule of thumb, everything that only modifies `src/qt` is a GUI-only pull
request. However:

* For global refactoring or other transversal changes the node repository
  should be used.
* For GUI-related build system changes, the node repository should be used
  because the change needs review by the build systems reviewers.
* Changes in `src/interfaces` need to go to the node repository because they
  might affect other components like the wallet.

For large GUI changes that include build system and interface changes, it is
recommended to first open a pull request against the GUI repository. When there
is agreement to proceed with the changes, a pull request with the build system
and interfaces changes can be submitted to the node repository.

The project coding conventions in the [developer notes](doc/developer-notes.md)
must be followed.

### Committing Patches

In general, [commits should be atomic](https://en.wikipedia.org/wiki/Atomic_commit#Atomic_commit_convention)
and diffs should be easy to read. For this reason, do not mix any formatting
fixes or code moves with actual code changes.

Make sure each individual commit is hygienic: that it builds successfully on its
own without warnings, errors, regressions, or test failures.

Commit messages should be verbose by default consisting of a short subject line
(50 chars max), a blank line and detailed explanatory text as separate
paragraph(s), unless the title alone is self-explanatory (like "Corrected typo
in init.cpp") in which case a single title line is sufficient. Commit messages should be
helpful to people reading your code in the future, so explain the reasoning for
your decisions. Further explanation [here](https://chris.beams.io/posts/git-commit/).

If a particular commit references another issue, please add the reference. For
example: `refs #1234` or `fixes #4321`. Using the `fixes` or `closes` keywords
will cause the corresponding issue to be closed when the pull request is merged.

Commit messages should never contain any `@` mentions (usernames prefixed with "@").

Please refer to the [Git manual](https://git-scm.com/doc) for more information
about Git.

  - Push changes to your fork
  - Create pull request

If a pull request is not to be considered for merging (yet), please
prefix the title with [WIP] or use [Tasks Lists](https://help.github.com/articles/basic-writing-and-formatting-syntax/#task-lists)
in the body of the pull request to indicate tasks are pending.

### Address Feedback

At this stage, one should expect comments and review from other contributors. You
can add more commits to your pull request by committing them locally and pushing
to your fork until you have satisfied all feedback.

Note: Code review is a burdensome but important part of the development process, and as such, certain types of pull requests are rejected. In general, if the **improvements** do not warrant the **review effort** required, the PR has a high chance of being rejected. It is up to the PR author to convince the reviewers that the changes warrant the review effort, and if reviewers are "Concept NACK'ing" the PR, the author may need to present arguments and/or do research backing their suggested changes.

### Squashing Commits

If your pull request contains fixup commits (commits that change the same line of code repeatedly) or too fine-grained
commits, you may be asked to [squash](https://git-scm.com/docs/git-rebase#_interactive_mode) your commits
before it will be reviewed. The basic squashing workflow is shown below.

    git checkout your_branch_name
    git rebase -i HEAD~n
    # n is normally the number of commits in the pull request.
    # Set commits (except the one in the first line) from 'pick' to 'squash', save and quit.
    # On the next screen, edit/refine commit messages.
    # Save and quit.
    git push -f # (force push to GitHub)

Please update the resulting commit message, if needed. It should read as a
coherent message. In most cases, this means not just listing the interim
commits.

If you have problems with squashing or other git workflows, you can enable
"Allow edits from maintainers" in the right-hand sidebar of the GitHub web
interface and ask for help in the pull request.

Please refrain from creating several pull requests for the same change.
Use the pull request that is already open (or was created earlier) to amend
changes. This preserves the discussion and review that happened earlier for
the respective change set.

The length of time required for peer review is unpredictable and will vary from
pull request to pull request.

Release Policy
--------------

The project leader is the release manager for each Vertcoin Core release.

Copyright
---------

By contributing to this repository, you agree to license your work under the
MIT license unless specified otherwise in `contrib/debian/copyright` or at
the top of the file itself. Any work contributed where you are not the original
author must contain its license header with the original author(s) and source.

repository: vertcoin-project/vertcoin-core

repo_name: vertcoin-project/vertcoin-core


text:
# Rue
A quiet but helpful build system.

## Getting Started

You'll need to have Ruby installed, this repository downloaded, and - for best
results - a symlink to the file "rue.rb" somewhere on your path.  If you've done
all of these things, you're ready to configure a project.

Rue uses a configuration file named "ruefile".  Run the `rue` command from the
same directory as that file.  Rue will load the file automatically, read your
project's configuration, and be on its way.

If your project directory looked like this:

    + myproject/
      + src/
        - hello.cpp
        - hello.h
        - main.cpp
      - ruefile

Your ruefile could look like this:

```ruby
Rue.project do |p|
    p.target('hello.out', :srcdir => 'src')
end
```

Then, after running Rue, your directory would look like this:

    + myproject/
      + builds/
        + all/
          + default/
            + obj/
              + hello.out/
                - hello.cpp.o
                - main.cpp.o
            + bin
              - hello.out
        - latest -> all/default/bin
      + src/
        - hello.cpp
        - hello.h
        - main.cpp
      - .ruecache
      - ruefile

Your shiny new executable can be found in "builds/latest".  And all object files
have been stored in the "builds" directory, so cleaning up is as simple as going
in and deleting it (which is exactly what happens when you run `rue clean`).

That's it!

## What just hapened?

You told Rue that your project was made up of one Target (executable / library)
that was called "hello.out" and that had the root of its source tree at "src".
Rue took care of the rest - it found all the source files in that directory,
figured out how they depended on one another, and compiled them down to the
desired executable, keeping cached versions of the intermediate object files so
it won't have to do nearly as much work next time.

You may have seen a message about Rue not being able to load a cache file.  Rue
determines dependencies by going through source files, which is potentially
expensive.  So it keeps a dependency cache as well.

## Details

Rue has two main forms of configuration: Targets and Builds.  A Target, as we've
already seen, is something the compiler is expected to produce.  A Build is a
scope for configuration options you only want in certain situations.  For
example, if you only want debugging info in your debug builds, and only want to
spend cycles optimizing for your release builds, you could write a ruefile like
this:

```ruby
Rue.project do |p|
    p.default_build = 'debug'

    # Global settings:
    p[:cpp][:flags] += ' -Wall -Wextra'

    p.build 'debug' do
        # Only for debug builds
        p[:cpp][:flags] += ' -g'
    end

    p.build 'release' do
        # Only for release builds
        p[:cpp][:flags] += ' -O3'
    end

    p.target 'hello.out', :srcdir => 'src'
end
```

You can build either explicitly with the commands `rue debug` and `rue release`;
the  `default_build`  setting controls what happens when you run just `rue`.  In
the example above, Rue will run a debug build.

repository: xavierholt/rue

repo_name: xavierholt/rue


text:
# Contributing
Contributions are **welcome** and will be fully **credited**.
We accept contributions via Pull Requests on [Github](https://github.com/kadet1090/keylighter).

## Documentation
Detailed documentation related to KeyLighter development can be found in
[`/Docs/`](https://github.com/kadet1090/keylighter/Docs/) directory.

## Issues
Don't want to code but have suggestion or found issue? That's cool too -
Just remember to properly describe it, and if it's highlighting problem
report it via KeyLighter page: http://keylighter.kadet.net/.
Submit code which is highlighted incorrectly, click **create issue**
button and fill issue with more information.

![buttton](https://i.imgur.com/0MEF9sc.png)

In other case create issue via GitHub with template:
```md
Describe what is wrong, include piece of code or screenshot if needed.

# Steps to reproduce
...

# What was expected result?
...

Version: Version number or commit hash if using dev-master - preferably `git describe --all --long` output.
```

## Pull Requests
- **[PSR-2 Coding Standard](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-2-coding-style-guide.md)** - The easiest way to apply the conventions is to install [PHP Code Sniffer](http://pear.php.net/package/PHP_CodeSniffer).
- **Add tests!** - Your patch won't be accepted if it doesn't have tests.
- **Document any change in behaviour** - Make sure the `README.md` and any other relevant documentation are kept up-to-date.
- **Consider our release cycle** - We try to follow [SemVer v2.0.0](http://semver.org/). Randomly breaking public APIs is not an option.
- **Create feature branches** - Don't ask us to pull from your master branch.
- **One pull request per feature** - If you want to do more than one thing, send multiple pull requests.
- **Send coherent history** - Make sure each individual commit in your pull request is meaningful. If you had to make multiple intermediate commits while developing, please [squash them](http://www.git-scm.com/book/en/v2/Git-Tools-Rewriting-History#Changing-Multiple-Commit-Messages) before submitting.
- **Fill an issue** - For bigger changes you should fill an issue, especially when code architecture is going to be altered.

## Running Tests
``` bash
$ ./vendor/bin/phpunit
```

**Happy coding**!


text:
PastecR
=======

[![Travis-CI Build Status](https://travis-ci.org/mdlincoln/PastecR.svg?branch=master)](https://travis-ci.org/mdlincoln/PastecR) [![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/github/mdlincoln/PastecR?branch=master&svg=true)](https://ci.appveyor.com/project/mdlincoln/PastecR)

Wrapper for the [Pastec](http://pastec.io/) image search and recognition engine API.

[Directions for building and running Pastec can be found here.](http://pastec.io/doc#setup)
(Note that if you are trying to install Pastec on OS X or Ubuntu, you may find that [this fork does better at locating the necessary libraries.](https://github.com/mdlincoln/pastec/tree/libjson_fix))

Once you have an instance of Pastec running, you can start interacting with it using PastecR.

## Installation

```r
# install.packages("devtools")
devtools::install_github("mdlincoln/PastecR")
library(PastecR)
```

## Usage

[Pastec](http://pastec.io/) is an [open-source](https://github.com/Visu4link/Pastec) image matching engine that does Google-images-esque fuzzy searching of a database of images that you compile.
It is very good at finding close-but-not-exact matches, such as different versions of a photograph, or rotated, cropped, or resized versions of images.

PastecR provides a wrapper around the Pastec API, which can be particularly useful when parsing the results returned by an image search request.

## Self-hosted or Saas?

You can [compile and run](http://pastec.io/doc/oss/) Pastec yourself, however there is also a hosted version available with both a free and a paid option at <https://api.pastec.io>.
PastecR supports both options:

```r
library(PastecR)

# open_pastec_server defaults to the same port defaults as Pastec
ops <- open_pastec_server(url = "localhost", port = 4212)

# You can find the index_id and auth_key for your api.pastec.io account at
# <https://api.pastec.io/manager/apiPage>
hps <- hosted_pastec_server(index_id = "XXXXXXXXXXXXXXXXXXXX", auth_key = "XXXXXXXXXXXXXXXXXXXX")
```

## Load images and search

We'll be using a number of artowrks for this example, including three different versions of a print.

![Portret van Desiderius Erasmus, Philips Galle, Hans Holbein (II), Benedictus Arias Montanus, 1572](http://www.rijksmuseum.nl/media/assets/RP-P-1906-1485&200x200)
![Portret van Desiderius Erasmus, Philips Galle, Hans Holbein (II), Janus Vitalis, 1604 - 1608](http://www.rijksmuseum.nl/media/assets/RP-P-1906-1486&200x200)
![Portret van Desiderius Erasmus, Philips Galle, Hans Holbein (II), Benedictus Arias Montanus, 1572](http://www.rijksmuseum.nl/media/assets/RP-P-1906-1487&200x200)
![Militia Company of District II under the Command of Captain Frans Banninck Cocq, Known as the 'Night Watch', Rembrandt Harmensz. van Rijn, 1642](http://www.rijksmuseum.nl/media/assets/SK-C-5&200x200)

Once you have established either your own instance of Pastec, or an account at <https://api.pastec.io>, you may add images with the `add_image()` command.
You must set an integer `image_id` when adding.

```r
# Get image paths
erasmus1 <- system.file("img", "RP-P-1906-1485.jpg", package = "PastecR")
erasmus2 <- system.file("img", "RP-P-1906-1486.jpg", package = "PastecR")
erasmus3 <- system.file("img", "RP-P-1906-1487.jpg", package = "PastecR")
nightwatch <- system.file("img", "SK-C-5.jpg", package = "PastecR")

add_image(erasmus1, 1, ops)
add_image(erasmus2, 2, ops)
add_image(erasmus3, 3, ops)
add_image(nightwatch, 4, ops)

# Images can also be removed by index
remove_image(4, ops)
```

Once your index is loaded, you can search for similar images, and parse the results with a number of helper commands.

```r
search_result <- search_image(erasmus1, ops)
results_as_data_frame(search_result)
```

```
##   height width  x   y image_id scores tags
## 1    827   592 53 142        1    964   NA
## 2    803   567 64 159        3     62   NA
## 3    796   575 56 173        2     59   NA
```

See `?pastec_response` for other parsing functions.

## Index operations

To clear the index, use `clear_index(server)`.
On the open, self-hosted version of Pastec, you can also save and load index files to disk by using `save_index()` and `load_index()`.
At the moment, these commands are not available for the SaaS version of pasted, and will throw an error.

---
[Matthew Lincoln](http://matthewlincoln.net)

repository: mdlincoln/PastecR

repo_name: mdlincoln/PastecR


text:
# Conqueuer

Conqueuer (pronounced like conquer) is a non-persistent Elixir work queue.

### Documentation and Information

The [docs](http://hexdocs.pm/conqueuer/0.5.1/Conqueuer.html) can be found on the
hexdocs website and [further information](https://hex.pm/packages/conqueuer) on the
hex website.

### Installation

Conqueuer can be installed like:

  1. Add test to your list of dependencies in `mix.exs`:

        def deps do
          [{:conqueuer, "~> 0.5.1"}]
        end

  2. Ensure test is started before your application:

        def application do
          [applications: [:conqueuer]]
        end

repository: midas/conqueuer

gha_language: Elixir

repo_name: midas/conqueuer