text:
Analysis of Secondary School Enrollment Rate and Teen Fertility Rate: Econometrics
================
Charlie Zheng
4/20/2020

Executive Summary
=================

Does improving a country’s secondary school enrollment rate lower its teen fertility rate? To answer the question, this econometric study is conducted by using OLS regression and difference-in-difference estimate. The study discovered that the increase of secondary school enrollment rate causes the decrease of teen fertility rate.

Data
====

``` r
wdi <- read.csv("wdi.csv")
df <- na.omit(wdi %>% select(countryname,year,sp_ado_tfrt,se_sec_nenr))
df <- rename(df,fertility=sp_ado_tfrt,enrollment=se_sec_nenr)
countries <- unique(df$countryname)
for (i in countries){
  dfsubset <- df %>% filter(countryname==i)
  #remove countries with fewer than 5 entries
  if (nrow(dfsubset)<5){
    countries = countries[countries!=i]
  }
}
df <- subset(df,countryname %in% countries)
```

OLS regression data
-------------------

In order to study the correlation between secondary school enrollment rate and teen fertility rate, the data were retrieved from the World Bank’s World Development Indicators (WDI). Entries with missing data and countries with 5 or fewer entries were removed. After the data cleaning, there are 185 countries left in the dataset. The variables are "secondary school enrollment rate (% net)", represent the percentage of secondary-school-age teenagers who participated the secondary schools in their country; and "teen fertility rate (births per 1,000 women ages 15-19)". From this dataset, I will randomly choose 40 countries, exclude the regions, and remain only the countries. There are 31 countries left in this randomly chosen sample.

``` r
set.seed(65)
sample.countries<- sample(countries,40)
#excluding regions, only include countries
sample.countries = sample.countries[-c(5,6,14,17,22,23,32,33,38)]
df2 <- subset(df,countryname %in% sample.countries)
```

Here is the descriptive statistics about these countries:

``` r
description <- data.frame(country=character(),start_year=integer(),end_year=integer(),average_secondary_school_enrollment=double(),average_teen_fertility_rate=double())
for (i in sample.countries){
  descrdf <- df2 %>% filter(countryname==i)
  descr <- data.frame(country=i,start_year=min(descrdf$year),end_year=max(descrdf$year),average_secondary_school_enrollment=mean(descrdf$enrollment),average_teen_fertility_rate=mean(descrdf$fertility))
  description <- rbind(description,descr)
}
description
```

    ##                  country start_year end_year
    ## 1                 Brazil       2007     2013
    ## 2              Nicaragua       1971     2010
    ## 3               Colombia       2005     2014
    ## 4    Antigua and Barbuda       2000     2014
    ## 5           Burkina Faso       1983     2013
    ## 6                Lebanon       2006     2012
    ## 7               Portugal       1973     2014
    ## 8  Sao Tome and Principe       1988     2011
    ## 9              Swaziland       1970     2013
    ## 10                 Samoa       1995     2014
    ## 11                 Ghana       1999     2015
    ## 12               Belarus       2010     2014
    ## 13        United Kingdom       1971     2014
    ## 14                  Cuba       1972     2013
    ## 15               Bolivia       2001     2013
    ## 16              Cambodia       1998     2008
    ## 17                Latvia       1994     2014
    ## 18              Malaysia       1970     2014
    ## 19      Macao SAR, China       1990     2014
    ## 20               Burundi       1976     2014
    ## 21             Argentina       1974     2013
    ## 22               Lao PDR       1992     2014
    ## 23               Grenada       1972     2014
    ## 24    Iran, Islamic Rep.       2009     2014
    ## 25                Poland       1999     2013
    ## 26                 Japan       1978     2013
    ## 27              Bulgaria       1996     2014
    ## 28                Angola       1972     2010
    ## 29           Afghanistan       1974     2014
    ## 30            Cabo Verde       1987     2014
    ## 31               Myanmar       1999     2014
    ##    average_secondary_school_enrollment average_teen_fertility_rate
    ## 1                            78.070459                   69.208520
    ## 2                            30.096843                  134.782067
    ## 3                            75.351264                   61.131560
    ## 4                            82.360324                   52.968600
    ## 5                            10.739043                  135.300060
    ## 6                            68.938279                   13.153114
    ## 7                            65.482198                   23.652247
    ## 8                            32.995250                   96.646444
    ## 9                            26.691730                  112.456127
    ## 10                           71.040775                   34.742380
    ## 11                           42.582463                   73.770629
    ## 12                           96.382066                   20.723440
    ## 13                           86.328528                   28.880275
    ## 14                           72.072438                   70.170933
    ## 15                           72.991392                   80.168418
    ## 16                           24.577289                   48.477960
    ## 17                           87.454518                   18.240200
    ## 18                           62.408566                   18.939070
    ## 19                           74.227745                    4.221700
    ## 20                            8.455610                   42.302262
    ## 21                           76.343168                   65.304644
    ## 22                           31.730650                   78.158010
    ## 23                           71.688490                   52.409200
    ## 24                           80.111640                   28.727100
    ## 25                           90.724343                   15.683787
    ## 26                           98.500041                    4.873889
    ## 27                           85.871675                   43.216926
    ## 28                            8.625692                  203.226000
    ## 29                           29.932566                  117.535520
    ## 30                           54.954892                   87.452523
    ## 31                           39.970080                   21.764154

Difference in Difference Data
-----------------------------

In 1996, the government of Peru passed education reforms that extended free and compulsory school education to all students aged between 5 and 16 (Clark).This reform significantly improved the secondary school enrollment rate in Peru after 1998. Therefore, I choose to compare the data of Peru and Colombia, another South American country which did not implement such an education reform, from 1993 to 2002. The variables are "secondary school enrollment rate (% gross)", represent the percentage of gross population who participated the secondary schools in their country; and "teen fertility rate (births per 1,000 women ages 15-19)".

``` r
Peru <- wdi %>% filter(countryname=="Peru",year>1992,year<2003) %>% select(year,sp_ado_tfrt,se_sec_enrr)
Peru <- rename(Peru,fertility=sp_ado_tfrt,enrollment.gross=se_sec_enrr)
Colombia <- wdi %>% filter(countryname=="Colombia",year>1992,year<2003) %>% select(year,sp_ado_tfrt,se_sec_enrr)
Colombia <- rename(Colombia,fertility=sp_ado_tfrt,enrollment.gross=se_sec_enrr)
```

There are no missing data in Peru's dataset. The only missing data are found in Colombia's secondary school enrollment rate. Because there are no significant change in Columbia's secondary school enrollment rate, I imputed the missing data with the mean of last year's data and next year's data.

``` r
for (i in 1:length(Colombia$enrollment.gross)){
  if (is.na(Colombia$enrollment.gross[i])){
    Colombia$enrollment.gross[i]<-(Colombia$enrollment.gross[i-1]+Colombia$enrollment.gross[i+1])/2
  }
}
```

Here are the illustrations of the data:

``` r
p1 <- ggplot(Peru,aes(x=year))+
  geom_line(aes(y=fertility,color="teen fertility rate"))+
  geom_line(aes(y=enrollment.gross,color="secondary school enrollment rate"))+
  ggtitle("Peru")+
  xlab("Year")+
  ylab("Percentage")+
  ylim(50,90)+
  scale_x_continuous("year", labels = as.character(Peru$year), breaks = Peru$year)+
  geom_vline(xintercept = 1997)
dfperu <- data.frame(country="Peru",start_year=min(Peru$year),end_year=max(Peru$year),average_secondary_school_enrollment=mean(Peru$enrollment.gross),average_teen_fertility_rate=mean(Peru$fertility))
p2 <- ggplot(Colombia,aes(x=year))+
  geom_line(aes(y=Colombia$fertility,color="teen fertility rate"))+
  geom_line(aes(y=Colombia$enrollment.gross,color="secondary school enrollment rate"))+
  ggtitle("Colombia")+
  xlab("Year")+
  ylab("Percentage")+
  ylim(50,90)+
  xlim(1993,2002)+
  scale_x_continuous("year", labels = as.character(Colombia$year), breaks = Colombia$year)+
  geom_vline(xintercept = 1997)
```

    ## Scale for 'x' is already present. Adding another scale for 'x', which
    ## will replace the existing scale.

``` r
dfcolombia <- data.frame(country="Colombia",start_year=min(Colombia$year),end_year=max(Colombia$year),average_secondary_school_enrollment=mean(Colombia$enrollment.gross),average_teen_fertility_rate=mean(Colombia$fertility))
p1
```

![](Educ-Fert_files/figure-markdown_github/unnamed-chunk-6-1.png)

``` r
p2
```

![](Educ-Fert_files/figure-markdown_github/unnamed-chunk-6-2.png)

``` r
rbind(dfperu,dfcolombia)
```

    ##    country start_year end_year average_secondary_school_enrollment
    ## 1     Peru       1993     2002                            77.20592
    ## 2 Colombia       1993     2002                            66.79231
    ##   average_teen_fertility_rate
    ## 1                     67.7003
    ## 2                     84.0806

From the graphs, we can clearly see that before 1997, both Peru and Colombia have no significant fluctuation in secondary school enrollment rate and teen fertility rate. After 1998, Peru's secondary school enrollment rate drastically increased and its teen fertility rate also decreased significantly. Whereas in Colombia, the secondary school enrollment rate do not have a significant change before or after 1995, and the teen fertility rate decreases year-by-year moderately.

Method
======

Method 1: OLS Regression
------------------------

The first method is OLS regression for each country throughout each year. The formula is: fertility\_hat = ß0 + ß1enrollment By randomly selecting these countries, I mitigated some omitted variable bias, such as difference of countries between economics, sexual culture, education; because these countries are located all over the 6 continents, consists of countries with most stages of economic and education development. However, there is still omitted variable bias, such as whether the secondary school in this country offer sex education. Because the original dataset does not measure this variable, this omitted variable bias cannot be eliminated. There is also another omitted variable bias, the time gap between each measurements. Because there are too much missing data, each country's data is from significantly different time period. This omitted variable bias cannot be eliminated either.

``` r
#countries whose enrollment is statistically significant
olsresult <- data.frame(country=character(),intercept=double(),coef_enrollment=double(),p_value_enrollment=double())
#OLS regression for each country
for (i in sample.countries){
  reg1 <- lm(fertility~enrollment,df2 %>% filter(countryname==i))
  ttest1 <- coeftest(reg1, vcov=vcovHC(reg1, type = "HC1"))
  if (ttest1["enrollment","Estimate"]<0 & ttest1["enrollment","Pr(>|t|)"]<0.05){
    olsresult <- rbind(olsresult,data.frame(country=i,intercept=ttest1["(Intercept)","Estimate"],coef_enrollment=ttest1["enrollment","Estimate"],p_value_enrollment=ttest1["enrollment","Pr(>|t|)"]))
  }
}
```

