text:
---
layout: post
title: Identifying Fraudulent Activities
subtitle: First Project in 2019
gh-repo: zigzagjie/Data-Science
gh-badge: [star, fork, follow]
tags: [Classification,WinterProject]
---

# Identifying Fraudulent Activities

## Happy New Year

Happy 2019. In 2019, to be the one who I want to be.

## Project Description

Company XYZ is an e-commerce site that sells hand-made clothes. You have to build a model that predicts whether a user has a high probability of using the site to perform some illegal activity or not.

The procedure of this project invovles:

- merge two datasets to transform its ip address to corresponding.
- feature engineering to find out features related to fraud activities
- Build a model to predict whether an activity is fraudulent or not.
- Explain how diﬀerent assumptions about the cost of false positives vs false negatives would impact the model.
- How would you explain your boss how the model is making the predictions? What kinds of users are more likely to be classiﬁed as at risk? What are their characteristics?
- Let's say you now have this model which can be used live to predict in real time if an activity is fraudulent or not. From a product perspective, how would you use it? That is, what kind of diﬀerent user experiences would you build based on the model output?

**From data science take home challenges **

## Import datasets

```python
import pandas as pd
pd.options.display.float_format = '{:.0f}'.format

transactions = pd.read_csv("Fraud/Fraud_Data.csv",parse_dates=True)
ip = pd.read_csv("Fraud/IpAddress_to_Country.csv")
```

```python
transactions.head()
```

      user_id
      signup_time
      purchase_time
      purchase_value
      device_id
      source
      browser
      sex
      age
      ip_address
      class

      0
      22058
      2015-02-24 22:55:49
      2015-04-18 02:47:11
      34
      QVPSPJUOCKZAR
      SEO
      Chrome
      M
      39
      732758369
      0

      1
      333320
      2015-06-07 20:39:50
      2015-06-08 01:38:54
      16
      EOGFQPIZPYXFZ
      Ads
      Chrome
      F
      53
      350311388
      0

      2
      1359
      2015-01-01 18:52:44
      2015-01-01 18:52:45
      15
      YSSKYOSJHPPLJ
      SEO
      Opera
      M
      53
      2621473820
      1

      3
      150084
      2015-04-28 21:13:25
      2015-05-04 13:54:50
      44
      ATGTXKYKUDUQN
      SEO
      Safari
      M
      41
      3840542444
      0

      4
      221365
      2015-07-21 07:09:52
      2015-09-09 18:40:53
      39
      NAUITBZFJKHWW
      Ads
      Safari
      M
      45
      415583117
      0

```python
ip.head()
```

      lower_bound_ip_address
      upper_bound_ip_address
      country

      0
      16777216
      16777471
      Australia

      1
      16777472
      16777727
      China

      2
      16777728
      16778239
      China

      3
      16778240
      16779263
      Australia

      4
      16779264
      16781311
      China

## Assign country according to their ip address

Firstly, I tried iterate all the rows in the ip dataframe. However, it took a lot of time.

Considering the dataset is sorted by lower bound and upper bound. Binary search can be applied here.

It turned out to be quicker and more efficient.

```python
def setCountry(x):
    """
   for index, row in ip.iterrows():
        if row['lower_bound_ip_address']<x and row['upper_bound_ip_address']>x:
            return row['country']
    return "Unknown"
    """

    ## the method above is too slow. We change to binary search
    low = 0
    high = 138845
    while low<=high:
        mid = low+(high-low)//2
        if ip.loc[mid,'lower_bound_ip_address']<=x and ip.loc[mid,'upper_bound_ip_address']>=x:
            return ip.loc[mid,'country']

        if ip.loc[mid,'lower_bound_ip_address']>x:
            high = mid-1
        elif ip.loc[mid,"upper_bound_ip_address"]<x:
            low = mid+1
    return "Unknown"

transactions["Country"] = transactions.ip_address.apply(setCountry)
```

Some ip address can not find its country.

```python
transactions.Country.value_counts().head()
```

    United States     58049
    Unknown           21966
    China             12038
    Japan              7306
    United Kingdom     4490
    Name: Country, dtype: int64

# Feature engineering

transactions have the current features. We need to dig more information from it.

First, let's check if user id is unique.

### Check if the user id is unique

```python
len(transactions.user_id)==len(transactions.user_id.unique())
```

    True

### Check if the device id is unique

Users can share the same device and they can be suspicious.

```python
len(transactions.device_id)==len(transactions.device_id.unique())
```

    False

### Check if the ip address is unique

Similarly, ip addresses can be the same for users if they try to fake.

```python
len(transactions.ip_address)==len(transactions.ip_address.unique())
```

    False

### Sharing info

One device id can appear multiple times. This could be suspicious.

```python
transactions['device_sharing']=transactions.groupby('device_id').user_id.transform('count')
transactions['ip_sharing']=transactions.groupby('ip_address').user_id.transform('count')
```

### sharing ip and sharing device

It turns out if two device is the same and their ip address it more likedly to be the same as well. But it is not always the case. Therefore, we would keep two features.

```python
(transactions['ip_sharing']==transactions['device_sharing']).value_counts()
```

    True     139583
    False     11529
    dtype: int64

### Encode country

I tried two methods.

- First, encode country into frequent ones and rare one. For example, most of users are from US, China and Japan. We would record their nations while for others just label "rare".

- Second, just encode country into Known and Unknown.

It turns out two methods did not make big differences. To simply, we select the second method to represent the country.

```python
def encodeCountry(x):
    if x in ['United States', 'Unknown', 'China', 'Japan', 'United Kingdom',
       'Korea Republic of', 'Germany', 'France', 'Canada', 'Brazil', 'Italy',
       'Australia', 'Russian Federation']:
        return x
    else:
        return "Rare"

def encodeCountry1(x):
    if x=="Unknown":
        return 0
    else:
        return 1

transactions['ipvalid']=transactions.Country.apply(encodeCountry1)
```

### Dig dates

We are also given when the user signed up and when the user purchased. It is understandable the period between the sign up and purchase time matters. Also, when the user signed up and when the user purchased can be important as well. We extracted days, months, and hour from its date.

```python
transactions['purchase_day']=pd.to_datetime(transactions.purchase_time).dt.dayofweek
transactions['purchase_hour']=pd.to_datetime(transactions.purchase_time).dt.hour
transactions['purchase_month']=pd.to_datetime(transactions.purchase_time).dt.month

transactions['signup_day']=pd.to_datetime(transactions.signup_time).dt.dayofweek
transactions['signup_hour']=pd.to_datetime(transactions.signup_time).dt.hour
transactions['signup_month']=pd.to_datetime(transactions.signup_time).dt.month

transactions['length'] = pd.to_datetime(pd.to_datetime(transactions.signup_time)-pd.to_datetime(transactions.purchase_time)).dt.day

```

```python
transactions.ipvalid.value_counts()
```

    1    129146
    0     21966
    Name: ipvalid, dtype: int64

```python
users = transactions.drop(["user_id","device_id","ip_address","Country","signup_time","purchase_time"],axis=1)
users.head()
```

      purchase_value
      source
      browser
      sex
      age
      class
      ipvalid
      purchase_day
      purchase_hour
      purchase_month
      signup_day
      signup_hour
      signup_month
      length
      device_sharing
      ip_sharing

      0
      34
      SEO
      Chrome
      M
      39
      0
      1
      5
      2
      4
      1
      22
      2
      9
      1
      1

      1
      16
      Ads
      Chrome
      F
      53
      0
      1
      0
      1
      6
      6
      20
      6
      31
      1
      1

      2
      15
      SEO
      Opera
      M
      53
      1
      1
      3
      18
      1
      3
      18
      1
      31
      12
      12

      3
      44
      SEO
      Safari
      M
      41
      0
      0
      0
      13
      5
      1
      21
      4
      26
      1
      1

      4
      39
      Ads
      Safari
      M
      45
      0
      1
      2
      18
      9
      1
      7
      7
      11
      1
      1

## Model

It is time to build a model to predict a fraud. First, we need split training and test.

### Train test split and conversion

```python
from sklearn.model_selection import train_test_split
X = users.drop(["class"],axis=1)
X = pd.get_dummies(X,drop_first=True)
y = users["class"]

X_train, X_test, y_train, y_test = train_test_split(X,y,stratify=y,test_size=0.3,random_state=42)

```

```python
X.shape
```

    (151112, 19)

### Find the best model and best parameters

Here, we tried several classification models and found random forest classifier works well.

In this case, since it is a highly imbalanced dataset. We used AUC metric to evaluate a model. AUC is a great metric for this type problem. Also, AUC gives the general performance for all the thresholds. Last, we care about the balanced between false negatives and false positives, so AUC would be fit.

**The baseline model can give 90.66% accuracy**

```python
100-transactions['class'].mean()*100
```

    90.635422732807456

### GridSearchCV

Grid serach cv makes our life easier. However, it can take longer time. Thus, I firstly used train and test to test each models and narrowed down to random forest classifier.

```python
from sklearn.model_selection import GridSearchCV

param_grid = {
    'max_depth':[40,50,60],
    'max_features':[4,8,13,19],
    #"min_samples_leaf":[3,4,5],
    #"min_samples_split":[8,10,12],
    "n_estimators":[10]
}
model = RandomForestClassifier(min_samples_leaf=1,criterion='gini')

grid_search_model = GridSearchCV(estimator=model,param_grid=param_grid,cv=5,scoring="roc_auc")
grid_search_model.fit(X_train,y_train)
grid_search_model.best_params_
```

    {'max_depth': 60, 'max_features': 4, 'n_estimators': 10}

```python
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC

#model = LogisticRegression(class_weight="balanced")
model = RandomForestClassifier(class_weight={1:1,0:1},n_estimators=10,
                               max_features=4,max_depth=60,min_samples_leaf=1,criterion='gini')
#good,min_samples_split=0.15
#model = GaussianNB()
#model =  KNeighborsClassifier(2) #good
#model = DecisionTreeClassifier(max_depth=12,max_features=5) #good   #class_weight={1:1.5,0:1}
#model =  SVC(kernel="linear", C=0.025)
#model =  SVC(gamma=2, C=1)  # too slow

model.fit(X_train,y_train)
y_pred = model.predict(X_test)

from sklearn.metrics import classification_report
print(classification_report(y_test,y_pred))
```

                 precision    recall  f1-score   support

              0       0.95      1.00      0.98     41089
              1       0.96      0.54      0.69      4245

    avg / total       0.96      0.95      0.95     45334

**Model Evaluation**

In general, the model gives 96% accuracy greater than the baseline one. Thus, it performs well.

Then, for each class, the precision high. It indicates that if we predicts a class, the predicted can be really true. In other words, if we tell an activity is suspicious, it is higly real. However, the recall for class 1 is 0.54, suggesting we can only find half of true fraud activities.

```python
from sklearn.metrics import roc_auc_score
from sklearn.metrics import roc_curve
import matplotlib.pyplot as plt

y_pred_proba = model.predict_proba(X_test)[::,1]
fpr, tpr, _ = roc_curve(y_test,  y_pred_proba)
auc = roc_auc_score(y_test, y_pred_proba)

plt.plot(fpr,tpr,label="auc="+str(auc))
plt.legend(loc='best')
```

    <matplotlib.legend.Legend at 0x213893c1710>

