text:
[![image](https://www.linkpicture.com/q/WhatsApp-Image-2021-05-26-at-11.51.50-AM-1.jpeg)](https://www.linkpicture.com/view.php?img=LPic60b92367359df34049977)

## The Casually Serious Podcast!

We would like to define our objective in the most startup-life hustler's definition.

```
We are in the business of investing our time into
other people's experiences and marketing them to
the audience.
```

### Our Mission

Our mission is very clear. To produce the kind of content videos which we wish we ourselves saw growing up. We take it upon our responsibility to really ensure that we are our brother's keepers.

### Our Guests

1. Nihar Dhulekar
```
Nihar was our first guest among the
```

### Where to Listen!
1. [Youtube](https://www.youtube.com/channel/UCSvldnJ2awBrBmgGJFwda-Q)
3. [Spotify]()
4. [Apple Podcasts]()
5. [Google Podcasts]()
6. [Anchor.fm]()

### Newsletter
Sign up to our Episode Newsletter to catch along with us for all prompt updates about our latest episodes!

### Contact

**Casually Serious Official** : contact us for collaborations
- [Instagram](https://instagram.com/casuallyserious_official?utm_medium=copy_link)

Abhinav Gudipati
- [Linkedin](https://www.linkedin.com/in/abhinav-gudipati-609794197/)

Fazal Khan
- [Instagram]()
- [Linkedin](https://www.linkedin.com/in/fazal-khan-3a430b18b/)


text:
# Get Config Data from API
***Note: We've configured the NASA test organization to send config information down with the use of `OddView`s as the main way of constructing data in the application. This is completely optional. You may format your data however you like on the Oddworks dashboard. For example: you may just want to call all collections or videos directly.***

Now it's time to make our `SplashActivity` actually do something. First we'll set up the member variables...

```java
// app/java/sample.oddworks.com.oddsampleapp/SplashActivity

// ...
public class SplashActivity extends AppCompatActivity {
    // Constants
    private static final String HOME_VIEW_NAME = "homepage";

    // Data
    private RestServiceProvider restServiceProvider = RestServiceProvider.getInstance();
    private ApiCaller apiCaller = restServiceProvider.getApiCaller();
    private Context context;

    // ...
}
```

There's a new class that we're interacting with called `ApiCaller`. This does exactly what it sounds like and is the class used to make calls to the API.

The first thing we'll want to do in our `onCreate` method after setting the content view is set our context.

```java
// app/java/sample.oddworks.com.oddsampleapp/SplashActivity

// ...
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_splash);
    context = this;
}
// ...
```

The next thing check to see if the application is connected to the internet. This method may be useful in other classes in our application so instead of creating a method for it in our `SplashActivity` we'll create a `Utility` class with a method to check if there is internet connectivity.

```java
// app/java/sample.oddworks.com.oddsampleapp/Utility

package sample.oddworks.com.myoddworksapplication;

import android.content.Context;
import android.net.ConnectivityManager;

public class Utility {
    public static boolean hasInternetConnection(Context context) {
        ConnectivityManager con_manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);

        if (con_manager.getActiveNetworkInfo() != null && con_manager.getActiveNetworkInfo().isAvailable() && con_manager.getActiveNetworkInfo().isConnected()) {
            return true;
        } else {
            return false;
        }
    }
}
```

In order for this to work, we'll need to add some permissions to our `AndroidManifest` file right before the opening `application` tag.

```xml
// app/manifests/AndroidManifest.xml

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
```

Now we can check to see if the app has connectivity in the `SplashActivity`'s `onCreate` method:

```java
// app/java/sample.oddworks.com.oddsampleapp/SplashActivity

// ...
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_splash);
    context = this;

    if (Utility.hasInternetConnection(getApplicationContext())) {
        apiCaller.getConfig(new ConfigRequestCallback());
    } else {
        // handle failure by notifying user on UI
        // consider giving them a "retry" button
        // perhaps via a Snackbar
    }
}

private final class ConfigRequestCallback implements OddCallback<Config> {
    @Override
    public void onSuccess(Config config) {
        // handle success
    }

    @Override
    public void onFailure(final Exception exception) {
        // handle failure
    }
}
// ...
```

If the app is connected to the internet we use the `apiCaller` to request configuration from the API and pass it a callback class that implements an `OddCallback`. If there's a failure we should notify the user of this and give them the option to retry. *Warning: if you try to manipulate the UI within this callback you will crash the application since you aren't running on the main thread. You must specify that you'd like to run on the main thread if you'd like to make any UI updates.*

# Getting View Data from API

Assuming the config request returns successful we can use the config object to set up many things about our app. For now, we'll only focus on the views that the config sends us.

```java
// app/java/sample.oddworks.com.oddsampleapp/SplashActivity

// ...
private final class ConfigRequestCallback implements OddCallback<Config> {
    @Override
    public void onSuccess(Config config) {
        Map<String, String> views = config.getViews();
        String homeView = views.get(HOME_VIEW_NAME);

        apiCaller.getView(homeView, new HomeViewRequestCallback(HOME_VIEW_NAME));
    }

    @Override
    public void onFailure(final Exception exception) {
        // handle failure
    }
}

private final class HomeViewRequestCallback implements OddCallback<OddView> {

    public HomeViewRequestCallback() {

    }

    @Override
    public void onSuccess(OddView view) {
        OddApp oddApp = OddApp.getInstance();

        oddApp.setHomeView(view);
    }

    @Override
    public void onFailure(final Exception exception) {
        // handle failure
    }

    public String getViewType() {
        return mViewType;
    }
}
// ...
```

Here, we're creating a custom `OddCallback` for the view that we're requesting through the `apiCaller`. Remember, the setter methods for each view utilize the `OddStore` so we'll have access to this information throughout the app if the member variables in `OddApp` get collected from memory.

The last thing we need to do in our `SplashActivity` is launch a new Activity that will make use of all the data we've fetched. First we'll need to create a new Activity, we'll call ours `HomeActivity`. Now in the `HomeViewRequestCallback` section of our `SplashActivity` we'll make sure we have all our data and launch a new Intent:

```java
// ...
@Override
public void onSuccess(OddView view) {
    OddApp oddApp = OddApp.getInstance();

    oddApp.setHomeView(view);

    Intent home = new Intent(context, HomeActivity.class);
    startActivity(home);
}
// ...
```

repository: RatioInteractive/oddworks-android-sdk

branch_name: refs/heads/master

extension: md

gha_language: Java

license_type: permissive

repo_name: RatioInteractive/oddworks-android-sdk


text:
计算张量的逆置换。

**别名** : [ `tf.compat.v1.invert_permutation` ](/api_docs/python/tf/math/invert_permutation), [ `tf.compat.v1.math.invert_permutation` ](/api_docs/python/tf/math/invert_permutation), [ `tf.compat.v2.math.invert_permutation` ](/api_docs/python/tf/math/invert_permutation)

```
 tf.math.invert_permutation(
    x,
    name=None
)

```

This operation computes the inverse of an index permutation. It takes a 1-Dinteger tensor  `x` , which represents the indices of a zero-based array, andswaps each value with its index position. In other words, for an output tensor `y`  and an input tensor  `x` , this operation computes the following:

 `y[x[i]] = i for i in [0, 1, ..., len(x) - 1]`

The values must include 0. There can be no duplicate values or negative values.

#### 例如：

```
 # tensor `x` is [3, 4, 0, 2, 1]
invert_permutation(x) ==> [2, 4, 3, 0, 1]

```

#### 参数：
- **`x`** : A  `Tensor` . Must be one of the following types:  `int32` ,  `int64` . 1-D.
- **`name`** : A name for the operation (optional).

#### 返回：
A  `Tensor` . Has the same type as  `x` .

license: MIT

repository: veaba/tensorflow-docs

repo_name: veaba/tensorflow-docs


text:
# Quartz2d
Playing with CoreGraphics (Quartz2D) framework

## Preview

![alt tag](https://github.com/ihak/Quartz2d/blob/master/rects.png)


text:
# secure-elect

### Overview

secure-elect is a Voting System DApp (Dencentralized Application) built on the Ethereum Network. It contains an Ethereum smart contract that holds an election between two candidates. The smart-contract is integrated with a client-side application that allows users to cast votes on the Ethereum Blockchain.

![alt text](http://www.dappuniversity.com/voting_form.png)

### Depedencies:

Technologies/Frameworks: NPM, Truffle Framework, Ganache, MetaMask

Languages: Solidity, JavaScript, Html

gha_language: JavaScript

gha_license_id: MIT


text:
# Quoter

This is an Android application I made in my freetime. It is about quotes. The app shows a new quote each day taken from Wikiquote. And it has a popular quotes page that shows quotes from reddit.com/r/quotes subreddit. User also can save quotes in the app. Quotes can be shared as images with a lot of customization. Feel free to check out the code and use anything you want :)

# Features

* A new quote every day.
* Popular quotes from [/r/quotes](https://www.reddit.com/r/quotes) subreddit.
* Write your own quotes.
* Save your favorite ones.
* Share quotes as images with lots of customizing options.

License
=======

	Copyright 2016 Mehmet Dilaveroğlu

    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: mdilaveroglu/Quoter-Android

repo_name: mdilaveroglu/Quoter-Android


text:
# Visit helper

The `visit` helper is the main API behind this addon. This function allows you to render a page generated by FastBoot into Ember's testing container.

```js
import { module, test } from 'qunit';
import { setup, visit } from 'ember-cli-fastboot-testing/test-support';

module('FastBoot | home-page test', function(hooks) {
  setup(hooks);

  test('it renders a page...', async function(assert) {
    await visit('/');

    // ...
  });

});
```

## Options

Visit can take an optional second parameter that lets you control the request sent to FastBoot. Many FastBoot applications will have conditional logic based on the incoming HTTP request. For example, you may want to render a different template based on the requesting browser's user agent.

### HTTP Headers

We can generate a FastBoot request with different HTTP headers using `visit`'s options.

```js
import { module, test } from 'qunit';
import { setup, visit } from 'ember-cli-fastboot-testing/test-support';

module('FastBoot | home-page test', function(hooks) {
  setup(hooks);

  test('it renders a page when given a specific user-agent', async function(assert) {
    await visit('/', {
      headers: {
        'user-agent': 'A crawling bot!'
      }
    });

    // ...
  });

});
```

The headers object can be configured with any HTTP header. You can change the hostname or set a logged in user cookie.

```js
await visit('/', {
  headers: {
    'cookie': 'user_id=12345;',
    'host': 'example.com'
  }
});
```

### Customizing App.visit

FastBoot's main entry point is its `App.visit` API. This method normally takes a URL and an options object that contains request and response data. However, heavily customized FastBoot applications will sometimes require additional data to be present in the options object.

FastBoot testing will pass through any options given to the visit helper when rendering pages in FastBoot. For example, here's how the following test code will translate to a FastBoot render.

```js
test('It can pass custom options to fastboot', async function(assert) {
  await visit('/', {
    meta: {
      version: '1.2.3'
    }
  });
});

// This will render FastBoot using the following

fastbootApp.visit('/', { meta: { version: '1.2.3' }});
```

repository: embermap/ember-cli-fastboot-testing

repo_name: embermap/ember-cli-fastboot-testing


text:
---
layout: post
title: NLP resources(people, paper, dataset, book, ...)
modified: 2019-09-04
tags:
  - paper
  - dataset
  - book
categories: [NLP]
comments: true
---

## Paper

`I wrote down some papers before, but now, it's been overloaded in NLP industry, so now, I'm considering I can't put it down all over the things. `

#### Pre-training

- BERT [BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding
](https://arxiv.org/abs/1810.04805)

- GPT-2: [Improving Language Understanding by Generative Pre-Training](https://s3-us-west-2.amazonaws.com/openai-assets/research-covers/language-unsupervised/language_understanding_paper.pdf)

#### AI Ethics

- Tolga Bolukbasiet al, 2019 [Man is to Computer Programmer as Woman is to Homemaker? Debiasing Word Embeddings
](https://arxiv.org/abs/1607.06520)

- Nikhil Garg et al, 2017 [Word Embeddings Quanfity 100 Years of Gender and Ethnic Stereotypes](https://arxiv.org/pdf/1711.08412.pdf)

## Dataset

- [XNLI: Evaluating Cross-lingual Sentence Representation](https://arxiv.org/abs/1809.05053)

- [Google's pre-trained models, Google's TensorFlow repository for the BERT](https://github.com/google-research/bert)

- [PyTorch Pretrained Bert](https://github.com/huggingface/pytorch-pretrained-BERT)

## Book

- Introduction to Information Retrieval, Christopher D. Manning.

- [Foundations of Statistical Natural Language Processing, Christopher D. Manning.](https://mitpress.mit.edu/books/foundations-statistical-natural-language-processing)

- [NLTK Book](http://www.nltk.org/book/)

## Article

Want less biased decisions? Use algorithms

#### Lanuage Processing other than English

1. [Challenges of Chinese Natural Language Processing - Segmentation](https://www.smartdatacollective.com/challenges-chinese-natural-language-processing-segmentation/)

2. [Multilingual Natural Language Processing Applicationns: Finding the Structure of Words](http://www.informit.com/articles/article.aspx?p=1887522&seqNum=2) *Sep 20, 2012*

3. [Natural Language Processing: State of The Art, Current Trends and
Challenges](https://arxiv.org/pdf/1708.05148.pdf)

4. [The State of Neural Machine Translation for Asian Languages](https://slator.com/features/the-state-of-neural-machine-translation-for-asian-languages/)

5. [Clinical Natural Language Processing in languages other than English: opportunities and challenges](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5877394/) *Mar 30, 2018*


text:
---
title: Panel
category: Layout
source: https://github.com/crinklesio/feo-css/blob/main/src/layout/_pancake.scss
---

`.panel-<l/r>` allow you to create a responsive two-column layout. One column has a fixed width, while the other column takes all the available space. The `l` or `r` indication determines which column will be fixed, the _left_ or _right_ column, respectively. Whenever the width of the parent container falls below a certain threshold, the layout moves to two rows, instead of two columns.

![](/img/panel.png)

## Utility classes

As already hinted by the image above, there are several `.panel` linked utility classes that can be applied to alter how the layout behaves.

- `.panel-f-<name>`: set the width (or size!) of the controllable panel, based on `$feo-breakpoints`. The default value is `50%`.
- `.panel-w-<name>`: set the min-width of the wrapper, based on `$feo-breakpoints`.
- `.panel-g-<name>`: set the gap between the two columns. This gap is applied both horizontally and vertically. Based on the, based on `$feo-sizes`.

> If the utility classes are not flexible enough and you want to adjust the way the layout pattern behaves, adjust the `--panel-gap`, `--panel-fixed`, and/or `--panel-width` custom properties on the element you are applying this pattern to.

repository: alolalo/feo-css

branch_name: refs/heads/main

repo_name: alolalo/feo-css


text:
### [CVE-2018-16975](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-16975)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

An issue was discovered in Elefant CMS before 2.0.7. There is a PHP Code Execution Vulnerability in /designer/add/stylesheet.php by using a .php extension in the New Stylesheet Name field in conjunction with <?php content, because of insufficient input validation in apps/designer/handlers/csspreview.php.

### POC

#### Reference
- https://github.com/jbroadway/elefant/issues/286

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
# Tablestore SDK for Python

This topic describes the version history of Tablestore SDK for Python.

## Version: 5.1.0

Release date: July 22, 2019

Download URL: [aliyun-tablestore-python-sdk-5.1.0.tar.gz](https://tablestore-doc.oss-cn-hangzhou.aliyuncs.com/aliyun-tablestore-sdk/python/aliyun-tablestore-python-sdk-5.1.0.tar.gz)

Change records: Local transactions are supported.

## Version: 5.5.0

Release date: May 29, 2019

Download URL: [aliyun-tablestore-python-sdk-5.5.0.tar.gz](https://tablestore-doc.oss-cn-hangzhou.aliyuncs.com/aliyun-tablestore-sdk/python/aliyun-tablestore-python-sdk-5.0.0.tar.gz)

Change records:

-   The query of whether search indexes exist is supported.
-   The problems that occur when next\_token does not exist are fixed.

## Version: 4.6.0

Release date: February 15, 2019

Download URL: [aliyun-tablestore-python-sdk-4.6.0.tar.gz](https://tablestore-doc.oss-cn-hangzhou.aliyuncs.com/aliyun-tablestore-sdk/python/aliyun-tablestore-python-sdk-4.6.0.tar.gz)

Change records:

-   Search indexes are supported.
-   Global secondary search indexes are supported.

## Version: 4.3.0

Release date: December 12, 2017

Download URL: [aliyun-tablestore-python-sdk-4.3.0.tar.gz](http://docs-aliyun.cn-hangzhou.oss.aliyun-inc.com/assets/attach/31723/cn_zh/1513135454080/aliyun-tablestore-python-sdk-4.3.0.tar.gz)

Change records: Tablestore SDK for Python is compatible with python 3, including Python 3.3, Python 3.4, Python 3.5, and Python 3.6.

## Version: 4.2.0

Release date: September 12, 2017

Download URL: [aliyun-tablestore-python-sdk-4.2.0.tar.gz](https://docs-aliyun.cn-hangzhou.oss.aliyun-inc.com/assets/attach/31723/cn_zh/1505269726128/aliyun-tablestore-python-sdk-4.2.0.tar.gz)

Change records: STS is supported.

## Version: 4.1.0

Release date: June 28, 2017

Download URL: [aliyun-tablestore-python-sdk-4.1.0.tar.gz](https://docs-aliyun.cn-hangzhou.oss.aliyun-inc.com/assets/attach/31723/cn_zh/1498788749932/aliyun-tablestore-python-sdk-4.1.0.tar.gz)

Change records: Tablestore SDK for Python is compatible with Python 2.6.

## Version: 4.0.0

Release date: June 27, 2017

Download URL: [aliyun-tablestore-python-sdk-4.0.0.tar.gz](https://docs-aliyun.cn-hangzhou.oss.aliyun-inc.com/assets/attach/31723/cn_zh/1498447550671/aliyun-tablestore-python-sdk-4.0.0.tar.gz)

Change records:

-   Max versions is supported.
-   Time to live \(TTL\) is supported.
-   The auto increment feature for primary key columns is supported.

## Version: 2.1.0

Release date: October 15, 2016

Download URL: [aliyun-ots-python-sdk-2.1.0.zip](https://docs-aliyun.cn-hangzhou.oss.aliyun-inc.com/assets/attach/27352/cn_zh/1476688620683/aliyun-tablestore-python-sdk-2.1.0.zip)

Change records:

-   The conditional update and filter features are supported.
-   The bug of invalid retry policies are fixed inside Tablestore SDK for Python.

## Version: 2.0.8

Release date: March 30, 2016

Download URL: [aliyun-ots-python-sdk-2.0.8.zip](https://ots-public-sdk.oss-cn-hangzhou.aliyuncs.com/aliyun-ots-python-sdk-2.0.8.zip)

Change records: Parameters that can be configured for the connection pool are adjusted to support access over HTTPS and certificate-based authentication.

## Version: 2.0.7

Release date: December 30, 2015

Download URL: [aliyun-ots-python-sdk-2.0.7.zip](https://ots-public-sdk.oss-cn-hangzhou.aliyuncs.com/aliyun-ots-python-sdk-2.0.7.zip)

Change records: Reserved capacity unit \(CU\) settings in the code example are modified based on pay-as-you-go.

## Version: 2.0.6

Release date: October 23, 2015

Download URL: [aliyun-ots-python-sdk-2.0.6.zip](https://ots-public-sdk.oss-cn-hangzhou.aliyuncs.com/aliyun-ots-python-sdk-2.0.6.zip)

Change records: The exponential backoff strategy is adjusted to process some exceptions.

## Version: 2.0.5

Release date: September 25, 2015

Download URL: [ots\_python\_sdk-2.0.5.zip](https://ots-public-sdk.oss-cn-hangzhou.aliyuncs.com/ots_python_sdk-2.0.5.zip)

url: https://raw.githubusercontent.com/hglakfs/ots/12f4b07f37cc945ae4fd6bca25135427adf4d9aa/intl.en-US/SDK Reference/Download SDK/Tablestore SDK for Python.md

repository: hglakfs/ots

filename: Tablestore SDK for Python.md

repo_name: hglakfs/ots


text:
# waifu2x-ncnn-vulkan
waifu2x converter ncnn version, runs fast on intel / amd / nvidia with vulkan

waifu2x-ncnn-vulkan use ncnn project [https://github.com/Tencent/ncnn] as the universal nerual network inference framework

# download windows exe for your intel/amd/nvidia GPU card
https://github.com/nihui/waifu2x-ncnn-vulkan/releases

This package includes all the binary and models required, it is portable, no cuda or caffe runtime needed :)

# usage
```
waifu2x.exe [input image] [output png] [noise=-1/0/1/2/3] [scale=1/2] [blocksize=400]
```
* noise = noise level, large value means strong denoise effect, -1=no effect
* scale = scale level, 1=no scale, 2=upscale 2x
* blocksize = tile size, use smaller value to reduce GPU memory usage, default is 400

If you encounter crash or error, try to upgrade your GPU driver

intel https://downloadcenter.intel.com/product/80939/Graphics-Drivers

amd https://www.amd.com/en/support

nvidia https://www.nvidia.com/Download/index.aspx

# speed compared with waifu2x-caffe-cui

Windows 10 1809, AMD R7-1700, Nvidia GTX-1070, Nvidia driver 419.67, CUDA 10.1.105, cudnn 10.1

```
Measure-Command { waifu2x.exe input.png output.png 2 2 [block size] }
```
```
Measure-Command { waifu2x-caffe-cui.exe -t 0 --gpu 0 -b 1 -c [block size] -p cudnn --model_dir ./models/cunet -s 2 -n 2 -m noise_scale -o input.png -i output.png }
```

||image size|target size|block size|total time(s)|GPU memory(MB)|
|---|---|---|---|---|---|
|waifu2x-ncnn-vulkan|200x200|400x400|400/200/100|0.59/0.59/0.59|332/332/81|
|waifu2x-caffe-cui|200x200|400x400|400/200/100|2.54/2.39/2.36|3017/936/843|
|waifu2x-ncnn-vulkan|400x400|800x800|400/200/100|0.87/0.81/0.86|1204/332/81|
|waifu2x-caffe-cui|400x400|800x800|400/200/100|2.91/2.43/2.7|3202/1389/1178|
|waifu2x-ncnn-vulkan|1000x1000|2000x2000|400/200/100|2.38/2.68/2.66|1227/332/97|
|waifu2x-caffe-cui|1000x1000|2000x2000|400/200/100|4.04/3.79/4.35|3258/1582/1175|
|waifu2x-ncnn-vulkan|2000x2000|4000x4000|400/200/100|7.66/8.06/9.00|1227/348/97|
|waifu2x-caffe-cui|2000x2000|4000x4000|400/200/100|7.01/7.54/10.11|3258/1499/1200|
|waifu2x-ncnn-vulkan|4000x4000|8000x8000|400/200/100|29.33/30.55/34.37|1245/348/97|
|waifu2x-caffe-cui|4000x4000|8000x8000|400/200/100|18.45/21.85/31.82|3325/1652/1236|

# sample
## original image
![origin](https://raw.githubusercontent.com/nihui/waifu2x-ncnn-vulkan/master/0.jpg)
## upscale 2x with ImageMagick
```
convert origin.jpg -resize 200% output.png
```
![browser](https://raw.githubusercontent.com/nihui/waifu2x-ncnn-vulkan/master/1.png)
## upscale 2x with ImageMagick Lanczo4 filter
```
convert origin.jpg -filter Lanczos -resize 200% output.png
```
![browser](https://raw.githubusercontent.com/nihui/waifu2x-ncnn-vulkan/master/4.png)
## upscale 2x with waifu2x noise=2 scale=2
```
waifu2x.exe origin.jpg output.png 2 2
```
![waifu2x](https://raw.githubusercontent.com/nihui/waifu2x-ncnn-vulkan/master/2.png)

# original waifu2x project
https://github.com/nagadomi/waifu2x

https://github.com/lltcggie/waifu2x-caffe

# ncnn project (>=20190512)
https://github.com/Tencent/ncnn/tree/07260527fc62af13d8f2f117fa6e95fb1837eb3d


text:
---
title: OpenNebula Hybrid Cloud
order: 2
---

This page explains more about what OpenNebula is and how it fits in with VirtEngine.

---

## [VirtEngine](https://virtengine.com)

VirtEngine is an Open Source Hybrid Cloud Management platform that integrates with multiple infrastructure endpoints, one of them being OpenNebula.

VirtEngine offers a Hosting Provider edition that provides the ability to offer Infrastructure to end-users with billing enabled.

## [OpenNebula](https://opennebula.org)

OpenNebula is a fully Open Source Management Platform that allows you to delpoy a Private Cloud to manage internally, OpenNebula has public API's which can allow third party software to interact with it which is how VirtEngine connects to OpenNebula to create and manage VM's.

#### [Virtualization](https://docs.opennebula.org/5.6/deployment/open_cloud_host_setup/index.html)
- [KVM](https://docs.opennebula.org/5.6/deployment/open_cloud_host_setup/kvm_driver.html)
- [VMWare vCenter](https://docs.opennebula.org/5.6/deployment/vmware_infrastructure_setup/index.html)
- [Xen (Supports 5.0)](https://github.com/OpenNebula/addon-xen)
- [LXC/LXD](https://github.com/OpenNebula/addon-lxcone)

#### [Storage](https://docs.opennebula.org/5.6/deployment/open_cloud_storage_setup/overview.html#datastore-types)
- [Filesystem](https://docs.opennebula.org/5.6/deployment/open_cloud_storage_setup/fs_ds.html#fs-ds)
- [Ceph](https://docs.opennebula.org/5.6/deployment/open_cloud_storage_setup/ceph_ds.html#ceph-ds)
- [LVM](https://docs.opennebula.org/5.6/deployment/open_cloud_storage_setup/lvm_drivers.html#lvm-drivers)
- [Raw Device Mapping Datastore](https://docs.opennebula.org/5.6/deployment/open_cloud_storage_setup/dev_ds.html#dev-ds)
- [iSCSI - Libvirt Datastore](https://docs.opennebula.org/5.6/deployment/open_cloud_storage_setup/iscsi_ds.html#iscsi-ds)
- [LizardFS](https://opennebula.org/ecosystem/lizardfs/)

#### [Networking](https://docs.opennebula.org/5.6/deployment/open_cloud_networking_setup/index.html)
- [Bridged Networks](https://docs.opennebula.org/5.6/deployment/open_cloud_networking_setup/bridged.html)
- [802.1Q VLAN Networks](https://docs.opennebula.org/5.6/deployment/open_cloud_networking_setup/bridged.html)
- [VXLAN Networks](https://docs.opennebula.org/5.6/deployment/open_cloud_networking_setup/vxlan.html)
- [Open vSwitch Networks](https://docs.opennebula.org/5.6/deployment/open_cloud_networking_setup/vxlan.html)

## Setup and Deployment

OpenNebula is fairly simple to install and delpoy, and we recommend deploying it before installing VirtEngine.

VirtEngine is tested and stable with KVM, the default Hypervisor of OpenNebula.

In order to use Opennebula, you need to install Sunstone on a Management Server - and then install as much KVM Nodes as you'd like.

#### OpenNebula Front-End
Installing OpenNebula's Front-End includes the following packages:
- Sunstone (User Interface)
- CLI Tools
- Ruby API
- OpenNebula Daemon

#### [Front-End Deployment](https://docs.opennebula.org/5.6/deployment/opennebula_installation/index.html)

### OpenNebula KVM Node

When installing a KVM Node you must provide password-less access from the Master to the Node.

#### [KVM Node Deployment](https://docs.opennebula.org/5.6/deployment/node_installation/kvm_node_installation.html)

### Demo of Installing OpenNebula + VirtEngine

(Video Coming Soon)

### Demo of using OpenNebula + VirtEngine

(Video Coming Soon)

gha_language: CSS


text:
[![HitCount](http://hits.dwyl.io/rcjkierkels/domotica-server.svg)](http://hits.dwyl.io/rcjkierkels/domotica-server)
[![contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/dwyl/esta/issues)
[![Known Vulnerabilities](https://snyk.io/test/github/rcjkierkels/domotica-server/badge.svg?targetFile=package.json)](https://snyk.io/test/github/rcjkierkels/domotica-server?targetFile=package.json)

# About Domotica Server
The domotica server works together with [domotica clients](https://github.com/rcjkierkels/domotica-client) and the [domotica app](https://github.com/rcjkierkels/domotica-app). The domotica server has a rest API with which you can create jobs. Job consists of tasks. You tell the server which tasks the job consists of and which clients will perform these tasks. You also specify on the server which actions need to be taken when a tasks generates an event. The domotica client itself checks the server for new tasks and will execute an async worker to perform the tasks. Lets take a look at an example. Let’s say we have a job that is ‘monitoring your garage door’. Take a look at the diagram below:

![Schematic](https://roland.kierkels.net/wp-content/uploads/2019/02/domotica-diagram-2.png)

More info: https://roland.kierkels.net/2019/02/selfmade-domotica-system/

# Requirements
* PHP >= 7.2.0
* Apache2 or higher
* OpenSSL PHP Extension
* PDO PHP Extension
* Mbstring PHP Extension
* JSON PHP Extension

# Installation
```
# Add the correct information to your .env file
cp .env-example .env

composer install
php artisan migrate

```

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

# License
This application is open-source software licensed under the MIT license.

repository: rcjkierkels/domotica-server

repo_name: rcjkierkels/domotica-server


text:
# SQL Compact

## SQL Server CE Support

SQL Server CE is supported with the following limitations:

 - The SQL Server CE provider does not support modifying the CommandText property during SQL interception.
 - That is necessary in order to do some of the dynamic parameter value replacements.
 - This means that Contains (IEnumerable) is not supported on SQL Server CE and will throw an exception.
 - SQL Server CE does not support the "like @value+'%'" syntax as mentioned [here](https://stackoverflow.com/questions/1916248/how-to-use-parameter-with-like-in-sql-server-compact-edition).
 - So string.StartsWith(@value) is not supported and will throw a Format exception.


text:
### [CVE-2007-0946](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2007-0946)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

Unspecified vulnerability in Microsoft Internet Explorer 7 on Windows XP SP2, Windows Server 2003 SP1 or SP2, or Windows Vista allows remote attackers to execute arbitrary code via crafted HTML objects, which results in memory corruption, aka the first of two "HTML Objects Memory Corruption Vulnerabilities" and a different issue than CVE-2007-0947.

### POC

#### Reference
- https://docs.microsoft.com/en-us/security-updates/securitybulletins/2007/ms07-027

#### Github
No PoCs found on GitHub currently.


text:
# Changelog

## [0.1.3] - 2021-04-14
- BUG fix in get_valid_currency_list: recurrent ConnectionError
- Added side and group_by arguments to currency.get function
- New notebooks with examples
- Added join argument to sgs.get function

## [0.1.2] - 2021-01-25
- New sgs module downloads time series from SGS BACEN's site
- Notebooks created to show a few examples
- Date class moved to utils module

## [0.1.1] - 2021-01-16

- Bug fixes

## [0.1.0] - 2021-01-16

- First commit
- currency module downloads currency rates quoted in Brazilian Real (BRL)

repository: PedroDnT/python-bcb

repo_name: PedroDnT/python-bcb


text:
## ⚠ Extensions Invalid!

**The extension of one or more of your committed files is invalid!**

For your project files they should have one of these: **${MARKDOWN_EXTENSIONS}**
For your logo images they should have one of these: **${IMAGE_EXTENSIONS}**

The following files have invalid extensions:
**${INVALID_FILES}**

repository: timhagn/lint-md-fm

repo_name: timhagn/lint-md-fm


text:
Redux Loading Queue
===================

A loading queue for Redux

```js
npm install --save @chegg/redux-loading-queue
```

## Usage

Add the `loadingReducer` to your store under `loading`.

```js
import { createStore, combineReducers } from 'redux'
import { loadingReducer } from '@chegg/redux-loading-queue'

const store = createStore(
  combineReducers({
    loading: loadingReducer
  })
)
```

To add or remove an item with a certain id to the loading queue, use the provided actions.

```js
import { loadingShow, loadingHide } from '@chegg/redux-loading-queue'

const uuid = '123e4567-e89b-12d3-a456-426655440000'

store.dispatch(loadingShow(uuid))

store.dispatch(loadingHide(uuid))
```

Wrap your loading view with `AppLoading`.
The view will show as long as _at least one_ item is in the queue.

```jsx
<AppLoading>
  <div>Loading..</div>
</AppLoading>
```

## Maintainers

Philip Stewart ([@sodoku](https://www.github.com/sodoku))

Yvan Volochine ([@gusano](https://www.github.com/gusano))

## License

Apache v2, Copyright 2016 Chegg Inc.

repository: easybiblabs/react-components

repo_name: easybiblabs/react-components


text:
# rails-template

## Description
rails template for kubernetes deployment

[see generated sample](https://github.com/astrocket/rails-template-stimulus)

## Requirements
* Rails 7.x (w/tailwind)
* Ruby 3.x

## Installation

To generate a Rails application using this template, pass the `-m` option to `rails new`, like this:

```bash
$ rails new project -T -d postgresql --css tailwind \
    -m https://raw.githubusercontent.com/astrocket/rails-template/master/template.rb
```

## What's included?

* Kubernetes & Docker for production deploy
* Tailwind & Stimulus by importmaps
* ActiveJob, Sidekiq, Redis setting for background job
* ActiveAdmin + ArcticAdmin for application admin
* Rspec + FactoryBot setting for test code

## Foreman start task

Procfile based applications

with `foreman start`

It runs

* rails
* tailwind
* sidekiq

## Stimulus.js generator

Stimulus specific generator task.

with `rails g stimulus posts index`

It generates

* `app/javascript/posts/index_controller.js` with sample html markup containing stimulus path helper.

## Kubernetes & Docker

With [kubernetes](https://kubernetes.io/) you can manage multiple containers with simple `yaml` files.

Template contains

* deployment [guide](k8s/README.md.tt) for DigitalOcean's cluster from scratch
* Let's Encrypt issuer and Ingress configuration
* demo deployment yaml to instantly run sample hashicorp/http-echo + nginx app
* basic puma, nginx and sidekiq deployment setup

## Testing

[rspec-rails](https://github.com/rspec/rspec-rails)

[factory-bot](https://github.com/thoughtbot/factory_bot/wiki)

> Run test specs
```bash
bundle exec rspec
```

repository: astrocket/rails-template

repo_name: astrocket/rails-template


text:
# tmo-monitor
A lightweight Python 3 script that can monitor the T-Mobile Home Internet Nokia 5G Gateway for band and connectivity and reboot as needed.

Currently checks for n41 5G signal and connectivity to either google.com or a configurable host via ping.

Windows is not currently supported, but should work well with *nix OSes.

## Getting Started

### Install dependencies

`pip -r requirements.txt`

### Mark as executable

`chmod +x ./tmo-monitor.py`

## Usage
```
usage: tmo-monitor.py [-h] [-I INTERFACE] [-H PING_HOST] username password

Check T-Mobile Home Internet 5g band and connectivity and reboot if necessary

positional arguments:
  username              the username. should be admin
  password              the administrative password

optional arguments:
  -h, --help            show this help message and exit
  -I INTERFACE, --interface INTERFACE
                        the network interface to use for ping
  -H PING_HOST, --ping-host PING_HOST
```

## Options
**Interface:** `--interface`
    Can be used to specify the network interface used by the ping command. Useful if T-Mobile Home Internet is not your default network interface: e.g., this is running on a dual WAN router.

**Ping Host** `--ping-host`
    Defaults to `google.com` - override if you'd like to ping an alternate host to determine internet connectivity.

## Known Issues
Windows OS ping implementation is not supported.

## Roadmap

(Not yet implemented):
- Specify desired band locking
  - 4g
  - 5g
- Disable band locking check
- Disable ping/connectivity check
- Alternate connectivity checks
- Disable reboot behavior
- systemd service configuration

## Tip
Run this script with either a cronjob or as a systemd service to implement periodic recurring T-Mobile Home Internet health checks with automatic rebooting.

repository: koreanfoodrocks/tmo-monitor

repo_name: koreanfoodrocks/tmo-monitor


text:
# Bitcoin CashPlus

Everything Bitcoin Cash Offers +  CPU / GPU Mining with Equihash

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

Bitcoin Cash Plus is a fork of the Bitcoin blockchain that will occur on December 15th 2018.

At the predetermined block height, Bitcoin Cash Plus miners will begin creating blocks with a new proof-of-work algorithm, and this will cause a bifurcation of the Bitcoin blockchain. The original Bitcoin blockchain will continue on unaltered, but a new branch of the blockchain will split off from the original chain. The new branch is a distinct blockchain with the same transaction history as Bitcoin up until the fork, but then diverges from it. As a result of this process, a new crypto currency will be born.

## Links
https://t.co/g3trObTJgC
* Website: http://bitcoincashplus.org
* Slack: [invitation](https://slackpass.io/bitcoincashplus)

repository: nhutminhptit/bitcoincashplus

repo_name: nhutminhptit/bitcoincashplus


text:
---
id: bit-dev
title: bit.dev Overview
sidebar_label: Overview
---

Bit.dev server is a cloud service provided by Bit. Accessing bit.dev server requires registering a user account on the bit.dev server. To export and import components from a local workspace to the account, the developer must login from the local workspace.

![Bit.dev](https://storage.googleapis.com/static.bit.dev/docs/images/bit.dev.png)

> Unlike bit-cli tool that is open-sourced, bit.dev server is proprietary and owned by Bit.

Bit.dev server provides these functions:

## Remote Collections Hosting

A Remote Collection is a curated list of shared components on a remote server. The remote collection is used for collaborating on components between bit workspaces. Bit.dev provides hosting for remote collections for all the users.

> Only components deployed on bit.dev collections can be installed using package managers (NPM or Yarn)

Each remote collection contains the bit scope of its components as well as additional information on the collection:

- **Collection name** - The name by which the bit scope in the collection is available to developers for sharing or consuming components.
- **Visibility** - Determines who can view the Collection: A public collection is a free collection that is visible for all registered users. A private collection is limited to the organizations registered users.
- **License** - The default code license that is applicable for all the components shared in the collection (such as MIT, GPL or other licenses)

### Permissions for Collections

bit.dev provides a secured and reliable hub for sharing both public and private code. There are few cases where dependencies between components that are hosted in different collections and owners may harm reliability to provide with working components and not exposing private code.
To ensure this does not happen, bit.dev enforces the following rules on components exported to multiple collections:

- Components in public collections cannot depend on private components: A public component is available for the entire Bit community. Therefore, it may not depend on components that reside in public collections.
- Components in private collection cannot depend on components in other organizations: Dependencies in private collections may depend on public collections or on private collections that belong to the same account (personal or organization).

### Users and Roles

Collection's members are assigned with 3 possible roles:

| Role | Admin | Developer | Viewer |
|---|---|---|---|
| View Components* | Yes | Yes | Yes |
| Import Components* | Yes | Yes | Yes |
| Install Components * | Yes| Yes | Yes |
| Export Components | Yes| No | No |
| Manage members | Yes | No | No |
| Edit collection's information | Yes | No | No |

> *Viewing, importing and installing is available for all users for public collections.

## Component Playground

![Component Playground](https://storage.googleapis.com/static.bit.dev/docs/images/playground.png)
The component playground is a web-based editor and a rendering environment for each component hosted on Bit.dev server.
The component playground enables developing example wrappers for the component to show its usage.

## Component CI

When a component is exported to bit.dev, the components CI (Continuous Integration) runs a container for building and testing the component. The container uses the compiler and tester defined for the component in the original project.

The component is built in an isolated environment. The isolated environment contains the packages and dependencies defined for the component but does not have all the remaining project definitions. This isolation makes sure the component is truly stand-alone and is consumable by other projects.

The Component's CI displays the results for the component build and test run on the component page on [bit.dev](https://bit.dev). When finishing the build and test tasks, the remote container is purged.
The component is then available in the component playground.

Each container on the bit.dev CI runs:

- Ubuntu jessie
- headless chrome driver
- latest version of Bit
- node 8

Each container is limited to:

- 10 minutes run time
- 2GB RAM
- 0.5 CPU core

## Components Explorer

Bit.dev components explorer allows searching across all the remote collections that the user has access to,  such as the public collections and the user’s or organization's components.
The component explorer is using metadata on the component:  tags, language, framework, and size for advanced searching capabilities.

repository: cloudsoh/docs

gha_license_id: NOASSERTION

repo_name: cloudsoh/docs


text:
CoLedger
=====================

CoLedger is a collaborative, simplified and customized accounting and budgeting software for teams with and without accounting backgrounds.

This is the backend and frontend repository of CoLedger.

[CoLedger API documentation](http://docs.coledger.apiary.io)

## Demo

To check out and play around with the application you can go to the [App sign-in page](https://coledgerapp.herokuapp.com/users/sign_in) and login with username **testuser** and password **password**.

## Installation

Make sure you have MongoDB installed in your development machine.

Clone this project using Git, and install dependencies:

```
bundle install
```

Then run `rails server` to start the development web server.

## Data Management
Use the popular document-based database MongoDB to manage CoLedger's data.

## User Features

CoLedger offers a range of features which exceed the mininum accounting transaction requirements:

* **Flash messages**: All `POST` actions in the app will render flash messages after the redirections. This will allow users to receive immediate feedback on what they have done.
* **Data validation**: All forms have sensible validations. If something is invalid an error message will be displayed clearly next to the user input.
* **User, account, project CRUD**: Creating, reading, updating and deleting features are all available.
* **Instant Figure calculations**: All the agregated numbers on the top of account columns for each project would be updated instantly from user "Drag and Drop" actions.
* **Visualisation**: Visualising project relevant or account specific figures in trends and graphs.
* **One to many poject management**: A user is allowed to maintain and manage more than one projects.
* **Comments and attachments for accounting column**: For entries within each accounting column, comments are allowed as well as adding relevant attachments (e.g. purchase invoice) to it.
* **Customization of account scheme, background customization**: The account scheme and webpage backgound colors could be customised.

## Technical Feature
* **Front end browser**: JavaScript and AngularJS
* **Communication between fron end and application**: AJAX
* **Application Server**: Rails Back-end (RESTfull API)
* **Database Server**: MongoDB

## Security
* **Using MongodDB**: to prevent injection vulnerabilities.
* **Authentication**: We have opted to use token-based API authentication, instead of cookies for our back-end session management. This ensures that a session token must be explicitly set in the HTTP header for every request, rather than being automatically managed by the browser. Even though cookies can be made secure, using token-based authentication eliminates a whole class of risks related to the use of cookies, including CSRF. The session token persists in the browser's SessionStorage area.
* **CORS**: By default, CoLedger serves the front-end code and back-end API in the same domain name for simplicity of deployment. In the future, however, the front-end can be separated from the back-end. In that case, the CORS setting for the back-end service will be set to only allow XMLHttpRequest requests from the authorised front-end domain name.
* **By default**: CoLedger serves the front-end code and back-end API in the same domain name for simplicity of deployment. In the future, however, the front-end can be separated from the back-end. In that case, the CORS setting for the back-end service will be set to only allow XMLHttpRequest requests from the authorised front-end domain name.

repository: ryanzhou/coledger

repo_name: ryanzhou/coledger


text:
Return the string encoded with JSON from the whole array

## Script Data
---

| **Name** | **Description** |
| --- | --- |
| Script Type | javascript |
| Tags | entirelist, transformer, general |

## Inputs
---

| **Argument Name** | **Description** |
| --- | --- |
| value | The array to join if it has single element |

## Outputs
---
There are no outputs for this script.

repository: demisto/content

gha_language: Python

repo_name: demisto/content


text:
# Add ECS instances {#task_zn2_2nx_rfb .task}

This topic describes how to manually add ECS instances to a scaling group.

Before manually adding ECS instances, ensure that the instances to be added meet the following conditions:

-   The instances are in the same region as the scaling group.
-   The instances do not belong to any other scaling groups.
-   The instances are in the **Running** state.
-   The instances to be added can be of either the classic network type or VPC type, but you must take note of the following limits:
    -   When the scaling group is classic network-connected, only classic network-connected instances can be added to the group.
    -   When the scaling group is VPC-connected, only instances in the same VPC as the group can be added to the group.

Before manually adding ECS instances to a scaling group, ensure that the group meet the following conditions:

-   The scaling group is in the **Enabled** state.
-   The scaling group is not currently executing any scaling activities.

The scaling configuration of the scaling group does not affect whether ECS instances can be manually added. Therefore, you can manually add ECS instances even with in the [Cool-down time](reseller.en-US/User Guide/Usage notes/Cool-down time.md#).

Typically, Auto Scaling scales out ECS instances based on your specifications. However, if the instance inventory is insufficient or the sum of ECS instances to be added and existing ECS instances in the scaling group exceeds the upper limit of the group, the number of actually scaled out instances may be less than what you specified. In these cases, check the scaling group configuration to troubleshoot the issue. If the problem persists, submit a ticket.

1.  Log on to the [Auto Scaling console](https://partners-intl.console.aliyun.com/#/ess).
2.  On the Scaling Groups page, click **Manage** in the **Actions** column corresponding to the scaling group to add instances.

    ![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/40594/155815436221748_en-US.png)

3.  In the left-side navigation pane of the displayed page, click ECS Instances. On the page that appears, click **Add Existing Instances**.

    ![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/40594/155815436221749_en-US.png)

4.  In the dialog box that appears, select available ECS instances in the left-side list, click **\>** to add the selected instances to the scaling group, and click **OK**.

    ![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/40594/155815436221750_en-US.png)

5.  Go to the Manually Added tab to view the result.

    ![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/40594/155815436321751_en-US.png)

    **Note:** If the page does not refresh automatically, click **Refresh** in the upper-right corner of the page.

url: https://raw.githubusercontent.com/ericzhong2010/ess/abf6e75163084f16682ec85b66e9fcb8b0e44be6/intl.en-US/User Guide/Manual scaling/Add ECS instances.md

filename: Add ECS instances.md


text:
---
title: Swiss R4L
summary: 2 days workshop

tags:
- r4l
- swissR4L

date: "2017-10-11T00:00:00Z"

image:
  focal_point: Smart

links:
- icon: user
  icon_pack: fas
  name: Wafa Johal
  url:

- icon: user
  icon_pack: fas
  name: Pierre Dillenbourg
  url:

---
# Venue
The workshop will take place at the Hotel Victoria in Villars-sur-Ollon (aka, Villars, a Ski resort of the Vaud Canton). http://www.eurotel-victoria.ch/villars/

Villars is situated on the other side of the Leman Lac from Geneva.
After enjoying the beautyful view of the lake on the way to Aigle by train, you will find a bus (144) that runs every 30min and drops you by the hotel.
The trains to Aigle are frequent and you can find direct inter-regional train from major Swiss cities : from Bern train station (2h30), from Geneva train station (1h20), Geneva airport (1h30). Lausanne (35 min).

# List of topics
- Adaptive mechanisms for robot tutors, personalization and adaptation algorithms for tutoring interactions
- Design of autonomous systems for tutoring interactions
- Theories and methods for tutoring (pedagogical and language acquisition)
- Shared knowledge and knowledge modelling in HRI
- Human-robot collaborative learning
- Attachment and learning with a social robot (social and cognitive development)
- Engagement in educational human-robot interaction
- Human-robot relationship assessment
- Designing student models and assessing student’s learning
- Playful learning with a robot
- Human-robot creativity
- Kinesthetic and non-verbal communication in human-robot interaction
- Impact of embodiment on learning
- Technical innovation in learning or teaching robots
- Long term learning interactions, design and methodologies for repeated human-robot encounters
- Robots for learners with special needs and special abilities
- Education and re-training for adults
- Rehabilitation and re-education
- Privacy and ethical issues in robot tutoring applications

# Prepare your workshop
The workshop will be organised around 6 sections. Each sections will address a challenge in HRI for learners.

1. Non-verbal interaction and verbal interaction: impact of gestures, verbal feedback etc.
2. Kinesthetic learning vs other learning modalities: how does dynamic and tangible interaction influence the learner experience?
3. Learning gain and applications: do we learn better/ more with robots? what influence the learning gain? what can we teach with a robot (limitation in the curricula)? How do we design the learning task?
4. Autonomy and reasoning about learners knowledge: how to adapta, personalise learning?
5. In the classroom or managing group of learners: how to cope with several learners? collaboration, robot facilitator?
6. Engagement and motivation: how is engagement affecting learning? novelty effect.
In order to frame the discussion, we ask you to contribute by preparing 3 slides related to the theme of the session. You can present a point of view, an experiment, an algorithm …

# Resources


text:
+++
title = "Reference Mappings"
chapter = false
weight = 30
+++

## Required Fields

The following table maps the [Jira Development Information](https://developer.atlassian.com/cloud/jira/software/rest/#api-group-Development-Information) APIs with respective AWS APIs for [GetRepository](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetRepository.html) and [GetCommit](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetCommit.html).

            Atlassian

            AWS

            repositories

            name
            The name of this repository.
            repositoryName
            The name of the repository to which the commit was made.

            url
            The URL of this repository.
            cloneUrlHttp
            The URL to use for cloning the repository over HTTPS.

            commits

            id
            The ID of this entity. Will be used for cross entity linking.
            commitID
            The commit ID. Commit IDs are the full SHA of the commit.

            issueKeys
            List of issues keys that this entity is associated with. They must be valid JIRA issue keys.

            updateSequenceId
            An ID used to apply an ordering to updates for this entity in the case of out-of-order receipt of update requests.

            hash
            The hash of the commit.
            commitID
            The commit ID. Commit IDs are the full SHA of the commit.

            message
            The commit message.
            message
            The commit message associated with the specified commit.

            author
            The author of this commit.
            author
            Information about the author of the specified commit.

            fileCount
            The total number of files added, removed, or modified by this commit.

            authorTimestamp
            The author timestamp of this commit.
            date
            The date when the specified commit was commited.

            displayId
            Shortened identifier for this commit, used for display.
            commitID
            The commit ID. Commit IDs are the full SHA of the commit.


text:
---
layout: post
title: How to Safely Stumble Home Drunk
categories:
- blog
---

What is the safest way to get from point A to point B? A simple question with a not so simple answer. What does it mean to be safe? Is it the feeling of safety or actually being safe? How are of either of these measured? Most importantly, If I've had too much too drink, what is my safest way home?

We begin to answer these abstract questions in a very tangible environment. Classic 1980's arcade games. I love the 80's.

## Ms. Pac-Man

In 1981 Ms. Pac Man was released forever giving people like me a reason to get out of bed in the morning. ![](/assets/images/ms-pacman-board-245x300.jpg){:style="float: left;margin-left: 7px;margin-right: 7px;margin-top: 7px;"} In the figure to the left, the small yellow boxes are pills Ms. Pac Man eats for points, and the 4 super pills allow Ms. Pac Man to eat the ghosts. The 4 tunnels on the left and right edges, "wrap" the board. For example, if Ms. Pac Man enters the tunnel in the top left she will come out on the top right.

Let's suppose that Ms. Pac Man wants to get from the lower left hand corner to the upper right super pill. In this model we assume the four ghosts emanate some sort of danger that Ms. Pac Man must be aware of. Let's make the following assumptions.

1. The ghosts will not actually kill (eat) Ms. Pac Man, they simply are sources of danger.
2. The danger (ghosts) is static; the ghosts do not move.
3. The effect of each ghosts danger at a point (a,b) is related to the distance between the ghost and the point.
4. Ms. Pac Man can only change course at intersections, or places on the map where she can make a choice to change direction at a 90 degree angle.

This simplified version of the game is a basis for a mathematical model. This mimics the problem of a person walking from an intersection A to an intersection B. Assume we have historic crime data we can give a prediction, of sorts, of the amount of danger on a given path. **Solving the Ms. Pac Man problem is the beginning of solving the safe path problem in a real-world city scenario**. The shortest path problem has a long history. Because of computing power we can now apply these algorithms to larger and more complex graphs. An example was tackled in a paper ([here](http://www2.cs.uic.edu/~urbcomp2013/urbcomp2014/papers/Galbrun_Safe%20Navigation.pdf)) and my application to Ms. Pac Man is yet another variation.

# The Model

We can model the Ms. Pac Man board as a graph. A graph, denoted by $$G$$, is a collection of vertices or nodes, denoted with a $$V$$, and a collection of edges that connect the nodes denoted by $$E$$. We use the notation $$G=(V,E)$$. Every intersection cited in bullet point 4 above is a vertex and every path between intersections is an edge.

Using the schematic described above we can label the vertices as the ordered pair (a,b). The intersection at the lower left is then vertex (1,1). We impose a 26x26 grid that corresponds with the pills on the board and in doing so we now have a and b are both integers. Using this model we have the following network representation of the board.

![](/assets/images/MsPac_Board-620x629.png)

## Solving the Problem: Dijkstra's Algorithm

Now that we have our model we want to solve the graph. We have many nodes and many edges and so computing the graph by hand becomes laborious. We enlist our friend Python to do the heavy lifting. An algorithm exists that will solve the graph. But first we need to decide how we measure the danger from the ghosts.

### A Kernel Density Estimate for the Distribution of Danger

Let $$x=(a,b)$$ be the point where Ms. Pac Man is located and let $$g_i=(a_i,b_i), i=1,2,3,4$$ be fixed coordinates for each ghost. The danger at the point $$x$$, denoted as $$d(x)$$, is

$$ d(x) = C\sum_{i=0}^{4}f\left(||x - g_i||\right)$$

where $$C$$ is a constant and $$f$$ is a function.

For reasons beyond the scope of this discussion we choose the constant $$C$$ and the function $$f$$ so that

$$ d(x) = \frac{1}{4h^2}\sum_{i=1}^{4}\frac{1}{\sqrt{2\pi}}e^{-||x - g_i||^2/2h^2}$$

The value $$h$$ is the bandwidth of the distribution. The bandwidth helps control the "reach" of the danger.

This function (1) is called a Kernel Density Estimate (KDE) and is essentially a continuous version of a histogram. In order to define the danger on any given edge $$e$$ we simply take the sum of $$d(x)$$ for $$x\in e$$. To normalize the probability we introduce the risk along an edge $$r(e)$$ and define it,

$$ r(e) = \frac{d(e)}{\sum_{e'\in E} d(e')}$$

where E is the set of all edges.

At this point we have assigned a weight - the risk - to each edge. We have a weighted bidirectional graph. We can now apply algorithms from network analysis to answer the question "what is the safest path from A to B?"

## Dijkstra's Algorithm

Given a graph with weighted edges how can we algorithmically find the (superlative) path? We could be looking for the shortest, longest, safest, fastest or cheapest path depending on the context. Here we will use Dijkstra's Algorithm. The figure below, from WikiCommons, tries to visually explain how the algorithm works.

![](/assets/images/Dijkstra_Animation.gif)

Essentially, you keep taking the (short, long, safe, fast or cheap)-est route and, as you move along the path, update the previous paths if a (short, long, safe, fast or cheap)-er path exists.

## Using Python to Solve Ms. Pac-Man's Problem

The networkX package has built in solvers that include Dikjstra's algorithm. Once we have defined the graph it takes but a few lines of code to solve the problem. One realization is the following graph,

![](/assets/images/MsPac_Large.png)

In the graph the red path is the safest path and the blue path is the shortest . The purple path is where the shortest and safest overlap.![](/assets/images/Ghost_Danger_0.png){:style="float: right;margin-right: 7px;margin-right: 7px;margin-top: 7px;"} The green dots represent the ghosts and the two yellow dots are the starting and ending points. The plot to the right is a density map of the ghost danger. The green area represents the least amount of danger while the brown represents the highest source of danger. As we will see in the next two examples, the safest path was chosen to stay away from the ghost. The next two pictures are included with the corresponding ghost danger density alongside.

![](/assets/images/2nd_Boards.png){:height="360px" width="720px"}
![](/assets/images/Density_Ghosts_22.png)

### What's next?

I have applied this model to a subset of the city of Denver, Colorado. I will present those results in a later blog post. Along with a colleague I hope to develop an application that could be useful for the adventurous walker.

Whomever thinks about how useful this is needs to consider the difference between what is probable and what is possible. Safety is never guaranteed.

There are other similar applications of Dijkstra's algorithms: What is the most "satisfying" path home? Which way home burns the most calories? Which way home has the most bars? Then once you leave the bar you need to decide the safest way ... oh wait ... 🙂


text:
# Power Apps PCF control to display text with typewriter effect

![Type Writer Text Control](Demos/../../Demos/Drop shadow text in Model-Drive Apps_small.gif)

Following properties are configurable

- Text
- Color
- Font
- Font size
- Font weight
- Duration
- Repeat

gha_language: TypeScript


text:
# Deep Learning Inference Server Clients

The NVIDIA Inference Server provides a cloud inferencing solution
optimized for NVIDIA GPUs. The server provides an inference service
via an HTTP endpoint, allowing remote clients to request inferencing
for any model being managed by the server.

This repo contains C++ and Python client libraries that make it easy
to communicate with the inference server. Also included are C++ and
Python versions of *image\_client*, an example application that uses
the C++ or Python client library to execute image classification
models on the inference server.

The inference server itself is delivered as a containerized solution
from the [NVIDIA GPU
Cloud](https://www.nvidia.com/en-us/gpu-cloud/). See the [Inference
Container User
Guide](https://docs.nvidia.com/deeplearning/sdk/inference-user-guide/index.html)
for information on how to install and configure the inference server.

Use [Issues](https://github.com/NVIDIA/dl-inference-server/issues) to
report any issues or questions about the client libraries and
examples. A [DevTalk
forum](https://devtalk.nvidia.com/default/board/262/container-attis-inference-server)
is also available for Inference Server issues and questions.

## Branches

**master**: Active development branch. Typically will be compatible with
 the currently released NVIDIA Inference Server container, but not
 guaranteed.

**yy.mm**: Branch compatible with NVIDIA Inference Server yy.mm, for
  example 18.05.

## Building the Clients

Before building the client libraries and applications you must first
install some prerequisites. The following instructions assume Ubuntu
16.04. OpenCV is used by image\_client to preprocess images before
sending them to the inference server for inferencing. The python-pil
package is required by the Python image\_client example.

    sudo apt-get update
    sudo apt-get install build-essential libcurl3-dev libopencv-dev libopencv-core-dev python-pil software-properties-common

Protobuf3 support is required. For Ubuntu 16.04 this must be installed
from a ppa, but if you are using a more recent distribution this step
might not be necessary.

    sudo add-apt-repository ppa:maarten-fonville/protobuf
    sudo apt-get update
    sudo apt-get install protobuf-compiler libprotobuf-dev

Creating the whl file for the Python client library requires setuptools.

    pip install --no-cache-dir --upgrade setuptools

With those prerequisites installed, the C++ and Python client libraries
and example image\_client application can be built:

    make -f Makefile.clients all pip

Build artifacts are in build/.  The Python whl file is generated in
build/dist/dist/ and can be installed with a command like the following:

    pip install --no-cache-dir --upgrade build/dist/dist/inference_server-1.1.0-cp27-cp27mu-linux_x86_64.whl

## Image Classification Example

The image classification example that uses the C++ client API is
available at src/clients/c++/image\_client.cc. After building, the
executable is available at build/image\_client. The python version of
the image classification client is available at
src/clients/python/image\_client.py.

To use image\_client (or image\_client.py) you must first have an
inference server that is serving one or more image classification
models. The image\_client example requires that the model have a
single image input and produce a single classification output.

A simple TensorRT MNIST model is provided in the examples/models
directory that we can use to demonstrate image\_client. Following the
instructions in the [Inference Container User
Guide](https://docs.nvidia.com/deeplearning/sdk/inference-user-guide/index.html),
launch the inference server container pointing to that model store.
For example:

    nvidia-docker run --rm --shm-size=1g --ulimit memlock=-1 --ulimit stack=67108864 -p8000:8000 --mount type=bind,source=/path/to/dl-inference-server/examples/models,target=/tmp/models nvcr.io/nvidia/inferenceserver:18.05 /opt/inference_server/bin/inference_server --model-store=/tmp/models

Replace /path/to/dl-inference-server/examples/models with the
corresponding path in your local clone of this repo. Once the server
is running you can use image\_client (or image\_client.py) to send
inference requests to the server.

    image_client -m mnist_plan -s VGG examples/data/3.pgm

By default the client prints the most probable classification for the image.

    Prediction totals:
            cnt=1   (3) three

Use the -c flag to see more classifications.

    image_client -m mnist_plan -s VGG -c 3 examples/data/3.pgm
    Output probabilities:
    batch 0: 3 ("three") = 0.996513
    batch 0: 5 ("five") = 0.00348471
    batch 0: 4 ("four") = 2.07097e-06
    Prediction totals:
            cnt=1   (3) three

The -b flag allows you to send a batch of images for inferencing.
Currently image\_client just sends the same image multiple times, so
you will just see the same classification results repeated (as
indicated by the 'cnt' value).

    image_client -m mnist_plan -s VGG -b 2 examples/data/3.pgm
    Prediction totals:
            cnt=2   (3) three

## C++ API

The C++ client API exposes a class-based interface for querying server
and model status and for performing inference. The commented interface
is available at src/clients/c++/request.h.

The following shows an example of the basic steps required for
inferencing (error checking not included to improve clarity, see
image_client.cc for full error checking):

```c++
// Create the context object for inferencing using the latest version
// of the 'mnist' model.
std::unique_ptr<InferContext> ctx;
InferContext::Create(&ctx, "localhost:8000", "mnist");

// Get handle to model input and output.
std::shared_ptr<InferContext::Input> input;
ctx->GetInput(input_name, &input);

std::shared_ptr<InferContext::Output> output;
ctx->GetOutput(output_name, &output);

// Set options so that subsequent inference runs are for a given batch_size
// and return a result for ‘output’. The ‘output’ result is returned as a
// classification result of the ‘k’ most probable classes.
std::unique_ptr<InferContext::Options> options;
InferContext::Options::Create(&options);
options->SetBatchSize(batch_size);
options->AddClassResult(output, k);
ctx->SetRunOptions(*options);

// Provide input data for each batch.
input->Reset();
for (size_t i = 0; i < batch_size; ++i) {
  input->SetRaw(input_data[i]);
}

// Run inference and get the results. When the Run() call returns the ctx
// can be used for another inference run. Results are owned by the caller
// and can be retained as long as necessary.
std::vector<std::unique_ptr<InferContext::Result>> results;
ctx->Run(&results);

// For each entry in the batch print the top prediction.
for (size_t i = 0; i < batch_size; ++i) {
  InferContext::Result::ClassResult cls;
  results[0]->GetClassAtCursor(i, &cls);
  std::cout << "batch " << i << ": " << cls.label << std::endl;
}
```

## Python API

The Python client API provides similar capabilities as the C++
API. The commented interface for StatusContext and InferContext
classes is available at src/clients/python/\_\_init\_\_.py.

The following shows an example of the basic steps required for
inferencing (error checking not included to improve clarity):

```python
from inference_server.api import *

# Create input with random data
input_list = list()
for b in range(batch_size):
    in = np.random.randint(size=input_size, dtype=input_dtype)
    input_list.append(in)

# Run inferencing and get the top-3 classes
ctx = InferContext("localhost:8000", "mnist")
results = ctx.run(
    { "data" : input_list },
    { "prob" : (InferContext.ResultFormat.CLASS, 3) },
    batch_size)

# Print results
for (result_name, result_val) in iteritems(results):
    for b in range(batch_size):
        print("output {}, batch {}: {}".format(result_name, b, result_val[b]))
```

repository: ryanolson/dl-inference-server

repo_name: ryanolson/dl-inference-server


text:
# Web Scraper

A web scraper taking as arguments a list of URIs and a list of XPath queries to perform on each document. Returns an instance of [`DataInterface`](https://github.com/opportus/web-scraper/blob/master/src/DataInterface.php).

## Installation

```bash
$ composer require opportus/web-scraper
```

## Usage

```php
Use Opportus\WebScraper\WebScraper;

$uris = [
    'https://en.wikipedia.org/wiki/Web_scraping',
    'https://en.wikipedia.org/wiki/XPath',
];

$queries = [
    '//p[1][node()]',
    '//div[@id="mw-normal-catlinks"]/ul//li[node()]',
];

$scraper = new WebScraper();

$data = $scraper->scrap($uris, $queries); // @see https://github.com/opportus/web-scraper/blob/master/src/DataInterface.php
```

repository: opportus/web-scraper

repo_name: opportus/web-scraper


text:
---
title: Java- User Defined Exceptions
permalink: "/java/user-defined-exceptions"
key: java-user-defined-exceptions
categories:
- Java
tags:
- Java
---

User Defined Exceptions
==========================

User defined exceptions are those which are developed by JAVA programmer as a
part of Application development for dealing with specific problems such as
negative salaries, negative ages.

3 Steps to developing user defined exceptions

-   Choose the appropriate user defined class must extends either
    **java.lang.Exception** or **java.lang.RunTimeException** class.

-   That class must contain a **parameterized Constructor by taking string as a
    parameter**.

-   Above constructor must call super constructor with string Ex : **super(s)**

> Example

For implementing example, we must create 3 classes

1.  **User defined Exception class**

2.  **A class with a method which throws User defined Exception**

3.  **Main class which calls above method**

**1.User Defined Exception class**
```java
public class NegativeNumberException extends Exception {

  public NegativeNumberException(String s) {
    super(s);
  }

}
```

2.A class with a method which throws User defined Exception throws & throw
```java
public class Salary {
  public void show(int sal) throws NegativeNumberException {
    if (sal < 0) {
      throw new NegativeNumberException("Salary Should be >1");
    } else {
      System.out.println("Your Sal is :" + sal);
    }
  }
}
```

3.Main class which calls above method
```java
public class UserMain {
  public static void main(String[] args) {
    Salary salary = new Salary();
    try {
      salary.show( - 100);
    } catch(NegativeNumberException e) {
      e.printStackTrace();
    }
  }
}
excep.NegativeNumberException: Salary Should be > 1
at excep.Salary.show(Salary.java: 8)
at excep.Salary.main(Salary.java: 18)
```
In Real time CSW Id Start with A1 & Contains 8 digit number, so if given ID not
met the requirement Throws CSWException

path: /java/18.User Defined Exceptions.md

filename: 18.User Defined Exceptions.md


text:
# SE575_group14

Special thanks to Daniel Van Flymen (https://github.com/dvf) for his "Learn Blockchains by Building One" tutorial.

Dependencies are:

    Flask v0.12.2

    Requests v2.18.4

    Python v3.8.6

    Node.js v10.23.0

    Npm v5.6.0

To install Flask and requests, you can use the following pip command:

    $ pip install Flask==0.12.2 requests==2.18.4

Before running the client side, you need to run the server side. To run the server-side, simply run the blockchain.py file in either cmd or a code editor such as VS Code.

If you are using cmd, then change your directory to the one containing the "blockchain.py" file, and then write the following command:

    $ python3 blockchain.py

After running the sever-side you will see a message saying:

    * Running on http://<IP_ADDRESS>:8080/ (Press CTRL+C to quit)

There are multiple ways to run the client side, the most easiest and interactive is the with a web browser. To do that, locally open the URL port on any browser (we tested on chrome):

    http://<IP_ADDRESS>:8080/ or http://localhost:8080/

After opening the localhost, you can see your address. That address is unique to only you.


text:
## Release Notes for GlusterFS 3.5.1

This is mostly a bugfix release. The [Release Notes for 3.5.0](./3.5.0.md)
contain a listing of all the new features that were added.

There are two notable changes that are not only bug fixes, or documentation
additions:

1. a new volume option `server.manage-gids` has been added
   This option should be used when users of a volume are in more than
   approximately 93 groups (Bug [1096425](https://bugzilla.redhat.com/1096425))
2. Duplicate Request Cache for NFS has now been disabled by default, this may
   reduce performance for certain workloads, but improves the overall stability
   and memory footprint for most users

### Bugs Fixed:

- [765202](https://bugzilla.redhat.com/765202): lgetxattr called with invalid keys on the bricks
- [833586](https://bugzilla.redhat.com/833586): inodelk hang from marker_rename_release_newp_lock
- [859581](https://bugzilla.redhat.com/859581): self-heal process can sometimes create directories instead of symlinks for the root gfid file in .glusterfs
- [986429](https://bugzilla.redhat.com/986429): Backupvolfile server option should work internal to GlusterFS framework
- [1039544](https://bugzilla.redhat.com/1039544): [FEAT] "gluster volume heal info" should list the entries that actually required to be healed.
- [1046624](https://bugzilla.redhat.com/1046624): Unable to heal symbolic Links
- [1046853](https://bugzilla.redhat.com/1046853): AFR : For every file self-heal there are warning messages reported in glustershd.log file
- [1063190](https://bugzilla.redhat.com/1063190): Volume was not accessible after server side quorum was met
- [1064096](https://bugzilla.redhat.com/1064096): The old Python Translator code (not Glupy) should be removed
- [1066996](https://bugzilla.redhat.com/1066996): Using sanlock on a gluster mount with replica 3 (quorum-type auto) leads to a split-brain
- [1071191](https://bugzilla.redhat.com/1071191): [3.5.1] Sporadic SIGBUS with mmap() on a sparse file created with open(), seek(), write()
- [1078061](https://bugzilla.redhat.com/1078061): Need ability to heal mismatching user extended attributes without any changelogs
- [1078365](https://bugzilla.redhat.com/1078365): New xlators are linked as versioned .so files, creating <xlator>.so.0.0.0
- [1086743](https://bugzilla.redhat.com/1086743): Add documentation for the Feature: RDMA-connection manager (RDMA-CM)
- [1086748](https://bugzilla.redhat.com/1086748): Add documentation for the Feature: AFR CLI enhancements
- [1086749](https://bugzilla.redhat.com/1086749): Add documentation for the Feature: Exposing Volume Capabilities
- [1086750](https://bugzilla.redhat.com/1086750): Add documentation for the Feature: File Snapshots in GlusterFS
- [1086751](https://bugzilla.redhat.com/1086751): Add documentation for the Feature: gfid-access
- [1086752](https://bugzilla.redhat.com/1086752): Add documentation for the Feature: On-Wire Compression/Decompression
- [1086754](https://bugzilla.redhat.com/1086754): Add documentation for the Feature: Quota Scalability
- [1086755](https://bugzilla.redhat.com/1086755): Add documentation for the Feature: readdir-ahead
- [1086756](https://bugzilla.redhat.com/1086756): Add documentation for the Feature: zerofill API for GlusterFS
- [1086758](https://bugzilla.redhat.com/1086758): Add documentation for the Feature: Changelog based parallel geo-replication
- [1086760](https://bugzilla.redhat.com/1086760): Add documentation for the Feature: Write Once Read Many (WORM) volume
- [1086762](https://bugzilla.redhat.com/1086762): Add documentation for the Feature: BD Xlator - Block Device translator
- [1086766](https://bugzilla.redhat.com/1086766): Add documentation for the Feature: Libgfapi
- [1086774](https://bugzilla.redhat.com/1086774): Add documentation for the Feature: Access Control List - Version 3 support for Gluster NFS
- [1086781](https://bugzilla.redhat.com/1086781): Add documentation for the Feature: Eager locking
- [1086782](https://bugzilla.redhat.com/1086782): Add documentation for the Feature: glusterfs and oVirt integration
- [1086783](https://bugzilla.redhat.com/1086783): Add documentation for the Feature: qemu 1.3 - libgfapi integration
- [1088848](https://bugzilla.redhat.com/1088848): Spelling errors in rpc/rpc-transport/rdma/src/rdma.c
- [1089054](https://bugzilla.redhat.com/1089054): gf-error-codes.h is missing from source tarball
- [1089470](https://bugzilla.redhat.com/1089470): SMB: Crash on brick process during compile kernel.
- [1089934](https://bugzilla.redhat.com/1089934): list dir with more than N files results in Input/output error
- [1091340](https://bugzilla.redhat.com/1091340): Doc: Add glfs_fini known issue to release notes 3.5
- [1091392](https://bugzilla.redhat.com/1091392): glusterfs.spec.in: minor/nit changes to sync with Fedora spec
- [1095256](https://bugzilla.redhat.com/1095256): Excessive logging from self-heal daemon, and bricks
- [1095595](https://bugzilla.redhat.com/1095595): Stick to IANA standard while allocating brick ports
- [1095775](https://bugzilla.redhat.com/1095775): Add support in libgfapi to fetch volume info from glusterd.
- [1095971](https://bugzilla.redhat.com/1095971): Stopping/Starting a Gluster volume resets ownership
- [1096040](https://bugzilla.redhat.com/1096040): AFR : self-heal-daemon not clearing the change-logs of all the sources after self-heal
- [1096425](https://bugzilla.redhat.com/1096425): i/o error when one user tries to access RHS volume over NFS with 100+ GIDs
- [1099878](https://bugzilla.redhat.com/1099878): Need support for handle based Ops to fetch/modify extended attributes of a file
- [1101647](https://bugzilla.redhat.com/1101647): gluster volume heal volname statistics heal-count not giving desired output.
- [1102306](https://bugzilla.redhat.com/1102306): license: xlators/features/glupy dual license GPLv2 and LGPLv3+
- [1103413](https://bugzilla.redhat.com/1103413): Failure in gf_log_init reopening stderr
- [1104592](https://bugzilla.redhat.com/1104592): heal info may give Success instead of transport end point not connected when a brick is down.
- [1104915](https://bugzilla.redhat.com/1104915): glusterfsd crashes while doing stress tests
- [1104919](https://bugzilla.redhat.com/1104919): Fix memory leaks in gfid-access xlator.
- [1104959](https://bugzilla.redhat.com/1104959): Dist-geo-rep : some of the files not accessible on slave after the geo-rep sync from master to slave.
- [1105188](https://bugzilla.redhat.com/1105188): Two instances each, of brick processes, glusterfs-nfs and quotad seen after glusterd restart
- [1105524](https://bugzilla.redhat.com/1105524): Disable nfs.drc by default
- [1107937](https://bugzilla.redhat.com/1107937): quota-anon-fd-nfs.t fails spuriously
- [1109832](https://bugzilla.redhat.com/1109832): I/O fails for for glusterfs 3.4 AFR clients accessing servers upgraded to glusterfs 3.5
- [1110777](https://bugzilla.redhat.com/1110777): glusterfsd OOM - using all memory when quota is enabled

### Known Issues:

- The following configuration changes are necessary for qemu and samba
  integration with libgfapi to work seamlessly:

      1. gluster volume set <volname> server.allow-insecure on
      2. restarting the volume is necessary

            gluster volume stop <volname>
            gluster volume start <volname>

      3. Edit `/etc/glusterfs/glusterd.vol` to contain this line:

            option rpc-auth-allow-insecure on

      4. restarting glusterd is necessary

            service glusterd restart

More details are also documented in the Gluster Wiki on the [Libgfapi with qemu libvirt](https://github.com/gluster/glusterfs-specs/blob/master/done/GlusterFS%203.5/libgfapi%20with%20qemu%20libvirt.md) page.

- For Block Device translator based volumes open-behind translator at the client side needs to be disabled.

- libgfapi clients calling `glfs_fini` before a successfull `glfs_init` will cause the client to
  hang has been [reported by QEMU developers](https://bugs.launchpad.net/bugs/1308542).
  The workaround is NOT to call `glfs_fini` for error cases encountered before a successfull
  `glfs_init`. Follow [Bug 1091335](https://bugzilla.redhat.com/1091335) to get informed when a
  release is made available that contains a final fix.

- After enabling `server.manage-gids`, the volume needs to be stopped and
  started again to have the option enabled in the brick processes

        gluster volume stop <volname>
        gluster volume start <volname>

repository: gluster/glusterdocs

repo_name: gluster/glusterdocs


text:
# Pubsub
Lets say you want to listen to events outside of your store or perhaps you want to
create a pub sub scenario where an event might not be tied to a store at all.
To do this, we can inject the `EventStream` observable and just listen in.
To make determining if the event is what we actually want to listen to, we have a
RxJS pipeable operator called `ofEvent(NewAnimal)` we can use too!

```javascript
import { EventStream, ofEvent } from 'ngxs';

@Injectable()
export class RouteHandler {
  constructor(private eventStream: EventStream, private router: Router) {
    this.eventStream
      .pipe(ofEvent(NewAnimal))
      .subscribe((action) => alert('New Animal!'));
  }
}
```

repository: rhutchison/ngxs

repo_name: rhutchison/ngxs


text:
**Using**

1. Use contest "service-catalog" to communicate with the service catalog API server:

```bash
$ kubectl config use-context service-catalog
```

2. Build using make:

```bash
$ make build
```

3. Run script:

```bash
$ ./service-catalog-client
```
You can override the following params:

```bash
$ ./service-catalog-client --broker broker --instance instance --chart zookeeper --version 1.1.0 --namespace test-ns --binding binding
```
Also you can override chart values in the values.json file.


text:
# SQL_ETL-using-incremental
This repository contains SQL scripts that creates both OLTP and OLAP files, and perform ETL process from OLTP to OLAP using incremental loading technique.

- 01_StarterScript Create the OLTP DB file is SQL script that creates OLTP database.
- 02_SetupScript Create the DW DB file is SQL script which creates OLAP database.
- ETL_incremental file is SQL script which synchronize OLTP and OLAP database using incremental loading technique including both synchronization and merge. After synchronization, OLAP database will reflect exact same data from OLTP database.

Once the procedures are successfully executed, OLAP database will be used for reporting purposes.


text:
If you've had surgery,
you might remember starting to count
backwards from ten,
nine,
eight,
and then waking up with the surgery
already over before you even got to five.

You were under anesthesia,
which is much more complicated.
You were unconscious,
but you also couldn't move,
form memories,
or, hopefully, feel pain.
Without being able to block all those
processes at once,
many surgeries would be
way too traumatic to perform.
Ancient medical texts from Egypt,
Asia and the Middle East
all describe early anesthetics
containing things like opium poppy,
mandrake fruit,
and alcohol.
Today, anesthesiologists often combine
regional, inhalational
and intravenous agents
to get the right balance for a surgery.
Regional anesthesia blocks pain signals
from a specific part of the body
from getting to the brain.
Pain and other messages travel through
the nervous system as electrical impulses.
Regional anesthetics work by setting up
and electrical baracade.
They bind to the proteins
in neurons' cell membranes
that let charged particles in and out,
and lock out positively charged particles.
One compound that does this is cocaine,
whose painkilling effects
were discovered by accident
when an ophthalmology intern
got some on his tongue.
It's still occasionally used
as an anesthetic,
but many of the more common
regional anesthetics
have a similar chemical structure
and work the same way.
But for major surgeries where you need
to be unconscious,
you'll want something that acts
on the entire nervous system,
including the brain.
That's what inhalational anesthetics do.
In Western medicine, diethyl ether
was the first common one.
It was best known as a recreational drug
until doctors started to realize that
people sometimes didn't notice
injuries they received
under the influence.
In the 1840s, they started sedating
patients with ether
during dental extractions and surgeries.
Nitrous oxide became popular
in the decades that followed
and is still used today.
although ether derivatives,
like sevoflurane, are more common.
Inhalational anesthesia is usually
supplemented with intravenous anesthesia,
which was developed in the 1870s.
Common intravenous agents include
sedatives, like propofol,
which induce unconsciousness,
and opioids, like fentanyl,
which reduce pain.
These general anesthetics
also seem to work
by affecting electrical signals
in the nervous system.
Normally, the brain's electrical signals
are a chaotic chorus
as different parts of the brain
communicate with each other.
That connectivity keeps you awake
and aware.
But as someone becomes anesthetized,
those signals become calmer
and more organized,
suggesting that different
parts of the brain
aren't talking to each other anymore.
There's a lot we still don't know
about exactly how this happens.
Several common anesthetics bind to
the GABA-A receptor in the brain's neurons.
They hold the gateway open,
letting negatively charged particles
flow into the cell.
Negative charge builds up
and acts like a log jam,
keeping the neuron from transmitting
electrical signals.
The nervous system has lots
of these gated channels,
controlling pathways for movement,
memory,
and consciousness.
Most anesthetics probably
act on more than one,
and they don't act on
just the nervous system.
Many anesthetics also affect the heart,
lungs,
and other vital organs.
Just like early anesthetics,
which included familiar poisons like
hemlock and aconite,
modern drugs can
have serious side effects.
So an anesthesiologist has to mix
just the right balance of drugs
to create all the features of anesthesia,
while carefully monitoring
the patient's vital signs,
and adjusting the drug mixture as needed.
Anesthesia is complicated,
but figuring out how to use it
allowed for the development
of new and better surgical techniques.
Surgeons could learn how to routinely
and safely perform C-sections,
reopen blocked arteries,
replace damaged livers and kidneys,
and many other life-saving operations.
And each year, new anesthesia techniques
are developed
that will ensure more and more patients
survive the trauma of surgery.

repository: prewittdavon/TEDVis

repo_name: prewittdavon/TEDVis