Method 2:Difference in Difference
---------------------------------

The treatment "group" is Peru. The control "group" is Colombia. The formula is: fertility\_hat = 0 + ß1Peru\_enrollment + ß2After + ß3Peru\_enrollment\*After

Although this comparison eliminites the omitted variable bias such as difference in culture, economics and education policy; this data set still suffers from the omitted variable bias that these two countries have different secondary school enrollment rate and teen fertility rate at the first place. There is also a threat to the external validity, because the evidence found in Peru may not be able to be applied to other countries in the world.

Results
=======

Result of OLS regression
------------------------

``` r
olsresult
```

    ##                  country intercept coef_enrollment p_value_enrollment
    ## 1                 Brazil  95.22160     -0.33319998       1.083821e-03
    ## 2              Nicaragua 188.17574     -1.77406238       8.327197e-11
    ## 3               Colombia 137.53101     -1.01391061       4.466536e-05
    ## 4           Burkina Faso 159.95346     -2.29567947       1.805537e-16
    ## 5                Lebanon  19.97232     -0.09891757       2.576087e-02
    ## 6               Portugal  45.77557     -0.33785246       6.934623e-08
    ## 7  Sao Tome and Principe 116.02514     -0.58731769       2.641541e-02
    ## 8              Swaziland 193.53959     -3.03777486       2.630048e-09
    ## 9                  Samoa  61.77512     -0.38052424       3.516566e-02
    ## 10                 Ghana  98.77823     -0.58727461       1.220721e-06
    ## 11               Belarus  66.50266     -0.47497651       1.111921e-02
    ## 12        United Kingdom  71.71547     -0.49618821       8.277607e-06
    ## 13                  Cuba 168.89714     -1.36981919       4.674622e-24
    ## 14               Bolivia 186.75786     -1.46030150       2.353980e-02
    ## 15              Cambodia  51.77444     -0.13412692       7.987789e-04
    ## 16              Malaysia  90.45142     -1.14587390       3.714588e-18
    ## 17      Macao SAR, China  11.91991     -0.10371072       8.074978e-08
    ## 18               Burundi  51.95990     -1.14215726       3.658933e-08
    ## 19             Argentina  88.37273     -0.30216312       1.844482e-07
    ## 20               Lao PDR 112.56644     -1.08439098       1.571686e-08
    ## 21               Grenada 133.10079     -1.12558637       3.613241e-05
    ## 22              Bulgaria 165.14832     -1.41992568       8.800732e-03
    ## 23                Angola 269.28477     -7.65837340       4.689551e-03
    ## 24           Afghanistan 176.79097     -1.97963163       1.217755e-02
    ## 25            Cabo Verde 120.28281     -0.59740422       1.497068e-05
    ## 26               Myanmar  40.93080     -0.47952477       1.118741e-06

After running the OLS regression for every countries in the sample. There are 26 countries' enrollment coefficients negative and statistically significant at 90% confidence level. There are statistically siginificant evidence showing that the increase of secondary school enrollment rate is associated with the decrease of teen fertility rate. For example, in Brazil, on average, a unit increase of secondary school enrollment rate is associated with 0.33 unit decrease of teen fertility rate. Compared with the sample size of 31, these 26 countries provide abundant evidence of this association, but does not entail the causal impact.

Result of Difference in Difference
----------------------------------

``` r
summary(did)
```

    ## Warning in summary.lm(did): essentially perfect fit: summary may be
    ## unreliable

    ##
    ## Call:
    ## lm(formula = fertility ~ Peru + After + PeruAfter, data = Colombia)
    ##
    ## Residuals:
    ##        Min         1Q     Median         3Q        Max
    ## -3.358e-14 -1.332e-14  3.246e-15  1.078e-14  3.779e-14
    ##
    ## Coefficients:
    ##               Estimate Std. Error    t value Pr(>|t|)
    ## (Intercept) -5.023e+00  5.887e-12 -8.532e+11   <2e-16 ***
    ## Peru        -6.906e+00  4.616e-13 -1.496e+13   <2e-16 ***
    ## After        8.509e+01  5.888e-12  1.445e+13   <2e-16 ***
    ## PeruAfter    6.654e+00  4.616e-13  1.441e+13   <2e-16 ***
    ## ---
    ## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
    ##
    ## Residual standard error: 2.482e-14 on 6 degrees of freedom
    ## Multiple R-squared:      1,  Adjusted R-squared:      1
    ## F-statistic: 7.765e+27 on 3 and 6 DF,  p-value: < 2.2e-16

PeruAfter is statistically significant at 90% confidence level. On average, the decrease of Peru's teen fertility rate is 6.654 units higher than the change of Colombia's teen fertility rate. therefore, Peru's improvement of its secondary school enrollment rate caused the decrease of its teen fertility rate.

license: MIT

repository: charliezcr/Teen-Fertility-and-Eductaion

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: charliezcr/Teen-Fertility-and-Eductaion


text:
# ghm