![png](https://raw.githubusercontent.com/zigzagjie/jieloudata/master/img/blog/fraud/output_33_1.png)

**AUC=0.83. The model is good.**

The threshold now is 0.5.

We can treak the threshold based on assumptions on trade-off between true positives and false positives.

False positives happen when the activity is valid but predicted fraud. If the cost of false positives is higher, we may lose a lot potential buyers because we close the valid transaction. In this case, we maybe conservative. Thus, we increase the cut-off, the threshold. Thus, buyers are harder to be predicted as fraud.

False negatives happen when the activity is fraud but not detected. If the cost of false negatives is higher, we may have a loss since the transaction is fraud. In this case, we maybe aggressive to find more fraud activities. Thus, we decrease the cut-off, the threshold. Thus, buyers are easier to be predicted as fraud.

## Feature Importance

```python
X.columns
```

    Index(['purchase_value', 'age', 'device_sharing', 'purchase_day',
           'purchase_hour', 'purchase_month', 'signup_day', 'signup_hour',
           'signup_month', 'length', 'ipvalid', 'ip_sharing', 'source_Direct',
           'source_SEO', 'browser_FireFox', 'browser_IE', 'browser_Opera',
           'browser_Safari', 'sex_M'],
          dtype='object')

```python
pd.options.display.float_format = '{:.3f}'.format
pd.Series(model.feature_importances_,index=X.columns).sort_values(ascending=False)
```

    device_sharing    0.222
    ip_sharing        0.173
    length            0.158
    purchase_value    0.067
    age               0.053
    purchase_month    0.052
    signup_month      0.051
    purchase_hour     0.050
    signup_hour       0.050
    signup_day        0.035
    purchase_day      0.032
    sex_M             0.010
    browser_IE        0.008
    browser_FireFox   0.008
    browser_Safari    0.008
    source_SEO        0.007
    source_Direct     0.007
    ipvalid           0.007
    browser_Opera     0.003
    dtype: float64

**device sharing, ip sharing, how long it takes for a user to have a first purchase since sign up, purcahse vlaue, and age is top 5 features in predicting a fraud activity**

However, if we want to know the direction, we have to build a single decision tree to take a look.

```python

from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier(max_features=19,max_depth=3,min_samples_leaf=1,criterion='gini') #good   #class_weight={1:1.5,0:1}

model.fit(X_train,y_train)
y_pred = model.predict(X_test)
from sklearn.metrics import classification_report

print(classification_report(y_test,y_pred))
```

                 precision    recall  f1-score   support

              0       0.95      1.00      0.98     41089
              1       1.00      0.53      0.70      4245

    avg / total       0.96      0.96      0.95     45334

**Notice, decision tree classifier can work well.**

```python
pd.options.display.float_format = '{:.3f}'.format
pd.Series(model.feature_importances_,index=X.columns).sort_values(ascending=False)
```

    ip_sharing        0.850
    length            0.089
    device_sharing    0.055
    source_Direct     0.005
    purchase_month    0.001
    purchase_hour     0.000
    signup_hour       0.000
    age               0.000
    ipvalid           0.000
    purchase_day      0.000
    signup_day        0.000
    sex_M             0.000
    signup_month      0.000
    browser_Safari    0.000
    source_SEO        0.000
    browser_FireFox   0.000
    browser_IE        0.000
    browser_Opera     0.000
    purchase_value    0.000
    dtype: float64

```python
from sklearn.externals.six import StringIO
from IPython.display import Image
from sklearn.tree import export_graphviz
import pydotplus

dot_data = StringIO()
##export_graphviz(model, out_file=dot_data,
#                filled=True, rounded=True,
 #              special_characters=True)
#graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
#Image(graph.create_png())

with open("fraud_tree.txt", "w") as f:
    f = export_graphviz(model, out_file=f,feature_names = X.columns,class_names=['NotFraud','Fraud'])
```

**Visualizing tree with [webgraphviz](http://webgraphviz.com/)**

![png](https://raw.githubusercontent.com/zigzagjie/jieloudata/master/img/blog/fraud/tree.png)

### Interpretation

- if an ip address is shared between more than one user and opened less than 30.5 days -->fraud

Shared IP adrress and quick purchase after singing up lead to high probability of fraud.

## Product

The final model is randomforest classifier. As the assumption of cost of false negatives and false positives varies, the threshold can be tweaked to meet the requirements. At this point, the model has a 0.5 threshold.

If the cost of false negatives is higher, we need to decrease false negatives. In other words, we need increase the number of positive predictions. To realize it, the threshold need to be decreased.

On the other hand, if the cost of false positives is higher, we need to increase the threshold.

After deciding the threshold, the suspicious transaction should be asked for further authorization.

## Review

In this project, we did:

1. Binary Search and basic data manipulation
2. Classification model built and hyperparameters tuning
3. ROC Curve interpretation and trade-off
4. Decision Tree built and visualization (not sure why graphviz did not work on Notebook)
5. Product sense view

In the future,

1. Leanr gradient boosting method
2. further learn the relationship with product design
3. ROC and Precision-recall trade off [this article](https://machinelearningmastery.com/roc-curves-and-precision-recall-curves-for-classification-in-python/)


text:
# Packer.Vagrant.Chef
Templates for building Vagrant base boxes with Packer and Chef.

## Requirements
[Packer](https://www.packer.io/) - Tested with version 1.0.0

[Hyper-V](https://www.microsoft.com/en-us/cloud-platform/server-virtualization) - Tested with Windows 10 version 1703

[Chef](https://downloads.chef.io/) - Tested with version 1.4.3

## Usage
`> packer validate Windows10ExterpriseEditionEval1703.json`

`> packer build Windows10ExterpriseEditionEval1703.json`

## Testing
`> vagrant up`

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
![MisClientes](https://i.ibb.co/CwrcqrW/Arco-Linux-2020-03-18-1584545696-screenshot-1366x768.jpg)
![MisClientes](https://i.ibb.co/3zHRXkv/Arco-Linux-2020-03-18-1584545727-screenshot-1366x768.jpg)
![MisClientes](https://i.ibb.co/mvDqNtD/Arco-Linux-2020-03-18-1584545739-screenshot-1366x768.jpg)

# django-misclientes
A simple django app to manage clients

Thanks to all [Django Cuba](https://t.me/DjangoCuba) Telegram Group!!!!!
* Luis Miguel Pozo Gonzalez
* @codeshard
* @Felix Pupo
* @Guillermo Roig

## Create virtual environment and install requirements

### Clone this repository

````git
git clone https://github.com/dcruz1990/django-misclientes
````

### Define virtualenv environment

```
virtualenv -p python .venv
```

### Install requirements

```
pip install -r requirements
```

### Install WeasyPrint

* Please follow [this official guide](https://weasyprint.readthedocs.io/en/latest/install.html).

If you are using Debian like distributions you need to install these packages:

```sudo apt-get install build-essential python3-dev python3-pip python3-setuptools python3-wheel python3-cffi libcairo2 libpango-1.0-0 libpangocairo-1.0-0 libgdk-pixbuf2.0-0 libffi-dev shared-mime-info```

## Run server in local environment

### Run makemigrations

````
python manage.py makemigrations
````

### Run migrations

````
python manage.py migrate
````

### Compile .po to .mo

````
python manage.py compilemessages
````

### Update assets

````
python manage.py collectstatic --noinput

````

### Run server for development

```
python manage.py runserver
```

### Visit you application

```
http://localhost:8000/
```

## Run with Docker

### Requirements
- Docker
- docker-compose
- Docker image for python >= 3.6 (https://hub.docker.com/_/python)
- Docker image for nginx:alpine (https://hub.docker.com/_/nginx)

### Build and run containers stack with docker-compose

````
docker-compose -f ./container/docker-compose up -d --build
````

If it's the first time, wait to compile your application Docker's image or wait that required Docker's images be downloaded to compile your application Docker's image

### Visit you application

```
http://localhost/
```

## Contact
*<EMAIL_ADDRESS>*<EMAIL_ADDRESS>

[]: https://t.me/DjangoCuba

gha_language: HTML


text:
# Laravel Shopify Sync

A Laravel-Shopify App / Starting Point (with a focus on data synchonization)

## Highlights

> This package in still under development.

## Suggestions

Wait...

## Composer

    $ composer require dan/laravel-shopify-sync dev-master

## Contributors

- [Diogo Gomes](https://github.com/diogogomeswww)

## License

MIT.

repository: danrichards/laravel-shopify-sync

gha_language: PHP

gha_license_id: MIT

repo_name: danrichards/laravel-shopify-sync


text:
## Chart Engine

Stock charting library built with [Typescript](https://www.typescriptlang.org/) using HTML5 Canvas element for drawing.

### Features

* Dynamically loaded data;
* Price-based chart types;
* Extendable indicators;
* Extendable figures.

#### Chart types

* Candlestick
* Heikin-Ashi
* Hollow
* Line
* Line Break
* Mountain
* OHLC
* Range Bars
* Renko

#### Indicators

* Double Exponential Moving Average
* Exponential Moving Average
* Simple Moving Average
* Smoothed Moving Average
* Triple Exponential Moving Average
* Triangular Moving Average
* Weighted Moving Average
* Aroon Up/Down
* Average Directional Index
* Average True Range
* Bollinger Bands
* Correlation
* Directional Movement Index
* Highest High / Lowest Low
* Historical Volatility
* Ichimoku Kinko Hyo
* Mean Deviation
* Parabolic SAR
* Pivot Points
* Rainbow
* Ratiocator
* Supertrend
* Standard Deviation
* Typical Price
* Aroon Oscillator
* Disparity Index
* Double Smoothed Stochastic
* Fast Stochastic
* Momentum
* Overbought/Oversold
* Rate of Change
* Relative Strength Index
* Slow Stochastic
* William’s %R
* Commodity Channel Index
* Moving Average Convergence/Divergence
* Relative Strength (Levy)

#### Figures

* Curve
* Date Range
* Ellipse
* Fibo Fan
* Fibo Level
* Fibo Projection
* Fibo Time Projection
* Gann Fan
* Horizontal line
* Line
* Path
* Pitchfork
* OHLC Proj
* Rectangle
* Text
* Trend Channel
* Triangle
* Vertical line

### Starting samples locally

```
npm install
gulp build
ws -d ./sample-webserver
http://localhost:8000/demo/index.html
```

### Demo

[Demo](https://chartengine.github.io/)

*Note that demo app uses external resource to get assets data*.

repository: LykkeCity/ChartEngine

gha_language: JavaScript

repo_name: LykkeCity/ChartEngine


text:
---
title: "Update your Workspace"
chapter: false
weight: 15
---

#### Install dependencies

- Run the following commands in the Cloud9 terminal to update [nvm](https://github.com/nvm-sh/nvm) (Node Version Manager) and install [jq](https://stedolan.github.io/jq/) (a command-line JSON processor) and [Locust](https://locust.io/) (a load testing tool)
```
nvm install stable
sudo yum -y install jq
sudo pip3 install locust
```


text:
JoyStickController

The joyStickController is a software based on SDL, to get datas from stick, hat, button from an XBOX controller.

OBJECTIF

Use an XBOX controller to control my quadricopter.

GETTING STARTED

This project is developped in C, with the SDL.

The Project is develop under ECLIPSE
You will need the following configuration to used SDL2

	Configure Eclipse to use SDL2

    Right click your Project under “Package Explorer” and select Properties.
    Select (C/C++ General > Paths and Symbols > Libraries)
    Click “Add” and add “SDL2″ and click "OK"
    Click “Add” and add “SDL2main” and click "OK" (optional)

AUTHOR

ROMET Pierre Student in embedded software at "Universite de Technologie de Belfort-Montbéliard - France" PSEUDO: Aldarme

CONTRIBUTING

Thank, currently, no contribution. this soft is apart of my final years student projet.

LICENSE

This project is licensed under the MIT license - see the LICENSE.md file for details

repository: Aldarme/JoyStickController

repo_name: Aldarme/JoyStickController


text:
Should you accept shares for working at a company?
tags:
- mentorship
- mentorship-series
- client project valuation
- technical-founder
---

# Edition 1

In the first edition, we explore possible approaches to providing estimation for a client project, how to evaluate if you should accept payment in shares, and possible approaches to being a Technical Founder.

## Question 1: How do you give a client valuation for a software project?

Valuation can be approached in several ways (not exhaustive):

1. How much time you might end up spending on it (including maintenance after it goes live)
2. How much value it can return to the client (you'll have to prove that it will return a certain value)
3. How much worth it can return to you (e.g help build your portfolio)

#### Option 1: How much time you might end up spending on it

For this, you'll first have to know what your rate is (e.g. how much do you charge hourly)

Based on that, you can estimate how much time working on the project will take, then you can do a calculation based on that.

For example, let's say your hourly rate is $20, and the project is estimated to take 40 hours (this time should be based on how much time you actually have, e.g. considering school, other clients, etc).

So base amount becomes: 40 * $20 = $1600

Then you can consider how you want to approach maintenance of the project after it's completed. For example:
- Provide a 3 month cost-free maintenance window, then bill for any additional work or requests based on your rate
- Have the client retain you on a retainer basis, where you agree on a monthly fee, and you're available for support (this should be separate from "new requests")

As you can see with all this, it's very important to have a contract with your client.

The contract can say something like:
- These are the features we've agreed on
- This is how long it will take
- This is how much it will cost
- This is what we'll do if there are modifications to be made, or features to be added

For Software as a Service (Saas) projects, it's also important to factor in costs that the client will have to cover after the project goes live, e.g. servers, hosting, etc

#### Option 2: how much value it will return to the client

In this scenario, you end up doing research and showing the value that the product you're building will bring to the client.

For example, consider this high level scenario:

> Let's say that the client currently has an e-commerce website, and they want you to update it so that they can get more clients.
> Let's say that for every 100 people that visit the website per day, 10 buy something, and the client earns a profit of $50 per customer.
>> So currently, their profit comes to: $50 * 10 = $500 per day.

> If you improve the website, and now 20 people out of a hundred end up buying something (i.e you've increased conversion), then it means you've increased the client's profits by 100% (they're now getting a profit of $1000 per day).

> So in this case, you can tell the client: Based on this work, we're able to increase your returns by 100%
> This can be a starting point for a negotiation for how much the project would cost.
> You could agree that after the improvements are made, you get to keep 20% of the profit made (so you keep earning as long as the project runs); **OR**
> You could project to your client the value of getting 100% increase in profit over 1 / 2 / 5 / 10 years, and propose that the client pays a fraction of that, once off.

In this case, you're showing the value you're providing, so you have a stronger negotiating base.

This option, however, requires that you do quite a bit of research so that you can demonstrate this value to the client. So it means that it's useful to have some context into the client's business.

#### Option 3: How much worth it can return to you (e.g help build your portfolio)

In this scenario, you're looking to increase your exposure, so maybe the financial returns you get are not a huge priority.

You might end up taking the overall approach of option 1 (i.e have a billing rate), and then you can use this project as part of your portfolio.

As is the case with option 1, a contract is important, and it's useful that you agree on the terms and scope of work.

#### Project Pre-Work
In all these approaches, there is "pre-work" that you may end up doing so that you can present a case to the client.

For example, you may spend time preparing a presentation with all the research and a proposal for the work to be done.

Remember, at this point, you are actually working, so it makes sense to bill for this. Your approach to billing here may be that you offer a slightly lower rate, or you agree with the client that the time spent in the proposal will be included in the overall project cost -- either way, you need to get paid for that as well.

This aspect of billing for the proposal also allows you to weed out the jokers vs. people who are serious about a project.

#### Recommended Reading
[@tom_hirst](https://twitter.com/tom_hirst) wrote an excellent thread on this topic on Twitter, I highly recommend checking that out.

Pricing freelancing projects.

Everything I've learned.

A thread.
— Tom Hirst (@tom_hirst) June 30, 2020

He's also written an excellent book on Pricing Freelance Projects, I recommend you check it out:

- Full book (purchase): [Pricing Freelance Projects](https://tom-hirst.gumroad.com/l/pcUlz)
- Summary: [Pricing Freelance Projects Book Summary](https://www.tomhirst.com/pricing-freelance-projects/)

## Question 2: For clients that want to pay in shares, how do you evaluate if that's a worthy commitment that will pay off in future

This is the thing, you can't really know, because you can't tell the future.

This approach is usually taken in startups where money is tight -- but it's always a gamble.

Most times, unless it's a very unique idea, it's probably not worth it.

That said, this could be an opportunity for you to execute Option 3 above: building your portfolio.

So you can choose to charge a reduced rate + the shares.

Again, a contract is very very important here. It's better to have it all written down!

## Question 3: Suppose you were to form a company as a technical person / founder, with the other person being the "business" side of things. How do you justify that the technical expertise is worth a part of the company, when the business person is the one doing the actual funding?

I think that justification comes from showing that value that will come from your technical contributions (similar to Option 2 above)

For example, when discussing this, you can ask them to either:

1. Pay you for each transaction/sale that comes from whatever tech you build
2. Give you a share of the business upfront
3. Pay you just for building all the tech (and then you hand over afterwards)

So you can present these options, and then you can agree on which approach to take in your partnership.

For example, if they don't have the money to pay you for upfront building the tech, then giving you a share of the business is the "debt" they incur to get your services.

When you phrase it this way (i.e. as "debt"), the negotiation becomes whether or not they think it's good debt to take on.


text:
---
title: "About"
permalink: "About"

---

<!---
## [![Resume](https://raw.githubusercontent.com/SeokLeeUS/seokleeus.github.io/master/_images/_Resume/Resume_Seok_Lee_Dec292021.jpg)]({{https://github.com/SeokLeeUS/seokleeus.github.io}}/assets/Seok_Lee_Resume_in_R_Dec292021.pdf)
-->

I am a seasoned mechatronics engineer with 17+ years of business development and program management experience in the automotive sector. Recognized for demonstrating a natural aptitude for leading complex design projects that exceed all expectations, as well as for creating novel solutions to mitigate project risks, I have a verifiable history of contributing directly to company growth and expansion throughout my career. As such, I have consistently exceeded performance goals and I am adept at achieving maximum operational output with minimal resource expenditure.

Professional focal points include team leadership, entrepreneurship, process improvement, tools and technology, data modeling, multitasking, and adaptability. Delivering superior administration on the latter areas of expertise requires utilization of effective communication skills and problem-solving skills, as well as business acumen, systems analysis, project management and resource management to support efficiency and maximum returns.

Currently, I am Technical Business Development Manager for Vitesco Technologies. Under my leadership, I oversee business development for start-ups in Electrical Vehicles, Fuel Cells (FC), and micro-mobility domain systems categories. In addition, I liaise with senior leadership, team members, and clients to ensure the company’s business development support structure is driving the business forward with minimal expenditures.

Colleagues describe me as a progressive, driven, down-to-earth, technical and managerial expert who can be relied on to offer superior solutions that deliver profitable results on time and under budget.

I am interested in contacting former colleagues and managers, as well as other professionals in my field. Feel free to contact me [via<EMAIL_ADDRESS>or [LinkedIn](https://www.linkedin.com/in/seoklee).

license: Unlicense


text:
# Gulp 4+ Modular Preset By Octapia

It's an open source project by Octapia under MIT licence

## What is gulp?

Gulp is a automation toolkit that helps you automate time-consuming tasks in your application development

## What we did?

- Build css from sass/scss. Autoprefix and minification applied
- Javascript minification
- Build optimized images
- Live reload
- Clean directory

## Cli Commands

- gulp (Start's live server and will watch your future work)
- gulp prod (Start's live server and will watch your future work also minify css, javascript)
- gulp clean (Clean public directory)

## License

- **[MIT](http://en.wikipedia.org/wiki/MIT_License)** @ **[Octapia](https://www.facebook.com/octapia.com.bd)**

## Support

- Keep praying for us

## Contact us

- **[Website Owner](https://www.facebook.com/groups/websiteowner)**
- **[Octapia](https://www.facebook.com/octapia.com.bd)**
- **[Upwork](https://www.upwork.com/o/companies/~011335ddde8074293a/)**


text:
## Torn API Wrapper

### Installation
The preferred method of installation is via Composer.

    composer require pixels/torn-api

### Usage
There are services for all API endpoints. They all follow the same pattern as the example below.
```php
$masterApiKey = 'masterApiKey'; // Used as a fallback if no key is specified in a request
$selections = [\Torn\Services\UserService::BASIC];
$userId = 'someUserId';
$userApiKey = 'yourApiKey';
$useTornProxyByDefault = false;
$forceTornProxy = true; // Allows you to use Torn Proxy for a specific request
$httpClient = new GuzzleHttp\Client();

$client = new Torn\Client($httpClient, $masterApiKey, $useTornProxyByDefault);
$userService = new Torn\Services\UserService($client);
$user = $userService->fetch($userId, $selections, $userApiKey, $forceTornProxy);
```

repository: tim-dewit/torn-api

repo_name: tim-dewit/torn-api


text:
# scrapy-item-pipelines

Various scrapy item pipelines

## Installation

pip install scrapy-item-pipelines

## SaveToKafkaPipeline

Item pipeline to push items to kafka. Items will be converted into JSON format and pushed to a defined kafka topic.

### Settings

```
SL_SCRAPY_ITEM_PIPELINES_SETTINGS = {
    "push_to_kafka_hosts": "localhost:9092"  # Kafka broker hosts. Separated with a comma.
    "push_to_kafka_default_topic": ""  # kafka default topic.
}
```

### Usage

If items should be pushed to different kafka topics per item, the topic can be defined in the item class.
Also if a data key should be pushed to kafka we can define the item field value to use by defining it
in the item class. If no `kafka_data_key` is defined no data key will be pushed.

```
class DemoItem(scrapy.Item):
    kafka_topic = "topic-to-push-items"
    kafka_data_key = "another_unique_field"

    field_name = scrapy.Field()
    another_unique_field = scrapy.Field()
```

After configuring add `scrapy_item_pipelines.streaming.PushToKafkaPipeline` to the ITEM_PIPELINES setting.

```
ITEM_PIPELINES = {
    ...
    ...
    "scrapy_item_pipelines.streaming.PushToKafkaPipeline": 999,
}
```

## FilterDuplicatesPipeline

Item pipeline to filter out duplicate items calculated using defined keys in the item.

### Usage

Define an attribute called unique_key in the item. If the unique key is a single field
unique_key can be defined as a string or if the unique key is a multi field key unique_key
should be a tuple of strings. If no unique_key is defined filtering will be done using `id` field.
If you want to skip duplicate filtering for an item define unique_key as None.

The pipeline will include a stats called `duplicate_item_count` which is the number
of duplicate items dropped.

```
class DemoItem(scrapy.Item):
    field1 = scrapy.Field()
    field2 = scrapy.Field()

    unique_key = None  # duplicates won't be filtered.

class DemoItem(scrapy.Item):
    # No unique_key is defined. Filtering will be done using `id` field.
    field1 = scrapy.Field()
    field2 = scrapy.Field()
    id = scrapy.Field()

class DemoItem(scrapy.Item):
    field1 = scrapy.Field()
    field2 = scrapy.Field()

    unique_key = "field1"  # Duplicates will be filtered using field1.

class DemoItem(scrapy.Item):
    field1 = scrapy.Field()
    field2 = scrapy.Field()

    unique_key = ("field1", "field2")  # Duplicates will be filtered using both field1 and field2
```

Add `scrapy_item_pipelines.misc.FilterDuplicatesPipeline` to the ITEM_PIPELINES setting.

```
ITEM_PIPELINES = {
    ...
    ...
    "scrapy_item_pipelines.misc.FilterDuplicatesPipeline": 500,
}
```

repository: singletonlabs/scrapy-item-pipelines

repo_name: singletonlabs/scrapy-item-pipelines


text:
**Note:** auto-generated from comments in: ./support/AC_Utils.cmake

## AC_Utils.cmake:

Defines needed utility functions that are (or should be) dependent on any autocoding calls to
be made. Other utilities should go in *Utils.cmake*.

## Function `serialns`:

Execute a command and set the serial namespace variable in "SERIAL_NS" parent. This allows us to
predict the output files generated by the python dictionary generator.

- **AI_XML:** path to AI XML used for serializable parsing
- **Return: SERIAL_NS** (set in outer scope)

## Function `acwrap`:

This function wraps the actual call to the autocoder in order to ensure that the functions are
performed correctly. This replaces a wrapper shell in order to step toward Windows support. This
function registers the autocoding steps specific to `codegen.py`.

Note: as the autocoder is rewritten, this will likely need to change.

- **AC_TYPE:** serializable, port, component, or topology
- **AC_FINAL_SOURCE:** final position of the CPP file
- **AC_FINAL_HEADER:** final position of the HPP file
- **AI_XML:** AI xml input to autocoder
- **XML_FILE_DEPS:** xml file dependencies
- **MOD_DEPS:** xml and hand specified module dependencies
- **Return: AC_OUTPUTS** (set in outer scope)

repository: suriyaa/fprime

branch_name: refs/heads/devel

repo_name: suriyaa/fprime


text:
# Django Swagger Render

## Getting Started

### Prerequisites

- python >= 3.5
- Django >= 2.0

### Installation

Install using pip

```
pip install django-swagger-render
```

Add 'swagger_render' to your INSTALLED_APPS setting.

```
INSTALLED_APPS = [
    ...
    'swagger_render',
]
```

Create the folder where you will store your documentation

```
mkdir docs
```

Create the `index.yml` file with some `OPENAPI` or `Swagger` specifications

```
touch docs/index.yml
```

Serve your documentation files
```
urlpatterns += static('/docs/', document_root='docs')
```

Add `SWAGGER_YAML_FILENAME` setting to your `settings.py`

```
SWAGGER_YAML_FILENAME = '/docs/index.yml'
```

Add the `SwaggerUIView` to your urls

```
from swagger_render.views import SwaggerUIView

urlpatterns = [
    ...
    path('swagger/', SwaggerUIView.as_view()),
]
```

Voila!

repository: progremir/django-swagger-render

repo_name: progremir/django-swagger-render


text:
# tutorial-privacy-popup

## Introduction
This tutorial shows how to use a Decision Point Campaign to display a localized privacy policy to players when they first launch the game. A **privacyPolicyViewed** event is recorded to identify players that have seen the privacy policy and a **privacyPolicyTimestamp** metric is recorded in order to build a segment that could be used for re-targetting in the event of a policy update.

![en_GB Popup](Images/popup-en_GB.png)

The output of this tutorial is a **Prefab** package that can be imported into an existing Unity project and used with minimal effort.

## Using the Prefab
The following steps show you how to use the privacy policy prefab in your own projects with minimal integration.

### Download the Privacy Policy Prefab
1 -  Download the latest Privacy Policy prefab file from the [Releases](https://github.com/deltaDNA/tutorial-privacy-popup/releases) page.

2 - Import it into your Unity project by selecting the Assets > Import Package > Custom Package option on the Unity Editor menu, then select the downloaded package file and import it.

Alternatively, drag and drop the package file into the Prefabs folder in the Unity Editor Projects window.

3 -   Drag and Drop the Privacy Policy Prefab into your Scene.

The privacy policy popup does require that you are using deltaDNA in your project, but other than that it is completely self contained. Each time the game is launched it will wait until the deltaDNA SDK is running then check the Decision Point campaign interface to see if it should download and display a Privacy Policy Popup.

Naturally, the privacy policy prefab and the deltaDNA SDK should be added to a scene that is active as soon as practically possible after the app has loaded..
![Importing the prefab](Images/import-popup.png)

### Create a Decision Point
A [decision point](https://docs.deltadna.com/reference/setup/manage-decision-points/) is essentially a place in the game where you want to check to see if game should do something different from normal for the player at this specific point in time.

The game will reach out to the deltaDNA server and anounce that it has this specific player at this point in the game, the server will then tell the game what to do.

The response will be based on the [decision point campaigns](https://docs.deltadna.com/reference/engage/campaigns-3/create-campaign/) that are configured and active, their priorioty, the player's [segmentation](https://docs.deltadna.com/reference/analyze/segmentation-2/) based on current and historical data and any campaign logic defined in the campaign.

So, to start with we need a decision point to say *"The player is here in the game"*

1 - Create a decision point called **privacyPolicyCheck** from the SETUP > Manage Decision Points menu in the DEV environment of your game in the [deltaDNA platform](https://deltadna.net). Then click the "Save" button
![Create Decision Point](Images/decision-point.png)

2 - Publish the decision point to your LIVE environment, until you do so it will only be available to campaigns on your DEV environment.
![Publish Decision Point](Images/publish-decision-point.png)

### Creat an Event
The privacy policy prefab will record a **privacyPolicyViewed** event each time the privacy policy popup is shown to a player. But, the deltaDNA platform will reject it as an unknown event unless we create an event schema for it.

1 - Create a new event called **privacyPolicyViewed** from the SETUP > Manage Events menu in the DEV environment of your game in the [deltaDNA platform](https://deltadna.net).

2 - Add a new **privacyPolicyAccepted** parameter to the **eventParams** section of your new event. The parameter should be created as a **required** INTEGER parameter and you should set the Last, Max and Sum metrics to true.

This event parameter will allow you to identify if the player hit the accept button or simply dismissed the privacy policy popup.

3 - Add a new **privacyPolicyTimestamp** parameter to the **eventParams** section of your new event. The parameter should be created as a **required** TIMESTAMP parameter and you should set the First and Last metrics to true.

This event parameter will be stored as a metric and we will be able to use it on subsequent privacy policy update campaigns to target players who last saw the privacy policy before or after a particular date and time.

4 - As an optional step, you can delete the **userLevel, userScore** and **userXP** parameters from this event. They are optional parameters that won't be populated by the privacy policy popup code. Whether you leave them in or remove them will make no material difference, but youe event will look cleaner if you remove them.

The final event should look like this.
![privacyPolicyViewed event](Images/privacyPolicyViewed-event.png)

5 - Don't forget to "Save" your event.

6 - Publish the event to your LIVE environment, until you do so it will only be available in your DEV environment and any events sent to your LIVE environment will be rejected.
![Publish privacyPolicyViewed event](Images/publish-privacyPolicyViewed-event.png)

### Create a "Privacy Policy Popup" Image Message
A localised [Image Message Action](https://docs.deltadna.com/reference/engage/actions/image-message-actions/) will be sent to the player and displayed as a popup image by the SDK. The contents of the popup will be based on the **userLocale** information their device revealed to the decision point campaign at runtime.

The following image elements need to be supplied for each localised version of the popup
* A background grpahic containing the popup panel and any text
* A button graphic for the player to accept the popup
* *Optionally a close button to dimiss the popup*

1 - Create a new **Image Message** Action called from the ENGAGE > In Game Actions  menu in the [deltaDNA platform](https://deltadna.net).

2 - Set it to "Send image contents on everyEngage request"
*This will make sure that the player will see the image message even if there is an issue downloading or displaying the image the first time around. Settings later on in the campaign will ensure they don't see it more than once.*
![Image Message on every request](Images/image-message-send-every-request.png)

3 - Add the "Main Image" for your popup, this contains the background and default text to display. Set the behaviour of the Image to "Dismiss" if the user clicks on it. Then set the position and margin options.
![Image Message Main Image](Images/image-message-main.png)

4 - Use the Localise button to add additional variants of the main image for each "Language" required. Repeat this step as necessary.
![Image Mesasge Main Image Localised](Images/image-message-main-language.png)

5 - Add a "Button" graphic and set it to have an Action called "Accept" when clicked
![Image Message Button](Images/image-message-button.png)

6 - Use the localise button to upload different language variant of your button graphic. Repeat this step for all language variants.
![Image Message Localised Button](Images/image-message-button-localised.png)

7 - *You can add an additional "Close" button if you want. If you do, set the Action behaviour on it to "Dismiss" if the player clicks it.*

8 - Drag any buttons in to position in the preview paneal and and check your popup looks OK.
![Image Message Preview](Images/image-message-preview.png)

9 - Set the Image Message background settings
![Image Message Background Settings](Images/image-message-background.png)

10 - Don't forget to "Save" your Image Message Action.

### Create a "Privacy Policy Popup" Decision Point Campaign
The privacy popup display will be controlled by a [Decision Point Campaign](https://docs.deltadna.com/reference/engage/campaigns-3/create-campaign/). The game will make a request to the specific decision point each time it launches, the decision point campaign engine will return the correctly localised image message if the player is elligable to see the popup at this precise time.

1 - Create a new **Decision Point Campaign** from the ENGAGE > In Game > Decision Point Campaigns menu in the [deltaDNA platform](https://deltadna.net).

2 - Give your campaign a name and description

3 - If there are any other campaigns currently active on the same decision point you will beed to consider the Priority setting, else you can leave this at the default value.

4 - Set the "Decision Point" to us the "Privacy Policy" decision point created earlier.
![Decision Point Selection](Images/decision-point-selection.png)

5 - Set the player segment that the campaign will target to "All Players"
![Decision Point Segmen](Images/decision-point-segment.png). You can refine this if you only want to show the privacy policy popup to a subset of players.

6 - The Start and End Date for the campaign can be set to specific dates if required, but in this example we will set the campaign to start immediately and run forever until we stop it.

7 - Leave the AB Test switch set to "NO" unless you plan on testing different versions of your popup.
![Decision Point DateRange](Images/decision-point-daterange.png)

8 - Configure the content for "Action 1" to use the "Privacy Policy" Image Message Action setup earlier and set the "Final State" toggle switch to "YES" as we want to make sure the player exits the campaign after they have been shown the popup, they shouldn't see the popup multiple times.
![Decision Point Action](Images/decision-point-action.png)

9 - Set the campaign conversion to use the "privacyPolicyViewed" events to measure the success of the campaign.
![Decision Point Conversion](Images/decision-point-conversion.png)

10 - Save your campaign

11 - Navigate to the campaign conformation page, check your campaign details then click the "Launch" button, to start your campaign.
![Decision Point Campaign Launch](Images/decision-point-launch.png)

Your campaign will be live within about 10 minutes and can be cecked on a device or using the [SETUP > Engage Trace Tool](https://docs.deltadna.com/reference/setup/engage-qa-testing/).

## Appendix 1 - Country based localisation.
This tutorial has used the "language" component of the **userLocale** parameter that the SDK populates and sends with each decision point request. You may have noticed that the Image Message Action localisation system also lets you use the "Territory" as a component. However we have not made use of this feature as the deltaDNA Unity SDK does not populate the Territory correctly. However, if you are using this technique with the deltaDNA iOS or Android SDKs the "Territory" option can be used successfully.

## Appendix 2 - Localised text rather than images.
This tutorial has relied on the localised text for the popup being burnt into the popup image. Whilst this requires the creation of indivdual images for each locale variant, it leaves the graphic designer in control of the final image.

It would be possible to follow an alternate route and pass localised text to the game client as localised Game Parameters attached to an image message that contained just a single common image. The game client could then dynamically draw the text over the base image.

However, this approach introduces a few additional complexities.
* As well as sending the localised text as game parameters you will quickly realise that you may want to remotely configure the Title and Body text differently.
* You may want to remotely configure the Font, Font Size, Color, Alignment and Position with game parameters.
* What about drop shadows, glows or other text effects
* And different locale versions of the text may be quite different lengths, so the font size and position may need to vary.

So, for simplicity and image quality reasons, this tutorial stops short of dynamically drawn text overlays.

repository: deltaDNA/tutorial-privacy-popup

branch_name: refs/heads/main

repo_name: deltaDNA/tutorial-privacy-popup


text:
## Hi!

I built this because the metrics boards I wanted to use were too expensive. It's pretty shoddy right now, but it does the job, and I'm sure with a little community effort we could make this really useful.

To get it working:
If you're already setup on Heroku, skip these steps

Sign up on [Heroku](http://heroku.com/)
Download the [Heroku Toolbelt](https://devcenter.heroku.com/articles/heroku-command-line)

Then

Clone the repo
```
git clone https://github.com/wilsoncusack/metrics-board.git
```
Change directory into the app and create a heroku app
```
cd metrics-board
heroku apps:create your-app-name
```

Provision a Postgres Database
```
heroku addons:create heroku-postgresql:hobby-dev
```
(More info [here](https://devcenter.heroku.com/articles/heroku-postgresql#provisioning-the-add-on))

Provision a Redis Database
```
heroku plugins:install heroku-redis
heroku addons:create heroku-redis:hobby-dev -a your-app-name
```
(This will require a credit card, but you won't be billed below a certain usage. More info [here](https://devcenter.heroku.com/articles/heroku-redis))

Write the credentials to your enviroment
```
source env.sh
```

Then, to run locally (which will run a migration)
```
npm run dev
```

There is currently nothing setup client side to add to the accounts or users table.

You can add to the accounts by using the Heroku Postgres CLI
```
heroku pg:psql DATABASE_URL
```
And then once you're in
```
INSERT INTO accounts (name, mixpanel_api_secret) values (YOUR_NAME, YOUR_MIXPANEL_API_SECRET);
```
Or, with the server running
```
curl --data "accountName=YOUR-ACCOUNT-NAME&mixpanelAPISecret=YOUR-MIXPANEL-API-SECRET" localhost:3001/api/account
```

To add a user, with the server running, cURL (sorry there isn't a better way yet)
```
curl --data "username=YOUR-USERNAME&password=YOUR-PASSWORD&accountID=1&accountAdmin=true" localhost:3001/api/user
```
Account ID should be 1, unless you already created an account some other way.

To deploy, first build
```
cd client
npm run build
```

Then add the build
```
cd ..
git add client/build
git add .
git commit -m "adding build"
```
and push
```
git push
git push heroku master
```

It's built to run on [Heroku](http://heroku.com). Used [this](https://github.com/fullstackreact/food-lookup-demo) example for the client/server setup.

New to React, so I'm sure I'm not using it well.

New to Node, so I closely followed PG pool example
https://github.com/brianc/node-postgres/wiki/Example

Note: the demo site is insecure, so you should not use sensitive data on it.

To Do:
- [ ] Add account invite/new authentication. Right now anyone can add themselves to an account via a cURL request.
- [ ] Add ability to edit/delete widgets
- [ ] Add more integrations (right now only mixpanel)
- [ ] Add more widgets/display options (like graphs). Will also then need to add widget type to the widget table in the db.
- [ ] Add ability to compute formulas
- [ ] Drag and drop UI
- [ ] Add ability to create an account, client side
- [ ] Add ability to add and remove users from account, client side

repository: wilsoncusack/metrics-board

repo_name: wilsoncusack/metrics-board


text:
# amps-integration-datadog
Datadog AgentCheck for AMPS.

# Installation

Here are the steps to install the AMPS AgentCheck for Datadog:

1. Install the datadog agent on your AMPS host.

2. Copy the files from this github repo to your host:

```
    amps.py   -> /etc/dd-agent/checks.d
    amps.yaml -> /etc/dd-agent/conf.d
```

3. Edit the amps.yaml configuration file in /etc/dd-agent/conf.d to contain a list of AMPS instances on the host and their Admin ports. Example:

```
init_config:

instances:
    - name:  monolith
      admin: localhost:2345

    - name:  sample
      admin: localhost:8085
```

# Metric Descriptions

The metric names align with those found in the AMPS Monitoring Reference here:  http://www.crankuptheamps.com/documentation/

gha_language: Python


text:
# DevConnector 2.0

> Social network for developers

This is a MERN stack application from the "MERN Stack Front To Back" course on [Udemy](https://www.udemy.com/mern-stack-front-to-back/?couponCode=TRAVERSYMEDIA). It is a small social network app that includes authentication, profiles and forum posts.

## Updates since course published

Since the course was published, GitHub has [depreciated authentication via URL query parameters](https://developer.github.com/changes/2019-11-05-deprecated-passwords-and-authorizations-api/#authenticating-using-query-parameters)
You can get an access token by following [these instructions](https://help.github.com/en/github/authenticating-to-github/creating-a-personal-access-token-for-the-command-line)
For this app we don't need to add any permissions so don't select any in the _scopes_.
**DO NOT SHARE ANY TOKENS THAT HAVE PERMISSIONS**
This would leave your account or repositories vulnerable, depending on permissions set.

It would also be worth adding your `default.json` config file to `.gitignore`
If git has been previously tracking your `default.json` file then...

```bash
git rm --cached config/default.json
```

Then add your token to the config file and confirm that the file is untracked with `git status` before pushing to GitHub.
You'll also need to change the options object in `routes/api/profile.js` where we make the request to the GitHub API to...

```js
const options = {
  uri: encodeURI(
    `https://api.github.com/users/${req.params.username}/repos?per_page=5&sort=created:asc`
  ),
  method: 'GET',
  headers: {
    'user-agent': 'node.js',
    Authorization: `token ${config.get('githubToken')}`
  }
};
```

## Quick Start

### Add a default.json file in config folder with the folowing

```
{
  "mongoURI": "<your_mongoDB_Atlas_uri_with_credentials>",
  "jwtSecret": "secret",
  "githubToken": ""
}
```

### Install server dependencies

```bash
npm install
```

### Install client dependencies

```bash
cd client
npm install
```

### Run both Express & React from root

```bash
npm run dev
```

### Build for production

```bash
cd client
npm run build
```

## App Info

### Author

Brad Traversy
[Traversy Media](http://www.traversymedia.com)

### Version

2.0.0

### License

This project is licensed under the MIT License

repository: Kmonterohenriquez/devconnector-priv

repo_name: Kmonterohenriquez/devconnector-priv


text:
Final Study Guide
=======================================

## Short Essay Questions will be from:

1. Explain a zero knowledge proof to a layman.

Read the section "Ali Baba Cave" in Wikipedia on Zero Knowledge
Proof.  [https://en.wikipedia.org/wiki/Zero-knowledge_proof](https://en.wikipedia.org/wiki/Zero-knowledge_proof).
Be able to reproduce the cave diagram and write a short explanation of it.

2. Explain zk-SNARK -  What is the "SNARK" part of zk-SNARK.

"zk" is for zero knowledge.

SNARK is (S, N, AR, K)

* Succinct – the sizes of the hash functions (proofs) are tiny in comparison
to the length of the actual process required to create them.

* Non-interactive – there is no or only little interaction. For zk-SNARKs,
there is usually a setup phase and after that a single point of contact between
the prover and the verifier. Furthermore, SNARKs often have the so-called
“public verifier” property meaning that anyone can verify without
interacting anew, which is important for blockchains.

* ARguments – the verifier is only protected against computationally limited
provers. Provers with enough computational power can create proofs/arguments
about wrong statements. (Note that with enough computational power, any
public-key encryption can be broken). This is also called “computational
soundness,” as opposed to “perfect soundness.”

* of Knowledge – it is not possible for the prover to construct a
proof/argument without knowing a certain so-called witness. (For example the
address he wants to spend from, or the path to a
certain Merkle-tree node).

3. How can blockchain change accounting?

Double entry accounting was first recorded in 1340 in Genoa, Italy.  It has remained
basically the same since.  We have automated the same system that has been used for
hundreds of years.  Blockchain provides a mathematically provable way of implementing
accounting so that the most common form of accounting fraud is impossible to do.
This is the first real "technological" advance in accounting in 500+ years.

3. When was double entry accounting invented?

Double entry accounting was first recorded in 1340 in Genoa Italy.

3. What is a blockchain? - Why is blockchain important? - What are blockchains used for?

A blockchain is a set of blocks that are written over time, and stored in a publicly
accessible way.  Each block is cryptographically signed and the signatures are
used to chain the blocks together.   The blocks are distributed so that every
computer in the network has a copy of the blocks.   Blockchain is the underlying
technology behind BitCoin and other Cryptocurrencies.

4. Why is blockchain important?

Blockchain creates trust between un-trusting parties.  It is a system for verifying
that data that is entered has not changed over time.   It creates an immutable
data store that can be verified mathematically.

5. What is a smart contract?

A smart contract is a program that runs on a blockchain.  It is run by the "miners"
that run and maintain the chain.

6. What is "mining" in the context of a blockchain system?

Mining is the process of transferring funds from account to account and running of
smart contracts.  It also implements the digital signatures, (hashes), that provide
security for a blockchain.

7. What are the good properties of a blockchain?

* Immutable data

* Distributed data

* Verifiable data

* Distributed source of trust

8. What are the bad properties of a blockchain?

* Slowest database around.

* Most expensive database around.

9. How do blockchains create trust between non-trusting parties?

The data is distributed and verifiable by all parties.  Trust is no longer a part of
an institution, it is a mathematically verifiable system.

10. Why is a blockchain an expensive database?

Ethereum has 12,000 nodes, (computers), that have to all update the storage of any
data.  It is not cheap to update 12,000 computers every time.

11. Why are blockchains a so slow?

Ethereum has 12,000 nodes, (computers).  It takes time to update a large set of
computers.  Every computer has to see every block of data and append every
verified block to the chain.  Every new block of data has to be verified.
Mining also takes time.

12. What is Ethereum "gas" and how does this relates to Turing-Complete?

13. Explain the Byzantine Generals problem and how Threshold-ECDSA ( Honey Badger Byzantine Generals ) solves it.

Imagine that Byzantine empire has decided to capture a city. There is fierce resistance from within the city. The
Byzantine army has completely encircled the city. The army has many divisions and each division has a general. The
generals communicate between each as well as between all lieutenants within their division only through unreliable
messengers.

All the generals or commanders have to agree upon one of the two plans of action. Exact time to attack all at once or if
faced by fierce resistance then the time to retreat all at once. If the attack or retreat is without full strength then
it means only one thing — horrible defeat.

If all generals and/or messengers were trustworthy then it is a very simple solution. However, some of the messengers
and even a few generals/commanders are traitors. There is a very high chance that they will not follow orders or pass on
the incorrect message.

In message passing the desired result is that they all either agree or all disagree. Previous implementations (Lamport
82) of this required a *lot* of computational work to get the desired result.

BGP is applicable to every distributed network.

t-ECDSA solves this by having in its last stage encrypted data that thru key sharing can only be decrypted when you have
a threshold number of participants agree on the private key information. At the moment when you have the threshold
number then you can decrypt the data (the transactions in a blockchain) and the data is finalized and accepted.

Honey Badger sits on top of t-ECDSA.

## Coding:

1. Solidity - a simple contract to store the hash of a document and
a name for the document.

* When is the contract constructor run?

* Who can call the functions?

* What do the 2 functions do?

## Finance:

1. What is the Yield Curve?

A yield curve is a line that plots the interest rates, at a set point in time,
of bonds having equal credit quality but differing maturity dates. The most
frequently reported yield curve compares the three-month, two-year, five-year,
10-year and 30-year U.S. Treasury debt. This yield curve is used as a benchmark
for other debt in the market, such as mortgage rates or bank lending rates, and
it is used to predict changes in economic output and growth.

2.  An inverted or down-sloped yield curve suggests yields on longer-term bonds may
continue to fall, corresponding to periods of economic recession.

3. A Mutual Fund is an investment vehicle made up of a pool of money collected
from many investors for the purpose of investing in securities such as stocks,
bonds, money market instruments and other assets. ... A mutual fund's portfolio
is structured and maintained to match the investment objectives stated in its
prospectus.

##Solidity Code

```
  1  pragma solidity >=0.4.21 <0.6.0;
  2
  3  import "openzeppelin-solidity/contracts/ownership/Ownable.sol";
  4
  5  contract DocumentReg is Ownable {
  6
  7    mapping(bytes32 => bool) infoSet;
  8    mapping(bytes32 => address) infoOwner;
  9    mapping(bytes32 => string) infoData;
 10    mapping(bytes32 => string) infoName;
 11    uint256 minPayment;
 12
 13    event DocumentSet(string, bytes32, string);
 14
 15    constructor() public {
 16      minPayment = 0;
 17    }
 18
 19    function setPayment ( uint256 p ) public onlyOwner {
 20      minPayment = p;
 21    }
 22
 23    function newInfo (  string name, bytes32 infoHash, string info )
		public payable {
 24      require(!infoSet[infoHash], "already set, already has owner.");
 25      require(msg.value >= minPayment, "insufficient payment to set data.");
 26      infoSet[infoHash] = true;
 27      infoOwner[infoHash] = msg.sender;
 28      infoData[infoHash] = info;
 29      infoName[infoHash] = name;
 30      emit DocumentSet(name, infoHash, info);
 31    }
 32
 33    function updateInfo (  bytes32 infoHash, string info )
		public payable {
 34      require(infoOwner[infoHash] == msg.sender, "not correct owner of this data.");
 35      require(msg.value >= minPayment, "insufficient payment to update data.");
 36      string storage name;
 37      name = infoName[infoHash];
 38      infoData[infoHash] = info;
 39      emit DocumentSet(name, infoHash, info);
 40    }
 41
 42  }
```


text:
Install the SYNCHRONO module   {#module_synchrono_installation}
===============================

This is an optional module that enables the parallelization of Chrono::Vehicle simulation across different computing entities.

Read [the introduction to modules](modularity.html) for a technical
background on the modularity of the Chrono project.

## Features

The **SynChrono module** allows users to parallelize the dynamics computations for Chrono::Vehicles across MPI or DDS entities.

## Required Dependencies

- To build applications based on this module, the following are required:
  * MPI
    - Linux: Tested with [OpenMPI](https://www.open-mpi.org/) and [MPICH](https://www.mpich.org/).
    - Windows: Tested with [Intel MPI](https://software.intel.com/en-us/mpi-library/choose-download/windows) and [MS-MPI](https://docs.microsoft.com/en-us/message-passing-interface/microsoft-mpi). You must ensure that the MPI dll (either `impi.dll` or `msmpi.dll`) is on your system path, for example by running a post-installation script ([Intel MPI example](https://software.intel.com/content/www/us/en/develop/documentation/mpi-developer-guide-windows/top/installation-and-prerequisites/prerequisite-steps.html)).
  * [FlatBuffers](http://google.github.io/flatbuffers/)
    - A version is included in chrono_thirdparty as a submodule, for general development either that version or an externally built one can be used.
- The following are optional:
  * [FastDDS](https://fast-dds.docs.eprosima.com/en/latest/)
    - Please use the [latest binaries](https://www.eprosima.com/index.php/component/ars/repository/eprosima-fast-dds) for installation.
    - Versions provided by package managers will likely work as well if they are reasonably up to date.

## Building instructions

1. Initialize the FlatBuffers submodule in `chrono_thirdparty` with `git submodule init` and `git submodule update`.
    - For running programs with SynChrono you just need the FlatBuffers header from initializing the submodule.
    - If you make modifications to the FlatBuffers message schemas you will need either an external version of the FlatBuffers binaries (for example from a package manager) or to [build the submodule version](https://google.github.io/flatbuffers/flatbuffers_guide_building.html) included in `chrono_thirdparty`.

2. Repeat the instructions for the [full installation](@ref tutorial_install_chrono). Chrono::Vehicle is required and at least one of Chrono::Irrlicht or Chrono::Sensor is recommended for visualization. When you see the CMake window, you must make these additional changes:

3. Set the `ENABLE_MODULE_SYNCHRONO` as 'on', then press 'Configure' (to refresh the variable list).

4. (Optional) If using Fast_DDS set `USE_FAST_DDS` to 'on', then press 'Configure'.
    - If you used the installed binaries they should be picked up automatically by CMake
    - If you built from source or installed in a non-standard location, you'll have to manually specify `FAST_DDS_INSTALL_DIR`.

5. Press 'Configure' again, then 'Generate', and proceed as usual in the installation instructions.

## How to use it

- Consult the [SynChrono API](@ref synchrono).
- Read the [overview](@ref module_synchrono_overview).

repository: projectchrono/chrono

repo_name: projectchrono/chrono


text:
# icurve
A program for Interpolating curve. **icurve** is designed to interpolate across multiple columns in Data File. This script supports both CSV and Delimited Flat Files (TXT, DAT).

![Si_Palik_UV_Vis](examples/ex2/sample_interp_plot.png)

Dielectric functions of Silicon in UV to Visible region [Ref: E. D. Palik, Handbook of Optical Constants in Solids (Academic Press, 1997].

# Prerequisites

* Python 3
* matplotlib, scipy, pandas, numpy
* argparse

# Usage guide
**icurve** operates as a command line tool with the following sub-commands:

```python
python /path/to/icurve.py -f=sample.dat -s=1 -xmin=1 -xmax=5 -n=101 [-k=linear] [-p=yes]
```
sub-command | short-code | description
---|---|---
help | h |  Help for sub-command
filename |f, file | [**Required**] Filename
skiprows | s, skip | [**Required**] Number of lines to skip at the start of the file. This function will be used to ignore comment lines or header.
xmin | xmin | [**Required**] Minimum value of x for interpolation.
xmax | xmax | [**Required**] Maximum value of x for interpolation.
npoints | n | [**Required**] Number of points for interpolation.
kind | k | [**Optional**] Specifies the interpolation method.
**Default: linear**.
Options: linear, nearest, zero, slinear, quadratic, cubic, previous, next.
plot |p | [**Optional**] Plot the raw data vs. interpolated data.
**Default: No**.
Options: {Yes, Y, True, T, 1}, {No, N, False, F, 0}

# Reference
https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.interp1d.html

repository: ngoducthien/icurve

repo_name: ngoducthien/icurve


text:
# PAC likely to examine cancellation of six Tata Trusts' registration, alleged violations

Published at: **2019-11-06T00:00:00+00:00**

Author: **PTI**

Original: [Moneycontrol](https://www.moneycontrol.com/news/india/pac-likely-to-examine-cancellation-of-six-tata-trusts-registration-alleged-violations-4611931.html)

Days after the Income Tax Department cancelled registration of six Tata Trusts, sources in Parliament's Public Accounts Committee (PAC) on November 6 said it is actively considering the issue and is likely to examine the alleged tax related violations by the trusts.
Last year, the PAC had recommended a probe into the alleged tax violations by Tata Trusts, while its sub-panel on Direct and Indirect Taxes, in its report, flagged several alleged violations.
The PAC's sub-committee had also demanded a probe into the "blatant tax violations" by the trusts.

        Close

On November 1, Tata Trusts said the Income Tax Department has cancelled registration of its six trusts, including Jamsetji Tata Trust, RD Tata Trust and Tata Education Trust, following their decision to surrender the same.

        Read | Income tax department cancels registration of six Tata Trusts

The other trusts are Tata Social Welfare Trust, Sarvajanik Seva Trust, and Navajbai Ratan Tata Trust.
The sources in the newly-constituted PAC of the 17th Lok Sabha, which is headed by Congress leader Adhir Ranjan Chowdhury, said the panel will look into the cancellation of the issue and examine the alleged tax related violations as reported by the previous committee.
They further said the panel has discussed the issue where companies are using trust route to avoid tax liability and will look into all the related matters.
Tata Trusts, in a statement, had said the cancellation was a culmination of the decision taken by these six trusts in 2015 to surrender their registration and to not claim the associated income tax exemptions.
"The decision to surrender the registration (an option available in law) was taken in the best interests of the trusts and to maximise the resources available to the Trusts for their charitable work which is the principal object and focus of the Trusts," it further said.Special Thursday Expiry on 10th 7th NovEarly Closure to The Great Diwali Discount. Last Chance to get Moneycontrol PRO for a year @ Rs. 289/- only Coupon code: DIWALI

repository: dsadlollioygjmzvcxv/tdc-exported

repo_name: dsadlollioygjmzvcxv/tdc-exported


text:
JDocGen
=======

JSON Scheme to REST API visualization and documentation

Key features
====================
1. Support for [http://json-schema.org/](http://json-schema.org/)
2. View methods and objects rest-api in an easy-to-read web interface
3. Extensive descriptions of attributes, including the use of **html**
4. History of changes between builds documentation
5. Build management of the web interface with one button
6. Overall statistics on the methods and objects

Tree of methods and objects
---------------------------
![land](https://pp.vk.me/c629431/v629431610/33f53/x0SvbgHAF-M.jpg)

Example of method
---------------------------

![land](https://pp.vk.me/c629431/v629431610/33f5a/Xm261Lvo_ZM.jpg)

Example of object
---------------------------

![land](https://pp.vk.me/c629431/v629431610/33f61/s0zM8-yRZsk.jpg)

History
---------------------------

![land](https://pp.vk.me/c629431/v629431610/33f68/REIGEblKKHU.jpg)

Statistics methods
---------------------------

![land](https://pp.vk.me/c629431/v629431610/33f6f/vSMo2RmmSTA.jpg)

Statistics objects
---------------------------

![land](https://pp.vk.me/c629431/v629431610/33f76/L5QUI7sAaYw.jpg)

Setup
===================

1. Install the project by the rules **Yii2**
2. Install migration - **. /yii migrate**
3. Access by default - **admin/admin**

Operating procedure
===============

1. Set up for the current domain source json-file
2. Edit the json-documentation files
3. Push the button "Update documentation", updated documentation for the selected version

Object description
================

1. Catalog placement - **objects**
2. File name - with a small letter, e.g. **app/json-schema/v8/objects/chatMessage.json**
3. Describe objects standard json schema
4. By default, set **additionalProperties** as **false** **("additionalProperties": false)**

### Advanced object description

#### PARENT - indication of parent object

```json
"$schema": "http://json-schema.org/draft-04/schema#",
"id": "chatMessageParamsPlace",
"title": "Options for the type of place",
"type": "object",
"meta": {
  "parent": "chatMessage"
}
```

### Advanced attribute description

#### HTML - description as the html

```json
"entity_id": {
  "meta": {
    "html": "<table class=\"table\"> ... </table>"
  },
  "description": "Description of the parameter depends on entity_type:",
  "type": "string"
}
```

#### ENUM - Description of the enum elements

```json
"type": {
  "meta": {
    "enum": {
      "event": "description for event",
      "combo": "description for combo"
    }
  },
  "description": "default - text",
  "enum": [
    "event",
    "combo"
  ]
}
```

#### RESTRICTIONS - description of the restrictions on the business logic

```json
"from_chat_id": {
  "meta": {
    "restrictions": "Must be specified if the parameter is specified from_time"
  },
  "type": "string"
}
```

### Method description

Allocation - **methods/{controller_id}/{action_id}.json**, e.g. **methods/auth/changePhone.json**

#### The file structure for an individual action

```json
{
  "title": "Action name",
  "description": "Action description",
  "request": {
    ...
  },
  "response": {
    ...
  }
}
```

#### The file for the controller description

The directory controller placed a required file **meta.json**, which provides the name of the controller.

```json
{
  "title": "Authorization"
}
```

repository: playdayteam/jdocgen

repo_name: playdayteam/jdocgen


text:
Getting Started
------------------
- [Haskell Language](https://www.haskell.org/)
- [HaskellWiki](https://wiki.haskell.org/Haskell)
- [Hoogle](https://www.haskell.org/hoogle/)

Haskell Books
--------------

- [Learn you a Haskell for Great Good!](http://learnyouahaskell.com/), by M. Lipovača
- [Haskell Book](http://haskellbook.com/), by C. Allen and J. Moronuki

Haskell Videos
-------------

- [A History of Haskell: Being lazy with class](https://www.youtube.com/watch?v=3bjXGrycMhQ) *by Simon Peyton Jones*
- [Escape from the Ivory Tower: the Haskell Journey](https://www.youtube.com/watch?v=re96UgMk6GQ) *by Simon Peyton Jones*
- [Why Functional Programming Matters](https://www.youtube.com/watch?v=1qBHf8DrWR8&t=28s) *by John Hughes and Mary Sheeran*
- [Propositions as Types](https://www.youtube.com/watch?v=IOiZatlZtGU) *by Philip Wadler*
- [Category Theory for the Working Hacker](https://www.youtube.com/watch?v=V10hzjgoklA) *by Philip Wadler*

Misc
----

- [Haskell-cafe mailing list](https://mail.haskell.org/mailman/listinfo/haskell-cafe)
- [Haskell Humor](https://wiki.haskell.org/Humor)

extension: markdown

gha_language: Haskell


text:
# Skriva
Skriva (Skreeeeeva) is a barebones static blog Rails engine. Drop markdown files in a folder and have each file accessible with its own individual route. Inspired by the jekyll and high voltage gems.

# Wiki

Check out the [wiki](https://github.com/sunrick/skriva/wiki) for installation, usage and other directions.

## License
The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

repository: sunrick/skriva

repo_name: sunrick/skriva


text:
# Setting up WeaveScope for visualizing Kubernetes Pods, Services, Containers & Hosts

## Pre-requisite

- Docker for Mac
- GKE Cluster
- The ```docker context``` shows you GKE Cluster

```

kubectl create clusterrolebinding "cluster-admin-$(whoami)" --clusterrole=cluster-admin --user="$(gcloud config get-value core/account)"
```

## Installing WeaveScope

```
kubectl apply -f "https://cloud.weave.works/k8s/scope.yaml?k8s-version=$(kubectl version | base64 | tr -d '\n')"
```

This downloads a recent Scope image from Dockerhub and launches a probe onto every node as well as a single Scope app. Once launched, Scope doesn’t require any other configuration.

Allowable parameters for the launcher URL:

```
v - Weave Scope version or tag, e.g. latest current release is the default
k8s-service-type - Kubernetes service type (for running Scope in Standalone mode), can be either LoadBalancer or NodePort, by default this is unspecified (only internal access)
```

## Open Scope in Your Browser

```
kubectl port-forward -n weave "$(kubectl get -n weave pod --selector=weave-scope-component=app -o jsonpath='{.items..metadata.name}')" 4040
```

Now get ready to access via  http://localhost:4040.

![My Image](https://github.com/collabnix/dockerlabs/blob/master/kubernetes/workshop/weave.jpg)

repository: collabnix/dockerlabs

repo_name: collabnix/dockerlabs


text:
---
permalink: /publications/
title: "Publications"
excerpt: "publication.md"
last_modified_at: 2023-03-01 11:43:00
toc: true
toc_sticky: true
# tags: [publication]
layout: single
author_profile: true

---

## Conferences
1. Jun Ho Huh, Hyejin Shin, HongMin Kim, Eunyong Cheon, Youngeun Song, Choong-Hoon Lee, and Ian Oakley. 2023. WristAcoustic: Through-Wrist Acoustic Response Based Authentication for Smartwatches. Proc. ACM Interact. Mob. Wearable Ubiquitous Technol. 6, 4, Article 167 (December 2022), 34 pages. <https://doi.org/10.1145/3569473>

1. Song, Y., Oakley, I. (2022). PushID: A Pressure Control Interaction-Based Behavioral Biometric Authentication System for Smartwatches. In: Moallem, A. (eds) HCI for Cybersecurity, Privacy and Trust. HCII 2022. Lecture Notes in Computer Science, vol 13333. Springer, Cham. <https://doi.org/10.1007/978-3-031-05563-8_17>

## Journal
1. Youngeun Song & Ian Oakley (2022) PushPIN: A Pressure-Based Behavioral Biometric Authentication System for Smartwatches, International Journal of Human–Computer Interaction, DOI: <https://doi.org/10.1080/10447318.2022.2049144>

## Domestic conference
1. Youngeun Song, Ian Oakley.(2018).CordDial: Usability study about new enhanced TUI with elastic feedback for mobile platform.한국HCI학회 학술대회,(),28-31. <https://www.dbpia.co.kr/journal/articleDetail?nodeId=NODE07401343>

2. Youngeun Song, Haebin Lee, Gwangyoung Lee, Jaehee Lee, Hwajung Hong.(2017).PUPPIT: Pre-Adoption Experience for Novice Pet Owners via Combination of Augmented Reality and Tangible User Interaction.대한인간공학회 학술대회논문집,(),485-485. <https://www.dbpia.co.kr/journal/articleDetail?nodeId=NODE07301926>

3. Youngeun Song, Hyungmin Kang, Ian Oakley.(2016).CordDial : Cords and Dials for Tangible User Interaction on a Tablet Computer.대한인간공학회 학술대회논문집,(),413-413. <https://www.dbpia.co.kr/journal/articleDetail?nodeId=NODE07093916>

4. Youngeun Song, Suraiya Jahan Liza, Ian Oakley.(2016).Typing on the Edge.한국HCI학회 학술대회,(),223-225. <https://www.dbpia.co.kr/Journal/articleDetail?nodeId=NODE06645462>


text:
# Community Code of Conduct

## Overview

This document makes a reference to the rules of behavior for all contributors and maintainers in the community. All members agree to follow them to foster the growth of the community of tolerance, respect, and mutual understanding.

## Code of conduct

In the attempt to adopt the best practices from the most renowned open-source projects, our community members undertake to follow the rules outlined in the [Contributor Covenant](http://contributor-covenant.org), version 1.2.0, available [here](http://contributor-covenant.org/version/1/2/0/). Read it to learn about the harassment-free environment, examples of unacceptable behavior, and the responsibilities of the project maintainers.

## Violations

If you observe any instance of abusive, harassing, or otherwise unacceptable behavior, report it as an issue to the project maintainers specified in the `CODEOWNERS` document.

repository: SAP/luigi

repo_name: SAP/luigi


text:
---
layout: base
title:  'Statistics of PART in UD_Swedish_Sign_Language-SSLC'
udver: '2'
---

## Treebank Statistics: UD_Swedish_Sign_Language-SSLC: POS Tags: `PART`

There are 1 `PART` lemmas (8%), 1 `PART` types (0%) and 1 `PART` tokens (0%).
Out of 13 observed tags, the rank of `PART` is: 10 in number of lemmas, 13 in number of types and 13 in number of tokens.

The 10 most frequent `PART` lemmas: _

The 10 most frequent `PART` types:  SYFTE

The 10 most frequent ambiguous lemmas: _ (<tt>VERB</tt> 611, <tt>NOUN</tt> 362, <tt>PRON</tt> 175, <tt>ADV</tt> 119, <tt>X</tt> 71, <tt>DET</tt> 61, <tt>INTJ</tt> 56, <tt>ADJ</tt> 55, <tt>AUX</tt> 37, <tt>NUM</tt> 25, <tt>ADP</tt> 24, <tt>CCONJ</tt> 13, <tt>PART</tt> 1)

The 10 most frequent ambiguous types:

## Morphology

The form / lemma ratio of `PART` is 1.000000 (the average of all parts of speech is 54.615385).

The 1st highest number of forms (1) was observed with the lemma “_”: SYFTE.

`PART` does not occur with any features.

## Relations

`PART` nodes are attached to their parents using 1 different relations: <tt>mark</tt> (1; 100% instances)

Parents of `PART` nodes belong to 1 different parts of speech: <tt>VERB</tt> (1; 100% instances)

1 (100%) `PART` nodes are leaves.

The highest child degree of a `PART` node is 0.

repository: UniversalDependencies/docs

branch_name: refs/heads/pages-source

repo_name: UniversalDependencies/docs


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

iDSK is a tool to edit DSK (Amstrad CPC disk images) files from the command
line. You can add and remove files from your image, but also list BASIC and
DAMS source files (which are usually in a tokenized format, not plain ASCII).

iDSK can add and remove AMSDOS headers as needed.

repository: cpcsdk/idsk

gha_license_id: NOASSERTION

repo_name: cpcsdk/idsk


text:
# Preconfigured workflows

Once you have setup YAP feel free to download and run any of our preconfigured workflows listed below.

* RNASeq QC and Counts pipeline - [Download configuration](rnseq_qc_counts.zip)

	FastQC, FastqScreen- > Bowtie ->cooridnate and queryname sort -> Picard tools, Cufflinks, and HTSeq counts

* GATK Variant calling pipeline - [Download configuration](variant_call.zip)

	BWA -> Picard MarkDuplicates.bam -> GATk - RealignerTargetCreator, IndelRealigner, CountCovariates, TableRecalibration; Picard - QualityScoreDistribution, CalculateHsMetrics, CollectTargetedPcrMetrics

* ChIP-Seq peakcalling - [Download configuration](chipseq.zip)

	Fastq, fastq screen ->  alignment to hg19 with BWA -> filter low map quality reads -> coordinate sort -> peak calls using MACS2

* Bacterial classification - [Download configuration](bacterial_classification.zip)

	Fasta files -> classfication using mothur package -> summarize the results

repository: saitanishq/yap

repo_name: saitanishq/yap


text:
project_path: /web/_project.yaml
book_path: /web/updates/_book.yaml
description: The Chromium Chronicle, a monthly series geared specifically to Chromium developers — the developers who build the browser.

{# wf_updated_on: 2020-02-05 #}
{# wf_published_on: 2020-02-05 #}
{# wf_tags: chromium-chronicle #}
{# wf_featured_image: /web/updates/images/generic/cr-chron.jpg #}
{# wf_featured_snippet: Chrome’s testing strategy relies heavily on automated functional correctness tests and manual testing, but neither of these reliably catch minor UI regressions. Use pixel tests to automate testing your desktop browser UI. #}
{# wf_blink_components: N/A #}

# The Chromium Chronicle: Catching UI Regressions with Pixel Tests {: .page-title }

**Episode 10:** January, 2020

*by Sven Zheng in Bellevue, WA*

Chrome’s testing strategy relies heavily on automated functional correctness
tests and manual testing, but neither of these reliably catch minor UI
regressions. **Use pixel tests to automate testing your desktop browser UI.**

When writing a pixel test, avoid flakiness by (1) disabling animation,
(2) using mock data, and (3) testing the minimum possible surface area.

Here is a sample image used to verify pixel correctness for the omnibox:

And the code to verify the browser matches this image:

```cpp

IN_PROC_BROWSER_TEST_F(SkiaGoldDemoPixelTest, TestOmnibox) {
  // Always disable animation for stability.
  ui::ScopedAnimationDurationScaleMode disable_animation(
      ui::ScopedAnimationDurationScaleMode::ZERO_DURATION);
  GURL url("chrome://bookmarks");
  AddTabAtIndex(0, url, ui::PageTransition::PAGE_TRANSITION_FIRST);
  auto* const browser_view = BrowserView::GetBrowserViewForBrowser(browser());
  // CompareScreenshot() takes a screenshot and compares it with the golden image,
  // which was previously human-approved, is stored server-side, and is managed
  // by Skia Gold. If any pixels differ, the test will fail and output a link
  // for the author to triage the new image.
  bool ret = GetPixelDiff().CompareScreenshot("omnibox",
      browser_view->GetLocationBarView());
  EXPECT_TRUE(ret);
}
```

This code lives at [chrome/test/pixel/demo/skia_gold_demo_pixeltest.cc][1].
The relevant headers are `skia_gold_pixel_diff.h` for unit tests and
`browser_skia_gold_pixel_diff.h` for browser tests.

[1]: https://chromium.googlesource.com/chromium/src.git/+/refs/heads/master/chrome/test/pixel/demo/

The pixel diff and approval process is powered by Skia Gold. **Skia Gold pixel
tests provide a visual approval workflow, and allow developers to accept
small flakes by approving multiple gold images.**

Currently the test suite is running on the Windows FYI bot. Browser tests
and Views unit tests are supported.

{% include "web/_shared/helpful.html" %}

{% include "web/_shared/rss-widget-updates.html" %}

repository: rachelandrew/WebFundamentals

repo_name: rachelandrew/WebFundamentals


text:
### [Stats](https://github.com/ctcampbell/veracode-stats)

Summary statistics for a Veracode account on the command line.

![](https://img.shields.io/github/stars/ctcampbell/veracode-stats.svg)
![](https://img.shields.io/github/languages/top/ctcampbell/veracode-stats)
![](https://img.shields.io/github/contributors/ctcampbell/veracode-stats)
[![](https://img.shields.io/github/followers/ctcampbell?label=ctcampbell&style=social)](https://github.com/ctcampbell)

---
### [VeraData](https://github.com/sebcoles/VeraData)

Console application that will retrieve data (all scans, flaws, mitigations etc) for a given AppId and store the results in a relational schema (only supports MSSQL Server currently) ready for plugging your favourite BI tool into!

![](https://img.shields.io/github/stars/sebcoles/VeraData.svg)
![](https://img.shields.io/github/languages/top/sebcoles/VeraData)
![](https://img.shields.io/github/contributors/sebcoles/VeraData)
[![](https://img.shields.io/github/followers/sebcoles?label=sebcoles&style=social)](https://github.com/sebcoles)

---

repository: sebcoles/Veracode-Community-Projects

repo_name: sebcoles/Veracode-Community-Projects


text:
Introduction
============
THis template is base on AdminLTE.

**Download & Preview on [Almsaeed Studio](https://almsaeedstudio.com)**

Image Credits
-------------
[Pixeden](http://www.pixeden.com/psd-web-elements/flat-responsive-showcase-psd)

[Graphicsfuel](http://www.graphicsfuel.com/2013/02/13-high-resolution-blur-backgrounds/)

[Pickaface](http://pickaface.net/)

[Unsplash](https://unsplash.com/)

[Uifaces](http://uifaces.com/)

repository: vneverz/btadminYzu

repo_name: vneverz/btadminYzu


text:
---
layout: page
Title: Problem Scale
permalink: /problem_scale/
---

# The Scale of the Problem

## Global fossil fuel consumption

We consume about 100 million barrels (á ~160 litres), or 16 billion liters of crude oil **every day**. The world population is about 8 billion, so the _average_ consumption is roughly 2 liters per capita per day (we'll cover gas and coal later.) The US and China combined consume about 33% of the total, and Europe and Eurasia consume ~20% between them.

But the vast majority of the world population doesn't consume any fossil fuel at all: Latin Americans consume 4% of the total crude oil (without Brazil), and the almost 1 billion Africans consume about 2% (without Algeria, Egypt and Republic of South Africa). (BP Statistical Review of World Energy 2017).

## Global cooking fuel consumption

2.8 billion people cook their food on solid fuels like wood, crop residues, dung, charcoal, and coal (and they mostly walk on foot). Because they need to cook their food, and generally use very inefficient cooking methods, they participate to a huge extent in global deforestation... **unless they change their cooking methods**. Gasification of wood is the option to go for, because it is very efficient and has a number of other advantages covered below.

## Deforestation

Besides all other negative aspects of clearing vegetation, the carbon contained in wood will be metabolized to CO2 by microorganisms, or, more rapidly, by fire. At the current rate, the CO2 from this source contributes by about x % to the total

Dry wood, on average, consists of about 60% of carbon; most of the rest is hydrogen and oxygen, and smaller quantities of "ash" (minerals).

## Preventable CO2 formation

We could all walk on foot, and carry our goods, and prevent all emissions from transportation. But that is not the goal here. We want to prevent the looming climate collapse ovide reasonable luxury for all and prevent t

##

Other advantages...
, avoids almost all the smoke of traditional wood fires (which improves their respiratory health, and that of especially their young children), and the by-product, biochar, used properly, improves soil fertility, water retention capacity, ...

repository: zorbathegreek/shift-latest

repo_name: zorbathegreek/shift-latest


text:
Co-Simulation Model Generator
=========

Overview
---
Co-Simulation enables one to jointly simulate and verify their application programs along with the underlying hardware. This setup uses the [Redhat SID](https://sourceware.org/sid/) which provides various hardware and reference board models to run simulations. Verilog RTL can be translated into a SID model which can be plugged into a pre-configured SID board.

Tools Involved
---
The following tools are involved in this setup:
- [Redhat SID](https://sourceware.org/sid/): SID is a framework for building computer system simulations. The setup has currently been tested and supports
only the ARM7 PID Board.
- [Verilator](http://www.veripool.org/wiki/verilator): Converts Verilog hardware descriptions/RTL into C++/System C models.
- [eCos](http://ecos.sourceware.org/) eCos is a real-time operating system (RTOS) for embedded applications. The setup has been tested with eCos running on a SID simulated ARM7 PID Board.
- [eCos ARM EABI Toolchain](http://ecos.sourceware.org/tools/linux-arm-elf.html): Offers a GNU GCC toolchain based compiler and debugger that are compatible with eCos

License
---
MIT License

Setup
---
Coming Soon...

Installation
---
Coming Soon...

Usage
---
Coming Soon...

repository: deafbeed/sid-cosim-model-generator

repo_name: deafbeed/sid-cosim-model-generator


text:
## Code etc for importing images and associated expression annotation from VFB

## Strategy:

* A PyXB python datamodel is automatically generated from the XSD schema spec.
* Annotations are pulled from VFB CHADO (via views), or directly from the VFB OWL knowledgeBase - depending on the dataset:
  * Clones and individual neurons - annotations pulled from OWL (using Jython over Brain/OWLtools)
  * Expression patterns - simplest strategy is to pull from DB, but for a unified/sustainable code base perhaps better to go from SQL -> OWL first  - [draft code on VFB repo](https://github.com/VirtualFlyBrain/VFB_owl/blob/master/src/code/owl_gen/gen_exp_pattern_classes.py)

repository: PhenoImageShare/PhenoImageShare

gha_language: Java

repo_name: PhenoImageShare/PhenoImageShare


text:
# Log of Features and Updates

## Feature List
- [X] Scrollable snippet panel displaying snippets
- [x] Right click and save highlighted code (lines of code)
- [x] Copy snippet
- [x] Delete snippet
- [x] Insert snippet
- [x] Drag cell into panel to save (lines of code)
- [x] Search bar for snippets
- [ ] Snippet preview (on the side)
- [ ] Drag snippet into notebook
- [ ] Organize snippets by folders
- [ ] Bookmark snippets
- [ ] Most used snippets
- [ ] Save snippets maintaining cell structure
- [ ] Templated fields

## Log of Changes/Progress

### 6/13/2020 - 6/17/2020: