text:
# Streaming Service ML-React-App

With so many streaming platforms available today, how do you pick which one to subscribe to?

This is a web application with a React frontend and Flask backend that predicts what streaming service (out of Netflix, Hulu, Prime Video, or Disney+) a user should get, based on the user's responses to a form asking about the kinds of movies they'd like to watch.

I used a supervised learning model trained on features such as release year, runtime, minimum age, country, language, and genre to predict which platform a movie with those attributes would most likely be found on. I decided to go with Multinomial Logistic Regression since the multinomial part is for classifying data into multiple classes (not just two different classes). In my exploration, I tried out a Multinomial Logistic Regression classifier, Decision Tree classifiers, Support Vector Machine classifiers, and K Nearest Neighbors classifiers, and settled on the Multinomial Logistic Regression classifier.

## Technologies Used

React, JavaScript, CSS, React Bootstrap, Flask, Python, Python's sklearn library

## Acknowledgements

Thanks to this helpful guide on a ML React and Flask app template: https://towardsdatascience.com/create-a-complete-machine-learning-web-application-using-react-and-flask-859340bddb33

Also, thank you to this Kaggle dataset of Netflix, Hulu, Prime Video, and Disney+ movies that I trained my ML model on: https://www.kaggle.com/ruchi798/movies-on-netflix-prime-video-hulu-and-disney


text:
## 3.0.0

### Breaking Changes
- chore(amplify_lints)!: Remove `app_core.yaml` and `library_core.yaml`

### Features
- Dart 3 support (must update Dart SDK constraint to `^3.0.0`)

## 2.0.3

- Update repository URL

## 2.0.2

- Enforce `implementation_imports` to align with `package:lints`

## 2.0.1

- Fix package analysis issues

## 2.0.0

- Bumped min Dart SDK to 2.17
- Upgraded `package:lints` and `package:flutter_lints` dependencies to 2.0
- Migrated specs as follows:
    - `flutter_lib.yaml`, `dart.yaml` -> `library.yaml`
    - `flutter_app.yaml` -> `app.yaml`
- Ignores `implementation_imports` lint for `library.yaml` and `library_core.yaml`

Introduced the following new lints to `library.yaml`:
  - `always_use_package_imports`
  - `avoid_classes_with_only_static_members`
  - `avoid_dynamic_calls`
  - `avoid_field_initializers_in_const_classes`
  - `avoid_js_rounded_ints`
  - `avoid_multiple_declarations_per_line`
  - `cascade_invocations`
  - `comment_references`
  - `conditional_uri_does_not_exist`
  - `deprecated_consistency`
  - `eol_at_end_of_file`
  - `flutter_style_todos`
  - `join_return_with_assignment`
  - `no_runtimeType_toString`
  - `noop_primitive_operations`
  - `omit_local_variable_types`
  - `prefer_asserts_in_initializer_lists`
  - `prefer_final_in_for_each`
  - `prefer_final_locals`
  - `prefer_if_elements_to_conditional_expressions`
  - `prefer_int_literals`
  - `prefer_null_aware_method_calls`
  - `require_trailing_commas`
  - `sort_constructors_first`
  - `tighten_type_of_initializing_formals`
  - `unawaited_futures`
  - `unnecessary_null_checks`
  - `use_enums`
  - `use_if_null_to_convert_nulls_to_bools`
  - `use_late_for_private_fields_and_variables`
  - `use_named_constants`
  - `use_raw_strings`
  - `use_setters_to_change_properties`
  - `use_string_buffers`
  - `use_super_parameters`
  - `use_test_throws_matchers`
  - `use_to_and_as_if_applicable`

Introduced the following new lints to `app.yaml`:
  - `avoid_dynamic_calls`
  - `avoid_field_initializers_in_const_classes`
  - `eol_at_end_of_file`
  - `flutter_style_todos`
  - `omit_local_variable_types`
  - `prefer_final_in_for_each`
  - `prefer_final_locals`
  - `prefer_int_literals`
  - `prefer_null_aware_method_calls`
  - `require_trailing_commas`
  - `secure_pubspec_urls`
  - `sized_box_shrink_expand`
  - `sort_constructors_first`
  - `tighten_type_of_initializing_formals`
  - `unawaited_futures`
  - `unnecessary_null_checks`
  - `use_colored_box`
  - `use_decorated_box`
  - `use_enums`
  - `use_if_null_to_convert_nulls_to_bools`
  - `use_late_for_private_fields_and_variables`
  - `use_named_constants`
  - `use_raw_strings`
  - `use_setters_to_change_properties`
  - `use_super_parameters`
  - `use_test_throws_matchers`

To allow migration to the new lints, the old lints are available as `library_core.yaml` and `app_core.yaml` with only the upgrade to `package:lints` and `package:flutter_lints` v2.0.

## 1.1.0

### Chores

- Added `depend_on_referenced_packages` and `use_build_context_synchronously` lints

## 1.0.0 (2021-09-09)

### Chores