![Build Status](https://github.com/mpolden/ghm/workflows/ci/badge.svg)

A backup tool for GitHub repositories.

## Installation

Configure [GOPATH](https://golang.org/doc/code.html#GOPATH) and run:

    $ go install github.com/mpolden/ghm@latest

## Examples

Mirror all public repositories of user *mpolden* into `~/git`:

    $ ghm mpolden ~/git

Print git commands that would be run:

    $ ghm -n mpolden ~/git
    /usr/bin/git -C /home/martin/git/dotfiles.git fetch --prune
    /usr/bin/git clone --mirror git@github.com:mpolden/emacs.d.git /home/martin/emacs.d.git
    ...

*NOTE: If the repository doesn't already exist on disk, `git clone` will be run,
otherwise the repository is updated using `git fetch`.*

Speed up mirroring by running git commands concurrently:

    # Updating 52 repositories with concurrency level 1 (default)
    $ time ghm -q mpolden ~/git
    ghm mpolden ~/git  0.88s user 0.06s system 1% cpu 1:30.71 total

    # with concurrency level 20
    $ time ghm -c 20 -q mpolden ~/git
    ghm -c 20 -q mpolden ~/git  0.88s user 0.13s system 16% cpu 5.995 total

## Usage
```
$ ghm -h
Usage of ghm:
  -a	Skip archived repositories
  -c int
    	Number of repositories to mirror concurrently (default 1)
  -n	Print commands that would be run and exit
  -p string
    	Protocol to use for mirroring [git|https|ssh] (default "ssh")
  -q	Only print errors
  -s	Skip forked repositories

Arguments:
  <github-user>	GitHub username
  <path>	Path where repositories should be mirrored
```

repository: dumpmemory/ghm

repo_name: dumpmemory/ghm


text:
# **nuub bot**

_This is a discord bot group project by a python [server](https://discord.gg/EHv6CWnPF4)_

## About **nuub bot**
- nuub bot is an open source discord bot project under development.
- It is made with the `discord.py` python library.
- If you are willing to contribute to the project, join the discord server.

branch_name: refs/heads/main


text:
# Operations

This is the main page for DBA and DevOps.

## Tuning
- [Performance Tuning](Performance-Tuning.md)

## In & Out
- [ETL (Extract-Transform-Load)](ETL-Introduction.md)
- [Distributed Architecture](Distributed-Architecture.md)
- [Backup & Restore](Backup-and-Restore.md)
- [Export & Import](Export-and-Import.md)

## Install
- [Install as Service on Unix/Linux](Unix-Service.md)
- [Install as Service on Windows](Windows-Service.md)

repository: hethcox/orientdb-docs

repo_name: hethcox/orientdb-docs


text:
downstream-farmer
=================

Master: [![Build Status](https://travis-ci.org/Storj/downstream-farmer.svg?branch=master)](https://travis-ci.org/Storj/downstream-farmer)  [![Coverage Status](https://img.shields.io/coveralls/Storj/downstream-farmer.svg)](https://coveralls.io/r/Storj/downstream-farmer?branch=master)
Devel: [![Build Status](https://travis-ci.org/Storj/downstream-farmer.svg?branch=devel)](https://travis-ci.org/Storj/downstream-farmer) [![Coverage Status](https://img.shields.io/coveralls/Storj/downstream-farmer.svg)](https://coveralls.io/r/Storj/downstream-farmer?branch=devel)

## What is this I don't even?

`downstream-farmer` talks to [downstream-node](https://github.com/Storj/downstream-node).  In order to use it, you'll need a node up and running.  `downstream-node` requires MySQL and a working config, but *this app*, `downstream-farmer`, will require python-dev and libcrypto++-dev to install from source.

```
$ sudo apt-get install python-dev libcrypto++-dev
$ git clone -b devel https://github.com/Storj/downstream-farmer.git
$ cd downstream-farmer
$ pip install -r requirements.txt .
```

And connect to our test node by running:
```
$ downstream 'http://verify.driveshare.org'
```

This prototype performs three simple functions.  It connects to the specified downstream-node, it requests a chunk (which also gives it the first chunk challenge), and then it answers the chunk challenge.

**If this is at all confusing, we're doing it as a functional test in the travis.yml file, so watch it in action on Travis-CI.**

## Client Functions
Connects to a downstream compatible node. Should also generate a new account token and retrieves the heartbeat for the proof of storage.

    connect(url)

Queries the server for a file chunk, which in this prototype is simply a file seed for RandomIO to generate.

    get_chunk()

Answers the chunk contract that was retrieved with get_chunk().

    answer_challenge()

repository: nameone/downstream-farmer

repo_name: nameone/downstream-farmer


text:
# multirow-counter

This is a gem that encapsulates a multi-row counter for SQL.

## Why?

Typically SQL is not a great place to store a counter that is incremented often. For instance if you're counting the number of visits to a page by incrementing a SQL column and that page gets popular then there's a good chance that the SQL counter will become a benchmark. This is because doing an UPDATE on the row in question locks the row during the course of the UPDATE. So for many concurrent UPDATES there will be lots of lock contention.

## How?

This library addresses the issue with a hack. Rather than having a single row hold the value for a counter it creates multiple rows for one counter and the true value is the sum total of the value from all the related rows. This addresses the issue of lock contention by sending each UPDATE to a random one of the related rows, lowering the chance of lock contention happening.

## Usage

Bring the gem into your project:

``` ruby
gem 'multirow-counter'
```

Generate a new counter for a given model:

``` console
$ rails generate multirow_counter shop version 3
```

This will create the required migration and add the following delcaration to the Shop model:

``` ruby
class Shop < ActiveRecord::Base
  multirow_counter :version, :rows => 3
end
```

Then you can use it like so:

``` ruby
shop = Shop.find(1)
shop.new_version!
shop.new_version!
shop.version #=> 2
```

The multirow nature of the counter is hidden behind the interface. You can increment and read the counter as if it were a single column on the model.

## License

MIT

## Notes

table shops
  id

table shop_versions
  id
  shop_id
  counter_id
  value


text:
# Seismic interpretation
In this ML recipe, we demonstrate a simplified version of Seismic interpretation project, a recent development of Neuromation in the field of commercial oil exploration.

### Introduction

Seismic methods are based on the study of elastic wave propagation inside the earth. These waves are generated by explosions on the earth’s surface or by seismic sources in the earth’s crust. The seismic receivers, geophones, record on the surface of the earth the echo signal reflected from deep geological structures. The spatial structure of a seismic signal depends on the velocity of elastic wave propagation, which is a function of the physical parameters of rock formations (rock composition, porosity, fracture, moisture saturation, etc.) [link](https://www.sciencedirect.com/topics/earth-and-planetary-sciences/seismic-method)

![](./img/reflection-seismic-method-1.gif)
Reflection seismic surveying ([source](https://geoexpert.ch/methods/reflection-seismic-surveying/))

Post processing of the reflected signal allows to form a 2D seismic cross-section or a 3D array, a seismic cube. The horizontal axes of the seismic cube are located along the earth’s surface and usually measured in meters. The vertical axis represents depth and usually measured in units of time (occasionally - of distance). The cube is divided into vertical cross-sections along the axis of receivers (_inlines_) and across the axis of receivers (_crosslines_, _xlines_). Intersections of inlines and  crosslines make vertical lines (_seismic traces_). [link](https://medium.com/seismic-data-analysis-using-ai/seismic-data-analysis-using-ai-3ce18a18fbb)

![](./img/cube.gif)
An example of seismic cube ([source](http://cge.rosgeo.com/en/services/glubinnaya-3d-migraciya-do-summirovaniya/))

Seismic interpretation is a method of assessing petrophysical features of the subsurface from well-log and seismic data. Petrophysical data such as radioactivity, porosity, acoustic impedance, density, conductivity etc. are being logged at specific well locations and depths. Seismic data is a 3D representation of the entire reservoir area. The goal of seismic interpretation is finding an estimator from seismic data to the sparsely available well-log data so that petrophysical data can be predicted from the seismic data for the entire reservoir volume.

### Data
For demonstration purposes, we use open data from the Netherlands Offshore F3 Block, [link](https://terranubis.com/datainfo/Netherlands-Offshore-F3-Block-Complete). F3 is a block in the Dutch sector of the North Sea. The block is covered by 3D seismic that was acquired to explore for oil and gas in the Upper-Jurassic - Lower-Cretaceous strata.  The characteristics of the 3D seismic survey are the following:
- inline range: 100 through 750 lines, 25 m/line step
- crossline range: 300 through 1250 lines, 25 m/line step
- Z range: 0 though 1848 ms, 4 ms step
- area: 375.31 km^2

Within the survey, only four vertical wells are present. All wells have sonic and gamma ray logs. In this demo, we implement 4-fold crossvalidation training our model on 3 wells and validating on the remaining well.

![](./img/scene.png)

### Method
The model is a 2D-2D transcoder network trained to convert a 2D seismic image into 2D petrophysical image:

![](./img/network.png)

As input, we use vertical 2D seismic slices in the neighbourhood of the 4 wells. We crop 21 x 2 nearest slices along two horizontal inline/crossline axes. Training targets are being constructed as vertical projection of petrophysical data onto corresponding seismic plane. We transform 1D logs into 2D image adding second dimension and expanding it to 20-30 traces. Obviously, these targets cover only small region of a seismic slice, and training is implemented with 2D masked Mean Squared Error (MSE) loss.

An example of data unit:
![](./img/data.png)

### Results

We crossvalidate Gamma log model on the dataset of 168 projections (4 wells x 2 horizontal dimensions x 21 slice in each direction). We minimize masked MSE loss for 150 epochs. The model typically converges after 50 epochs. The Pearson correlation between true and predicted well logs is remarkably high, especially taking into account the limited size of the training data:

|well|correlation|
|:---:|:---:|
|F02-1|0.88|
|F03-2|0.70|
|F03-4|0.82|
|F06-1|0.81|
|**average**|0.80|

![](./img/results.png)

Needless to say that 4 item dataset isn't enough to draw serious conclusions from any ML project. The goal of this recipe is to demonstrate potential of the method with open seismic data. The commercial project this study is based on reaches correlation of ~90% and low MSE using proprietary data with large number of wells of complex geometry and other petrophysical properties.

## Quick Start

##### 0. Sign up at [neu.ro](https://neu.ro)
##### 1. Setup your local machine according to [instructions](https://neu.ro/docs) and log in
```shell
pip install -U neuromation
neuro login
```
##### 2. Run the recipe
```shell
git clone https://github.com/neuromation/ml-recipe-seismic.git
cd ml-recipe-seismic
make setup
make jupyter
```
##### 3. Run notebooks:

```shell
neuro login
make setup
make jupyter
```

See [Help.md](HELP.md) for the detailed Neuro Project Template Reference.

repository: neuro-inc/ml-recipe-seismic

gha_language: Python

gha_license_id: NOASSERTION

repo_name: neuro-inc/ml-recipe-seismic


text:
---
layout: post
title: 'bugfix #221 - java constructor is not called in UIApplicationDelegate implementation'
tags: [fix, native2java]
---
**History** [java constructor is not called in UIApplicationDelegate implementation #221](https://github.com/MobiVM/robovm/issues/221)
**Fix** [PR #222](https://github.com/MobiVM/robovm/pull/222)

UIApplicationDelegate is being created from native side. And it is constructor is not called so all instance members are not initialized. Yep same [#894](https://github.com/robovm/robovm/issues/894). But why?
<!-- more -->
Two reasons:
- constructor callbacks are generated for classes marked with @CustomClass annotation (there is 0% of UIApplicationDelegate has this in code)
- even if it is annotated there is no @Method annotation at default constructor of NSObject so it will be skipped

Fix does:
- adds @Method annotation to NSObject default constructor. But this will require developers to use @CustomClass which is lame and against today tradition not to.
- adds sugar during at compilation level. Compiler will consider any class that implements UIApplicationDelegate as @CustomClass (user has not to) and generate all required callbacks


text:
# dungeon_generator
Example dungeon generator for Goldsmiths MScCGE tools and middleware project.

This project in based on the version, provided by Andy Thomasson: https://github.com/andy-thomason/dungeon_generator

The dungeon is built, using corridors, rooms, intersections and corridor-stairs. Every tile is picked randomly, with weighted coefficients.

The main algorithm, on which I focused is the tile substitution.
As you can see after you randomly place for example 100 tiles, some of the tiles require wall, doorway or substitution with another tile. For example, 4-way intersection with only 2 ways occupied we can substitute it with 2-way tile.

Here’s the screenshot of the version before calling substitution algorithm:
![Alt text](/before.png?raw=true "Before")

After:
![Alt text](/after.png?raw=true "After")

Also, the simple aabb-collision detection algorithm was implemented by me.

At the end the opened connections are being filled with the rooms and locked with the walls from the outside. The number of open entrances is the parameter.

![Alt text](/result.png?raw=true "Result")

repository: NickVeselov/Dungeon-generator

repo_name: NickVeselov/Dungeon-generator


text:
# bitcode-builder
[![Build Status](https://secure.travis-ci.org/indutny/bitcode-builder.svg)](http://travis-ci.org/indutny/bitcode-builder)
[![NPM version](https://badge.fury.io/js/bitcode-builder.svg)](https://badge.fury.io/js/bitcode-builder)

A helper for [`bitcode`][0] module for building the LLVM Intermediate
Representation.

## Usage

```typescript
import { Builder } from 'bitcode-builder';

const b = new Builder();

const i32 = b.i(32);
const sig = b.signature(i32, [ i32, i32 ]);

const fn = sig.defineFunction(sig, [ 'param1', 'param2' ]);

const sum = fn.body.binop('add',
                          fn.getArgument('param1'),
                          fn.getArgument('param2'));
fn.body.ret(sum);

// Pass `fn` to `bitcode` module
```

See [`bitcode`][0] module for compiling the CFG to binary format.

#### LICENSE

This software is licensed under the MIT License.

Copyright Fedor Indutny, 2018.

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.

[0]: https://github.com/indutny/bitcode


text:
---
title: "Creating a Face Swapping Model in 10 Minutes"
date: "2021-01-13T22:10:03.284Z"
description: "Let's re-inplement face swapping in 10 minutes! This post shows a naive solution using a pre-trained CNN and OpenCV."
featuredImage: face_swap/ogp.jpg
tags: ["en", "machine-learning", "python", "cv"]
---

Face swapping is now one of the most popular features of Snapchat and SNOW. In this post, I'd like to share a naive solution for face swapping, using a pre-trained face parsing model and some OpenCV functions.

I'm going to implement face swapping as follows:
1. Parse the face into 19 classes.
2. Swap every part of the face with the counterpart.
3. Fill holes with local average colors.

The code is available at: https://github.com/shionhonda/face-swap.

## Face Parsing
For face parsing, I used [the pre-trained BiSeNet](https://github.com/zllrunning/face-parsing.PyTorch) because it's  accurate and easy to use. This model parses a given face into 19 classes such as left eyebrow, upper lip, and neck.

![](2021-01-13-22-22-53.png)

For this case, I selected 8 classes: left eyebrow, right eyebrow, left eye, right eye, nose, upper lip, mouth, and lower lip. These were used to generate 6 types of masks:
- left eyebrow mask
- right eyebrow mask
- left eye mask
- right eye mask
- nose mask
- mouth mask (including lips)

## Face swapping
Next, I swapped for each pair of parts. Since each part is in a different position in each picture, they are needed to be aligned. For example, the two right eyebrow masks below have slightly different positions.

![](2021-01-13-22-51-22.png)

This difference should be adjusted for the fine result, so I computed the shift in centroids with **OpenCV**'s `moments` function.

```python
def calc_shift(m0, m1):
    mu = cv2.moments(m0, True)
    x0, y0 = int(mu["m01"]/mu["m00"]), int(mu["m10"]/mu["m00"])

    mu = cv2.moments(m1, True)
    x1, y1 = int(mu["m01"]/mu["m00"]), int(mu["m10"]/mu["m00"])
    return (x0-x1, y0-y1)
```

Then I implemented the swapping part like:

```python
def swap_parts(i0, i1, m0, m1, labels):
    m0 = create_mask(m0, labels)
    m1 = create_mask(m1, labels)
    i,j = calc_shift(m0, m1)
    l = i0.shape[0]
    h0 = i0 * m0.reshape((l,l,1)) # forground
    y = np.zeros((l,l,3))

    # cancel the shift in centroids
    if i>=0 and j>= 0:
        y[:l-i, :l-j] += h0[i:, j:]
    elif i>=0 and j<0:
        y[:l-i, -j:] += h0[i:, :l+j]
    elif i<0 and j>=0:
        y[-i:, :l-j] += h0[:l+i, j:]
    else:
        y[-i:, -j:] += h0[:l+i, :l+j]

    h1 = i1 * (1-m1).reshape((l,l,1)) # background
    y += h1 * (y==0)

    return y
```

However, this left some holes (specifically, `m1 \ m0`, using the notation of set operation) in the generated image.

![](2021-01-13-23-05-27.png)

Note: Throughout this experiment, I used randomly-sampled photos from https://thispersondoesnotexist.com/.

## Fill in the Holes
As a naive approach, I used the average color of the boundary region to fill in the holes. In computer vision, this boundary region is called **morphological gradient**, and it is computed by OpenCV's `morphologyEx` function.

```python
def swap_parts(i0, i1, m0, m1, labels):
    ...

    h1 = i1 * (1-m1).reshape((l,l,1)) # background
    b = cv2.morphologyEx(m1.astype('uint8'), cv2.MORPH_GRADIENT, np.ones((5,5)).astype('uint8') ) # boundary region
    c = (np.sum(i1*b.reshape((l,l,1)), axis=(0,1)) / np.sum(b)).astype(int) # average color of the coundary
    # fill color in the hole
    h1 += c * m1.reshape((l,l,1))
    y += h1 * (y==0)

    return y
```

Finally, I got the following result.

![](result.jpg)

I have to admit that the result looks weird, but it means that this app is safe as it can't be used for DeepFake😇

## References
[1] [OpenCV: Image Moments](https://docs.opencv.org/3.4/d0/d49/tutorial_moments.html)
[2] [モルフォロジー変換 — OpenCV-Python Tutorials 1 documentation](http://labs.eecs.tottori-u.ac.jp/sd/Member/oyamada/OpenCV/html/py_tutorials/py_imgproc/py_morphological_ops/py_morphological_ops.html)
[3] Changqian Yu, Jingbo Wang, Chao Peng, Changxin Gao, Gang Yu, Nong Sang. "[BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation](https://arxiv.org/abs/1808.00897)". *ECCV*. 2018.

repository: shionhonda/hippocampus-garden

gha_language: JavaScript

repo_name: shionhonda/hippocampus-garden


text:
Nice event stream wrapper for the byzantine TfL Bus Departures API.

```
npm install tfl-busboy
```

## The what

A bunch of methods that call the API and return nested event stream objects, such as:

```javascript
busboy.around({lat: 51.371422, lng: -0.227344}, 10);
// eventually: {'2232': { stopPointName: 'North Cheam / Queen Victoria', ... }}
```

The objects in the stream are a map of Stop IDs to `Stop` objects, which represent a bus stop:

```javascript
var Stop = adt.newtype('Stop', {
  stopPointName: adt.only(String, undefined),
  stopId: adt.only(String, undefined),
  stopCode1: adt.only(String, undefined),
  stopCode2: adt.only(String, undefined),
  stopPointType: adt.only(String, undefined),
  towards: adt.only(String, undefined),
  bearing: onlyInt,
  stopPointIndicator: adt.only(String, undefined),
  stopPointState: onlyInt,
  latitude: onlyFloat,
  longitude: onlyFloat,
  // predictions: Map<PredictionID, Prediction>
  // messages: Map<MessageID, FlexibleMessage>
});
```

A `Prediction` is an object representing a bus on the way. Yes, there are keys duplicated from `Stop`. Deal with it.

```javascript
var Prediction = adt.newtype('Prediction', {
  stopPointName: adt.only(String, undefined),
  stopId: adt.only(String, undefined),
  stopCode1: adt.only(String, undefined),
  stopCode2: adt.only(String, undefined),
  stopPointType: adt.only(String, undefined),
  towards: adt.only(String, undefined),
  bearing: onlyInt,
  stopPointIndicator: adt.only(String, undefined),
  stopPointState: onlyInt,
  latitude: onlyFloat,
  longitude: onlyFloat,
  visitNumber: onlyInt,
  lineID: adt.only(String),
  lineName: adt.only(String),
  directionId: onlyInt,
  destinationText: adt.only(String),
  destinationName: adt.only(String),
  vehicleId: onlyInt,
  tripId: onlyInt,
  registrationNumber: adt.only(String),
  estimatedTime: onlyDate,
  expireTime: onlyDate
});
```

A `FlexibleMessage` is a generic service message pertaining to a `Stop`.

```javascript
var FlexibleMessage = adt.newtype('FlexibleMessage', {
  stopPointName: adt.only(String, undefined),
  stopId: adt.only(String, undefined),
  stopCode1: adt.only(String, undefined),
  stopCode2: adt.only(String, undefined),
  stopPointType: adt.only(String, undefined),
  towards: adt.only(String, undefined),
  bearing: onlyInt,
  stopPointIndicator: adt.only(String, undefined),
  stopPointState: onlyInt,
  latitude: onlyFloat,
  longitude: onlyFloat,
  messageUUID: adt.only(String),
  messageType: onlyInt,
  messagePriority: onlyInt,
  messageText: adt.only(String),
  startTime: onlyDate,
  expireTime: onlyDate
});
```

For more details of the keys, have a gander at the [TfL documentation](http://www.tfl.gov.uk/cdn/static/cms/documents/tfl-live-bus-and-river-bus-arrivals-api-documentation.pdf) (inb4 wtf pdf: i know, right?)

## The why

The TfL Live Bus API is awful. There is a single call that returns newline-separated JSON arrays. The arrays represent one of 5 different data types, each with different keys. The keys aren't in the returned data, you have to match up the keys you asked for, the keys in each type and the order in the documentation. There's a one-to-many relationship between `Stop` and `Prediction` and `Stop` and `FlexibleMessage`, but `Prediciton` and `FlexibleMessage` come back joined with their `Stop`. If you don't ask for any of the keys that a type uniquely has, that type gets filtered out, apart from `Stop`, which only comes back if you send `StopAlso=true`, even if you ask for `StopID`.

Argh.

## The API

### busboy.around(latlng, radius)()

Queries for stops within `radius` (in metres) of `latlng` (object containing `lat` and `lng`).

### Filter methods `busboy[key](value)`

`StopPointName, StopID, StopCode1, StopCode2, StopPointType, Towards, Bearing, StopPointState, VisitNumber, LineID, LineName, DirectionID, DestinationText, DestinationName, VehicleID, TripID, RegistrationNumber, StopPointIndicator, MessageType, MessagePriority`

Filters the response to stops, predictions or messages with a `key` of `value`. See Section 4.1.1 of the [TfL documentation](http://www.tfl.gov.uk/cdn/static/cms/documents/tfl-live-bus-and-river-bus-arrivals-api-documentation.pdf).

### busboy.query(queryObject)

Send an API request with the given query. Use one of the higher-level methods.

### busboy.withOptions(options)

Lets you override everything. `options` is passed to [`url.format`](http://nodejs.org/api/url.html#url_url_format_urlobj).

## Licence

MIT. Data provided by Transport for London. You must register at the [TfL Developer Portal](http://www.tfl.gov.uk/developers) if you want to use the official API.

repository: apaleslimghost/node-busboy

repo_name: apaleslimghost/node-busboy


text:
# Zen: the choices we made

## Why use git repo to publish components?

Q: normally a component platform will build it's own center service,
why **ticat** just use git repos?

The reason is to build a better community.

### User-centered VS official-centered

Most platforms are official-centered:
* The authority publish componets.
* Users pull their needed componets.
In this model it's hard to publish user-owned componets.

Some platform provide mirror tools and allow users to establish their center service.
But notice, the tools and maybe some access setting still under authority's control.

With git repo as a publish service,
**ticat** try to build a user-centered model,
Users can decide what to add to local disk,
And an important thing: anyone could become a publisher without any cost:
* Fork and edit the repo.
* Use git/github's access setting.

With this loose-auth model, we hope to constructe an active and layered ecosystem.

The layered community means, a developer don't need to be pro to contribute (to a specific group),
he could write crappy code at the very beginning,
but still can be a publisher sharing his work and assemble with all the pro modules,
once he have some good pieces, adapting his work into a higher-level publisher is very easy.

With **ticat**, the group can provide a easy-to-use environment for developer to get to know the project
(by many runnable flows), and a smooth path from beginner to core coding.

By that, we recommend "better than now" rule,
his work no need to be good, just need to be better (than now).

In this way, the project could partly improve,
and the community can gradually evolve.


text:
---
title: "How I Built a Simple Web Scraper"
date: "2020-08-23"
featuredImage: ./blog-images/building-a-web-scraper/sdg_preview.png
previewPic: "../../content/blog/blog-images/building-a-web-scraper/sdg_preview.png"
---

For my most recent project, [Spanish Diminutive Generator](https://github.com/WordsPerMinute/spanish-diminutive-generator), I tried to find an appropriate API. Although, my vision was bigger than my budget. Sometimes in development life, you might have to get scrappy and start web scraping. Since this is a personal project, I felt comfortable with this route because I won't be driving an unfair amount of traffic towards the source.

How does the app work? Input a word and get its Spanish diminutive, along with a photo.
```
    casa => casita
    café => cafecito
    pantelón => panteloncito

```

![](https://raw.githubusercontent.com/WordsPerMinute/spanish-diminutive-generator/master/overview.gif)

For the scope of this post, the need for the scraper isn't related to the images, but rather the words themselves.

In order to properly generate the diminutive form of the word entered, the algorithm needs to know the word's gender. In Spanish, there are two genders: masculine and feminine (whereas some languages, like German, has a neuter gender for a total of 3 genders). Usually, you can tell the gender of a Spanish word by its ending. Does it end in 'a'? It's feminine. What about 'o'? Masculine.

However, some words have the same ending letter but different genders. For example, 'lapiz' (pencil) is masculine, while 'nariz' (nose) is feminine. This means that my algorithm should turn 'lapiz' into 'lapicito' and 'nariz' into 'naricita'.

How will the algorithm know a word's gender? Again, no appropriate API was within the budget.  I knew this app's bandwidth wouldn't cause any problems for the recipient (otherwise scraping might be less than honorable), so it felt okay to implement this solution.

This is where I decided to enlist the help of my favorite dictionary, [www.wordreference.com](https://www.wordreference.com/) and a library called cheerio. After reading the basics via [Scraping data in 3 minutes with Javascript](https://medium.com/data-scraper-tips-tricks/scraping-data-with-javascript-in-3-minutes-8a7cf8275b31) and [cheerio](https://cheerio.js.org/)-[repo](https://github.com/cheeriojs/cheerio), I was ready to go.

First, I pick a word and head to 'https://www.wordreference.com/definicion/WORD-GOES-HERE', which makes it easy to string interpolate later. Below, the images show the exact CSS class I need (highlighted in green) to get the element that tells me the words gender. Yellow is also targeted by this CSS class, but I'm using '.first()' to isolate it. If the text content 'nm' (nombre masculino), the noun is male. If it's 'nf' (nombre feminino), the noun is female.

![lapiz definition](./blog-images/building-a-web-scraper/lapiz.png)

![nariz definition](./blog-images/building-a-web-scraper/nariz.png)

```

    // import cheerio
    const cheerio = require('cheerio');

    const response = await fetch(`https://www.wordreference.com/definicion/${word}`)
        let htmlText = await response.text();

        // this turns page's text into html you can run queries on
        let $ = cheerio.load(htmlText);

        // targets the aforementioned CSS class, it's value should be saved as 'nm' or 'nf'
        let genderInfo = $(.POS2').first().text()

```

The function eventually looks at index 1 of the string I'm getting back ('nm' gives me 'm', and 'nf' gives me 'f'). At this point, the scraper is mostly working BUT there's a problem. The  scraper is telling me the word 'amiga' is masculine. How could that be!?

![presidente definition](./blog-images/building-a-web-scraper/presidente.png)

As seen above, if the word can be BOTH masculine and feminine, such as 'el presidente/la presidente' or 'el amigo/la amiga', that same class selector I used before is returning a 6 character string 'nm, nf' instead of the 2 character I was expecting. What's one possible way to handle this?

```

    if (genderInfo.length > 2) {
        switch(word[word.length - 1]) {
            case 'o':
                break;
            case 'e':
                break;
            default:
                isFeminine = true;
        }
    } else {
        if ($('strong+ .POS2').text()[1] === 'f') {isFeminine = true}
    }

```

This works based on two important pieces of information - the actual word the user is passing, and the length of the string we scrape.

In if statement (the word has multiple gender possibilities), all we need to do is check the end of the word being passed. If the user passed 'amigo', they are intending for the masculine word, so we don't set isFeminine to true. If the user passed 'amiga', then neither of the first two cases would trigger, and so isFeminine would be set to true. (The generator currently doesn't accept definite articles, such as with 'el presidente' or 'la presidente', preceding a word - it would simply default to masculine until this is fixed.) If it's 2 characters, we know it's ONLY a masculine or feminine word, and we can check index 1 of the string in order to know which.

This scraper function allows me to verify the gender of a word a users passes before throwing it into a much larger conversion algorithm.

That's the basics of a web scraper!

[return home](https://coreyhodge.net)

repository: WordsPerMinute/gatsby-personal-site

repo_name: WordsPerMinute/gatsby-personal-site


text:
# AWS Lambda Function with SQS queue event source
Permissions to poll from queue included
```
[
    "sqs:DeleteMessage",
    "sqs:GetQueueAttributes",
    "sqs:ReceiveMessage"
]
```


text:
# Marketing Resources
This file contains explanation for the app's marketing resources used on the App Store.
The resources are split in four different folders.

## Folders

### [Pngs](Pngs)
This folder contains the app's screenshots used on the App Store.

### [Psds](Psds)
This folder contains the _.psd_ files used to create the files contained in the _Pngs_ folder.

### [Screenshots](Screenshots)
This folder contains the actual in-app screenshots taken on an iOS device or simulator.

## Screenshot scenarios
Following scenarios are represented in the screenshots.
### Take notes
A simple notebook page with some notes.
### Add text and image
A notebook page with an added image and a text view that is currently being edited.
### Dark Mode
Shows the app's dark mode support.
### Export
Shows the exporting capabilities of the app.
### Search
Shows an active notebook search.
### Folders
Shows notebooks organized in a folder.
### Share
Shows the support for iCloud synching on iPhone and iPad.
### Page types
Shows the different page types that can be added.

## File Names
File names contain only lowercase letters and numbers, words are separated by underscores.
File names are constructed as follows:
<_screenshot scenario_>\_<_device type_>\_<_screen size in inches_>.<_file extension_> \
e.g. _search_iphone_6.5.png_.

## Contributions
When contributing keep in mind that the folders ar interdependent as follows:
**_screenshots_ -> _psds_ -> _pngs_**.\
This means that a change in the _screenshots_ directory **must** be reflected by a change in the _psds_ and _pngs_ directory because the screenshot was used in the _.psd_ file which was used to create the final _.png_ file.

repository: Davaff/OpenNotebooks

repo_name: Davaff/OpenNotebooks


text:
# @artsy/renovate-config

This repo contains the shared configuration for Artsy's [renovate](https://renovatebot.com) setup.

## Usage

Add a `renovate.json` file to the root of your project. Use the `extends` key to uses one of our presets.

Your `renovate.json` file might look something like this

```json
{
  "extends": ["@artsy", "@artsy:example"]
}
```

Where `@artsy` is the `default` renovate config, and `@artsy:example` is the `example` renovate config (which doesn't actually exist).

The renovate config presets are stored in this projects package.json.

repository: mzikherman/renovate-config

repo_name: mzikherman/renovate-config


text:
pdje - (python) django email configuration app
===

Postfix, dovecot and opendkim support configuration lookups through SQL databases,
and Django models are a very simple configurator of SQL tables - with the built-in
admin features too!

This app is motivated in part by the Snowden revelations and the
["NSA"-proof email](http://sealedabstract.com/code/nsa-proof-your-e-mail-in-2-hours/)
[via](https://prism-break.org/en/categories/gnu-linux/#mail-servers)
blog post.

Quick-start
---
1. Add "pydje" to your INSTALLED_APPS setting
2. Run `./manage.py migrate` to update the databases
3. Access [the admin panel](http://<IP_ADDRESS>:8000/admin/)
4. Setup a user and add at least one alias for a domain


text:
## TAG Teleconference
##### 19 December 2018

Present: Dan, Travis, Peter, David
Chair: Dan
Scribe: Dan(ish)
Regrets: Hadley, Lukasz

--

Agenda:

* [transferable streams](https://github.com/w3ctag/design-reviews/issues/332) @torgo
* [IntersectionObserver V2](https://github.com/w3ctag/design-reviews/issues/328) @slightlyoff @dbaron
* [IndexedDB Transaction Explicit Commit API](https://github.com/w3ctag/design-reviews/issues/316) @cynthia @kenchris
* [Review MathML](https://github.com/w3ctag/design-reviews/issues/313) @cynthia @slightlyoff @dbaron
* [hrefTranslate attribute](https://github.com/w3ctag/design-reviews/issues/301) @torgo @hadleybeeman
* [User Activation API](https://github.com/w3ctag/design-reviews/issues/300) @dbaron @hadleybeeman
* [OffscreenCanvas new commit() and DedicatedWorker.requestAnimationFrame](https://github.com/w3ctag/design-reviews/issues/288)  @dbaron @travisleithead
* [TextEncoderStream and TextDecoderStream](https://github.com/w3ctag/design-reviews/issues/282) @cynthia @kenchris @travisleithead
* [Background fetch](https://github.com/w3ctag/design-reviews/issues/279) @slightlyoff @ @travisleithead
* [HTML General Review: Web Sockets HTML](https://github.com/w3ctag/design-reviews/issues/268) @slightlyoff @ylafon
* [Vehicle Information Service Specification (VISS) CR pending external feedback](https://github.com/w3ctag/design-reviews/issues/234) @cynthia @torgo @hadleybeeman
* [Media Capabilities](https://github.com/w3ctag/design-reviews/issues/218) @cynthia @travisleithead @plinss
* [<link> rel="modulepreload"](https://github.com/w3ctag/design-reviews/issues/213) @slightlyoff14
* [Intersection Observer review](https://github.com/w3ctag/design-reviews/issues/197) @dbaron
* [Privacy Mode](https://github.com/w3ctag/design-reviews/issues/101) @lknik
* [Task Scheduling](https://github.com/w3ctag/design-reviews/issues/72) @travisleithead

---

### [OffscreenCanvas new commit() and DedicatedWorker.requestAnimationFrame](https://github.com/w3ctag/design-reviews/issues/288)  @dbaron @travisleithead

Travis: porting games over to web workers - e.g. through web assembly.

David: worklets are designed for code that's happening on the UI thread or some other existing thread - isolation but not threading...

Travis: holding pattern -

### [transferable streams](https://github.com/w3ctag/design-reviews/issues/332) @torgo

Dan: work going on in whatwg and they asked for feedback on twitter

David: some of it is developer ergonomics

### [User Activation API](https://github.com/w3ctag/design-reviews/issues/300) @dbaron @hadleybeeman

David: [left recent comment] we can see how they respond to that. one worry is just that - if uses for this are people writing chrome specific stuff about permissions model, not so great. People shouldn't hard code how chrome's permission model into their web site. There is a way to get the permission with one click in chrome and one click in firefox but the reaity is it takes 2 clicks in firefox because of how the site asks for permission. So there will be a browser prompt each time. Chrome has user interaction - so sites have forced interaction even when they don't need it.  Real solution should be to have the permission API answer questions about - whether a permission request will be denied.

Travis: right now it's just 3 values, denied,allowed,prompt

David: there's the permissions API spec - a piece that people have agreed on - and work will happen in the new year

Travis: the proof point is - developers working around that lack of state - and providing the state should be something we [web platorm] do.

Dan: Jo from Samsung did a blog post: https://medium.com/samsung-internet-dev/a-crisis-of-permissions-80cf3b2c802e

Dan: still waiting for a workshop report- I will bug Sam from W3C about this.

Dan: David I think the issue you bring up here is important especially considering current events regarding browser engines.

Travis: maybe start a new issue?

[decided just to keep tracking it on issue 300]

### [Task Scheduling](https://github.com/w3ctag/design-reviews/issues/72) @travisleithead

Travis: timing ... intersection observer ...

[david recently suggested writing tests]

David: Intersection observer issue led me to that one.

Travis: happy to participate in some time to collaborate on writing tests... Will reach out on the 14th.

### [Intersection Observer review](https://github.com/w3ctag/design-reviews/issues/197) @dbaron

David: Two remaining issues - one falls back to the task scheduling issue (72). The other one was Peter's concern about string based APIs.

Peter: i think they fixed the string based APIs issue...

### call time discussion

[agreed to change call time for the 8th to 21:00 GMT on Tuesday the 8th]

branch_name: refs/heads/gh-pages

gha_language: HTML


text:
# Perlclip on mobile

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

> James Bach's Perlclip on mobile

## Demo <https://perclip-b465a.firebaseapp.com/#/>

I came to know [Perlclip](http://www.satisfice.com/tools.shtml) from Rapid Sofware Testing course. I find the tool is very useful especially its `counterstring` feature. Below is a quote from Perlclip help about counterstring:

```
counterstring {num} [{char}]:

Produces a special string of length {num} that counts its own characters.

"counterstring 10" would produce "*3*5*7*10*" which is a ten character long string,
such that each asterisk is at a position in the string equal to the number that
precedes it. This is useful for pasting into fields that cut off text, so that you
can tell how many characters were actually pasted.

You can specify a separator other than asterisk. "counterstring 15 A" would produce
"A3A5A7A9A12A15A"
```

I miss this feature when testing a mobile app. That's why I'm building a progressive web app for it. Pull requests are welcome! :)

## Build Setup

``` bash
# install dependencies
npm install

# serve with hot reload at localhost:8080
npm run dev

# build for production with minification
npm run build

# build for production and view the bundle analyzer report
npm run build --report

# run unit tests
npm run unit

# run e2e tests
npm run e2e

# run all tests
npm test
```

For detailed explanation on how things work, checkout the [guide](http://vuejs-templates.github.io/webpack/) and [docs for vue-loader](http://vuejs.github.io/vue-loader).

## Credits

- [Test Tools - James Bach - Sastisfice Inc.](http://www.satisfice.com/tools.shtml) for such a great idea of test tools
- Charles Bochet for teaching me how to make progressive web application in his [A progressive Web application with Vue JS, Webpack & Material Design](https://blog.sicara.com/a-progressive-web-application-with-vue-js-webpack-material-design-part-1-c243e2e6e402)

repository: juacompe/perlclip

repo_name: juacompe/perlclip


text:
# flask-graphql
A flask graphQL proof of concept project

```
python3 -m venv venv
source venv/bin/activate

pip install -r requirements.txt

export FLASK_APP=flaskr
export FLASK_ENV=development

flask run
```

repository: ammurdoch/flask-graphql

repo_name: ammurdoch/flask-graphql


text:
---
title: scm-branchwp-plugin 1.0
date: 2012-08-26T14:23:42+00:00
author: Sebastian Sdorra
slug: /plugins/scm-branchwp-plugin-1-0/
categories:
  - plugins
  - authorization-plugins

---
The [scm-branchwp-plugin](https://github.com/scm-manager/scm-branchwp-plugin)  adds branch write protection for repositories to SCM-Manager.

**Wiki:** <a href="https://bitbucket.org/sdorra/scm-manager/wiki/branchwp-plugin" target="_blank" rel="noopener noreferrer">https://bitbucket.org/sdorra/scm-manager/wiki/branchwp-plugin </a>

repository: dhuchthausen/website

gha_license_id: MIT

repo_name: dhuchthausen/website


text:
# Lens

A video chat application(like Zoom) built with NodeJS, React, WebRTC and socket.io

By [Oluwakeye John](https://github.com/oluwakeye-john)

Demo

**_The Backend is required for the code to work_**

Backend is at https://github.com/oluwakeye-john/Lens-Api

## Feature

This project is a video chat application that establishes video sharing between two clients.

## Built With

- React
- Socket IO
- Node JS
- Web RTC
- Styled Components

## Install

- Clone this repo
- Change the REACT_API_URL_API in the `.env.local` to whatever url your backend is running on
- run the following

```shell
    npm install
    npm start
```

Make sure the backend is running

## Deployment

When deploying, do not forget to add REACT_APP_API_URL to the enviromental variables of your deployment platform.

## License

This project is licensed under the MIT License - see the [LICENSE.md](https://github.com/oluwakeye-john/Lens-Frontend/blob/master/LICENSE) file for details

repository: Aptimyze/Lens-Frontend

repo_name: Aptimyze/Lens-Frontend


text:
[![PyPI version](https://badge.fury.io/py/raffaello.svg)](https://badge.fury.io/py/raffaello)
[![Build Status](https://travis-ci.org/clobrano/raffaello.svg?branch=master)](https://travis-ci.org/clobrano/raffaello)
[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/clobrano/5)

Raffaello - output colorizer
============================

Raffaello colorizes the output stream of any command-line tool (e.g. gcc/g++, cmake, dmesg, syslog and custom), making it easier to read.

## Usage

The raffaello's command line interface let you use two call modes: **pipes** and **command**.

In pipe mode you call raffaello like:

    <output stream source> | raffaello [options]

In command mode raffaello will call your stream source in your behalf

    raffaello [options] -c <output stream source>

To highlight the output stream, Raffaello has **2 color modes** and **2 styles modes**:

Color modes:

- **8 colors** mode let you use the following names: *black, red, green, yellow, blue, magenta, cyan, light_gray*. **NEW** Starting from version 3.0.3 Raffaello introduces a *blind* color: *lines matching the pattern with color "blind" will be REMOVED from the stream*. This will improve readability of dense stream output.

- **256 colors** mode let you use other 248 colors and choose between foreground or background colors (you can mix 8 colors mode names with 256 color mode names):

Color styles:

- Foreground color names are in the form `colorNUM`. E.g. foreground red is *color001*
- Background color names are in the form `bgcolorNUM`. E.g. background red is *bgcolor001*

With the styles you can blend colors in **bold** and **underlined**

- foreground red bold is *color001_bold*
- foreground red underlined is *color001_underlined*

Call `raffaello -l` to see the complete list of available colors.

### Full interface description

```
Usage: raffaello (-p PRESET | -r REQUEST | -f FILE | -l) [options]

    -p PRESET, --preset=PRESET              Prebuilt config files for coloring known output streams (gcc/g++, cmake, dmesg, gcc/g++, ModemManager, logcat...)
    -r REQUEST --request=REQUEST            The requested text/color mapping string. Multipe requests are separated by a space. Regular expression are supported. E.g. "error=>red [Ww]arning=>yellow_bold".
    -f FILE --file=FILE                     Path to the custom text=>color configuration file.
    -c COMMAND --command=COMMAND            Instead of using raffaello with pipes, set the command-line tool to be executed by raffaello directly. E.g. -c "dmesg -w".
    -m, --match-only                        Print only the lines that match against some defined pattern.
    -d DELIMITER --delimiter=DELIMITER      If you don't like "=>" as delimiter between text and color, use this flag to change it. E.g. -d & [default: =>]
    -l, --list                              List all the available colors and presets
    -v --verbose                            Enable debug logging
```

**NEWS**
- version 3.0.3 --match-only flag Print only the lines that match against any defined pattern.

## Examples

The simpler usage is using the `request` flag. The `request` flag requires a string in the form "text=>color anothertext=>anothercolor", where text can be a constant string or a [Regular expression](https://docs.python.org/2/library/re.html), while color is the name of the color to use (see [Usage](#Usage) section)

* Simple constant text highlight

        $ ifconfig eno1 | raffaello --request="collisions=>blue"

![example001](./examples/raffaello001.png)

* Highlight of multiple texts. Here you can see that spaces in the "text part" are not allowed. Use \s instead.

        $ ifconfig eno1 | raffaello --request="RX\spackets=>green TX\spackets=>red"

![example002](./examples/raffaello002.png)

* Highlight with regular expressions

        $ ifconfig eno1 | raffaello --request="\d+\.\d+\.\d+\.\d+=>green_bold"

![example003](./examples/raffaello003.png)

For more complex color mapping you can write a file with a line for each *text=>color* entry, like the following

    collisions=>blue
    RX\spackets=>green
    TX\spackets=>red
    \d+\.\d+\.\d+\.\d+=>green_bold

save the file and provide it to raffaello using its fullpath

    $ ifconfig eno1 | raffaello --file=$HOME/colorfile

![example004](./examples/raffaello004.png)

Color files can be reused in other color files using the `include` directive followed by the fullpath to the file.

Using fullpath is annoying, tough, so Raffaello has a special path under $HOME/.raffaello. All the colorfiles inside this folder can be passed using simply their filename, without the path.

    # include custom colorfile in $HOME/.raffaello
    include some_custom_colorfile

    # include custom color outside $HOME/.raffaello
    include $HOME/path/to/some_other_custom_color

    collisions=>blue
    RX\spackets=>green
    TX\spackets=>red
    \d+\.\d+\.\d+\.\d+=>green_bold

Raffaello provides some built-in colorfiles, called **presets**, for known tools like cmake, gcc/g++, dmesg, etc.
The presets can be used alone using `--preset` flag or even included in custom colorfile in order to extend their colormaps.

    # Include a preset colorfile
    include errors

    # include custom colorfile in $HOME/.raffaello
    include some_custom_colorfile

    # include custom color outside $HOME/.raffaello
    include $HOME/path/to/some_other_custom_color

    collisions=>blue
    RX\spackets=>green
    TX\spackets=>red
    \d+\.\d+\.\d+\.\d+=>green_bold

For a full list of presets, call `raffaello --list`.

## Raffaello is a python module

Raffaello can be used as a python module inside other source codes

```python
from raffaello import Raffaello, Commission

request = '''
error=>red
warning=>yellow_bold
bluish\stext=>color026
'''

c = Commission(request)
r = Raffaello(c.commission)

print(r.paint('Sample message with error, warning and a bluish text.'))
```

## Install

Install from source using setuptools. Just type the following command

    # python setup.py install

Install from [PyPI - the Python Package Index](https://pypi.python.org/pypi)

    # pip install raffaello

## Dependencies

* `docopt` language for description of command-line interfaces

repository: clobrano/raffaello

repo_name: clobrano/raffaello


text:
----------

![qcu](https://github.com/gopala-kr/Quantum-Dots/blob/master/45-Verticals/verta/zmfa/qcu.png)

----------
![qc_roadmap](https://github.com/gopala-kr/Quantum-Dots/blob/master/M1-Quantum-UseCase-Analysis/qc/qc_roadmap.png)

--------
![gc_skills](https://github.com/gopala-kr/Quantum-Dots/blob/master/23-Future-of-ET/etres/zd/gc_skills.png)

-------------
![qc41](https://github.com/gopala-kr/Quantum-Dots/blob/master/M1-Quantum-UseCase-Analysis/qc/qc41.png)

--------
![qc%40scale](https://github.com/gopala-kr/Quantum-Dots/blob/master/M1-Quantum-UseCase-Analysis/qc/qc%40scale.png)

----------
![qc42](https://github.com/gopala-kr/Quantum-Dots/blob/master/M1-Quantum-UseCase-Analysis/qc/qc42.png)

-------------------
![qc_hw](https://github.com/gopala-kr/Quantum-Dots/blob/master/M1-Quantum-UseCase-Analysis/qc/qc_hw.png)

--------------
![q2b](https://github.com/gopala-kr/Quantum-Dots/blob/master/M1-Quantum-UseCase-Analysis/qc/q2b.png)

----------------------
-----------------
Quantum simulators will enable the quantum approach to computation to advance faster than pure quantum hardware and pure quantum algorithms are currently advancing
Simulate complex chemical bonds and predict the structures of new drugs, semiconductors, and efficient catalysts.
Solve materials science problems (e.g. next-gen materials)

Quantum computers can be used to simulate other quantum systems, such as complex molecules, to predict the outcome of chemical processes. Simulating complex quantum phenomena could be one of the most important applications of quantum computing.
A key envisioned use is simulating molecular properties. In the long run, this can lead to advances in materials improvement and drug discovery. In quantum chemistry, quantum simulators could be used to simulate protein folding (misfolded proteins can cause diseases like Alzheimer’s and Parkinson’s).

Quantum chemistry attempts to understand the complicated bonds and reactions of molecules with the help of quantum mechanics. Many details of chemical processes cannot be simulated even with the largest and fastest supercomputers. By modeling these processes with the help of quantum computers, scientists expect a better understanding of chemical bonds and reactions to apply to drug discovery, materials science and medicine.
Characteristics

Quantum computing has the potential to help design new materials and industrial processes by precisely predicting the behavior of molecules, or even discovering new molecules. This could lead to the design of more efficient electric car batteries, new drug discovery, better artificial fertilizer production, carbon capture for air pollution, among so many other things. Quantum algorithms are the tools that tell quantum computers what to do; Trotter-type algorithms, for example, are used for molecular simulation or comparison, however their susceptibility to noise means that these applications won’t be practical for many years. In the meantime, the performances of classical algorithms are being enhanced by creating new, quantum-inspired algorithms.

Quantum-inspired molecular comparison refers to the use of structural molecular comparison algorithms that can be implemented and run on conventional computers, whose design is inspired by concepts from quantum information processing. Molecular comparison is a crucial part of early-phase drug design and discovery that involves intensive computational methods to review molecule matches and predict the positive effects of a therapy or drug while reducing negative side effects.
Characteristics

Quantum-inspired methods use parallelization and problem-reformulation in algorithms and hardware
Enhance classical computing using quantum-inspired algorithms (not fully-quantum).
Perform graph similarity; compare two or more graphs to detect common patterns (e.g. find shared traits in molecules).

Quantum-inspired algorithms will enable the quantum approach to computation to advance faster than pure quantum hardware and pure quantum algorithms are currently advancing.
Solve real life problems faster than classical algorithms. Potential to analyze larger-scale molecules more quickly and cost effectively.
Predict the positive effects of a therapy or drug while reducing negative side effects.

Today, it takes pharmaceutical companies at least 10 years and often billions of dollars to discover a new drug and bring it to market. Improving the front end of the process with quantum computing has the potential to  dramatically cut costs and time to market, repurpose pre-approved drugs more easily for new applications, and empower computational chemists to make new discoveries faster that could lead to cures for a range of diseases. Furthermore, the quantum simulation of chemical processes could in the future help solve problems in chemistry and thus, for example, give new impulses for materials science, medicine, and industrial chemistry.

-------------------
R&D FOR DRUG DISCOVERY

IBM has partnered with 15 universities in Africa, and will use IBM Q to research drug discovery based on Africa’s genetic diversity that could lead to new treatments for diseases like HIV or TB.

https://techcrunch.com/2019/06/12/ibm-brings-its-quantum-computer-program-to-16-african-universities/

-----------------------------------
NEW MATERIALS DISCOVERY

One of the most promising uses of quantum computing is the simulation and discovery of the properties of new materials and active products (for chemistry and pharmacy), through the simulation of atomic interactions. Projects based around this notion are in progress at Dow Chemicals and at Airbus.

https://corporate.dow.com/en-us/news/press-releases/dow-and-1qbit-announce-collaboration-agreement-on-quantum-computing

-------------------------

DRUG DISCOVERY AT QU&CO

Qu&Co is a Dutch-based quantum consulting firm which offers quantum-computational chemistry services to accurately simulate electron-dynamics on a large scale, for the discovery of new drugs and new chemicals and materials.

https://quandco.com/

---------------------------

HIGH-PERFORMANCE BATTERIES AT VOLKSWAGEN

Volkswagen has two in-house data labs for quantum computing in San Francisco and Munich. Volkswagen has also partnered with Google to explore structures for new materials, especially high-performance batteries for electric vehicles.

https://www.volkswagenag.com/en/news/2017/11/quantum-computing.html

-----------------------------

BATTERY CELL RESEARCH AT DAIMLER

Daimler, in partnership with IBM, is investigating quantum chemistry calculations for new battery technology. Daimler is also working with Google to create new materials for quantum technology and the development of new battery cells.

https://www.daimler.com/magazine/technology-innovation/quantum-computers-future-daimler-google-ibm-technology.html?r=blog

-----------------------------
SUSTAINABLE FERTILIZERS

Current artificial fertilizers are based on ammonia, made via the Haber process. They use high temperatures and pressures and are energy-intensive. Quantum computing could help scientists understand the Haber process at the molecular level, and start-up Rigetti points to its value in making fertilizers.

https://supplychainanalysis.igd.com/news/news-article/t/quantum-computers-a-supply-chain-quantum-leap/i/19846

-------------------------

R&D AT BIOGEN

As a leading biotech company, Biogen is seeking to advance the development of new drugs for neurological and neurodegenerative diseases. Biogen has teamed up with Accenture Labs and 1QBit, a quantum software startup, to speed up the discovery of new drugs.

-----------------

R&D AT AMGEN

Amgen Inc., a biopharmaceutical company, would be naturally interested in using quantum computers for molecular simulations. IBM has recently shown the potential of quantum-based computational chemistry with the record-breaking simulation of the BeH2 molecule (beryllium hydride).

https://edgy.app/11-companies-set-for-a-quantum-computing-leap

------------------------

ANALYSIS OF US ELECTORAL DATA

By testing historical election and polling data on quantum training models, QxBranch, a data analysis and quantum computing software firm based in Washington D.C, was able to generate 2016 election forecasts similar to other professional forecasters, but with final outcomes that gave the Trump campaign a higher likelihood of victory.

https://www.qxbranch.com/potential-for-improved-2020-election-forecasts-with-quantum-computers/

------------------

REINFORCEMENT LEARNING TO ENGINEER NOVEL THERAPEUTICS

The biotech firm ProteinQure creates computational R&D tools to perform drug design in silico. They leverage quantum computing, molecular simulations and reinforcement learning to engineer novel therapeutics.

https://www.proteinqure.com/

--------------

RECRUIT’S QUANTUM MACHINE LEARNING FOR MARKETING AND ADVERTISING APPS

Japan’s subsidiary Recruit Communications is testing quantum computing for marketing and advertising applications, specifically to improve recommendation systems with machine learning methods.

https://www.ciodive.com/news/4-early-real-world-quantum-computing-applications/520675/

--------------

ANALYSIS OF US ELECTRICAL GRID DATA

Researchers at Purdue University are working on a solution to problems that arise from the huge amount of data generated by the United States electrical grid. Sensors collect 3 petabytes of data every two seconds, meaning that data analysis on that scale is extremely challenging. A potential solution combines quantum algorithms with classical computing on small-scale quantum computers to speed up database accessibility.

https://www.bgp4.com/2018/10/16/annealing-quantum-computers-tackle-big-data-with-a-ml-quantum-boltzmann-machine/

--------------

REINFORCEMENT LEARNING FOR VW AUTONOMOUS CARS

Volkswagen is experimenting with QML to prove the value of reinforcement learning in Self Driving Cars, by taking feedback directly from the environment. However, reinforcement learning is a type of machine learning whose hunger for data is even greater than supervised learning and it is really difficult to get enough data for reinforcement learning algorithms.

https://www.businessmodelsinc.com/solving-real-world-problems-with-quantum-computing/

-----------

OPTIMIZATION OF UTILITIES NETWORK SUPPLY QUALITY

The Dubai Electricity and Water Authority (DEWA) is experimenting around distribution and optimization of the water and electricity networks, partnering with Microsoft in quantum.

https://news.microsoft.com/2018/06/28/microsoft-and-dewa-bringing-quantum-computing-to-dubai/

----------

QUANTUM NETWORKS

KPN has implemented end-to-end quantum key distribution (QKD) in its network between KPN datacenters in The Hague and Rotterdam, the Netherlands. It is collaborating with ID Quantique, a Swiss company specialized in quantum encryption.

https://www.quantaneo.com/%E2%80%8BKPN-and-QuTech-to-collaborate-on-quantum-internet_a122.html

-----------

China takes QKD seriously

Most of China’s massive investment in quantum has gone toward quantum security itself, including the development of quantum key distribution (QKD). China looks to be all in on QKD networks. The country has already built a 1,263-mile link between Beijing and Shanghai to deliver quantum keys. And a successful QKD demonstration by the Chinese Micius satellite was reported across the 4,700 miles between Beijing and Vienna.

https://www.technologyreview.com/2019/12/12/131600/china-is-beating-the-us-when-it-comes-to-quantum-security/

---------

SECURE ONLINE BANKING AT ABN AMRO

Dutch bank ABN Amro studies how quantum computing technology can be used to secure online banking.
The banking giant is working with QuTech, which was jointly established by Delft University of Technology and the Netherlands Organisation for Applied Scientific Research, to prove that quantum key distribution can be used to secure data traffic.

https://www.computerweekly.com/news/252465850/Dutch-bank-and-universities-begin-defence-against-quantum-computings-dark-side

------------

BT WORKS TO SECURE ITS NETWORK

BT announced an ‘unhackable’ quantum-secured network in June 2018. The collaborative project was led by the Quantum Communications Hub, part of the UK National Quantum Technologies Programme.
The quantum link itself is said to be virtually “unhackable” because it relies on the use of single particles of light (photons), to transmit data encryption “keys” across the fibre. Should this communication be intercepted, the sender will be able to tell that the link has been tampered with and the stolen photons cannot then be used as part of the key, rendering the data stream incomprehensible to the hacker.

https://www.computerweekly.com/news/252442910/BT-announces-unhackable-quantum-secured-network

------------

QUANTUM SAFE SYSTEM ON DEUTSCHE TELEKOM‘S TRIAL NETWORK

SK Telecom has applied its quantum safe system on Deutsche Telekom’s trial network and plans to expand deployment to parts of commercial networks this year.
The South Korean telco's quantum-safe system consists of quantum key distribution, quantum random number generator, and an operating system.

https://www.zdnet.com/article/sk-telecom-applies-quantum-key-to-deutsche-telekom-network/

---------------

KPN WORKS TO MAKE QUANTUM-SAFE INTERNET A REALITY

KPN will be providing the infrastructure and locations that QuTech, a collaboration between TU Delft and TNO, will use for research and development. A desired application of a quantum internet is to provide virtually unbreakable privacy and a foundation of secure communication, guaranteed by the fundamental laws of physics.

https://www.overons.kpn/en/news/2019/kpn-and-qutech-join-forces-to-make-quantum-internet-a-reality

---------------------------

PORTFOLIO OPTIMIZATION AND RISK ANALYSIS

Quantum computing can be applied for many financial problems, such as portfolio optimization, finding arbitrage opportunities, and perform credit scoring.

https://www.ibm.com/downloads/cas/MBZYGRKY

-----------------

PORTFOLIO OPTIMIZATION AT MORGAN STANLEY

Morgan Stanley articulated the bank’s hope of speeding up portfolio optimizations, such as Monte Carlo simulations, with the help of quantum computing.

https://www.americanbanker.com/news/why-banks-like-barclays-are-testing-quantum-computing

----------------

PORTFOLIO OPTIMIZATION IN BANKING

First movers are the Royal Bank of Scotland, Goldman Sachs, and Citigroup which have funded quantum computing startups directly. Barclays and JPMorgan Chase have been experimenting with IBM’s quantum computing technology and joined the IBM Q Network.

https://digitaleweltmagazin.de/2019/01/28/starting-the-quantum-incubation-journey-with-business-experiments/

------------------

ASSET OPTIMIZATION AT NATWEST

NatWest is using Fujitsu quantum-inspired digital annealer technology to solve some of its most complex, challenging and time-consuming financial investment problems by optimizing its mix of high-quality liquid assets including bonds, cash and government securities.

https://www.fujitsu.com/fts/about/resources/news/press-releases/2018/emeai-20181002-fujitsu-drives-quantum-inspired-project-to.html

----------------------------

BBVA pursues quantum advantage for investment portfolio optimization

BBVA is examining various lines of research to determine how quantum technologies could represent an advantage over traditional tools in different financial use cases such as dynamic portfolio optimization, credit scoring process optimization and currency arbitrage optimization. The bank launched a strategy that involves forging alliances, strengthening its internal capacity around this technology, evaluating the available tools, and developing proof of concepts in collaboration with research centers, traditional businesses and startups alike.

https://www.bbva.com/en/bbva-pursues-the-financial-sectors-quantum-advantage/

-------------------

TRAFFIC FLOW OPTIMIZATION IN VOLKSWAGEN

The Volkswagen Group is the world’s first automaker to publicly use quantum computers, further expanding its digital capabilities. The company is cooperating with quantum computing company D-Wave Systems on a research project for traffic flow optimization. The project involves publicly available data from Beijing taxis that were used to plot optimal routes.

----------------------------

ROUTE OPTIMIZATION AT FORD

Ford is currently working with NASA (National Aeronautics and Space Administration) in the U.S. to examine how quantum computing can improve its business. One idea being explored is routing diesel delivery vehicles in such a way as to reduce harmful pollutants by ensuring their drive cycles are operating within an optimal range. Another idea is improving productivity in its manufacturing plants.

https://europe.autonews.com/automakers/how-vw-bosch-ford-daimler-aim-gain-quantum-computing

----------------------------------

OPTIMIZING VALIDATION PROCEDURES AT LOCKHEED MARTIN

Lockheed Martin, the American global aerospace, defense, security and advanced technologies company, is researching quantum computing for the purpose of optimizing and shortening validation procedures from 8 months to 6 weeks using embedded software.

https://www.digitaltrends.com/computing/lockheed-martin-d-wave-quantum-annealer/

---------------------------------

ROUTE OPTIMIZATION AT AIRBUS

Airbus is already exploring the use of quantum computing in areas such as “route optimization and satellite imagery." Moreover, in January 2019 the aircraft giant announced a global competition to encourage developers to find ways quantum computing can be applied to “aircraft design”.

https://digitaleweltmagazin.de/2019/01/28/starting-the-quantum-incubation-journey-with-business-experiments/

-------------------------------------------------

FLEET OPTIMIZATION AT DENSO

Denso, the global automotive components manufacturer headquartered in Japan, is working on the optimization of the operations of a fleet of electrical delivery vehicles. Partnering with Toyota, the research uses vehicle location data from 130,000 commercial vehicles and cloud-based quantum systems to analyze the information and improve efficiency.

https://singularityhub.com/2018/02/01/why-quantum-computers-will-be-an-amazing-tool-for-social-innovators/

----------------------

OPTIMIZATION OF UTILITIES NETWORK SUPPLY QUALITY

The Dubai Electricity and Water Authority (DEWA) is experimenting around distribution and optimization of the water and electricity networks, partnering with Microsoft in quantum.

https://news.microsoft.com/2018/06/28/microsoft-and-dewa-bringing-quantum-computing-to-dubai/

---------------------------------------

DRUG DISCOVERY

A quantum computer would be able to map out trillions of molecular combinations and quickly identify the ones that would most likely work, significantly cutting down the cost and the time of drug development

https://www.businessinsider.in/science/7-awesome-ways-quantum-computers-will-change-the-world/articleshow/47006938.cms

----------------

TRAFFIC OPTIMIZATION

The management and optimization of traffic (road, rail, air, etc.), the operation of vehicle fleets and the management of autonomous vehicles are promising fields where the inherent qualities of Quantum could well express their potential. Several companies are evaluating this around the optimization of filling of airline fleets in near real time and in a global way.

https://www.businessinsider.in/science/7-awesome-ways-quantum-computers-will-change-the-world/articleshow/47006938.cms

--------------------

OPTIMIZATION IN ENERGY EXPLORATION

Quantum computing could be used to improve oil exploration. BP and ExxonMobil have projects ongoing on this topic.

https://www.spglobal.com/marketintelligence/en/news-insights/trending/x4cbur85qkeeniymgckgag2

----------------------

GENOME SEQUENCING

Quantum computing could be used to accelerate the sequencing of DNA genes, disrupting the healthcare industry.

https://www.technologynetworks.com/informatics/news/the-power-of-quantum-computing-harnessed-for-dna-study-298183

-------------------------

CANCER TREATMENT

Quantum computing could be used to the optimization of treatment in radiotherapy and better and faster detection of brain tumors, which could be done in seconds instead of hours or weeks. This could mean reduced exposure to X-rays by simulating and optimizing the movement of waves in the human body.

https://news.microsoft.com/innovation-stories/quantum-computing-mri-cancer-treatment/

---------------------

SPACE EXPLORATION

NASA has partnered with Google to research quantum computational methods for exoplanet detection from analysis of telescopic observations, alongside analysis of optimization and planning problems.

https://www.nas.nasa.gov/projects/quantum.html

https://nas.nasa.gov/assets/pdf/Quantum_Computer_Fact_Sheet_Fall2015.pdf

-----------------------------
--------------------------

QUANTUM SAFE NETWORKING

QuantLR used Ultimately Secure Quantum Key Distribution (QKD) solutions to secure data communication at a lower cost. QuantLR successfully deployed a POC showing that QKD is ready for mass deployment at a cost reduction of 90% over all previously deployed solutions.

------------------------
QUANTUM KEY DISTRIBUTION

Battelle installed commercial Quantum Key Distribution (QKD) system in the US connecting its headquarters in Columbus, Ohio to production facility in Dublin, Ohio. The QKD hardware used was Cerberis model from ID Quantique. Combined with ID Quantique’s Centauris encryptor, this provides a 1Gbps link with Layer2 encryption. The link between facilities requires dedicated dark (unlit) fiber.

-------------------------

ENCRYPTION FOR ELECTRONIC VOTING

Estonia has deployed i-voting system that allows citizens to vote at their convenience. The system uses public key infrastructure for secure digital authentication and signing. The infrastructure also allows forwarding data by using an encrypting key pair: a public encryption key and a private decryption key.

---------------------------------

QUANTUM NETWORKS

KPN has implemented end-to-end quantum key distribution (QKD) in its network between KPN datacenters in The Hague and Rotterdam, the Netherlands. It is collaborating with ID Quantique, a Swiss company specialized in quantum encryption.

--------------

Secure mobile communications

Mitsubishi Electric has developed the world’s first “one-time pad software,” an advanced encryption technique for mobile phones to ensure that telephone conversations remain confidential. Additionally, the company is involved in implementing their technology in a project being conducted by the National Institute of Information and Communications Technology to test the viability of mobile communications over a quantum secure network.

-------------------------

Digital sign

Blackberry: Launched a solution which will allow software to be digitally signed using a scheme that will be hard to break with a quantum computer. The Solution is actually the product of a partnership between BlackBerry and Isara Corporation, a company whose mission is to build quantum-safe security solutions. BlackBerry is using Isara’s cryptographic libraries to help sign and protect code as security evolves.

--------------------------

Cryptographic algorithims

KPN: Dutch landline and mobile telecommunications company implemented end-to-end quantum key distribution (QKD) in its network between KPN datacenters in The Hague and Rotterdam. KPN is collaborating with ID Quantique, a Swiss company specialized in quantum encryption.

--------------------

Visibility and incident management

Swiss Canton of Geneva: Implemented for the first time IDQ’s hybrid encryption solution, using state of the art Layer 2 encryption combined with Quantum Key Distribution (QKD). The Cerberis solution secures a point-to-point Gigabit Ethernet link used to send ballot information for the federal and cantonal elections from the central ballot counting station to the Geneva government data center.

-----------------------

- https://ksusentinel.com/2021/02/26/global-quantum-computing-market-keyplayers-1qb-information-technologies-inc-qc-ware-corp-google-inc-qxbranch-llc/
- https://www.prnewswire.com/news-releases/the-worldwide-quantum-computing-industry-is-expected-to-reach-1-7-billion-by-2026--301229132.html
- https://www.scientificamerican.com/article/googles-quantum-computer-achieves-chemistry-milestone/
- https://www.newscientist.com/article/2253089-google-performed-the-first-quantum-simulation-of-a-chemical-reaction/

---------------------
------------------------------------

repository: ghuioio/Quantum-Dots

repo_name: ghuioio/Quantum-Dots