- chore(amplify_lints): Add amplify_lints package (#808)

repository: aws-amplify/amplify-flutter

branch_name: refs/heads/main

extension: md

gha_language: Dart

license_type: permissive

repo_name: aws-amplify/amplify-flutter


text:
_Visit the eBay TSV utilities [main page](../README.md)_

# number-lines

A simpler version of the Unix `nl` program. It prepends a line number to each line read from files or standard input. This tool was written primarily as an example of a simple command line tool. The code structure it uses is the same as followed by all the other tools. Example:
```
$ number-lines myfile.txt
```

Despite it's original purpose as a code sample, `number-lines` turns out to be quite convenient. It is often useful to add a unique row ID to a file, and this tool does this in a manner that maintains proper TSV formatting.

See the [number-lines reference](../docs/ToolReference.md#tsv-number-lines-reference) for further details.

repository: wilzbach/tsv-utils-dlang

branch_name: refs/heads/master

repo_name: wilzbach/tsv-utils-dlang


text:
# Work with Azure Storage Tables and Queues in a C# Application

* Connect to your dev virtual machine, open the console application called "AzureTables" in the Module2/LAB2 folder
* Restore the nuget packages
* Update the connection string in app.config
* Use the code samples to create a table and practice reading and writing items to the table
* Use the code samples to create a queue and practice enqueing and dequeuing messages

repository: AzureInterface/azure-dev-class

repo_name: AzureInterface/azure-dev-class


text:
mistakes.computer
=================

A silly project to try out [Deno Deploy]. Picks a random thing that was a
mistake (most of which the application uses 😅). Provides a website,
JSON endpoint, and [Mattermost] slash command.

### Endpoints

* Website: <https://mistakes.computer/>
* JSON: <https://mistakes.computer/mistake.json>
* Slash command: `/mistake Wesley's bot was`

Local Development
-----------------

For local development you need [Deno]. Then install [deployctl]:

    deno install --allow-read --allow-write --allow-env --allow-net --allow-run --no-check --unstable -r -f https://deno.land/x/deploy/deployctl.ts

Run the local server:

    deployctl run --watch --libs=ns,fetchevent src/index.tsx

License
-------

MIT

[Deno]: https://deno.land/
[Deno Deploy]: https://deno.com/deploy
[deployctl]: https://github.com/denoland/deployctl
[Mattermost]: https://mattermost.com/

license: MIT

gha_license_id: MIT


text:
# Change Log

## 0.0.25 (unreleased)

- Replace predeploy hack with something more robust.

## 0.0.24

- Remove proxy-agent stub #6172
- Pull in latest CLI changes (July 25, 2023)

## 0.0.24-alpha.1

- Add more user-friendly API permission denied messages

## 0.0.24-alpha.0

- Remove Google sign-in option from Monospace.
- Fix some Google sign-in login/logout logic.
- Prioritize showing latest failed deploy if it failed.

## 0.0.23 (July 13, 2023)

- Same as alpha.5, marked as stable.

## 0.0.23-alpha.5 (July 12, 2023)

- More fixes for service account detection logic.
- Better output and error handling for init and deploy steps.

## 0.0.23-alpha.4 (July 11, 2023)

- Fix for service account bugs

## 0.0.23-alpha.3 (July 7, 2023)

- UX updates
  - Get last deploy date
  - Write to and show info level logs in output channel when deploying
  - Enable user to view service account email

## 0.0.23-alpha.2 (July 6 2023)

- Service account internal fixes plus fix for deploying Next.js twice in a row

repository: firebase/firebase-tools

gha_language: TypeScript

repo_name: firebase/firebase-tools


text:
**We are moving to https://etcd.netlify.com with help from CNCF.**

#### etcd Documentation

This is experimental etcd documentation.

Please visit https://etcd.readthedocs.io/en/latest for latest builds.

#### Install and build

```bash
# https://docs.readthedocs.io/en/latest/getting_started.html
pip install sphinx sphinx-autobuild
pip install sphinx_rtd_theme

make help
make html
```

And open `_build/html/index.html` file for preview.

repository: ailabstw/etcd

gha_language: Go

repo_name: ailabstw/etcd


text:
# Remove kube-proxy's automatic clean up logic

## Table of Contents

<!-- toc -->
- [Summary](#summary)
- [Motivation](#motivation)
  - [Goals](#goals)
  - [Non-goals](#non-goals)
- [Proposal](#proposal)
- [Graduation Criteria](#graduation-criteria)
- [Implementation History](#implementation-history)
- [Alternatives](#alternatives)
<!-- /toc -->

## Summary

Remove any clean up functionality in kube-proxy that is done automatically/implicitly.
More concretely, kube-proxy should only attempt to clean up its proxy rules when the `--cleanup` flag is set.

## Motivation

Historically, kube-proxy has been built with a "clean up" functionality that allows it to find and remove any proxy
rule that it created. This functionality runs in two steps. The first step requires an explicit request from
the user by setting the `--cleanup` flag in which case kube-proxy would attempt to remove proxy rules associated with
all its proxy modes and then exit. The second step is done automatically by kube-proxy on start-up in which kube-proxy
would detect and remove any proxy rules associated with the proxy modes it was not currently using.

We've learned by now that trying to automatically clean up proxy rules is prone to bugs due to the complex dependency
between all the proxy modes and the Linux kernel. There are overlapping proxy rules between the iptables
and IPVS proxy modes which can result in connectivity issues during start-up as kube-proxy attempts to clean up
these overlapping rules. In the worse case scenario, kube-proxy will flush active iptable chains every time it is restarted.
This KEP aims to simplify this clean up logic, and as a result, make kube-proxy's behavior more predictable and safe.

### Goals

* Simplify the clean up code path for kube-proxy by removing any logic that is done implicitly by kube-proxy.
* Remove bugs due to overlapping proxier rules, causing user-visible connectivity issues during kube-proxy startup.

### Non-goals

* Re-defining the set of proxy rules that should be cleaned up.
* Improving the performance of kube-proxy startup.

## Proposal

Only clean up iptables and IPVS proxy rules if `--cleanup` is set.
If `--cleanup` is not set, start kube-proxy without cleaning up any existing rules.

For example, remove code like [this](https://github.com/kubernetes/kubernetes/blob/e7eb742c1907eb4f1c9e5412f6cd1d4e06f3c277/cmd/kube-proxy/app/server_others.go#L180-L187) where kube-proxy attempts to clean up proxy rules in a proxy mode it is not using.

```go
    if proxyMode == proxyModeIPTables {
	    ...
	    userspace.CleanupLeftovers(iptInterface)
	    // IPVS Proxier will generate some iptables rules, need to clean them before switching to other proxy mode.
	    // Besides, ipvs proxier will create some ipvs rules as well.  Because there is no way to tell if a given
	    // ipvs rule is created by IPVS proxier or not.  Users should explicitly specify `--clean-ipvs=true` to flush
	    // all ipvs rules when kube-proxy start up.  Users do this operation should be with caution.
	    if canUseIPVS {
		    ipvs.CleanupLeftovers(ipvsInterface, iptInterface, ipsetInterface, cleanupIPVS)
	    }
	    ...
```

With proxy clean up always requiring an explicit request from the user, we will also recommend users to reboot their nodes if they choose to
switch between proxy modes. This was always expected but not documented/vocalized well enough. The `--cleanup` flag should only be used in the event that a
node reboot is not an option. Accompanying a proxy mode switch with a node reboot ensures that any state in the kernel associated with the previous
proxy mode is cleared. This expectation should be well documented in the release notes, the Kubernetes docs, and in kube-proxy's help command.

## Graduation Criteria

* kube-proxy does not attempt to remove proxy rules in any proxy mode unless the `--cleanup` flag is set.
* the expectations around kube-proxy's clean up behavior is stated clearly in the release notes, docs and in kube-proxy's help command.
* there is documentation strongly suggesting that a node should be rebooted along with any proxy mode switch

## Implementation History

* 2019-03-14: initial [bug report](https://github.com/kubernetes/kubernetes/issues/75360) was created where kube-proxy would flush iptable chains even when the proxy mode was iptables

## Alternatives

* Removing support for cleaning up other proxy modes has been suggested. For example, if a user wished to change proxy modes,
rather than running `kube-proxy --cleanup`, users would be advised to restart the worker node.
* Continue to support automatic/implicit clean up of proxy rules by fixing any existing bugs where overlapping rules are removed.
Though we can continue to support this, doing so correctly is not trivial. The overlapping rulesets between the existing
proxy modes makes it difficult to fix this without adding more complexity to kube-proxy or changing the proxy rules in an incompatible way.

repository: kubernetes/enhancements

repo_name: kubernetes/enhancements


text:
# DestinationError

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**code** | **string** | Error Codes:

invalid_store_secrets: While distributing to store, secrets provided for store are not valid.

store_release_bad_request: Proper package release details for the store is not provided.

store_release_unauthorized: User is not authorized to publish to store due to invalid developer credentials.

store_release_forbidden: Publish to store is forbidden due to conflicts/errors in the release version and already existing version in the store.

store_release_promotion: Release already distributed, promoting a release is not supported.

store_track_deactivated: One or more tracks would be deactivated with this release. This is not supported yet.

store_release_not_found: App with the given package name is not found in the store.

store_release_not_available: The release is not available.

internal_server_error: Failed to distribute to a destination due to an internal server error.
 | [optional]
**message** | **string** |  | [optional]
**id** | **string** |  | [optional]
**name** | **string** |  | [optional]

[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

license: MIT,Unlicense

detected_licenses: MIT Unlicense

gha_language: Python


text:
========

UpscalingToolbox

========

UpscalingToolbox contains analysis scripts that can be used
to upscale pore-scale measurements made using the LBPM-WIA software
package. Tools are implemented using the R software distribution.
Specific capabilities of Upscaling Toolbox include:

* ingestion of csv files containing
* analysis of averaging logs and time series information
* unit conversion and data non-dimensionalization
* tools for fitting constitutive relationships
* statistical characterization of geologic materials
* plotting tools

=======

Use the R package manager to install dependencies from CRAN

install.packages(<packagename>)

* ggplot2
* mgcv
* data.table
* pspline

repository: JamesEMcClure/UpscalingToolbox

repo_name: JamesEMcClure/UpscalingToolbox


text:
#Features in more depth

## Static Files
Serving static files via **Hendrix** is optional but easy.

A default static file handler is built into Hendrix which can be used by adding the following to your settings:
```python
HENDRIX_CHILD_RESOURCES = (
  'hendrix.contrib.resources.static.DefaultDjangoStaticResource',

  # uncomment if you would like to serve the django admin static files
  #'hendrix.contrib.resources.static.DjangoAdminStaticResource',
  )
  ```
  No other configuration is necessary.  You don't need to add anything to urls.py.

  You can also easily create your own custom static or other handlers by adding them to ```HENDRIX\_CHILD\_RESOURCES```.

## SSL
This is made possible by creating a self-signed key. First make sure you have
the newest **patched** version of openssl.
Then generate a private key file:
```bash
$ openssl genrsa > key.pem
```
Then generate a self-signed SSL certificate:
```bash
$ openssl req -new -x509 -key key.pem -out cacert.pem -days 1000
```

Finally you can run single SSL server by running:
```bash
$ hx start --dev --key key.pem --cert cacert.pem
```
or a process distributed set of SSL servers:
```bash
hx start --dev --key key.pem --cert cacert.pem -w 3
```
Just go to `https://[insert hostname]:4430/` to check it out.
N.B. Your browser will warn you not to trust the site... You can also specify
which port you want to use by passing the desired number to the `--https_port`
option

##Caching

At the moment a caching server is deployed by default on port 8000. Is serves
gzipped content, which is pretty cool - right?

However, if you wanted to switch away from the cache server you can always point
to the http port (default 8080).

It works by forwarding requests to the http server running the app and
caches the response depending on the availability of `max-age` [seconds] in a
`Cache-Control` header.

#####Busting the cache

Note that you can bust the cache (meaning force it not to cache) by passing
a query in your GET request e.g. `http://somesite.com/my/resource?somevar=test`.
You can also force the query to cache by specifying `cache=true` in the query
e.g. `http://somesite.com/my/resource?somevar=test,cache=true` (so long as a
`max-age` is specified for the handling view).
What this means is that you can let the browser do some or none of the js/css
caching if you so want.

#####Caching in Django

In your project view modules use the `cache_control` decorator to add
a `max-age` of your choosing. e.g.

```python
from django.views.decorators.cache import cache_control

@cache_control(max_age=60*60*24)  # cache it for a day
def homePageView(request):
...
```

and that's it! Hendrix will do the rest. Django docs examples [here](https://docs.djangoproject.com/en/dev/topics/cache/#controlling-cache-using-other-headers)

#####Turning cache off

You can turn caching on by passing the flags `-c` or `--cache`. You can also change which
port you want to use with the `--cache_port` option.

#####Global Vs Local

If you're running multiple process using the `-w` or `--workers` options caching
will be process distributed by default. Meaning there will be a reverse proxy
cache server for each process. However if you want to run the reverse
proxy server on a single process just use the `-g` or `--global_cache` flags.

... here "local" means local to the process.

## Testing

In your virtualenv first run the following:

pip install -r requirements
pip install -r test-requirements

Tests live in `hendrix.test` and are most easily run using Twisted's
[trial](https://twistedmatrix.com/trac/wiki/TwistedTrial) test framework.
```bash
/home/jsmith:~$ trial hendrix
hendrix.test.test_deploy
DeployTests
test_multiprocessing ...                                               [OK]
test_options_structure ...                                             [OK]
test_settings_doesnt_break ...                                         [OK]

-------------------------------------------------------------------------------
Ran 3 tests in 0.049s

PASSED (successes=3)
```
**trial** will find your tests so long as you name the package/module such that
it starts with "test" e.g. `hendrix/contrib/cache/test/test_services.py`.

Note that the module needs to have a subclass of unittest.TestCase via the expected
unittest pattern. For more info on *trial* go [here](https://twistedmatrix.com/trac/wiki/TwistedTrial).

N.B. that in the `hendrix.test` `__init__.py` file a subclass of TestCase
called `HendrixTestCase` has been created to help tests various use cases
of `hendrix.deploy.HendrixDeploy`


text:
# qprivnote-app
Simple android app to create and share encrypted notes links using https://privnote.com.

Android build info:
- build OpenSSL libraries (you can use https://github.com/esutton/android-openssl) and copy them to openSSL dir
- add android build files (Manifest.xml, etc) via QtCreator

repository: jackopoz/qprivnote-app

repo_name: jackopoz/qprivnote-app


text:
---
layout: post
title: "Airways: Optimization-Based Planning of Quadrotor Trajectories according to High-Level User Goals"
date: 2019-06-27 14:14:51
categories: arXiv_RO
tags: arXiv_RO Knowledge Drone Optimization
author: Christoph Gebhardt, Benjamin Hepp, Tobias Naegeli, Stefan Stevsic, Otmar Hilliges
mathjax: true
---

* content
{:toc}

##### Abstract
In this paper we propose a computational design tool that al-lows end-users to create advanced quadrotor trajectories witha variety of application scenarios in mind. Our algorithm al-lows novice users to create quadrotor based use-cases withoutrequiring deep knowledge in either quadrotor control or theunderlying constraints of the target domain. To achieve thisgoal we propose an optimization-based method that gener-ates feasible trajectories which can be flown in the real world.Furthermore, the method incorporates high-level human ob-jectives into the planning of flight trajectories. An easy touse 3D design tool allows for quick specification and edit-ing of trajectories as well as for intuitive exploration of theresulting solution space. We demonstrate the utility of our ap-proach in several real-world application scenarios, includingaerial-videography, robotic light-painting and drone racing.

##### Abstract (translated by Google)

##### URL
[http://arxiv.org/abs/1906.11669](http://arxiv.org/abs/1906.11669)

##### PDF
[http://arxiv.org/pdf/1906.11669](http://arxiv.org/pdf/1906.11669)


text:
# Customized dotfiles

## dotfiles

The dotfiles are how you personalize your system.
You can read more about dotfiles in the holman repo [holman dotfiles](https://github.com/holman/dotfiles).

These dotfiles are mine, focused in Plugins and mappings for Vim.

## Install

First you need to change your shell for **zsh**

Install zsh and set to default:

```sh
sudo apt-get install zsh
chsh -s /bin/zsh user
```
Then:

```sh
git clone git@github.com:lcostantini/dotfiles.git ~/.dotfiles
cd ~/.dotfiles
script/bootstrap
```

This will symlink the appropriate files in `.dotfiles` to your home directory.
Everything is configured and tweaked within `~/.dotfiles`.

The main file you'll want to change right off the bat is `zsh/zshrc.symlink`,
which sets up a few paths that'll be different on your particular machine.

## Configuration for Vim

In the file **vimrc.symlink** you can find all the plugins and configuration that i use for vim.
You can find the file **vimrc.symlink** in ~/.dotfiles/vim/

The best way to install and configuration all is with the plugin [Vundle](https://github.com/gmarik/Vundle.vim)
You can read about Vundle in the link or simply can do this:
```sh
git clone https://github.com/gmarik/Vundle.vim.git ~/.vim/bundle/Vundle.vim
```
Then launch vim and run:
```sh
:PluginInstall
```

## Contributing

In vim/vimrc.symlink you will see all the plugins and mappings
that i used and a short description about each one.

If you want to colaborate [Fork it](https://github.com/lcostantini/dotfiles/fork),
remove what you don't use, and build on what you do use.

## Info

I forked [Olvap](https://github.com/olvap/dotfiles) dotfiles and start my own.
In master branch we have synchronized the repos and in branch customized i have my own changes.

repository: lcostantini/dotfiles

gha_language: Shell

repo_name: lcostantini/dotfiles


text:
---
title: "Plugins"
autotoc: true
view: layout.twig
collection: "Getting Started"
---

# Plugin

All of the logic in the Client is handled by plugins. You simply chain them together.

```js
Client()
  .use(ssh({
    port: '22'
  }))
  .connect('/var/socket')
```

...it's as easy as that!

repository: PKuebler/metalsmith

repo_name: PKuebler/metalsmith


text:
# Focuing on
* How to study data engineering?
* How to become a data engineer?
* Let's look at the big picture!

---

# Lectures
* [Data Flair - Learn Data Engineering](https://data-flair.training/blogs/)

---

# Useful References
* [https://github.com/igorbarinov/awesome-data-engineering](https://github.com/igorbarinov/awesome-data-engineering)
* [https://github.com/meirwah/awesome-workflow-engines](https://github.com/meirwah/awesome-workflow-engines)
* [https://github.com/manuzhang/awesome-streaming](https://github.com/manuzhang/awesome-streaming)
* [Docker vs Kubernetes vs Apache Mesos](https://mesosphere.com/wp-content/uploads/2018/08/TheMyth-Infographic-2x.jpg)

---

# IaaS Platform
## Openstack
- [What is OpenStack](https://www.openstack.org/software/)
- [https://www.openstack.org/](https://kubernetes.io/)

## Amazone EC2
- Proprietary
- [https://aws.amazon.com/ko/ec2/](https://aws.amazon.com/ko/ec2/)

## Google Compute Engine
- Proprietary
- [https://cloud.google.com/compute/?hl=ko](https://cloud.google.com/compute/?hl=ko)

## Azure IaaS
- Proprietary
- [https://azure.microsoft.com/ko-kr/overview/what-is-azure/iaas/](https://azure.microsoft.com/ko-kr/overview/what-is-azure/iaas/)

## DigitalOcean
- Proprietary
- [https://www.digitalocean.com/products/droplets/](https://www.digitalocean.com/products/droplets/)

---

# PaaS Platoform
## Cloud Foundry
- [https://www.cloudfoundry.org/](https://www.cloudfoundry.org/)

## Amazon Lamda
- Proprietary
- [https://aws.amazon.com/ko/lambda/](https://aws.amazon.com/ko/lambda/)

## Google App Engine
- Proprietary
- [https://cloud.google.com/appengine/docs/](https://cloud.google.com/appengine/docs/)

## Microsoft App Service
- Proprietary
- [https://azure.microsoft.com/en-us/services/app-service/?v=18.51](https://azure.microsoft.com/en-us/services/app-service/?v=18.51)

---

# Linux OS
## CoreOS
- A lightweight Linux operating system designed for clustered deployments
- [https://github.com/coreos/](https://github.com/coreos/)

---

# Distributed Platform
## Openshift
- Container support
-  A container application platform that brings Docker and Kubernetes to the enterprise.
- [https://github.com/openshift](https://github.com/openshift)

## DC/OS
- Container + Non-container support
- Chronos + Marathon + Aurora, etc. based on Mesos.
- Premium paid model for extra features
- [https://dcos.io/](https://dcos.io/)

---

# Distributed Framework
## Mesos
- Support both containerized and non-containerized (e.g. analytics and stateful data services) workloads
- Even can run kubernetes on it
- A distributed systems kernel (Framework)
- [http://mesos.apache.org/](http://mesos.apache.org/)

---

# Container Framework
## Docker
- Provide operatiing-system-level virtualization
- [https://www.docker.com/](https://kubernetes.io/)

## LXC
- Operating-system-level virtualization method for running multiple isolated Linux systems (containers) on a control host using a single Linux kernel
- [https://linuxcontainers.org/ko/lxc/introduction/](https://linuxcontainers.org/ko/lxc/introduction/)

---

# Container Orchestration
## Kubernetes
- Open-source system for automating deployment, scaling, and management of containerized applications.
- [https://kubernetes.io/](https://kubernetes.io/)

## Marathon
- Apache Mesos Framework for Docker orchestration
- [https://mesosphere.github.io/marathon/](https://mesosphere.github.io/marathon/)

## Docker Swarm
- Native clustering for Docker. It turns a pool of Docker hosts into a single, virtual host.
- [https://github.com/docker/swarm](https://github.com/docker/swarm)

## Amazon ECS
- Amazon Elastic Container Service
- [https://aws.amazon.com/ko/ecs/](https://aws.amazon.com/ko/ecs/)

## HashiCorp Nomad
- [https://www.nomadproject.io/](https://www.nomadproject.io/)

## Metronome
- Apache Mesos framework for scheduled jobs.
- [https://github.com/dcos/metronome](https://github.com/dcos/metronome)

## Chronos
- Apache Mesos framework for cron job  orchestration.
- [https://github.com/mesos/chronos](https://github.com/mesos/chronos)

## Aurora
- Apache Mesos framework for long-running services and cron jobs
- [http://aurora.apache.org/](http://aurora.apache.org/)

---
# Data warehouse (Datalake)
## Hadoop Ecosystem
* [Study](hadoop.md)
* [hadoop](https://hadoop.apache.org/)
* Monitoring
    * [Ambari](https://hadoop.apache.org/)
* Database
    * [HBase](#hbase)
* Processing
    * [Map Reduce](#mapreduce)
    * [hive](#hive)
    * [Pig](#pig)
* Execution Engine
    * [Tez](https://tez.apache.org/)
* Resource Manager
    * [Yarn](https://hadoop.apache.org/docs/current/hadoop-yarn/hadoop-yarn-site/YARN.html)
* FileSystem
    * [HDFS](#hdfs)

## Amazon Redshift
* https://aws.amazon.com/ko/redshift/

## Snowflake
* https://www.snowflake.com/

---

# Security
## Kerberos
* [https://web.mit.edu/kerberos/](https://ranger.apache.org/)

## LDAP
* [https://tools.ietf.org/rfc/rfc4511.txt](https://tools.ietf.org/rfc/rfc4511.txt)

## Knox
* [https://knox.apache.org/](https://knox.apache.org/)

## Ranger
* [https://ranger.apache.org/](https://ranger.apache.org/)

---

# Data Companies
## Amazone AWS
* [https://aws.amazon.com](https://aws.amazon.com)
* [Products](https://aws.amazon.com/ko/products/)

## Google Cloud
* [https://cloud.google.com/](https://cloud.google.com/)
* [Products](https://cloud.google.com/products/)

## Microsoft Azure
* [https://azure.microsoft.com](https://azure.microsoft.com)
* [Products](https://azure.microsoft.com/ko-kr/services/)

## Alibaba Cloud
* [https://www.alibabacloud.com](https://www.alibabacloud.com)

## IBM Cloud
* [https://www.ibm.com/cloud/](https://www.ibm.com/cloud/)

## SAP Cloud
* [https://cloudplatform.sap.com/index.html](https://cloudplatform.sap.com/index.html)

## Oracle Cloud
* [https://cloud.oracle.com/home](https://cloud.oracle.com/home)

## Red Hat Cloud suite
* [https://www.redhat.com/ko/technologies/cloud-computing/cloud-suite](https://www.redhat.com/ko/technologies/cloud-computing/cloud-suite)

## Apache Cloud Stack
* [https://cloudstack.apache.org/](https://cloudstack.apache.org/)

## Cloudera
* [https://www.cloudera.com/](https://www.cloudera.com/)

## Hotornworks
* [https://hortonworks.com/](https://hortonworks.com/)

## Databricks
* [https://databricks.com/](https://databricks.com/)

## Teradata
* [https://www.teradata.com/](https://www.teradata.com/)

# Snowflake
* [https://www.snowflake.com/](https://www.snowflake.com/)

---

# Workflow
## Airflow
* [Study](airflow.md)
* [https://airflow.apache.org/](https://airflow.apache.org/)

## Azkaban
* [https://azkaban.github.io/](https://azkaban.github.io/)

## Oozie
* [http://oozie.apache.org/](http://oozie.apache.org/)

## Luigi
* [https://github.com/spotify/luigi](https://github.com/spotify/luigi)

## Dkron
* [https://dkron.io/](https://dkron.io/)

## Nomad
* [https://www.nomadproject.io/](https://www.nomadproject.io/)

# Data Ingestion
## Kafka
- [http://kafka.apache.org/](http://kafka.apache.org/)

## RabbitMQ
* [https://www.rabbitmq.com/](https://www.rabbitmq.com/)

## Sqoop
* [http://sqoop.apache.org/](http://sqoop.apache.org/)

---

# Data Stream Processing
## Flink
* [https://flink.apache.org/](https://flink.apache.org/)

## Spark Streaming
* [https://spark.apache.org/streaming/](https://spark.apache.org/streaming/)

---

# Data Batch Processing
## Mapreduce
* [http://hadoop.apache.org/docs/current/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.html](http://hadoop.apache.org/docs/current/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.html)

## Hive
* [Study](hive.md)
* [https://hive.apache.org/](https://hive.apache.org/)

## Spark
* [https://spark.apache.org/](https://spark.apache.org/)
* [https://www.datacamp.com/community/tutorials/apache-spark-python](https://www.datacamp.com/community/tutorials/apache-spark-python)

## Presto
* [https://prestodb.io/](https://prestodb.io/)

## Storm
* [http://storm.apache.org](http://storm.apache.org)

## Impala
* [https://impala.apache.org](https://impala.apache.org)

## Pig
* [https://pig.apache.org/](https://pig.apache.org/)

# Samza
* [http://samza.apache.org](http://samza.apache.org)

## Imply
* Powered by [Druid](#druid)
* [https://imply.io/](https://imply.io/)

## Mahout
* [http://mahout.apache.org/](http://mahout.apache.org/)

## HAWQ
* [http://hawq.apache.org/](http://hawq.apache.org/)

## Drill
* [https://drill.apache.org/](https://drill.apache.org/)

## Kylin
* [http://kylin.apache.org](http://kylin.apache.org)

----

# Databases
## MySQL
* [https://www.mysql.com/](https://www.mysql.com/)

## Mongo DB
- [https://docs.mongodb.com/manual/mongo/](https://docs.mongodb.com/manual/mongo/)

## ElasticSearch
- [https://www.elastic.co/](https://www.elastic.co/)

## Redis
- [http://redis.io/](http://redis.io/)

## HBase
- [https://hbase.apache.org/](https://hbase.apache.org/)

## InfluxDB
- [https://github.com/influxdata/influxdb](https://github.com/influxdata/influxdb)

## OpenTSDB
- [https://github.com/OpenTSDB/opentsdb](https://github.com/OpenTSDB/opentsdb)

## Prometheus
  - [https://prometheus.io/](https://prometheus.io/)

## Cassandra
* [http://cassandra.apache.org/](http://cassandra.apache.org/)

## Riak
* [ https://github.com/basho/riak](https://github.com/basho/riak)

## Druid
* [http://druid.io/](http://druid.io/)

---

# Business Intelligence (Analysis & Visualization)

## Hue
* [http://gethue.com/](http://gethue.com/)

## Yanagishima
* [https://github.com/yanagishima/yanagishima](https://github.com/yanagishima/yanagishima)

## Tableau
* [https://www.tableau.com/](https://www.tableau.com/)

## Kibana
* [https://www.elastic.co/products/kibana](https://www.elastic.co/products/kibana)

## Grafana
* [https://grafana.com/](https://grafana.com/)

## Chronograf
* [https://github.com/influxdata/chronograf](https://github.com/influxdata/chronograf)

## Superset
* [https://superset.incubator.apache.org/](https://superset.incubator.apache.org/)

## Metabase
* [https://www.metabase.com/](https://www.metabase.com/)

## redash
* [https://redash.io/](https://redash.io/)

## Zeppelin
* [https://zeppelin.apache.org/](https://zeppelin.apache.org/)

## IBM Cognos Analytics
* [https://www.ibm.com/products/cognos-analytics](https://www.ibm.com/products/cognos-analytics)
---

# File System
## HDFS
* [Study](hdfs.md)
* [https://hadoop.apache.org/docs/r1.2.1/hdfs_design.html](https://hadoop.apache.org/docs/r1.2.1/hdfs_design.html)

---

# Data Serialization Formats
## ORC
* [Study](orc.md)
* [https://orc.apache.org/](https://orc.apache.org/)

## Avro
* [https://avro.apache.org/](https://avro.apache.org/)

## JSON
* [https://json.org/](https://json.org/)

## BSON
* [http://bsonspec.org/](http://bsonspec.org/)

## Protocol Buffers
* [https://developers.google.com/protocol-buffers/](https://developers.google.com/protocol-buffers/)

## Thrift
* [https://thrift.apache.org/](https://thrift.apache.org/)

## YAML
* [https://yaml.org/](https://yaml.org/)

## XML
* [https://www.w3.org/TR/REC-xml/](https://www.w3.org/TR/REC-xml/)

---

# Log Collector
## Flunetd
* [https://www.fluentd.org/](https://www.fluentd.org/)

## Logstash
* [https://www.elastic.co/products/logstash](https://www.elastic.co/products/logstash)

## Beats
* [https://www.elastic.co/kr/products/beats](https://www.elastic.co/kr/products/beats)

## StatsD
## collectd
## dd-agent
## Telegraf
## logrotate
## Graphite
## Flume

---

# Tracing

## Zipkin
* [https://zipkin.io/](https://zipkin.io/)

---

# Configuration Management
## Ansible
* [https://www.ansible.com/](https://www.ansible.com/)

## Chef
* [https://www.chef.io/chef/](https://www.chef.io/chef/)

## Salt
* [https://github.com/saltstack/salt](https://github.com/saltstack/salt)

## CFEngine
* [https://github.com/cfengine/core](https://github.com/cfengine/core)

## Puppet
* [https://github.com/puppetlabs/puppet](https://github.com/puppetlabs/puppet)

## Vagrant
* [https://www.vagrantup.com/](https://www.vagrantup.com/)

# Web Servers
## Nginx
* [https://nginx.org/en/](https://nginx.org/en/)
* [http://nginx.org/en/docs/beginners_guide.html](http://nginx.org/en/docs/beginners_guide.html)

## Apache
* [https://httpd.apache.org/](https://httpd.apache.org/)

## Tomcat
* [https://tomcat.apache.org/](https://tomcat.apache.org/)

## Jetty
* [http://www.eclipse.org/jetty/](http://www.eclipse.org/jetty/)

---

# Distributed Synchronization Service
## Zookeeper
* [https://zookeeper.apache.org/](https://zookeeper.apache.org/)

---

# Uncategorized
## Data Visualization libraries
* Apache Calcite [https://calcite.apache.org/](https://calcite.apache.org/)
* d3.js
* chart.js
* Leaflet.js
* Database.js
* Swiper.js
* vue.js
* AOS(animation on scroll)
* https://seaborn.pydata.org/
* https://matplotlib.org/index.html


text:
# General Electric (GE) Implementation

## Supported MRI systems (version xm 1)

The following MRI systems support the free waveform sequence, ordererd by gradient system type:

* XRMB
  * Discovery MR450 1.5T
  * Discovery MR750 3.0T
* XRMW
  * Optima MR450w 1.5T
  * Discovery MR750w 3.0T
  * SIGNA Artist
  * SIGNA Architect
* HRMW
  * SIGNA Premier

### Selecting different protocols on the scanner

There are three predefined diffusion acquisition protocols; short, intermediate and long. A given protocol is selected by setting CV27 to a value between 1 and 3, as detailed below.

#### Short protocol (CV27 = 1)

| Waveform| b-values [ms/µm²] | Acq. volumes |
|------|------|-------|
|  LTE    |   0.1,  1.0,  2.0   | 4, 10, 15      |
|  STE    |   0.1,  1.0,  2.0   |    6, 10, 10   |

#### Intermediate protocol (CV27 = 2)

| Waveform| b-values [ms/µm²] | Acq. volumes |
|------|------|-------|
|  LTE    |   0.1, 0.7, 1.4, 2.0   |  6, 6, 10, 21  |
|  STE    |   0.1, 0.7, 1.4, 2.0   |   6, 6, 10, 15 |

#### Long protocol (CV27 = 3)

| Waveform| b-values [ms/µm²] | Acq. volumes |
|------|------|-------|
|  LTE    |   0.1, 0.7, 1.4, 2.0 | 6, 6, 16, 30  |
|  PTE    | 0.1, 1.0, 2.0  | 6, 10, 15  |
|  STE    |   0.1, 0.7, 1.4, 2.0   |    6, 6, 10, 10|

### Accessing the experimental information
The waveforms and experiment parameter structure (xps) files are provided by GE. They can be downloaded from this repository, or can be found in the folder `/usr/g/research/extwd/waveforms/` on the scanner. The files are named after the gradient system and the CV27 value. For example, the information about the long protocol on the Signa Artist platform are found in the XRMW003.mat file.

There are two files types of interest for each gradient system and protocol combination:

**txt**: a comma separated file where all acquisition volume b-values, b-delta values and diffusion directions are stored

**mat**: a MATLAB file that contains three variables.

`encoding_table` is a Nx5 MATLAB table that holds the encoding direction, b-value and b-delta values of each of the N acquisition volumes.

`waveforms` is a 19127x3xN MATLAB array that contains waveform of the x, y and z gradient for each of the N acquisition volumes.

`xps` is a MATLAB struct containing all information for creating parametric maps using the MDM MATLAB library.

The xps compatible witht the md-dMRI framework can be generated by using the function `mdm_xps_ge_xm1`.

gha_language: MATLAB


text:
![Estar Words](screenshots/banner.png)

A demo of a space battle using WebGL.

This project was implemented by [@brusteca](https://github.com/brusteca) and [@federivero](https://github.com/federivero) for the 2017 Advanced Computer Graphics class at FIng, UdelaR.

## How to run

Download the code, run a web server on the directory ([you can use something simple like Chrome 200 OK](https://chrome.google.com/webstore/detail/web-server-for-chrome/ofhbbkphhbklhfoeikjpcbhemlocgigb?hl=en)), and open `/main.html`.

Use W, A to move, Q, E to roll, arrow keys to pitch, and space bar to shoot.

## Screenshots

![](screenshots/01.png)
![](screenshots/02.png)
![](screenshots/03.png)
![](screenshots/04.png)
![](screenshots/05.png)

repository: brusteca/cga-estar-words

repo_name: brusteca/cga-estar-words


text:
# Bitnami Azure Container Instance (ACI) Templates

This repository contains all currently available Bitnami Azure Container Instance (ACI) Templates.

## Current templates

* [Bitnami WordPress](wordpress)
* [Bitnami Jenkins](jenkins)

## License

Copyright (c) 2015-2018 Bitnami

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

repository: javsalgar/aci-templates

repo_name: javsalgar/aci-templates


text:
# Gmail
An OMG service for Gmail microservice.

### Installation
* Install golang version 1.11+

### Get credentials file
* https://developers.google.com/gmail/api/quickstart/go
* Download client configuration credentials.json and token.json file.

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

repository: heaptracetechnology/gmail-microservice

repo_name: heaptracetechnology/gmail-microservice


text:
---
hrs_structure:
  division: '1'
  volume: '1'
  title: '3'
  chapter: '23'
  section: 23-95
type: hrs_section
tags:
  - Government
menu:
  hrs:
    identifier: HRS_0023-0095
    parent: HRS0023
    name: 23-95 Review for 2022 and every fifth year thereafter
weight: 40225
title: Review for 2022 and every fifth year thereafter
full_title: 23-95 Review for 2022 and every fifth year thereafter
---
**[§23-95] Review for 2022 and every fifth year thereafter.** (a) The credits and deductions under the income tax and financial institutions tax listed in subsection (c) shall be reviewed in 2022 and every fifth year thereafter.

(b) The auditor shall submit the findings and recommendations of the reviews to the legislature and governor at least twenty days prior to the convening of the immediately following regular session.

(c) This section shall apply to the following:

(1) Section 235-5.5--Deduction for individual housing account deposit;

(2) Section 235-7(f)--Deduction of property loss due to a natural disaster;

(3) Section 235-16.5--Credit for cesspool upgrade, conversion, or connection;

(4) Section 235-19--Deduction for maintenance of an exceptional tree;

(5) Section 235-55.91--Credit for the employment of a vocational rehabilitation referral;

(6) Section 235-110.2--Credit for in-kind services contribution for public school repair and maintenance; and

(7) Sections 235-110.8 and 241-4.7--Credit for ownership of a qualified low-income housing building. [L 2016, c 245, pt of §2]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# NYC-Subway-live-status-react-native
This is a working example of a React Native live status app for New York Subway.

## New York Subway Live Status:

New York’s Metropolitan Transportation Authority (MTA) does have a website where they provide API data feeds. However, their log-in and account management system are very tricky to navigate. I’ve never managed to get passed the initial log-in stage. If you’d like to try your luck, be my guest:
https://datamine.mta.info/

Luckily, MTA also maintains another resource which requires no log-ins. The following page lists out live status of Subway lines in plain .txt format. It seems to be updated in real time.
http://web.mta.info/status/serviceStatus.txt

The first couple of lines of this file looks like this as of this writing.

````
…
<line>
<name>123</name>
    <status>PLANNED WORK</status>
    <text> … (some more text strings here that tells the nature of engineering work, location and other details)…</text>
    <Date>09/15/2019</Date>
    <Time> 5:45AM</Time>
  </line>
…
````

This is telling us the line 123 (the red one) is currently experiencing disruption due to a planned engineering work. And the structure of the file seems consistent i.e., there is another block that looks pretty much like this for the line 456, 7, ACE and so on.
That means we can parse the text in this URL to manually find the status text for each line. You can use a combination of a few basic string manipulation commands of javascript to find strings that are observed after X number of characters after <name>123</name>.
Repeat the process for <name>456</name> and you get the next one. It is a tedious string manipulation, but it does the job.

## Making API requests:
We are using react-native-axios to make multiple requests in one batch. This will allow us to pool the requests for all the Subway lines and execute at the same time.

Follow the instruction here to install:
https://www.npmjs.com/package/react-native-axios

## Styling:
NY Subway lines are often depicted as big circles with line name in them.
Here is how you draw a circle in React Native.

````

circle: {
    width: 25,
    height: 25,
    borderRadius: 25 / 2,
    backgroundColor: 'grey',
  },

````

The description text is either black (“GOOD SERVICE”) or orange (everything else). The conditional styling is done like this:

````
{color:  text01 == "GOOD SERVICE" ? 'black' : 'orange'}
````

For official colour palette of MTA Subway lines, see the link below.
http://web.mta.info/developers/resources/line_colors.htm

The result should look like this:
![Image description]( https://github.com/LeoUrushi/assets/blob/master/Screen_NewYorkSubwayAPI_sample.png)

Editable example:
https://snack.expo.io/@leourushi/api-demo_ny-subway

Working example:
https://apps.apple.com/us/app/new-york-subway-map/id1463337846

gha_language: JavaScript


text:
# coffee-go
[![](https://img.shields.io/badge/golang-1.14-blue)](https://golang.org/) [![](https://img.shields.io/badge/docker-19.03.13-9cf)](https://www.docker.com/)

coffee-go written by golang and integrated by mongo-db, this is a standarization
for development API service using golang and mongodb.

## Setup for Development
you'r system should be installed depedencies like `go`, `make`, `docker-engine` and `docker-compose`

```bash
# Clone project and change directory to project folder
$ git clone https://github.com/fajrulaulia/coffee-go.git && cd coffee-go/

# build and run mongodb service
$ make service-up

# Run Application on Development Mode
$ go run cmd/main.go

```

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## Author
- Fajrul Aulia

## License
[apache-2.0](https://choosealicense.com/licenses/https://choosealicense.com/licenses/apache-2.0/)

repository: fajrulaulia/coffee-go

repo_name: fajrulaulia/coffee-go


text:
# Find Records That Have Multiple Associated Records

A common type of table association in a relational database is a one-to-many
relationship. For instance, a database representing a bookshelf may have an
`authors` table where each record can be associated with multiple records in
the `books` table. That relationship is represented by a `author_id` foreign
key column on `books` that points to `authors.id`.

We can write a query to find all authors that have not zero or one, but
multiple books by doing a join and then tacking on a `having` clause.

```sql
select authors.id, authors.name, count(books.id)
  from authors
  join books
    on authors.id = books.author_id
  group by authors.id
  having count(books.id) >= 2;
```

This will result in a listing of author ids, author names, and their number of
books.

It does this by joining books to authors, grouping by the `authors.id` to
produce a set of records unique to each author, and then combining multiple
books by aggregating them with a `count`. The `having` clause is necessary
because it is our way of _filtering_ on an aggregate value, in this case the
`count`.

repository: jbranchaud/til

gha_language: Vim Script

repo_name: jbranchaud/til


text:
# itemsense-viztool-js
> A web-based visualization tool for using your ItemSense Instance.

*This tool is under active development and may be unstable at times.  It is presented as-is as a reference and prototyping tool for ItemSense.  It is not recommended to build production solutions based on this tool.*

For more information about ItemSense, check out http://developer.impinj.com.

## Installation
Once you have cloned the repository, you need version 4.0.0 of node and upwards. check your node version with the following command:
```bash
$ node --version
```
If you have an older version of node, or don't have not at all, you can install it by going to https://nodejs.org/en/download/
Once node is installed, three commands should be run
To get the application ready for execution, run the following two commands:
```javascript
$ npm install
$ npm install -g gulp
$ gulp compile
```
NOTE:  Tested using node v5.8.0
Consider a tool such as nvm (Node Version Manager) to switch to 5.8.0

Once those have completed, you can now start up a server:
```javascript
$ npm start
```

Once the server executable is running, just browse to **http://localhost:3001** to see it in action.

## Disclaimer
Copyright ©2018 Impinj, Inc. All rights reserved.
You may use and modify this code under the terms of the Impinj Software Tools License & Disclaimer.
Visit https://support.impinj.com/hc/en-us/articles/360000468370-Software-Tools-License-Disclaimer
for full license details, or contact Impinj, Inc. at<EMAIL_ADDRESS>for a copy of the license.


text:
# Check Digit

https://justingolden21.github.io/check-digit/

### About

A simple utility for checking digits

### Functionality

Step 1:

Numbers are converted to letters with the following dictionary:

	'a':1,
	'b':2,
	'c':3,
	'd':4,
	'e':5,
	'f':6,
	'g':7,
	'h':8,
	'i':9,
	'j':1,
	'k':2,
	'l':3,
	'm':4,
	'n':5,
	'o':6,
	'p':7,
	'q':8,
	'r':9,
	's':2,
	't':3,
	'u':4,
	'v':5,
	'w':6,
	'x':7,
	'y':8,
	'z':9

Dashes (-) are treated as 0s and take up a spaace.

Remaining non-numeral characters are ignored.

Step 2:

Each number is multiplied by 1, 3, or 7 depending on which order it appears in the sequence, where:

%3==0 : 1,
%3==1: 3,
%3==2: 7

Step 3:

The numbers are summed, then the sum is divided by 10.

The result of that number modulo 10 times 10 (the "leftover" after the decimal place) is what we subtract from 10 to get the result.

For example:

123 => 12.3 => 0.3 => 3 => 10-3 => 7

Note: If result would be 10, it's 0 instead.


text:
---
title : DAY 5 - Gatsby for Apps
subtitle : Making Progress
slug : day-5
date : 2020-01-05
author : Lucie B
---

Spent a little more time today looking into Gatsby for apps and found a few interesting resources.

The Youtube [Gatsby Dynamic App Tutorial](https://www.youtube.com/watch?v=RVNC61rkFxw) by Ben Award [@benawad](https://twitter.com/benawad) confirmed my previous finding that using Gatsby to build dynamic applications is a very good option.
The short tutorial provides a demo of how to set up your environment for building a dynamic app in Gatsby that works along with any other static pages. Once set up, it seems that there is little difference to working with a create-react-app project setup.

Gatsby docs about [Client-only Routes & User Authentication](https://www.gatsbyjs.org/docs/client-only-routes-and-user-authentication/) and the [@reach/router](https://www.gatsbyjs.org/docs/reach-router-and-gatsby/) where also useful.

## Making Progress

So at the end of today, I have a starting point in terms of my setup and am confident that what I am looking at creating is possible using Gatsby. I have a lot to learn yet but I feel, I am on the right track.

I will set this research aside for now and over the next few days, refine the wireframe for my web app idea.  There are also some minor adjustments I want to make to my main site, as well as this [#100DaysofGatsby](https://twitter.com/hashtag/100DaysofGatsby) blog page. Enough to keep me busy until the second challenge for #100DaysofGatsby is announced!

#### Till tomorrow, Happy coding!


text:
#Kotka for Big Cartel Readme#

Designed and Developed by WeTheme [http://www.wetheme.com/](http://www.wetheme.com/)

##Overview##

Kotka is now an open source theme, released under the MIT license (details below).

There is no support for this theme.

If you would like to purchase a theme with support, theme settings and heaps of features, please take a look at the range of Shopify themes on our website:

[http://www.wetheme.com/shopify-themes/](http://www.wetheme.com/shopify-themes/)

##Installation##

**You should only attempt to install this theme if you have advanced knowledge of HTML, CSS and JS. There is no support for this, or any of our other Big Cartel themes.**

1. Select the 'Sexy' or 'Blocks' theme
2. Copy/paste all of the files contained within the repo to the pages in your Big Cartel store
3. Fill in the settings at the top of the 'Home' and 'Layout' page
4. Push any updates/improvements you make back here :)

If you would like to purchase a theme with support, theme settings and heaps of features, please take a look at the range of Shopify themes on our website:

[http://www.wetheme.com/shopify-themes/](http://www.wetheme.com/shopify-themes/)

##License##

MIT License

Copyright (c) 2016 WeTheme.

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: wetheme/Kotka---Big-Cartel

repo_name: wetheme/Kotka---Big-Cartel


text:
# jQuery Filter Table Plugin

This plugin will add a search filter to tables. When typing in the filter, any rows that do not contain the filter will be hidden.

One can also define clickable shortcuts for commonly used terms.

See the demos at http://sunnywalker.github.com/jQuery.FilterTable

## Usage

Include the dependencies:

```html
<script src="/path/to/jquery.js"></script>
<script src="/path/to/bindWithDelay.js"></script> <!-- optional -->
<script src="/path/to/jquery.filtertable.js"></script>
<style>
p.filter-table { margin: 0; }
ol.quick { margin: 0; margin-bottom: 1em; padding: 0; list-style: none; }
ol.quick li { display: inline; margin-right: 10px; }
td.alt { background-color: #ffc; background-color: rgba(255, 255, 0, 0.2); }
</style> <!-- or put the styling in your stylesheet -->
```

Then apply `filterTable()` to your table(s):

```html
<script>
$('table').filterTable(); //if this code appears after your tables; otherwise, include it in your document.ready() code.
</script>
```

## Options

| Option | Type | Default | Description |
| ------ | ---- | ------- | ----------- |
| `callback` | function(`term`, `$table`) | _null_ | callback function after a filter is performed
| `columnSelector` | string | td | selector of table cells (td)
| `containerClass` | string | filter-table | class of filter input container
| `containerTag` | string | p | tag name of filter input container
| `highlightClass` | string | alt | class added to matching table cells (td)
| `inputName` | string | filter-table | name of filter input
| `inputPlaceholder` | string | search this table | placholder in filter input
| `inputType` | string | search | type of filter input
| `inputLabel` | string | Filter: | label added before the filter input (null for no label)
| `minRows` | integer | 8 | only show the filter on tables with this number of rows or more
| `quickList` | array | [] | list of phrases to quick fill the search
| `quickListContainerClass` | string | quick | class of quick list container
| `quickListContainerTag` | string | ol | tag name of quick list container
| `quickListItemClass` | string | quick | class of each quick list item
| `quickListItemTag` | string | li | tag of each quick list item
| `rowSelector` | string | tbody > tr | selector applied to table rows (tr)
| `visibleClass` | string | visible | class added to visible rows

## Styling

Suggested styling:

```css
p.filter-table { margin: 0; }
ol.quick { margin: 0; margin-bottom: 1em; padding: 0; list-style: none; }
ol.quick li { display: inline; margin-right: 10px; }
td.alt { background-color: #ffc; background-color: rgba(255, 255, 0, 0.2); }
```

There is a caveat on automatic row striping. While alternating rows can be striped with CSS, such as:

```css
tbody td:nth-child(even) { background-color: #f0f8ff; }
```

Note that CSS cannot differentiate between visible and non-visible rows. To that end, it's better to use jQuery to add and remove a striping class to visible rows by defining a callback function in the options.

```javascript
$('table').filterTable({
	callback: function(term, table) {
		table.find('tr').removeClass('striped').filter(':visible:').addClass('striped');
	}
});
```

## Dependencies

Other than jQuery, the plugin will take advantage of Brian Grinstead's [bindWithDelay](https://github.com/bgrins/bindWithDelay) if it is available.

## Change Log

### 1.5

- Rewrite to CoffeeScript
- Support for custom row and cell selectors
- Adjustments to generated markup (quick list is now a real list)
- Further options to customize markup (tag and class names)

### 1.4

- Fixed a bug with filtering rarely showing rows that did not have a match with the search query.
- Added example pages.
- Improved inline documentation of the source code.

### 1.3

- The functionality is not reapplied to tables that have already been processed. This allows you to call `$(selector).filterTable()` again for dynamically created data without it affecting previously filtered tables.

### 1.2

- Changed the default container class to `filter-table` from `table-filter` to be consistent with the plugin name.
- Made the cell highlighting class an option rather than hard-coded.

### 1.1

- Initial public release.

## License

(The MIT License)

Copyright (c) 2013 Sunny Walker<EMAIL_ADDRESS>& Tomas Celizna<EMAIL_ADDRESS>
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.

THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 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.


text:
protoc-gen-redact (PGR)
=======================
[![Build](https://github.com/Shivam010/protoc-gen-redact/workflows/Build/badge.svg)](https://github.com/Shivam010/protoc-gen-redact/actions?query=workflow%3ABuild)
[![Go Report Card](https://goreportcard.com/badge/github.com/Shivam010/protoc-gen-redact?dropcache)](https://goreportcard.com/report/github.com/Shivam010/protoc-gen-redact)
[![Go Reference](https://pkg.go.dev/badge/github.com/Shivam010/protoc-gen-redact.svg)](https://pkg.go.dev/github.com/Shivam010/protoc-gen-redact)
[![License](https://img.shields.io/badge/license-apache2-mildgreen.svg)](./LICENSE)
[![GitHub release](https://img.shields.io/github/release/Shivam010/protoc-gen-redact.svg)](https://github.com/Shivam010/protoc-gen-redact/releases)

_protoc-gen-redact (PGR)_ is a protoc plugin to redact field values in GRPC client calls from the server. This plugin
adds support to protoc-generated code to redact certain fields in the GRPC calls.

Developers only need import the PGR extension and annotate the messages or fields in their proto files to redact:

```protobuf
syntax = "proto3";

package user;

import "redact/redact.proto";
import "google/protobuf/empty.proto";

option go_package = "github.com/Shivam010/protoc-gen-redact/examples/user/pb;user";

message User {
    // User credentials
    string username = 1;
    string password = 2 [(redact.redact) = true]; // default redaction

    // User information
    string email = 3 [(redact.custom).string = "r*d@ct*d"];
    string name = 4;
    Location home = 5;
    message Location {
        double lat = 1;
        double lng = 2;
    }
}

service Chat {
    rpc GetUser(GetUserRequest) returns (User);
    rpc GetUserInternal(GetUserRequest) returns (User) {
        option (redact.method_skip) = true;
    }
    rpc ListUsers (google.protobuf.Empty) returns (ListUsersResponse) {
        option (redact.internal_method) = true;
    }
}

message GetUserRequest {
    string username = 1;
}

message ListUsersResponse {
    repeated User users = 1;
}

```

Request for Contribution
------------------------
Contributors are more than welcome and much appreciated. Please feel free to open a PR to improve anything you don't
like, or would like to add.

Please make your changes in a specific branch and create a pull request into master! If you can, please make sure all
the changes work properly and does not affect the existing functioning.

No PR is too small! Even the smallest effort is countable.

License
-------
This project is licensed under the [Apache License 2.0](./LICENSE)


text:
# Developers
Documentation about engine components can be found in here

## Organization
The source code is organized into namespaces and a file name convention.
For example, anything prefixed with `u_` belongs to the *utility* namespace,
which is also named `u`. The following namespaces and file prefixes exist:

| Prefix | Namespace | Description |
|--------|-----------|-------------|
| u_     | u         | utility     |
| m_     | m         | math        |
| r_     | r         | renderer    |
| c_     | c         | client      |

## Utility library
Neothyne doesn't use the C++ standard library, instead it rolls its own
implementation of common containers. They're not meant to be compatible with the
standard in any way, even if they share a similar API. The following containers
exist.

* u::pair
* u::set
* u::map
* u::string
* u::vector
* u::buffer
* u::stack

As well as a plethora of type traits and algorithmic functions which can be
found in `u_traits.h` and `u_algorithm.h` respectively. Miscellaneous utilites can
be found in `u_misc.h`.

## Shaders

Shaders in Neothyne are written in GLSL with a bit of syntax sugar.

Neothyne will emit a prelude to each shader containing the version of GLSL to
utilize as well as things like `HAS_TEXTURE_RECTANGLE` if the GPU supports that
feature. You can find a list of the macros it emits by searching for
`method::define` in the code-base.

Neothyne supports the `#include` directive in GLSL; similarly, Neothyne will emit
uniform guards to prevent declaring uniforms more than once.

The following code:
```
    uniform vec2 foo;
    uniform vec4 bar;
```

Will be converted into:
```
    #ifndef uniform_foo
    uniform vec2 foo;
    #define uniform_foo
    #define line 1
    #endif
    #ifndef uniform_bar
    uniform vec4 bar;
    #define line 2
    #endif
```
This way you can have uniforms declared in headers which can be included without
causing conflicts.


text:
# willitmerge

A command line tool to check if pull requests are mergeable.

```
$ willitmerge
Found 8 open pull requests on github.com/cakephp/docs.
Checking........DONE

Issue #376, https://github.com/cakephp/docs/pull/376, will it merge? NO!
Issue #272, https://github.com/cakephp/docs/pull/272, will it merge? NO!
Issue #212, https://github.com/cakephp/docs/pull/212, will it merge? NO!
Issue #209, https://github.com/cakephp/docs/pull/209, will it merge? NO!
Issue #207, https://github.com/cakephp/docs/pull/207, will it merge? YES!
Issue #223, https://github.com/cakephp/docs/pull/223, will it merge? YES!

$ willitmerge --rebase
Found 7 open pull requests on github.com/cowboy/grunt.
Checking.......DONE

Issue #413, https://github.com/cowboy/grunt/pull/413, will it rebase? YES!
Issue #405, https://github.com/cowboy/grunt/pull/405, will it rebase? YES!
Issue #404, https://github.com/cowboy/grunt/pull/404, will it rebase? YES!
Issue #399, https://github.com/cowboy/grunt/pull/399, will it rebase? YES!
Issue #395, https://github.com/cowboy/grunt/pull/395, will it rebase? YES!
Issue #363, https://github.com/cowboy/grunt/pull/363, will it rebase? YES!
Issue #350, https://github.com/cowboy/grunt/pull/350, will it rebase? YES!
```

## Install

Install with `npm install -g willitmerge`

## Usage

Navigate to the project folder you would like to check then run: `willitmerge`.
This will then look for the remote: upstream or origin in that order. Then
proceeds to check if each open pull request can be merged. Please note, this
will not actually do any merging... only checks.

### Options

```
$ willitmerge --help

  Usage: willitmerge [options]

  Options:

    -h, --help             output usage information
    -r, --remote <remote>  name of remote source eg origin, upstream
    --ignore <ignore>      list of issue #s to ignore eg 120,234,300
    --perpage <perpage>    number of issues to check at a time, max is 100
    --page <page>          page when using perpage pagination
    --rebase               rebase instead of merge
    -v, --verbose          display output of merge attempts
    -V, --version          output the version number

```

## API

To use willitmerge in your project:

``` javascript
var wim = require('willitmerge');

// This event is fired after issues have been received from github
wim.once('issues', function(issues) {
  // To test all the issues if they will merge then fire the `end` event
  wim.testIssues(issues);

  // or if you would like to write your own mechanism and test
  // each issue individually use:
  wim.testIssue(issue, function(err, iss) { });
});

// This event is fired after issues have been tested
wim.once('end', function(issues) {
  // `willitmerge` will be appended to each issue with the info about the test

  // Call to display the issues report, clean up and end the program
  wim.onEnd(issues);
});

// run the program
wim.run({
  perpage: 40 // set options here
});
```

## Contributing

This project uses [Grunt](http://gruntjs.com) for development. Please install
and run `grunt` before submitting a pull request. Thanks!

## Release History

* 0.2.1 Check for invalid github urls
* 0.2.0 Refactor to use git pull and --rebase instead of applying patches
* 0.1.2 Add perpage, page options.
* 0.1.1 Order PRs by least amount changed
* 0.1.0 Built willitmerge tool from grunt-willitmerge

## License

Copyright (c) 2012 Kyle Robinson Young

Licensed under the MIT license.

repository: shama/willitmerge

repo_name: shama/willitmerge


text:
# NSAttrbuttedString+MarkSymbol
a category of NSAttributedString.

can set font and color for marked part of string.

##Usage

`attributedText = [[NSAttributedString alloc] initWithString:@"this is the part of unmarked @@ this is the part of marked @@ this is another part of unmarked" fontMarked:[UIFont boldSystemFontOfSize:17] colorMarked:[UIColor colorWithRed:0.000f green:0.643f blue:0.965f alpha:1.00f] fontUnmarked:[UIFont systemFontOfSize:17] colorUnmarked:[UIColor blackColor]];`

The mark symbol is set as @@ as default.

Can use

`-(instancetype)initWithString:(NSString *)str symbol:(NSString *)sym fontMarked:(UIFont *)font1 colorMarked:(UIColor *)color1 fontUnmarked:(UIFont *)font2 colorUnmarked:(UIColor *)color2;`

to set customised symbol.

##License
MIT License


text:
# 关于本章

1、queue是最最常见的一种需求。

2、关于concurrent queue，我觉得总结的非常好的文章是: 1024cores [Producer-Consumer Queues](http://www.1024cores.net/home/lock-free-algorithms/queues)

这篇文章非常系统。

## Implementation

下面按照优先级进行排序。

### [cameron314](https://github.com/cameron314)

非常成熟的实现。

1、[readerwriterqueue](https://github.com/cameron314/readerwriterqueue)

A fast single-producer, single-consumer lock-free queue for C++

2、[concurrentqueue](https://github.com/cameron314/concurrentqueue)

A fast multi-producer, multi-consumer lock-free concurrent queue for C++11

### [rigtorp](https://github.com/rigtorp)

较成熟的实现。

1、[SPSCQueue](https://github.com/rigtorp/SPSCQueue)

A bounded single-producer single-consumer wait-free and lock-free queue written in C++11

2、[MPMCQueue](https://github.com/rigtorp/MPMCQueue)

### mstump [queues](https://github.com/mstump/queues)

A public domain lock free queues implemented in C++11

Public domain implementation of four different lock free queues:

- SPSC lock free dynamic queue which requires a memory allocation with each insert.
- MPSC lock free dynamic queue which requires a memory allocation with each insert.
- SPSC wait free bound queue/ring buffer which which uses a fixed size pre-allocated buffer.
- MPMC lock free bound queue/ring buffer which which uses a fixed size pre-allocated buffer.

### huangfcn [lockfree](https://github.com/huangfcn/lockfree)

repository: dengking/Parallel-computing

repo_name: dengking/Parallel-computing


text:
#WDI Project 2: Crow's Nest

## Summary
This app provides a visualization of tweets on a map.  The user can input a location, which causes the map to center on that location.  Geolocated tweets are streamed in real-time through Twitter's streaming API.  Only a small percentage of tweets are tagged with the user's exact location.  Many tweets are picked up by the app because they originate within the bounds of the map, or are "about" a location on the map, but they are not visualized.  The only tweets that are displayed are ones with exact user coordinates, or tagged with a specific point of interest that exists in Google's Places API.  A history page lists the locations that the user has visited in the app on a world map.

## Technologies used
* Node.js & Express.js server
* Postgres & Sequelize backend
* Passport & OAuth for authentication
* Socket.io & Twit for streaming tweets
* Bootstrap for front-end

## API's
* Twitter streaming API
* Google Maps
* Google Places

## Ongoing issues and future implementations
Twitter's OAuth callback doesn't come with an email address, so users who log in via Twitter have null entries for their email and username. In the future, I plan to implement a form for these users to complete their account information for local authentication. I would also like to make the t.co links in tweets clickable in the Google maps info windows.

Perhaps the biggest downfall of the app is the limited number of tweets that are tagged with exact locations. This is a result of Twitter moving towards a Four Square-based place-centric check-in system and away from users tagging their exact geocoordinates.  When use of this place-tagging system becomes more prevalent, the app will probably become more useful and more fun.

Tweets come with entities like hashtags and links, so future features could include ways to visualize hashtags.  This would be a good way to utilize all the tweets that are included in the stream that aren't tagged with exact coordinates.

##Link to design docs
https://www.dropbox.com/sh/wkc78l0fi8vh02c/AAA92nRJtDOd75bMlAm55Looa?dl=0

##User Stories
1. I'm a bored student sitting in class. I want a distraction, so I go to Crow's Nest and watch local tweets.  Maybe I also check some other locations, and tweet some of my own tweets and watch them pop up on the screen.

2. I'm an avid twitter user. I get into tweet conversations and arguments with people all the time. If I'm conversing with someone local, I want to be able to see their exact location on the map.


text:
#TODO

Get roster from somewhere
Load characters from roster in App.
	Chuck them in store
	Ref in feed

SERVER NOTE
	Make sure characters can not be changed mid match.

NOTE:

In item, for the introduction type.
Props has:
	- Player username (username)
	- Other player username (othername)
	- Character name (charname)
	- + text and type

[
	{
		"name": "*p, the character type",
		"intro": "I am a character! This is my intro!",
		"actions": [
			"*p used action 1!",
			"*p used action 2!",
			"*p used action 3!"
		],
		"reactions": [
			"*p was hit by action 1!",
			"*p was hit by action 2!",
			"*p was hit by action 3!"
		],
		"outro": "I have defeated *p!",
		"spared": "Wow that was lucky!"
	 (Tie)

user123 throws a huge fireball!
rofl420 does something gross!

The two attacks bounce of each other harmlessly!

... (Smited)

The gods have lost their patience!
user123 is smited by the gods!
rofl420 has escaped that cruel fate

... (Ending)

rofl420 is defeated!
user123 is the victor!

Dark Wizard, user123
	- blah blah blah

repository: Jacksonblair/ReactSfa

repo_name: Jacksonblair/ReactSfa


text:
## Binary Tree

 The Binary tree means that the node can have maximum two children. Here, binary name itself suggests that 'two';
therefore, each node can have either 0, 1 or 2 children. A binary tree has the benefits of both an ordered array and a
linked list as search is as quick as in a sorted array and insertion or deletion operation are as fast as in
linked list.

 Binary trees: Terminology

 Binary trees are defined by a root node and children nodes, each node being able to have at most two children.
There are a few keywords that we will need to know before we continue.

	 Height  — The height of a node is the maximum number of edges separating that node from a leaf (see leaf).
	 Depth   — The depth of a node is the number of edges separating that node from the root node.
  	 Size    — The size of a tree is the number of nodes it contains.
	 Balance — The balance factor of a node is the difference between the height of its left subtree and the
		   height of its right subtree.
	 Leaf    — A leaf is a node that doesn’t have any children, in other words, an end node.

 Order of operations

		There are three types of tree traversal ie, pre-order, post-order, in-order.

		For pre-order traversal, we visit the root node first, then the left subtree, and then the right subtree
		For in-order traversal, we visit the left subtree, then the root node, then the right subtree.
		For post-order traversal, we visit the left subtree first, then the right, and then the root node.

 Height and Depth of the Binary tree

The height of a node in a binary tree is the largest number of edges in a path from a leaf node to a target node. If
the target node doesn’t have any other nodes connected to it, the height of that node would be 0. The height of a
binary tree is the height of the root node in the whole binary tree. In other words, the height of a binary tree
is equal to the largest number of the edges from the root to the most distant leaf node.

A similar concept in a binary tree is the depth of the tree. The depth of a node in a binary tree is the total number
of edges from the root node to the target node. Similarly, the depth of a binary tree is the total number of edges from
the root node to the most distant leaf node.

 For example, let's take a binary tree

 Firstly, we’re calculating the height of the node C. So, according to the definition, the height of the node C is
the largest number of edges in a path from the leaf node to the node C. We can see for the node C, there are two paths:
C -> E -> G and C -> F. The largest number of edges among these two paths would be 2. Hence the height of node C is 2..

Now, let’s calculate the height of the binary tree. From the root, we can have three different paths leading to the
leaf nodes: A -> C -> F, A -> B -> D, and A -> C -> E -> G. Among these three paths, the path A -> C -> E -> G contains
the most number of edges that is 3. Therefore the height of the tree is 3.

Next, we want to find the depth of the node B. Now we can see that from the root, there is only one path to the node B,
and it has one edge. Hence the depth of the node B is 1. The depth of a binary tree is equal to the height of the tree.
Therefore, the depth of the binary tree is 3.

 Types of Binary tree

	The types of binary tree,
		i. Full / proper / strict binary tree
		ii. Complete binary tree
		iii. Perfect binary tree
		iv. Degenerate binary tree
		v. Balanced binary tree

 Strict binary tree

 The full binary tree is also known as a strict binary tree. The tree can only be considered as the full binary tree
if each node must contain either 0 or 2 children. The full binary tree can also be defined as the tree in which each
node must contain 2 children except the leaf nodes.

 Complete binary tree

 The complete binary tree is a tree in which all the nodes are completely filled except the last level. In the last
level, all the nodes must be as left as possible. In a complete binary tree, the nodes should be added from the left.

 Perfect binary tree

 A tree is a perfect binary tree if all the internal nodes have 2 children, and all the leaf nodes are at the same
level.

 Degenerate Binary tree

 The degenerate binary tree is a tree in which all the internal nodes have only one children.

 The above tree is a degenerate binary tree because all the nodes have only one child. It is also known as a
right-skewed tree as all the nodes have a right child only.

 Balanced tree

 The balanced binary tree is a tree in which both the left and right trees differ by atmost 1. For example, AVL and
Red-Black trees are balanced binary tree.

 The above tree is a balanced binary tree because the difference between the left subtree and right subtree is zero.

 Properties of binary tree

At each level of i, the maximum number of nodes is 2i.

The height of the tree is defined as the longest path from the root node to the leaf node. The tree which is shown
above has a height equal to 3. Therefore, the maximum number of nodes at height 3 is equal to (1+2+4+8) = 15. In
general, the maximum number of nodes possible at height h is (20 + 21 + 22+….2h) = 2h+1 -1.

The minimum number of nodes possible at height h is equal to h+1.

If the number of nodes is minimum, then the height of the tree would be maximum. Conversely, if the number of nodes is
maximum, then the height of the tree would be minimum.

If there are 'n' number of nodes in the binary tree.

The minimum height can be computed as:

As we know that,

n = 2h+1 -1

n+1 = 2h+1

Taking log on both the sides,

log2(n+1) = log2(2h+1)

log2(n+1) = h+1

h = log2(n+1) - 1

The maximum height can be computed as:

As we know that,

n = h+1

h= n-1


text:
# Alias

[Permalink](https://github.com/blynkkk/blynkkk.github.io/blob/b1f1a439851d4000d4d85ddab2f72db8d227d6cc/new/en/datastream_alias.md)

Cannot retrieve contributors at this time

 7 lines \(4 sloc\) 332 Bytes

## Datastream: Alias

Alias is an alternative Datastream name which can be changed by the end-user. For example, it can be used by voice assistants like Amazon Echo \(Alexa\) and Google Home Assistant .

You can only use letters, digits and spaces. No other characters are allowed

**IMPORTANT:** Duplicate aliases are not allowed.

gha_license_id: NOASSERTION


text:
# CodeFitness

Discover features of your favorite language by unlocking achievements

![helloworld achievement](demo.gif)

## Installing

Make sure you have Atom installed along with the command line tools, and run:

```
git clone https://github.com/nicktikhonov/codefitness
cd codefitness
npm install
apm link
```

repository: NickTikhonov/codefitness

repo_name: NickTikhonov/codefitness


text:
# PhpQuickCheck

[![Build Status](https://travis-ci.org/steos/php-quickcheck.svg?branch=master)](https://travis-ci.org/steos/php-quickcheck)

PhpQuickCheck is a generative testing library for PHP based on
clojure.test.check.

> Don't write tests. Generate them.
> - John Hughes

## Huh?

Generative testing, also called property-based testing, is about
describing the behaviour of your system in terms of properties that
should hold true for all possible input.

### Installation

PhpQuickCheck is available via Packagist. Just add it to your composer.json:

```
{
  "require": {
    "steos/php-quickcheck": "dev-master"
  }
}
```

### Examples

Here is a failing example:

```php
use QCheck\Generator as Gen;
use QCheck\Quick;

$stringsAreNeverNumeric = Gen::forAll(
    [Gen::asciiStrings()],
    function($str) {
        return !is_numeric($str);
    }
);

$result = Quick::check(1000, $stringsAreNeverNumeric);
var_dump($result);
```

This will produce something like the following output (json encoded for readability):

```
"result": false,
"seed":<PHONE_NUMBER>536,
"failing_size": 109,
"num_tests": 110,
"fail": [
    "727"
],
"shrunk": {
    "nodes_visited": 15,
    "depth": 4,
    "result": false,
    "smallest": [
        "0"
    ]
}
```

What this tells us that after 110 random tests the property was sucessfully falsified.
The exact argument that caused the failure was "727" which then got shrunk to "0".
So our minimal failing case is the string "0".

Here's another example:

```php
// predicate function that checks if the given
// array elements are in ascending order
function isAscending(array $xs) {
    $last = count($xs) - 1;
    for ($i = 0; $i < $last; ++$i) {
        if ($xs[$i] > $xs[$i + 1]) {
            return false;
        }
    }
    return true;
}

// sort function that is obviously broken
function myBrokenSort(array $xs) {
    return $xs;
}

// so let's test our sort function, it should work on all possible int arrays
$brokenSort = Gen::forAll(
    [Gen::ints()->intoArrays()],
    function(array $xs) {
        return isAscending(myBrokenSort($xs));
    }
);

var_dump(Quick::check(100, $brokenSort, ['echo' => true]));

```

This will result in output similar to:
```
......F
{
    "result": false,
    "seed":<PHONE_NUMBER>957,
    "failing_size": 6,
    "num_tests": 7,
    "fail": [
        [-3,6,5,-5,1]
    ],
    "shrunk": {
        "nodes_visited": 24,
        "depth": 7,
        "result": false,
        "smallest": [
            [1,0]
        ]
    }
}

```

As you can see the list that failed was `[-3,6,5,-5,1]` which got shrunk to `[1,0]`. For each run
the exact failing values are different but it will always shrink down to `[1,0]` or `[0,-1]`.

The result also contains the seed so you can run the exact same test by passing it as an option
to the check function:

```php
var_dump(Quick::check(100, $brokenSort, ['seed' =><PHONE_NUMBER>957]));
```

This always fails with the array `[-3,6,5,-5,1]` after 7 tests and shrinks to `[1,0]`.

### Generators

```php
// integers
Gen::ints()->takeSamples();
# => [0,1,-1,3,-2,0,3,3,-8,9]

// ascii strings
Gen::asciiStrings()->takeSamples();
# => ["","O","@","&5h","QSuC","","c[,","[Q","  ){#o{Z","\"!F=n"]

// arrays
Gen::ints()->intoArrays()->takeSamples();
# => [[],[],[-2],[0,0],[2],[4,-4,-1,2],[],[-5,-7,3,-2,2,0,-2], ...]

// randomly choose between multiple generators
Gen::oneOf(Gen::booleans(), Gen::ints())->takeSamples();
# => [false,true,false,false,2,true,true,3,3,2]

// randomly choose element from array
Gen::elements('foo', 'bar', 'baz')->takeSamples();
# => ["foo","foo","bar","bar","foo","foo","bar","baz","foo","baz"]

// tuples of generators
Gen::tuples(Gen::posInts(), Gen::alphaNumStrings())->takeSamples();
# => [[0,""],[1,""],[0,"86"],[3,"NPG"],[4,"1q"],[4,"6"],[1,"Eu60MN"],[1,"6q9D8wm"], ...]

// notEmpty - generated value must not be empty
Gen::arraysOf(Gen::ints())->notEmpty()->takeSamples();
# => [[0],[1],[1,1],[4,-1],[1],[0,0,1,1,-2],[-6,5,4,-2,-1],[3,7,-2],[-6,5],[-1,1,-4]]

// suchThat - generated value must pass given predicate function
// Note: Only do this if you can't generate the value deterministically. SuchThat may fail
// if the generator doesn't return an acceptable value after 10 times.
// (you can pass $maxTries as second argument if necessary).
$oddInts = Gen::ints()->suchThat(function($i) {
    return $i % 2 != 0;
});
$oddInts->takeSamples();
# => [1,1,-1,-3,5,5,-3,-7,1,7]

// frequency - 1/3 of the time generate posInts, 2/3 of the time booleans
Gen::frequency(1, Gen::posInts(), 2, Gen::booleans())->takeSamples();
# => [0,1,false,true,true,false,false,true,5,false]

// fmap - transform the value generated
Gen::posInts()->fmap(function($i) { return $i * 2; })->takeSamples();
# => [0,2,4,2,4,8,10,8,0,6]

// use fmap to generate day times
$daytimes = Gen::tuples(Gen::choose(0, 23), Gen::choose(0, 59))
    ->fmap(function($daytime) {
        list($h, $m) = $daytime;
        return sprintf('%02d:%02d', $h, $m);
    });

$daytimes->takeSamples();
# => ["03:35","17:03","23:31","17:50","08:41","23:07","17:59","05:10","03:47","09:36"]

// bind - create new generator based on generated value
$bindSample = Gen::ints()->intoArrays()->notEmpty()
    ->bind(function($ints) {
        // choose one random element from the int array
        return Gen::elements($ints)
        // and return a tuple of the whole array and the chosen value
        ->fmap(function($i) use ($ints) {
            return [$ints, $i];
        });
    });
$bindSample->takeSamples();
# => [..., [[4,-2,5,3,5],4],[[-3,5,5,6,2],5],[[1,-3,1,5,2],-3], ...]

// maps from string keys to daytimes
$daytimes->mapsFrom(Gen::alphaStrings()->notEmpty())->notEmpty()->takeSamples();
# => [{"v":"08:36"},{"i":"03:43","E":"14:38"},{"gUU":"03:08","UIc":"19:24"}, ...]

// maps from strings to booleans
Gen::alphaStrings()->notEmpty()->mapsTo(Gen::booleans())->notEmpty()->takeSamples();
# => [{"J":true},{"pt":true,"TgQ":false},{"M":true,"jL":false},{"rm":true}, ...]

// maps with fixed keys
Gen::mapsWith([
    'age'       => Gen::choose(18, 99),
    'name'      => Gen::tuples(
                       Gen::elements('Ada', 'Grace', 'Hedy'),
                       Gen::elements('Lovelace', 'Hopper', 'Lamarr')
                   )->fmap(function($name) {
                       return "$name[0] $name[1]";
                   })
])->takeSamples();
# => [{"age":50,"name":"Ada Lamarr"},{"age":97,"name":"Ada Hopper"},
#     {"age":81,"name":"Ada Lovelace"},{"age":55,"name":"Hedy Lamarr"}, ...]
```

## Automatic detection for Generators

The `Annotation` class provide a helper to automatically use a generator based
on the documented types for the function :

```
/**
 * @param string $s
 * @return bool
 */
function my_function($s) {
    return is_string($s);
}

Annotation::check('my_function');
```

This will test `my_function` using the `Generator::strings()` generator.

You can also register your own Generators using the
`Annotation::register($type, $generator)` method.

## Project Status

PhpQuickCheck is highly experimental and in its very early stages. Only
the core functionality has been implemented so far. At the moment the
project is mostly still in a proof-of-concept stage and there is
obviously no documentation whatsoever.

### Contributing

All suggestions, contributions and flames are welcome.

Feel free to fork and send a pull request. If you intend to make
major changes please get in touch so we can coordinate our efforts.

## Credits

All credit goes to clojure.test.check, this project is mostly just a
port.

## Requirements

Requires PHP 5.5.x with 64 bit integers and gmp extension.

## License

Copyright © 2014 Stefan Oestreicher and contributors.

Distributed under the terms of the BSD (3-Clause) license.

repository: israelcin/quickcin

repo_name: israelcin/quickcin


text:
WT - FeedHenry JavaScript SDK
========================

## Pull Requests

Be sure for each pull request that the base branch is WT and not the original FeedHenry repo.

## Version Branches

Version branches (ex. version-1.1.1) should be based off of the main develop branch. After development on the version is complete, tag the branch and merge it back into develop.

## Release Branches

To release a new version:
1. Create a branch off of the current version branch (ex. release-1.1.1).
2. Run `npm run build`.
3. Force add the entire `dist` folder and any changes to the `libs` folder. (To make this easier, remove `dist` and `libs` from the .gitignore before adding files)
4. Rebuild the latest version of https://github.com/willowtreeapps/fh-js-sdk with the new version of fh-sync-js.

FeedHenry Sync Javascript client
========================

Data synchonization javascript client.
Library can be used for offline storage of mobile applications data.

## Required setup

To use the sync client you need a sync server setup first see https://github.com/feedhenry/fh-sync or https://github.com/feedhenry/fh-sync-server.
Sync client using default Ajax handler to call sync server.
Server URL can be configured using following variables

- cloudUrl - URL to sync server
- cloudPath (optional) - allows to use custom endpoint for sync (defaults to `/sync/`)

For example:
```javascript

syncClient.init({
    cloudUrl:"http://localhost:3000",
    do_console_log: true,
    sync_frequency: 1,
    sync_active: false,
    storage_strategy: ['memory'],
    crashed_count_wait: 0
});

```

## Building

    npm install
    grunt

## Cordova client template

You can try [Cordova Sync Template](https://github.com/feedhenry-templates/feedhenry-cordova-sync-app). It uses fh-sync-js as a library for connecting to running sync server instance.

## Relation for fh-js-sdk

Feedhenry JS SDK contains various libraries and also includes fh-sync-js library.

repository: willowtreeapps/fh-sync-js

branch_name: refs/heads/develop

repo_name: willowtreeapps/fh-sync-js


text:
---
layout: layout.pug
navigationTitle:  Release Notes
title: Release Notes
menuWeight: 130
excerpt: Discover the new features, updates, and known limitations in this release of the NiFi Service
enterprise: false
---

# Release Notes for NiFi Service version 0.1.0-1.5.0

This is the first release of Apache NiFi to Universe. Based on the latest stable release version of Apache NiFi, version 1.5.0, this installation is supported on DC/OS version 1.9 and later. This has been built using the current stable version of the SDK (Version 0.40.2).

## Breaking Changes

This is a first release and you must perform a fresh install.

## Improvements

Based on the latest stable release of the `dcos-commons` SDK (Version 0.40.2), this installation provides numerous benefits:

- Integration with DC/OS features such as virtual networking and integration with DC/OS access controls
- Orchestrated software and configuration update, ability to add new nodes, increase memory and CPU. Installation on DCOS
Cluster provides the ability to restart and replace nodes.
- Placement constraints for pods
- Uniform user experience across all NiFi Cluster nodes
- Graceful shutdown for nodes
- Foldered installation

## Bug fixes

This is the first release to Universe. Reported bugs will be fixed in subsequent releases.

## Documentation

Released first version of Service guide with following topics:

### Table of Contents

- [Overview](../overview)
- [Install and Customize](../install)
- [Deployment Best Practices](../deploy-best-practice)
- [Security](../security)
- [Uninstall](../uninstall)
- [Command Reference](../command-reference)
- [Connecting Clients](../connecting-clients)
- [Managing](../managing)
- [Diagnostic Tools](../troubleshooting/diagnostictools)
- [API Reference](../api-reference)
- [Troubleshooting](../troubleshooting)
- [Limitations](../limitations)
- [Supported Versions](../supported-versions)
- [Release Notes](../release-notes)

repository: mesosphere/dcos-docs-site

gha_language: SCSS

repo_name: mesosphere/dcos-docs-site


text:
```toml
[advisory]
id = "RUSTSEC-2021-0017"
package = "postscript"
aliases = ["CVE-2021-26953"]
date = "2021-01-30"
url = "https://github.com/bodoni/postscript/issues/1"
categories = ["memory-exposure"]

[versions]
patched = [">= 0.14.0"]
```

# `Read` on uninitialized buffer may cause UB (`impl Walue for Vec<u8>`)

Affected versions of this crate passes an uninitialized buffer to a user-provided `Read` implementation.

Arbitrary `Read` implementations can read from the uninitialized buffer (memory exposure) and also can return incorrect number of bytes written to the buffer.
Reading from uninitialized memory produces undefined values that can quickly invoke undefined behavior.

This flaw was fixed in commit 8026286 by zero-initializing the buffer before handing to a user-provided `Read`.

repository: BurntSushi/advisory-db

repo_name: BurntSushi/advisory-db


text:
---
group: Global Styles
order: 5
title: Icons
---

An icon is a graphical representation of meaning. Icons can be used to express actions, state, and even to categorize data. Ant Design's icons adhere to the following two principles and are designed for cross-platform consistency:

- Graphics that are clear, intuitive, and simple enjoy a higher degree of recognition and are more easily understood
- All icons in the user interface should be consistent in style (detail design, perspective, stroke weight, etc.)

---

## System Icons

<ImagePreview>

</ImagePreview>

System icons are often used to represent commonly used operations, such as: save, edit, delete. Ant Design also includes icons to represent file types and state.

- [View the icons](/components/icon/)

### Key Contour Lines

<ImagePreview>

</ImagePreview>

Contour lines play an important role in making various icons with the same visual effect.

Please make all icons in the 1024×1024 resolution (16×16 64 times).

- [Illustrator tips](https://zos.alipayobjects.com/rmsportal/hmNuLjCkBssupcZgYAde.png)

<ImagePreview>

</ImagePreview>

<ImagePreview>

</ImagePreview>

<ImagePreview>

</ImagePreview>

<ImagePreview>

</ImagePreview>

### Stroke Weight

<ImagePreview>

</ImagePreview>

Consistent stroke weight is the key to maintaining the visual unity of the entire icon system. Ant Design's icons have a consistent line width of 72px.

### Corners

<ImagePreview>

</ImagePreview>

Consistent rounding of corners and sizing of angles is also an important element in maintaining visual unity.

Icons that follow Ant Design should have rounded corners and edges using a 72px radius.

### Visual Correction

<ImagePreview>

</ImagePreview>

In certain special cases (for example, when the icon is too compact), adjustments to line width, outlines, or other subtle changes may be made to increase readability.

### Perspective

<ImagePreview>

</ImagePreview>

Always keep a simple, flat style. Icons should not have a sense of depth nor a large amount of detail.

### Naming Conventions

<ImagePreview>

</ImagePreview>

Uniform naming conventions make finding icons faster and easier. For example, icons with a surrounding outline have a uniform "-o" suffix.

### Icon Sizing

<ImagePreview>

</ImagePreview>

Icons should be scaled according to the text size, according to the Ant Design specification.

For example, icons inline with 12pt font should be 12px in size with 8px of spacing.

### Color

<ImagePreview>

</ImagePreview>

The color of the icon should be consistent the color of the surrounding copy, unless the icon is being used to express state (in which case it should be colored accordingly).

---

## Business Icons

<ImagePreview>

</ImagePreview>

Business icons, unlike system icons, do not themselves have functional operations, but rather an abstraction that assists with copywriting. Compared to the system icon, the business icon is more rich in the details of the design, the size of the use of relatively large.

> Note: Business icons design principles and system icons are basically the same, the details of the processing (such as stroke weight, fillet size, etc.) depending on the specific scene may be.

### Icon Sizing

<ImagePreview>

</ImagePreview>

In normal use, there are 32px (minimum size), 48px and 64px (maximum size) three options.

### Color

<ImagePreview>

</ImagePreview>

There are two kinds of business icon, single-color (neutral color) and double-color (neutral color + primary color), the area of primary color does not exceed 40% of the entire icon.

repository: ant-design/ant-design

repo_name: ant-design/ant-design


text:
# Translators

You can translate the website online on the elementary Weblate instance: https://l10n.elementary.io/projects/website/. Please don't update directly files in `_lang/` on Github as they'll be overridden when pulling new translations.

You can propose new languages if they're not listed. Make sure to avoid requesting languages that already exist, for instance adding _Russian (Russia)_ when _Russian_ is available.

Please read the [branding guidelines](http://blog.elementary.io/post/107640994166/the-importance-of-our-brand) before translating and pay attention to spelling mistakes.

## Reviewing

It's not a good practice to review strings translated by ourselves. Instead, find someone else speaking your language and ask him to join the reviewers team (you can send a message to [the i18n team](mailto:i18n@elementary.io?subject=Review%20Team%20Request) to ask this).

## Updating

Languages are updated automatically when code is changed. This may take time to update, so please be patient.

# Web developers

## Extracting translations from HTML files

Translations strings are extracted from HTML files. A little command line PHP file is included to make this easier. Just run `php _backend/Console/Translation.php` to update the translation files. You can use `--help` for more options.

## Changing a translation key

If you want to change a translation key for an element, just add a `data-l10n-id` attribute:

```html
<p data-l10n-id="mylongparagraph">Blablabla</p>
```

## Disabling a translation

To ignore a translation string, set it to `false` in `/_lang/en/<page>.json`:

```js
{
    "elementary OS": false // Can't be translated
}
```

Alternatively, you can add the `data-l10n-off` attribute to a tag:
```html
<p data-l10n-off="1">I'm ignored.</p>
```

## Adding a new language to the list on the website

The list of available languages is hard-coded in [`_backend/Lib/L10n.php`](https://github.com/elementary/website/blob/master/_backend/Lib/L10n.php). If a new language is complete, you can add it by appending it to the list. Languages are sorted by index (see [ISO 639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes)) and are localized.

repository: elementary/website

gha_language: PHP

repo_name: elementary/website