text:
# Simple Todo App using CodeIgniter 4

## Setup

##### Creat a database with the following name:

`ci_todo_list`

##### create a table in the local database with the following name:

`todo`

##### Import the SQL dump from the root folder

or

##### Create 3 columns in the db as following:

`id : integer, primary key, auto increment`

`title : varchar`

`body : varchar`

`is_complete : boolean`

##### Update the `Config/Database.php` with your local database credentials

##### Rename the `env` file to `.env` and update the db credentials

##### Run the server using the following command:

`php spark serve`

##### Access the App using the following URL :

`http://localhost:8080`


text:
---
{
  "area": "anomaly-detection",
  "title": "Local Correlation Integral",
  "year": "2003",
  "categories": [
    "outlier-detection"
  ],
  "components": [],
  "introduced_by": null,
  "also_known_as": [
    "LOCI"
  ],
  "links": [
    {
      "title": "LOCI: Fast Outlier DetectionUsing the Local Correlation Integral",
      "resource": "Semantic Scholar",
      "icon": "semanticscholar",
      "url": "https://www.semanticscholar.org/paper/LOCI%3A-fast-outlier-detection-using-the-local-Papadimitriou-Kitagawa/88c2c3772201d4ee244e80b05f577cf79b454531"
    }
  ],
  "thumbnail": "local-correlation-integral-thumb.jpg",
  "card": "local-correlation-integral-card.jpg"
}
---
LOCI is highly effective for detecting outliers and groups of outliers (a.k.a. micro-clusters). In addition, it offers the following advantages and novelties: (a) It provides an automatic, data-dictated cut-off to determine whether a point is an outlier (b) It can provide a LOCI plot for each point; this plot summarizes a wealth of information about the data in the vicinity of the point, determining clusters, micro-clusters, their diameters and their inter-cluster distances (c) The LOCI method can be computed quickly.

Source, Image Source: [LOCI: fast outlier detection using the local correlation integral](https://www.semanticscholar.org/paper/LOCI%3A-fast-outlier-detection-using-the-local-Papadimitriou-Kitagawa/88c2c3772201d4ee244e80b05f577cf79b454531) [[PDF](http://www.cs.cmu.edu/~christos/PUBLICATIONS/icde03-loci-tr.pdf)]

license: MIT

repository: virtualgraham/unsupervisedpapers

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: virtualgraham/unsupervisedpapers


text:
---
title: "React With Debounce"
date: 2018-10-24T20:10:38+01:00
description: "How to debounce inputs in React using lodash"
categories:
  - development
tags:
  - react
---

Today I learned how to debounce inputs in a [React](https://reactjs.org/) component. This is something I have done in many other places, in plain JavaScript, in jQuery, in AngularJs and in VueJs. Whilst the concept is the same - have a user input some data (text, date, email, whatever), wait a short amount of time so that the user has finished typing and then do something. The idea being the "do something" does not happen whilst the user is still adding their data.
<!--more-->

Here is a simplified example of what I did:

```javascript
import React from "react";
import debounce from "lodash/debounce";

export default class MyForm extends React.Component {
  constructor(props) {
    super(props);

    this.state = {
      name: "",
      output: ""
    };
  }
  handleChange = e => {
    const value = this.parseInput(e.target.value);
    this.setState({ name: value });
    this.delayedChange();
  }
  delayedChange = debounce(() => {
    // Do something cool!
    this.setState({ output: `Hi! My name is ${this.state.name}` });
  }, 1000)
  parseInput(val) {
    // do some parsing!
    return val;
  }
  render() {
    return (
      <div className="myForm">
        <div className="myForm__form-group">
          <label htmlFor="name" className="myForm__form-label">
            Name
          </label>
          <input
            type="text"
            className="myForm__form-control"
            id="name"
            value={this.state.name}
            onChange={this.handleChange}
          />
        </div>
        <p>{this.state.output}</p>
      </div>
    );
  }
}
```

The only way I could get this to work was to have one method that handled the input and then triggered another debounced method. I am using [lodash](https://lodash.com/docs/4.17.10#debounce) for the debounce functionality. There is a really good explanation by Sebastian Lorber on [Stack Overflow](https://stackoverflow.com/a/28046731) on how to do this properly.

repository: freemagee/til

repo_name: freemagee/til


text:
## Printing Notes
Print this sample part as shown below to most accurately represent how your printer will handle printing bearing races.

![Test oriented with hole horizontal on print bed](PrintOrientation.png)

Just like the bearings, the clearances and ball size can all be adjusted from the internal spreadsheet. Remember that the bearing races may allow more flex than this test piece, since the bearing races are not joined together. To avoid having rattle in your bearing, it is better to have this test fit tightly.

path: /Clearance Test/README.md


text:
SpriteXchange
=============

SpriteXchange is a weekly program we have at Spritle where two people from our team present talks on various topics.

And this is,

> #### _A mini-blog journaling the talks given at our weekly SpriteXchange sessions._

You can view this blog at [spritexchange.spritle.com](spritexchange.spritle.com).

We will be blogging all about these talks here in this site complete with slides, code and photos. You can get the latest updates about our SpriteXchange sessions [here](https://twitter.com/search?f=realtime&q=%23spritexchange&src=savs)

---
Generated using Octopress. Hosted on GitHub Pages :heart:

repository: CarlosJordanDev/spriteXchange

repo_name: CarlosJordanDev/spriteXchange


text:
# wavelet-based-ecg-compression

The project was completed under the E&ICT Academy of IIT Guwahati setup by Government of India under MeiTY (Ministry of Electronics & Information Technology) & under the mentorship and supervision of Dr.Gaurav Trivedi, IIT Guwahati & Dr. Sandeep Raj, IIIT Bhagalpur.

This project implements ECG compression using wavelet transforms and Variable Run-Length Encoding. This code is written in Python for ease of understanding and usage, but the algorithm is efficient enough that it can be written in C and run on an embedded system with reasonable memory and CPU resources.

The motivation of this algorithm is to solve the problem of saving or wirelessly transmitting ECG data, which tends to have a high sampling rate. By compressing the signal, more data can be stored or wirelessly transferred using less power.

On the PhysioNet dataset used in this project, an average compression ratio of 12.8 was achieved with an average PRD of 0.385.

An overview of the algorithm is as follows:
## 1. Pre-processing Raw Waveform
Reducing the amount of information in the signal prior to compression will intuitively improve the compression ratio. As a simple pre-processing step, detrend the signal to remove and drift or DC offset. This is generally not considered useful information so it will be lost going forward.

Below is a excerpt of the dataset used in this project, both before and after detrending (note that the signal has very little drift or DC offset, so detrending effectively makes no difference):
![](https://github.com/nerajbobra/wavelet-based-ecg-compression/blob/master/figs/detrending.png "Detrending")

## 2. Wavelet Decomposition
In this project, the bior family of wavelet is utilized. Specifically, bior4.4 is used with 5 levels of decomposition. Below is an example of a wavelet decomposition of a 10 second block of pre-processed ECG data:
![](https://github.com/nerajbobra/wavelet-based-ecg-compression/blob/master/figs/wavelet_decomposition.png "Wavelet Decomposition")

## 3. Coefficient Thresholding
Depending on the decomposition level, many of the wavelet coefficients can be very small (close to zero) while just a handful of coefficients represent the vast majority of the total energy. To more efficiently represent the coefficients, do coefficient thresholding to retain the following percentages:
-approximate coefficients: 99.9%
-detail level 5 coefficients: 97%
-detail level 1 to 4 coefficients: 85%

The exact thresholds, and algorithm for thresholding, is detailed in the paper *An Efficient Coding Algorithm for the Compression of ECG Signals Using the Wavelet Transform* (linked below).

After thresholding, a binary map array is created that indicates whether any given value in the thresholded coefficients array is either zero or nonzero. If the coefficient was set to zero, the value in the binary map at the index of the zeroed coefficient is zero. Otherwise, the value in the binary map at the index of the coefficient is one.

A visual explanation of the above process:

Below is an example of before and after coefficient thresholding:
![](https://github.com/nerajbobra/wavelet-based-ecg-compression/blob/master/figs/wavelet_thresholding.png "Wavelet Thresholding")

## 4. Scale Thresholded Wavelet Coefficients
Before the wavelet coefficients can be quantized, they need to be scaled to the [0,1] range. To do this, each of the decoposition levels is shifted by the minimum value, and then divided by the maximum value. Both these values must be stored as floats for later reconstruction. Assuming each float is 32 bits, this step costs 32x2x6 = 384 bits.

Below is an example of the wavelet coefficients from step 3 scaled to [0,1]:
![](https://github.com/nerajbobra/wavelet-based-ecg-compression/blob/master/figs/wavelet_scaled.png "Wavelet Scaling")

## 5. Calculate Minimum Number of Bits for Quantization
Each wavelet coefficient at this point is a float in the range [0,1]. To quantize the coefficients to N bits, one would multiply each float by 2^(N)-1 and then round to the nearest integer. The smaller the value of N, the higher the compression ratio will be. The question is, how do we determine what the lowest acceptable value for N is?

The percentage root-mean-square difference is used as a metric to answer this question. The formula for the PRD is:
![](https://github.com/nerajbobra/wavelet-based-ecg-compression/blob/master/figs/PRD_eqn.gif "PRD Equation")

where Xi is the original signal and Xi bar is the reconstructed signal.

Starting at N=8, the signal is quantized, reconstructed, and the PRD associated with that value of N is calculated. N is then decremented by 1, and the process is repeated until the PRD crosses the defined threshold of 0.4 (which was determined through trial and error).

Below is a plot of the signal reconstructed with N = [8,7,6] and the associated PRD values:
![](https://github.com/nerajbobra/wavelet-based-ecg-compression/blob/master/figs/PRD.png "PRD Equation")

## 6. Quantization at N bits
In this step, simply quantize the signal for the value of N determined in the previous step.

For this particular 10 second segment, N=6. Below is a plot of the quantized signal:
![](https://github.com/nerajbobra/wavelet-based-ecg-compression/blob/master/figs/wavelet_quantized.png "Wavelet Quantized")

## 7. Combine Wavelet Coefficients/Binary Maps
Up until this step, the wavelet coefficients and their corresponding binary maps are all separated in their corresponding decomposition levels. This step simply combines them all into a single flat array. This will help increase the compression ratio.

## 8. Compress Wavelet Coefficients
For this particular block of data, N=6. Therefore, each quantized coefficient only has 6 bits of information. Yet, each coefficient is occupying 8 bits of space (ie, each coefficient is being stored as a byte). Simple bit packing is the compression algorithm for the wavelet coefficients.

Below is a visual example of the bit packing process for an example where N=4:

## 9. Compress Binary Map
The binary map consists of lots of repeated one's and zero's. One of the easiest (and quite effective) ways of compressing data with repetitive patterns is Variable Run-Length Encoding. The premise is to represent each number as a count. Since there is always going to be either a zero or a one in the binary map, and it will always switch, only the following two pieces of information need to be stored:
-the initial value (either a zero or a one)
-the run count, which is reset every time we switch from zero to one or vice versa

The diagram below explains the encoding scheme for the implementation of Variable Run-Length Encoding:

## 10. Calculate Compression Ratio
The compression ratio is calculated assuming the following information is being "transmitted" for reconstruction on the receiving end:
-the compressed coefficients (represented as bytes)
-the number of bits associated with the last byte of the compressed coefficients (1 byte)
-the scaling factors for each wavelet decomposition (6 decomposition levels x 2 scaling coefficients each = 12 float)
-the number of bits used to quantize the coefficients (1 byte)
-the compressed binary map (represented as bytes)
-the number of bits associated with the last byte of the compressed binary map (1 byte)
-the initial state of the binary map (one byte)

## 11. Decompress Binary Map
Simply repeat the compression step in reverse

## 12. Decompress Coefficients
Simply repeat the compression step in reverse

## 13. Remap Coefficients
Since the length of each of the decomposition levels are always constant, this is simply a process of re-separating the combined array into it's original 6 arrays.

## 14. Unscale Coefficients
Using the scaling coefficients that were stored through the compression step, re-scale the coefficients back to their original scale.

Below is a plot of the coefficients before scaling, and after unscaling:
![](https://github.com/nerajbobra/wavelet-based-ecg-compression/blob/master/figs/wavelet_rescaled.png "Unscaling Coefficients")

## 15. Wavelet Reconstruction
Finally, do wavelet reconstruction of the uncompressed signal.

Below is a plot of the original signal and the final, uncompressed, reconstruced signal:
![](https://github.com/nerajbobra/wavelet-based-ecg-compression/blob/master/figs/reconstructed.png "Wavelet Reconstruction")

Note that the compression ratio for this particular block was 12.0

## Other Notes
The ECG data used in this project was downloaded from the PhysioNet Apnea-ECG Database:
https://www.physionet.org/physiobank/database/apnea-ecg/

The following papers were used as a reference for designing this algorithm:
[An Efficient Coding Algorithm for the Compression of ECG Signals Using the Wavelet Transform](https://www.researchgate.net/profile/Bashar_Rajoub/publication/11423267_An_efficient_coding_algorithm_for_the_compression_of_ECG_signals_using_the_wavelet_transform/links/0912f5092ae7aeb7bf000000.pdf)
[ECG Compression using Discrete Symmetric Wavelet Transform](https://ieeexplore.ieee.org/abstract/document/575053/)
[A Wavelet Transform-Based ECG Compression Method Guaranteeing Desired Signal Quality](https://ieeexplore.ieee.org/document/730435/)

gha_language: Jupyter Notebook


text:
# jquery-accessibility
aria-controls, aria-expanded, aria-hidden are changed in user event.

[DEMO](https://rawgit.com/sty-dev/jquery-accessibility/master/demo/index.html "Demo html")

repository: sty-dev/jquery-accessibility

repo_name: sty-dev/jquery-accessibility


text:
# LYS_Automatic_Search

Please feel free to submit an issue if you encounter some issue :)

Citation: If you use this scripts make sure to cite : https://link.springer.com/article/10.1007/s11692-020-09507-9

Scripts that i) Mine the RCSB database [10] using the blast alignment tool to find the best matching homologous sequences ii) Fetch their domain positions by using Prosites [3,8,9] iii) Parse the output of PAML extracting the positional information of fast-evolving sites and transform them into the coordinate system of the protein structure iv) Output a file per gene with the positions correlations to its homologous sequence. This output is used as an input in the GUi to generate the graphical assesment. The basic tutorial on these scripts is available at https://youtu.be/ZUxUHWfQ9kw

Requires: Python3, Pandas, Numpy, Tkinter, PyMOL (I am afraid currently a license is needed to use the latest pyMOL that works in python 3) ---> Use anaconda 3 to install easily

WARNING: TKINTER STRUGGLES WITH HIGH DEFINITION SCREENS, not resolved yet by the tkinter people. So the GUI will look strange

![#f03c15](https://placehold.it/15/f03c15/000000?text=+) FIRST STEP:

-LYS_PDB_Search.py:

    ```python3 LYS_PDB_Search.py --Genes Proteins/Trial_sequences.fasta --Codeml Gene_and_path_to_codeml_result.fasta```

    a) INPUT FILES:

        1) File with coding sequences to analyze: Whatever format, preferably, simple identifiers without spaces (to avoid errors)

        2) Tab separated file : Column 1: gene identifier (same as in file a)) and Column 2: Path to the codeml output file containing the + sites

    b)OUTPUT FOLDERS:

        1)PDB_files: Contains the automatically downloaded PDB files (according only to the filtered results, saving memory and time)

        2)Positions_Dataframes: Contains the dataframes with the corresponding positions from the gene in the PDB sequence---> Offers the most important information: Search for 'Selected_and_Domain' (the most interesting positions where the +site is in the domain):

3)Lys_Pymol_Images: Empty for now

![#f03c15](https://placehold.it/15/f03c15/000000?text=+) SECOND STEP:

-LYS_PyMOL_input_Dataframe_GUI.py:
 If using in server and pymol python package version 2.2 installed via anaconda3 does not work download files outside the server and run the script with pymol python package version 1.8. Current versions of Pymol work too but you require a license

```python3 LYS_PyMOL_input_Dataframe_GUI.py```

Use this command sequence as examples to extract the Position dataframes and their corresponding PDB files to separated folders (again, in case pymol does not work properly in the server):

        ```bash
        #In the LYS_PDB_Search.py directory
        mkdir Dataframes_Selected_Domains
        cd Positions_Dataframe
        cp `grep -lir 'Selected_and_Domain' .` ../Dataframes_Selected_Domains
        cd ..
        ls Dataframes_Selected_Domains >> Filenames.txt
        sed 's/[^_]*_\([^_]*\)_.*/\1/g' Filenames.txt > Filenames2.txt
        mkdir PDB_files_Selected_and_Domains
        cd /home/lys/HUMMING/PDB_files
        cat ../Filenames2.txt |xargs cp -t ../PDB_files_Selected_and_Domains/
        ```
  a)INPUT FILE:

        Introduce in the GUI the path to the dataframe that the user wants to plot from the folder Positions_Dataframe. Adjust conveniently

        ATTENTION: If you executed and downloaded from a server the folders Dataframes_Selected_Domains and PDB_files_Selected_and_Domains, and you are working locally. Remember to rename the second folder to PDB_files and always work in the directory where the Dataframes_Selected_Domains and PDB_files are!! As well re-create the Lys_Pymol_Images folder , mimicking the one in the server (It will not be able to find the PDB files otherwise or where to put the images)

  b)OUTPUT FILE:

        Lys_Pymol_Images: The images will be directed to this folder

![alt text](https://github.com/artistworking/LYS_Automatic_Search/blob/master/MKKS_2.png)

    Examples of commands:

    # Test multiple sequences
    python3 LYS_PDB_Search.py --Genes Proteins/Trial_sequences.fasta --Codeml Gene_and_path_to_codeml_result.fasta
    # Test 1 sequence with a PDB file of personal choice (not via automatic search), the domains detection CAN be automatic (Prosites) or not
    python3 LYS_PyMOL_Prosites --PDB TLR7.pdb --Gene GENEaln/New_IDS/ENSTGUT00000008587.map2finch.fasta --M8 TLR7_ENSTGUT00000008587.map2finch.fasta/M8/out --prosite yes --sequence_number 1 --missing_data no
    #GUIs to test individually each protein
    #a) with dataframes obtained from LYS_PDB_Search.py
    python3 LYS_PyMOL_input_Dataframe_GUI.py
    #b) GUI equivalent to LYS_PyMOL_Prosites.py: Test 1 sequence with a PDB file of personal choice (not via automatic search), the domains detection CAN be automatic (Prosites) or not (if NOT, you need to download and input manually a fasta file with the domain sequences (caution cause they are collapsed into one, check them one by one) and it also needs the full PDB sequence as referred in this old version of the same script video tutorial: https://www.youtube.com/watch?v=v3MawxHLGSo , but the idea is the same)
    python3 LYS_PyMOL_GUI_Prosites.py

Additional Comments:

If the number of input sequences and the number of output dataframes is not the same is due to Prosites not been able to find functional domains on the structure. It is relatively common, therefore, simply use the additional scripts (LYS_PyMOL_GUI_Prosites.py or LYS_PyMOL_Prosites.py) to download the functional domains sequences from somewhere else (eg. Uniprot) and use the recommended PDB file from Full_Blast_results_against_PDB_Filtered.tsv. https://www.youtube.com/watch?v=v3MawxHLGSo

 Have fun!!! :D


text:
---
weight: 20
id: "yexpires"
title: "Add Expires or Cache-Control Header"
yahoo: "http://developer.yahoo.com/performance/rules.html#expires"
discuss: "http://developer.yahoo.net/blog/archives/2007/05/high_performanc_2.html"
tags: ["server"]
locales: "en"
notoc: "true"
description: ""
---

There are two aspects to this rule:

- For static components: implement "Never expire" policy by setting far future `Expires` header
- For dynamic components: use an appropriate `Cache-Control` header to help the browser with conditional requests

 Web page designs are getting richer and richer, which means more scripts, stylesheets, images, and Flash in the page. A first-time visitor to your page may have to make several HTTP requests, but by using the Expires header you make those components cacheable. This avoids unnecessary HTTP requests on subsequent page views. Expires headers are most often used with images, but they should be used on *all* components including scripts, stylesheets, and Flash components.

Browsers (and proxies) use a cache to reduce the number and size of HTTP requests, making web pages load faster. A web server uses the Expires header in the HTTP response to tell the client how long a component can be cached. This is a far future Expires header, telling the browser that this response won't be stale until April 15, 2010.

	Expires: Thu, 15 Apr 2010 20:00:00 GMT

 If your server is Apache, use the ExpiresDefault directive to set an expiration date relative to the current date. This example of the ExpiresDefault directive sets the Expires date 10 years out from the time of the request.

	ExpiresDefault "access plus 10 years"

 Keep in mind, if you use a far future Expires header you have to change the component's filename whenever the component changes. At Yahoo! we often make this step part of the build process: a version number is embedded in the component's filename, for example, yahoo\_2.0.6.js.

Using a far future Expires header affects page views only after a user has already visited your site. It has no effect on the number of HTTP requests when a user visits your site for the first time and the browser's cache is empty. Therefore the impact of this performance improvement depends on how often users hit your pages with a primed cache. (A "primed cache" already contains all of the components in the page.) We [measured this at Yahoo!](http://yuiblog.com/blog/2007/01/04/performance-research-part-2/) and found the number of page views with a primed cache is 75-85%. By using a far future Expires header, you increase the number of components that are cached by the browser and re-used on subsequent page views without sending a single byte over the user's Internet connection.

repository: jpokrzyk/yslow-rules

repo_name: jpokrzyk/yslow-rules


text:
# What IBM Watson Studio Provides?

- Extract __value__ & __insights__ from your data
- Easy to create __visualisations__
- Open source tools - __Jupyter Notebooks__, __RStudio__
- Machine Learning, Deep Learning Models
- Simplified graphical interface
- Visual recognition, Language classification, and more tools
- and more...

# Some IBM Tools for Data Science

## 1. Watson Knowledge Catalog

- It is a data catalog that is integrated with an __enterprise data governance platform__, also merges the analytic capabilities of Watson Studio.
- It protects data from __misuse__ and enables the __sharing of assets with automated__, __dynamic masking of sensitive data elements__.

### Main features

- Find data
- Catalog data
- Govern data
- Understand data
- Power data science
- Prepare data
- Connect data
- Deploy anywhere

## 2. Data Refinery

- Simplifying Data Preparation
  - __Cleansing__, __Shaping__, and __Preparing__ data _take up a lot of Data Scientist's time_.
  - These tasks come in the way of the more enjoyable parts of Data Science: analysing data and building ML models.
  - Data sets are __typically not readily consumable__. They need to be __refined and cleansed__.
  - IBM Data Refinery simplifies these tasks with an __interactive visual interface__ that enables __self-service data preparation__.
  - Data Refinery comes with Watson Studio on Public/Private Cloud and Desktop

## 3. SPSS Modeller Flows in Watson Studio

- It is an example SPSS Modeller Flow, the nodes can be used to see information about the models and to get predictions for new data.

- The main flow itself defines a pipeline consisting of several steps:

  - A Data Asset node for importing the data set

  - A Type node for defining metadata for the features, including a selection of the target attributes for the classification

  - An Auto Data Prep node for preparing the data for modelling

  - A Partition node for partitioning the data into a training set and a testing set

  - An Auto Classifier node called ‘churn’ for creating and evaluating the model

    Source: https://developer.ibm.com/tutorials/watson-studio-spss-modeler-flow/

### Visualisations examples from Modeller Flows in IBM Watson Studio

## 4. Model deployment strategies

### How to deploy models?

- Workflow solutions (tend to support only models built with the same produce)
- Open standards
  - Pytorch
  - Tensorflow
  - Scikit-Learn
  - Caffe2
  - mxnet
  - Keras
  - PMML
  - and more...

### Some workflow solutions

- Sage Maker by Amazon
- MLFlow by Databricks
- Airflow from Airbnb, now at Apache
- Kubeflow from Google

### Open standards for model deployment

- __Predictive Model Markup Language__ (PMML)
  - Created by Data Mining Group (DMG) in 1990s
  - __XML__ based, version 4.4 has 17 models + many transformations and model combination methods
  - Supported by > 30 companies and Open source packages
  - Can be generated by Watson Studio and SPSS products
- __Portable Format for Analytic__ (PFA) from DMG
  - __JSON__ based small programming language
  - 5-6 years old
  - Supported by several companies and open source packages

### IBM Watson Machine Learning

- Deploy models built with __Watson Studio__, __SPSS Modeller__, many open source packages
- Support for __PMML__ and __ONNX__
- Batch or online scoring

## 5. AutoAI and Watson OpenScale

### AutoAI features

- To help simplify an AI life-cycle management, AutoAI automates
  - __Data preparation__
  - __Model development__
  - __Feature engineering__
  - __Hyper-parameter optimisation__

### OpenScale feature

- __Fairness__: Detect and mitigate model bias; automatically recommend which attributes to monitor for bias.
- __Explainability__: audit and explain model decisions.
- __Model monitoring__: Monitor model performance, help to find causes when model drift is detected, possibly trigger retraining
- __Business impact__: Correlate model metrics and business KPIs to measure business impact; actionable metrics and alerts

url: https://raw.githubusercontent.com/stevekwon211/TIL/380c68f1f7a3a93788668f324f6aad9fbbbd4607/IBM Data Science/2. Tools for Data Science/3  week/IBM Tools for Data Science.md

branch_name: refs/heads/main

filename: IBM Tools for Data Science.md

gha_language: C


text:
Advanced Configuration
dfs.namenode.handler.count :
  * the number of the server threads for the namenode
  * Threads used for RPC calls from clients  and Datanodes( heartbeats and metadata operations)
  * Defaut in CM: 30 (non_CM default is 10)
  * Recomomded: Natualal logarithm of number of cluster nodes * 20
  * Symptoms of this being is connection refused messages in datanode logs as they tried to trasnmit block report to the namenode
  * used by namenode

dfs.datanode.failed.volumes.tolerated:( set in Hdfs /Datanodes )
* the number of volumes  allowed to fail before Datanodes takes itself offline, ultimately resulting in all of its blocks being replicated
CM_default: 0
Often Increased in machines with several disk
* used by Datanodes

dfs.datanode.max.locked.memory (off heap memory space)
* the maximum amount of memory in bytes a Datanodes used for caching
* Cm default : 4GB
* Must be less than the value of the OS configuration property
* Ulimt -1 for the datande user
* used by datanode

io.compress.codecs
* list of compression codecs that hadoop can use for file compression
* used by clients and all nodes running hadoop daemons
* Cm defaul include may

mapreduce.job.reduce.slowstart.completed.maps(yarn)
* the percenrtage of Map tasks which must be completed before the resourcemanager will schedule Reucers
on the cluster
* CM default is 0.8
*Recommendation 0.8
*Used by resourcemanager

mapreduce.reduce.shuffle.parallelcopies( yarn)
* number of threads a reducer can use in parallel fectch mapper output
cm_default : 10
Recommendation: ln(clusternodes )* 4
Used by sufflehandler

mapreduce.map.speculative
* whether to allow speculative Execution for map tasks
* CM default: false Recommendation false
* Used by Mapreduce Application Master

mapreduce.reduce.speculative
* whether to allow speculative Execution for reduce tasks
* CM default: false Recommendation false
* Used by Mapreduce Application Master

The Fair Scheduler is the only scheduler recommended by cloudera for production cluster
* the fair scheduler  organized YARN applications into pools
  - Pools are also known as queues in YARN technologies
  - Each user get a pool named after the user
  - Resources  are divided fairly between the pools
* Fair scheduler
  - Allows resources  to be controlled proportionally
  -Promotes  efficient utilization of clusters resources
  - Promotes fairness between schedulable entities
  - Allows short interactive and long production applications to co-exist
  - Awards  resources  to pools that most underserved
  - Gives  a container to the pool that has fewest resources  allocated
* Fair share of resources assigned to the pool is based on:
  - the total resources available across the cluster
  - the number of pools competing for cluster resources
* Excess cluster capacity is spread across all pools
  -the aim is to maintain the most even allocation possible so every pool received its
  fair share of resources
  - the fair share will never be higher than actual demand
* Pool can use more than their fair share when other pools are not in need of resourcemanager
 - this happened when their are no tasks eligible to run in  other pools

 * Single Resources Fairness
  - Fair Scheduling with single Resource fairness
    - Single applications on the basis of a single resource: Memory
* Dominant Resource Fairness (DRF)
  - fair Scheduling with DRF(Recommended)
    Schedule based applications on the basis of both memory and CPU

MINIMIN RESOURCE:
* Minimum Resources are the minimum amount of resources that must be allocated to the
pool prior to fair share allocation
NO resources are about to pool even when the minimum resources are configured

Pools with weightsPools with high weights received more resources during allocation

Fair Scheduler Preemption
if yarn.scheduler.fair.preemption is enabled:
 - the fair scheduler kills containers  that belong to pools operating over their fair share beyond configurable timeouts
 - pools operating below fair share received those reaped resources
  - not enable by default
2 Types of scheduler preemption
- Minimum share Preemption
- Fair share Preemption
Preemption avoiding killing container in a pool if it would cause that pool to being preemption container in other pools
  -this prevent a potentially endless cycle of pools
Use fair share preemption conservatively
  - Set min share preemption timeouts to the number of seconds a pool under fair share before preemption should begin
  - Default is infinite

Yarn Memory and CPU Settings
yarn.nodemanager.resource.memory-mb:
* Amount of RAM available on this host for YARN-managed Tasks
* Recommendation: the amount of RAM on host host minus the amount of ram need for non YARN managed work. (included memory needed by datanode daemons)
* Used by nodemanagers
yarn.nodemanager.resource.cpu-vcore
* Number of cores avaialbel on this host for yarn managed tasks
* recommendation: Number of cores - 1

yarn.scheduler.minimum-allocation-mb/yarn.scheduler.minimum-allocation-vcores
* Minimum Amount of memory of cpu cores to allocate for a containers
* Tasks request lower than these minimum will set these values
* CM defaults L 1 GB 1 core
Memory recommendations: Increase up to 4gb depending on your developer requirements
* Core: Keep the defaults

yarn.scheduler.increment-allocation-mb/vcores
* tasks with request that not multiples of these increment-allocation values  will rounded up to the nearest increments
CM default 512MB 1 core

mapreduce.Imapala.memory.mb /mapreduce.reduce.memory.mb
* Amount of memory to allocation for map and reduce tasks
* CM defaults 1Gb
Recommendation Increase up to 4 gb depending on your application

yarn.app.mapreduce.am.resource.mb
* amount of the memory to allocation for the applicationMaster
CM default 1Gb
Recommendation 1Gb

yarn.app.mapreduce.am.command-opts
Java options passed to application Master
By default application master get 1Gb of Heap Space
used by Mapreduce and APplication Master

mapreduce.map.java.opts / mapreduce.reduce.java.opts
* java options passed to Mappers and Reducers
default in Xmx=200m (200MB of heap space)
Recommedations: Increase to value from 1GB to 4Gb depending on the requirements from developpers
Used when Mappers and Reducers are lunch with rule of thumb of using 75% of the heap space as you had in the container
Example :

yarn.nodemanager.resource.memory-mb: 8192
mapreduce.map.memory.mb 4096
mapreduce.map.java.opts defaults -Xmx=200
Recommendation: set java heap size for Mappers and Reducers to 75% of the
mapreduce.map.memory.mb and mapreduce.reduce.memory.mb

Inventory the vcores and memory and disks
* Calculate the resource needed for other processes
  - reserve 3gb or 20 % of total memory for the os
  - Reserve resources for any non-hadoop Component
  - Reserve resource for other any hadoop components
    Hdfs caching
    Impalad , hbase region server, solr
* grant the resources not used by the above to your yarn containers
* Configure the YARN scheduler and application frameworks setting
  - based on the worker node profile determined above
  - Determine the number of containers needed to best support YARN applications based on the type of workload
  monitor usage and tune estimated values to find optimal settings

  From Cloudera Training

  The main rules to consider in mind are:

* yarn.scheduler.minimum-allocation-mb <= mapreduce.map.memory.mb <= yarn.scheduler.maximum-allocation-mb <= yarn.nodemanager.resource.memory-mb
* yarn.scheduler.minimum-allocation-mb <= mapreduce.reduce.memory.mb <= yarn.scheduler.maximum-allocation-mb <= yarn.nodemanager.resource.memory-mb
* yarn.scheduler.minimum-allocation-mb <= yarn.app.mapreduce.am.resource.mb <= yarn.scheduler.maximum-allocation-mb <= yarn.nodemanager.resource.memory-mb
* mapreduce.map.java.opts = mapreduce.job.heap.memory-mb.ratio * mapreduce.map.memory.mb
* mapreduce.reduce.java.opts = mapreduce.job.heap.memory-mb.ratio * mapreduce.reduce.memory.mb
* yarn.app.mapreduce.am.command-opts = mapreduce.job.heap.memory-mb.ratio * yarn.app.mapreduce.am.resource.mb

Example:
```
-Dmapreduce.map.memory.mb=6144
-Dmapreduce.map.java.opts=-Xmx4096m
-Dmapreduce.reduce.memory.mb=6144
-Dmapreduce.reduce.java.opts=-Xmx4096m
-Dyarn.app.mapreduce.am.resource.mb=6144
-Dyarn.app.mapreduce.am.command-opts=-Xmx4096m
```
for hive queries. this can be set to
```
SET mapreduce.map.memory.mb=6144
SET mapreduce.map.java.opts=-Xmx4096M
SET mapreduce.reduce.memory.mb=6144
SET mapreduce.reduce.java.opts=-Xmx4096M
```
* mapreduce.map.java.opts:  -Djava.net.preferIPv4Stack=true -Xmx4096M (in cloudera manager)

some documentations
https://docs.cloudera.com/HDPDocuments/HDP2/HDP-2.1.5/bk_installing_manually_book/content/rpm-chap1-11.html

  Fixing git Issues
  https://codewithhugo.com/fix-git-failed-to-push-updates-were-rejected/


text:
Environment variables [loaded by Vite](https://vitejs.dev/guide/env-and-mode.html#env-files) from `.env` files and `process.env`. Like [`$env/dynamic/private`](https://kit.svelte.dev/docs/modules#$env-dynamic-private), this module cannot be imported into client-side code. This module only includes variables that _do not_ begin with [`config.kit.env.publicPrefix`](https://kit.svelte.dev/docs/configuration#env).

_Unlike_ [`$env/dynamic/private`](https://kit.svelte.dev/docs/modules#$env-dynamic-private), the values exported from this module are statically injected into your bundle at build time, enabling optimisations like dead code elimination.

```ts
import { API_KEY } from '$env/static/private';
```

Note that all environment variables referenced in your code should be declared (for example in an `.env` file), even if they don't have a value until the app is deployed:

```
MY_FEATURE_FLAG=""
```

You can override `.env` values from the command line like so:

```bash
MY_FEATURE_FLAG="enabled" npm run dev
```

repository: tomblachut/svelte-intellij

gha_language: JavaScript

gha_license_id: MIT

repo_name: tomblachut/svelte-intellij


text:
# data_analyst_pet_projects
A collection of different tasks of DA's routine

## A/B-test results EDA and calculation

A DS department of some foodtech company made an improvement of main page sorting using ML-algorithm. The main page is the place where the user can choose the restaurant or other provider. An algorithm puts providers with higher average amount at the top of the page. That is why the change in sorting of the main page may cause an uplift in the average amount of check among all orders. The change of sorting is evaluated thorugh A/B-test with users splitted into two groups:
1. test_group = A - control group with default main page sorting
2. test_group = B - test group with main page sorting by ML-algorithm

### The final task is:
1. to choose key metrics to evaluate the results of a/b-test
2. to check the statistical significane of results
3. to create an explicit inerpretation of the test's results
4. to draw cocnlusions and recommendations for the bussiness unit based on previous points


text:
# Dbmover\MysqlProcedures
MySQL-specific plugin for (re)creating procedures.

## Installation
```sh
composer require dbmover/mysql-procedures
```

    This plugin is part of the `dbmover/mysql` meta-package.

## Usage
See `dbmover/core`.

## Caveats
You might have included delimiters in your schema, so you can easily copy/paste
procedure definitions into the MySQL shell. _You can remove them_. They're only
needed because the shell is silly. In fact, they trip DbMover up.

Your procedures can simply be written as:

```sql
CREATE FUNCTION foo()
BEGIN
    -- SQL...
END;
```

## Contributing
See `dbmover/core`.

repository: dbmover/mysql-procedures

repo_name: dbmover/mysql-procedures


text:
# Grafana Loki Helm Chart

Installs Grafana Loki in production setup - basically a Helm version of [Grafana Loki ksonnet deployment](https://github.com/grafana/loki/tree/master/production/ksonnet/loki). All default values are adjusted to
fit the ksonnet deployment.

Promtail can be deployed from the [Grafana Promtail chart](https://github.com/grafana/loki/tree/master/production/helm).

The only storage configuration currently support is Cassandra for indexing and Azure Storage Account for
chunk storage.

## Prerequisites

Add the MHI Vestas Offshore Wind public charts repository.

```sh
helm repo add mvow https://mhivestasoffshore.github.io/charts/
```

## Deploy Grafana Loki

```sh
helm upgrade --install loki
```

## Configuration

| Parameter | Description | Default |
| --------- | ----------- | ------- |
| `config.grpc_server_max_msg_size` | Setting max grpc message between components | `104857600` |
| `config.querierConcurrency` | Concurrency setting for querier | `16` |
| `config.http_listen_port` | HTTP port of components listening for http trafic | `80` |
| `config.htpasswd_contents` | Entry for `htpasswd` file of gateway nginx | `loki/password` |
| `config.replication_factor` | Replication factor for ingestor | `3` |
| `config.index_period_hours` | Retention period (168h ~ 30 days) | `168` |
| `config.cassandra.addresses` | Addresses for Cassandra cluster to store index | `''` |
| `config.cassandra.replication_factor` | Replication factor for Cassandra keyspace | `2` |
| `config.azure.account_name` | Azure Storage Account name | `''` |
| `config.azure.container_name` | Azure Storage Account blob container name (must be created in advance) | `''` |
| `config.azure.account_key` | Access key for Azure Storage Account | `''` |
| `distributor.name` | Name used to identify the distributor component in Kubernetes manifests, e.g., labels | `distributor` |
| `distributor.replicaCount` | Number of distributor replicas | `3` |
| `distributor.image.repository` | Docker repository for distributor | `grafana/loki` |
| `distributor.image.tag` | Docker tag for distributor | `1.5.0` |
| `distributor.affinity` | Affinity configuration for the distributor - default is preferred to not be scheduled on same node | |
| `distributor.resources` | Resources configuration for the distributor - default is requests `500m/500Mi` limits `1/1Gi` | |
| `ingester.name` | Name used to identify the ingester component in Kubernetes manifests, e.g., labels | `ingester` |
| `ingester.replicaCount` | Number of ingester replicas | `3` |
| `ingester.image.repository` | Docker repository for ingester | `grafana/loki` |
| `ingester.image.tag` | Docker tag for ingester | `1.5.0` |
| `ingester.affinity` | Affinity configuration for the ingester - default is preferred to not be scheduled on same node | |
| `ingester.resources` | Resources configuration for the ingester - default is requests `1/5Gi` limits `2/10Gi` | |
| `querier.name` | Name used to identify the querier component in Kubernetes manifests, e.g., labels | `querier` |
| `querier.replicaCount` | Number of querier replicas | `3` |
| `querier.image.repository` | Docker repository for querier | `grafana/loki` |
| `querier.image.tag` | Docker tag for querier | `1.5.0` |
| `querier.affinity` | Affinity configuration for the querier - default is preferred to not be scheduled on same node | |
| `querier.resources` | Resources configuration for the ingester | `{}` |
| `query_frontend.name` | Name used to identify the query frontend component in Kubernetes manifests, e.g., labels | `query-frontend` |
| `query_frontend.replicaCount` | Number of query frontend replicas | `2` |
| `query_frontend.image.repository` | Docker repository for query frontend | `grafana/loki` |
| `query_frontend.image.tag` | Docker tag for query frontend | `1.5.0` |
| `query_frontend.affinity` | Affinity configuration for the query frontend - default is preferred to not be scheduled on same node | |
| `query_frontend.resources` | Resources configuration for the query frontend - default is requests `2/600Mi` limits `1200Mi` | |
| `table_manager.name` | Name used to identify the table manager component in Kubernetes manifests, e.g., labels | `table-manager` |
| `table_manager.replicaCount` | Number of table manager replicas | `1` |
| `table_manager.image.repository` | Docker repository for table manager | `grafana/loki` |
| `table_manager.image.tag` | Docker tag for table manager | `1.5.0` |
| `table_manager.resources` | Resources configuration for the table manager - default is requests `100m/100Mi` limits `200m/200Mi` | |
| `gateway.name` | Name used to identify the gateway component in Kubernetes manifests, e.g., labels | `gateway` |
| `gateway.replicaCount` | Number of gateway replicas | `2` |
| `gateway.image.repository` | Docker repository for gateway | `nginx` |
| `gateway.image.tag` | Docker tag for gateway | `1.15.1-alpine` |
| `gateway.resources` | Resources configuration for the gateway - default is requests `10m/100Mi` | |
| `memcached.*` | memcached subchart used for caching chunks - defaults set to match the ksonnet scripts | |
| `memcached-index-queries.*` | memcached subchart used for caching index queries - defaults set to match the ksonnet scripts | |
| `memcached-index-writes.*` | memcached subchart used for caching index writes - defaults set to match the ksonnet scripts | |
| `memcached-frontend.*` | memcached subchart used for frontend caching - defaults set to match the ksonnet scripts | |
| `consul.*` | Consul subchart - using defaults from chart | |

repository: mhivestasoffshore/charts

repo_name: mhivestasoffshore/charts


text:
# A *Faster* Pytorch Implementation of Faster R-CNN

### Compilation

Install all the python dependencies using pip:
```
pip install -r requirements.txt
```

Compile the cuda dependencies using following simple commands:

```
cd lib
python setup.py build develop
```

It will compile all the modules you need, including NMS, ROI_Pooing, ROI_Align and ROI_Crop. The default version is compiled with Python 2.7, please compile by yourself if you are using a different python version.

## Authorship

This object detector is adapted from this [repo] (https://github.com/jwyang/faster-rcnn.pytorch), which is equally contributed by [Jianwei Yang](https://github.com/jwyang) and [Jiasen Lu](https://github.com/jiasenlu), and many others (thanks to them!).

## Citation

    @article{jjfaster2rcnn,
        Author = {Jianwei Yang and Jiasen Lu and Dhruv Batra and Devi Parikh},
        Title = {A Faster Pytorch Implementation of Faster R-CNN},
        Journal = {https://github.com/jwyang/faster-rcnn.pytorch},
        Year = {2017}
    }

    @inproceedings{renNIPS15fasterrcnn,
        Author = {Shaoqing Ren and Kaiming He and Ross Girshick and Jian Sun},
        Title = {Faster {R-CNN}: Towards Real-Time Object Detection
                 with Region Proposal Networks},
        Booktitle = {Advances in Neural Information Processing Systems ({NIPS})},
        Year = {2015}
    }


text:
# Question Answer Service

REST Service for questions and answers

## Database modeling

![model](model.svg)

## Directory tree

- `pkg`: Here is the main source code.
- `sql`: Here are all the SQL files to create the tables, data insertions and methods (it is not necessary run these files manually).
- `postman`: Here is a `json` file to import to your local Postman.

# 1. Requirements

| Software         | Version | Importance                   |
| ---------------- | ------- | ---------------------------- |
| 🐳 Docker         | 20.10.11 | Required                     |
| 🐙 Docker Compose | 1.29.2  | Required                     |
| 🐃 GNU Make       | 4.2.1   | Optional                     |
| 🚀 Postman        | 9.1.5   | Optional                     |

# 2. Prepare the environment file (.env)

1. Copy the `.env-example` file to `.env` file:

```shell
cp .env-example .env
```

2. Fill out the variables with your own credentials. If you want to start quickly,
these are the default values (do not modify):
```
API_PORT=8087

POSTGRES_DB=qas_db
POSTGRES_USER=qas
POSTGRES_PASSWORD=secret
POSTGRES_DRIVER=postgres
POSTGRES_HOST=qas_pgsql
```

# 3. Run the service
1. Execute the command `make l/up`. Or, if you are on _Windows_ execute:
```shell
docker-compose down --remove-orphans --rmi all
```
and
```shell
docker-compose --env-file ./.env up --detach --remove-orphans --force-recreate --build
```

>
> The queries at `.sql/` directory run with the `docker-composer` command (lines 21, 22),
> so it **is not necessary** run separately. (make sure that the API_PORT is 8087)
>

2.  Testing using postman

- You can import the **collection** file at `./postman/collection.json`
- You can import the **environment** file at `./postman/environment.json`

repository: kenesparta/questions-answers

repo_name: kenesparta/questions-answers


text:
# [COMPSCI 326 Web Programming](http://web-programming.org)
## Spring 2020
## Professor [Emery Berger](https://www.emeryberger.com)

- **Lectures:** TuTh 4:00PM - 5:15PM, South College Room W245
- **Labs:** Mo 4:00PM - 4:50PM, South College Room W245 (same room)
- **Course web page:** [http://web-programming.org](https://web-programming.org)
- **Textbook:** [Click for information](http://web-programming.org/#required-text)
- **Recommended IDE:** [Visual Studio Code](https://code.visualstudio.com/).
- **TAs:** Ziwei He: [ziweihe@umass.edu](mailto:ziweihe@umass.edu), Ishan Khatri: [ikhatri<EMAIL_ADDRESS>- **Office hours:** Ziwei He: CS207, Wednesdays 2:30pm-3:30pm
- **Piazza:** [https://piazza.com/class/k54kjhj9hsk1s4](https://piazza.com/class/k54kjhj9hsk1s4)
- **Course calendar:** [http://web-programming.org/schedule.html](http://web-programming.org/schedule.html)
- **Course syllabus:** [http://web-programming.org/syllabus.html](http://web-programming.org/syllabus.html)
- **In-class "whiteboard":** [COMPSCI 326 Spring 2020 whiteboard](https://github.com/web-programming-org/web-programming/blob/master/COMPSCI%20326%20Spring%202020%20whiteboard.pdf)

### Course Overview

The web is arguably today's most important application platform. Web browsers run on practically every device, and even many phone applications are in fact web applications under the covers. This course will cover a broad range of client-side web technologies, including HTTP itself, HTML5, CSS, and JavaScript; it will additionally cover key concepts for the server side of web applications, including key value stores and SQL servers. This course will also cover key concepts and technologies including AJAX, JavaScript libraries (e.g., jQuery), and web security. This course is hands-on and heavily project-based; students will construct a substantial dynamic web application based on the concepts, technologies, and techniques presented during lectures and in readings. This course satisfies the IE Requirement.

### Required Text

There is no required text.

### Course Development Environment

Given that this is a programming intensive course, it is important to highlight the development environment! Generally, most of what we cover in this course is available on all the typical operating systems. However, the team project allows you to explore additional environments that may have specific OS requirements. You are welcome to use those additional libraries/tools; however, you will not receive direct support for what you use. It is your responsibility for the installation, setup, and use of those additional components. You are welcome to use any editor, IDE, or tools to explore this material.

We strongly recommend that you use [Visual Studio Code](https://code.visualstudio.com/).

### Other Material

It is assumed that you have a computer to use for assignments in this course. It is highly recommended that you get a Dropbox account (or other file synching service) or USB memory stick to save files that you create for assignments. There are no excuses for missing or accidental deletion of work.

_Note_: you may only use GitHub for storing your work on individual assignments if you are using a private repository. Use of public repositories to store assignment solutions on github is considered cheating and will result in a failure for this course.

You are welcome to store and share your team project work on a public repo!

repository: OlinGoudey/web-programming

repo_name: OlinGoudey/web-programming


text:
# Date and Time handling in the SDK

## Status

decided

## Context

Currently we are using moment.js for handling date and time related types in the SDK.
Unfortunately moment is quite big in size and the project itself recommends to not use it for new projects: https://momentjs.com/docs/#/-project-status/recommendations/.
We are considering to move to the future JS native Date library [Temporal](https://github.com/tc39/proposal-temporal).
It proposes abstractions for all types that we need to handle OData:

* `Edm.DateTimeOffset` (v2 / v4) -> `Temporal.ZonedDateTime`
* `Edm.DateTime` (v2) -> `Temporal.DateTime`
* `Edm.Time` (v2) -> `Temporal.Time`
* `Edm.Date` (v4) -> `Temporal.Date`
* `Edm.Duration` (v4) -> `Temporal.Duration`
* `Edm.TimeOfDay` (v4) -> `Temporal.Time`

This is a Stage 2 proposal at the time being and will most likely reach stage 3 in 2020 still, there is no official timeline as to when stage 4 will be reached and when this is planned to become a standard.

## Decision

Allow to configure different serializers / deserializers for dates, but maybe even for all field types.
We will provide adapters for moment, string and Temporal serialization and switch the default implementation from moment to either string or Temporal depending on the state of the proposal at the time of switching.

Further it should be possible to switch the adapters globally.

Exemplary code snippet (API not yet decided):
```ts
const bupa = await BusinessPartner.requestBuilder().getAll().execute(destination)

bupa.date // Moment

const bupa = await BusinessPartner.requestBuilder().getAll().transform({
  "Edm.DateTime": temporalMiddleware.dateTime
}).execute(destination)

bupa.date // Temporal
```

## Consequences

This will allow users to easily switch implementation to what they see best fit for their use case and it will even allow them to write their own transformers.
We have to consider, that at the moment `moment` does not handle times for example, while temporal does, therefore transformation needs to be handled separately for those cases.
Also, url and payload serialization differ, while they are quite similar, therefore this approach needs to always consider two transformers for url and payload serialization.

## Alternative solutions

### Migrate to a different library first
Declined because this would mean that we introduce breaking changes twice.

### Accept stage 3 proposal risk
Declined as we think it is too risky and potentially too early for users to adopt it through the SDK.
Stage 3 proposals have been downgraded to stage 2 in the past.

### Wait for Temporal to reach stage 4
Declined, as we are planning to release a version 2 of the SDK in the first half of 2021 and it is unlikely this would fit our timeline unless we keep the old implementation until a version 3.

### Implement SDK Date wrapper that abstracts different libraries
Declined, because this would probably mean quite high implementation effort and is not flexible enough.

repository: exogee-technology/cloud-sdk-js

repo_name: exogee-technology/cloud-sdk-js


text:
# font-variant-east-asian

https://developer.mozilla.org/en-US/docs/Web/CSS/font-variant-east-asian

## normal
```css
.selector {
  composes: normal from 'hydrogencss/font-variant-east-asian.css'
}
```

or:
```css
.selector {
  composes: normal from 'hydrogencss/font-variant-east-asian/normal.css'
}
```

repository: eddiemoore/hydrogencss

repo_name: eddiemoore/hydrogencss


text:
# Character-Level Question Answering with Attention

|  |  |
| :--- | :--- |
| title | Character-Level Question Answering with Attention |
| author | David Golub, Xiaodong He |
| year | 2016 |
| paper |  http://www.aclweb.org/anthology/D16-1166 |
| github |  https://github.com/davidgolub/SimpleQA |
| paperweekly |  None |
| page | 10 |
| member | [@High128Net](https://github.com/High128Net) |


text:
dx11-vvvv
=========

DirectX11 Rendering within vvvv

[![Build status](https://ci.appveyor.com/api/projects/status/79m7u3obr15yopct?svg=true)](https://ci.appveyor.com/project/mrvux/dx11-vvvv)

# Licensing

vvvv dx11 nodes are released under a 3 clause [BSD license](https://raw.githubusercontent.com/mrvux/dx11-vvvv/master/License.md)

This library is free, but you are welcomed to support its development.

## Monthly donations via Patreon

[![Patreon](https://cloud.githubusercontent.com/assets/8225057/5990484/70413560-a9ab-11e4-8942-1a63607c0b00.png)](http://www.patreon.com/mrvux)

## Yearly invoice

If you are a company and Patreon is not ideal for you (exchange rates and inability to get proper invoices), I am also able to provide you a custom invoice (I am a registered company in France).

You will get the same rewards as per Patreon yearly equivalent.

## Custom develompent

If you have specific requirements, you can also sponsor custom development (either tailored to your requirements and private, or contributed back in the public repository).

# How to build

First of all, get the code of master branch

    git clone -b master git@github.com:mrvux/dx11-vvvv.git

Then update submodules.

    cd dx11-vvvv/
    git submodule init
    git submodule update

Open the `vvvv-dx11.sln` solution with Visual Studio: I installed Microsoft Visual Studio Express 2012 for Windows Desktop.

Set up targets, see screenshots below.

![open-configuration-manager!](https://raw.github.com/mrvux/dx11-vvvv/master/images/OpenConfigurationManager.png)

![set-targets!](https://raw.github.com/mrvux/dx11-vvvv/master/images/SetTargets.png)

Now, if you hit the Rebuild Solution button and you will gain a brand new lib and packs folders under Deploy/Debug folder.

![rebuild-solution!](https://raw.github.com/mrvux/dx11-vvvv/master/images/RebuildSolution.png)

Copy the content of vvvv core build under Deploy/Debug (recommended by mrvux if you want to build multiple times) or viceversa, copy lib and packs folders inside your vvvv folder.

gha_language: C#

gha_license_id: NOASSERTION


text:
# DIY React Validation Hook

Example of a simple way to implement validation with promise-based form validation.

### Running the example

```console
npm install
npm start
```

### Notes

This example uses two libraries that can probably be excluded

- [bluebird](http://bluebirdjs.com/docs/api-reference.html)
  - Use `Promise.reflect` as an alternative to `Promise.settleAll`
  - Can loop through promise inspections
- [immer](https://immerjs.github.io/)
  - Immutable validators and error state

repository: eiof/diy-react-validation-hook

gha_language: TypeScript

repo_name: eiof/diy-react-validation-hook


text:
### If you're using Chrome, you need to disable data saver and Async DNS. Google uses by default two technologies that interfere with host blocking.

1. To disable data saver, tap the three vertical dots in chrome, go to settings, search for "data saver" or "lite mode" and disable it.

2. To disable async dns, go to chrome://flags in your browser, search for Async and disable the asynchronous dns feature.

3. In your phone, go to Settings -> Applications -> Chrome -> Storage and clear cache.

4. Reboot!

©GoodbyeAds

✔Say Goodbye to Ads.

gha_language: Adblock Filter List


text:
---
layout: post
title: MvvmCross 4.0-beta4
date:   2015-10-21 11:37:35 +0100
categories: mvvmcross
---

New logo, Android support improvements, UWP presenter and bug fixes

In this release we introduced the first part of a series of changes to the website, blog and documentation: the logo!
We've changed it for all the Nuget packages, the current blog and other communication channels. We are proud to present it here:

![alt text](http://i.imgur.com/BvdAtgT.png "New MvvmCross Logo")

In this release we fixed:

New projects for Android Support packages

- Leanback [#90](https://github.com/MvvmCross/MvvmCross-AndroidSupport/pull/90) and [#99](https://github.com/MvvmCross/MvvmCross-AndroidSupport/pull/99)
- Preference [#91](https://github.com/MvvmCross/MvvmCross-AndroidSupport/pull/91)
- Design [#103](https://github.com/MvvmCross/MvvmCross-AndroidSupport/pull/103)

Note that some Android packages are on beta5 because beta4 had some issue's.

The [samples for Android-Support](https://github.com/MvvmCross/MvvmCross-AndroidSupport/tree/master/Samples) have been improved to handle more situations in an apps lifecycle, and show the new features MvvmCross has.
If you are missing functionality in the new projects please [add an issue](https://github.com/MvvmCross/MvvmCross-AndroidSupport/issues/new) so we can look into it. Any help / PR's would be appreciated!

- A custom multiple region presenter for Windows UWP has been added [#1157](https://github.com/MvvmCross/MvvmCross/pull/1157)
- New Android specific MvxPropertyChangedListener [#1145](https://github.com/MvvmCross/MvvmCross/pull/1145)
- Possibility to get fragment info by tag in MvxCachingFragmentActivity [#1143](https://github.com/MvvmCross/MvvmCross/pull/1143)
- MvvmCross Forms updated to the latest version [#25](https://github.com/MvvmCross/MvvmCross-Forms/pull/25)

The assembly versions on plugins have been bumped to <IP_ADDRESS>. If you run into trouble after updating, make sure that you have all references set to the latest version.

# Overview of all repo's

- [MvvmCross](https://github.com/MvvmCross/MvvmCross)
- [Android-Support](https://github.com/MvvmCross/MvvmCross-AndroidSupport)
- [Forms](https://github.com/MvvmCross/MvvmCross-Forms)
- [Plugins](https://github.com/MvvmCross/MvvmCross-Plugins)
- [Samples](https://github.com/MvvmCross/MvvmCross-Samples)

# Overview of changes in this release

## MvvmCross

- Value type conversions when binding to nfloat, nint or uint fixed
- GetFragmentInfoByTag added in MvxCachingFragmentActivity
- Added missing AssemblyInfo files for many projects
- Added Android specific PropertyChanged listener to avoid crashes
- WindowsCommon plugins are now valid for WindowsUWP projects
- Discover CanExecuteXyz Properties
- Added Multi region presenter for Windows projects
- Removed dependency on Bindings from CrossCore
- Added dependency on CrossCore from Bindings

## MvvmCross-Plugins

- Use BitmapCompat to get image sizes in DownloadCache
- Added missing AssemblyInfo files

## MvvmCross-AndroidSupport

- Improved samples
- Added ReplaceMode for Fragments in MvxCachingFragmentActivity
- Now comparing bundles to determine whether to replace a fragment or not
- GetFragmentInfoByTag added in MvxCachingFragmentActivity
- Built against the new v23 Android Support packages
- Added new porjects for leanback, design and preference

## MvvmCross-Forms

- Updated Xamarin.Forms package
- Built against new MvvmCross betas

The new release is available on [Nuget](https://www.nuget.org/packages?q=mvvmcross).

See the [issue list](https://github.com/MvvmCross/MvvmCross/issues?q=milestone%3A4.0.0+is%3Aclosed) for an overview of all solved issue's and merged pull requests.
Those lists are also available for [Android Support](https://github.com/MvvmCross/MvvmCross-AndroidSupport/issues?q=milestone%3A4.0.0+is%3Aclosed) and [MvvmCross Forms](https://github.com/MvvmCross/MvvmCross-Forms/issues?q=milestone%3A4.0.0+is%3Aclosed)

If you need any help you can get in touch via the [JabbR #mvvmcross](https://jabbr.net/#/rooms/mvvmcross) room, or open a topic on [StackOverflow](http://stackoverflow.com/questions/new/mvvmcross) and tag it with "MvvmCross".

Let us know if you find any bugs!

- Martijn00
- Cheesebaron ʕ•̫͡•ʔ

repository: MvvmCross/MvvmCross

branch_name: refs/heads/develop

detected_licenses: MS-PL Apache-2.0 MIT

gha_license_id: MS-PL

repo_name: MvvmCross/MvvmCross


text:
PhobosSwiftWechat
================
# Features
- 基于微信SDK的封装（检查微信版本、是否安装、安装地址、调起微信、处理回调等）

# Requirements
- iOS 10.0 or later
- Xcode 11.0 or later
- cocoapods 1.10.0 or later

# How To Use
- swift

```

import PhobosSwiftWechat

let wechat = PBSWechat.shared
wechat.configure(appId: "", universalLink: "")

```

# Installation
## Podfile

```
platform :ios, '10.0'
use_frameworks!
pod 'PhobosSwiftWechat', '~> 0.1.0'
```

# Author
[Restless Developer](https://github.com/restlesscode)

# Licenses
All source code is licensed under the [MIT License](../../LICENSE).

repository: ttttfix/phobos-swift

repo_name: ttttfix/phobos-swift


text:
### Installations for running keras-theano on GPU
1. Upgrade pip and install opencv2
```
cd ~
pip install --upgrade pip
pip install opencv-python
```
2. Upgrade keras and set theano background
```
pip uninstall keras
pip install keras
vi ~/.keras/keras.json
  {
    "backend": "theano",
    "image_data_format": "channels_first",
    "floatx": "float32",
    "epsilon": 1e-07
  }
```
3. Upgrade theano
```
pip uninstall theano
pip install theano==1.0.1
```
4. Install pygpu which is necessary to run theano on GPU
```
git clone https://github.com/Theano/libgpuarray.git
cd libgpuarray
mkdir Build
cd Build
cmake .. -DCMAKE_BUILD_TYPE=Release
make
make install
cd ..
python3 setup.py build_ext -L /root/libgpuarray/lib -I /root/libgpuarray/include
python3 setup.py install
sudo ldconfig
```
5. Run python on a specific GPU
```
THEANO_FLAGS=device=cuda0 python3
```

### How to run the project
1. Create high dense train patches
```
cd hdata
python3 HighDenseTrainPatchMaker.py
```
2. Create validation and test patches
```
cd ldata
python3 ValidationPatchMaker.py
python3 TestPatchMaker.py
```
3. Train FCN
```
THEANO_FLAGS=device=cuda0 python3 pagetrainf8.py
```
4. Predict test pages
```
python3 pagepredictf8.py
```
5. See the predictions in the folder called `out`.

repository: beratkurar/page-segmentation-using-fcn

repo_name: beratkurar/page-segmentation-using-fcn


text:
# _Epicodus Track Suggester_

#### _Helps students determine which programming track would be best for them, 01/13/2017_

#### By _**Elise St Hilaire**_

## Description

_{Epicodus offers five different tracks for students to study. These options can be intimidating, especially for students that don't have much technical background. Epicodus Track Suggester helps students determine which track would be best for them, based on a set of five multiple choice questions.}_

## Setup/Installation Requirements

* _Clone the repository_
* _Open the file in your preferred browser_
* _OR copy and paste this address in your browser:_
_eliseylenore.github.io/track-suggester_

## Known Bugs

_The webpage has to be refreshed before submitting the form a second time._

_Created a space for user to enter their name, but haven't quite figured out how to append this value to the div shown at the end, as the input comes through a separate form. There are also some issues with the gradient background at large viewport sizes.

## Support and contact details

_If you run into issues, I would appreciate if you let me know. Just message me at<EMAIL_ADDRESS>
## Technologies Used

_I used JavaScript and jQuery for the interactivity of the site. The jQuery was based on a CDN. The styling consists both of my own CSS styles and Bootstrap. I also used a CDN for Bootstrap._

### License

*These webpages are licensed under the MIT license.*

Copyright (c) 2016 **_Elise St Hilaire_**

repository: eliseylenore/track-suggester

repo_name: eliseylenore/track-suggester


text:
Web Author Document Preview Plugin
==================================

This sample plugin uses the `editor.previewAuthorDocument` to let the user preview another XML document inside a dialog.
The user has to browse for a file, then the file will be displayed inside a dialog.

repository: oxygenxml/web-author-sample-plugins

repo_name: oxygenxml/web-author-sample-plugins


text:
Due to the fact that Cake Modules are extending and altering the internals of the Cake, the Module Assembly needs to be loaded prior to the main Cake execution.  As a result, the only place that this can really happen is during the bootstrapping phase.  If you use the [latest version of the default bootstrapper](https://github.com/cake-build/resources/commit/3d112812353d714dad142c41f170b949f4a2eb2f) this process is made very easy.  All you need to do is the following.

1. Add a modules folder into your tools folder
2. Add a packages.config file into the newly created modules folder
3. Add the name and version of the Module that you want to use.  **NOTE:** At this point, the assumption is that you are hosting the Module on NuGet.org.  If this is not the case, then additional steps would be required.
4. An example packages.config file is shown below:

```
<?xml version="1.0" encoding="utf-8"?>
<packages>
	<package id="Cake.Chocolatey.Module" version="0.1.0" />
</packages>
```

5. Run the build as normal.  During the Cake Execution, it will recognise the Module Assembly which as been restored into the `tools/modules` folder, and load it.

**NOTE:** Similar to the recommendation [here](http://cakebuild.net/docs/tutorials/getting-started) regarding only checking in your packages.config and not the entire contents of the Cake tools folder, the same recommendation is applied here.  Only check-in the packages.config file in the modules folder, and not the entire contents.


text:
# Extra Food

React/Redux front end for ExtraFood API

LIVE DEMO: [http://extrafood.codyi.mobi](http://extrafood.codyi.mobi "Demo")

DEMO LOGIN<EMAIL_ADDRESS>
DEMO PASSWORD: demo$123

![Screenshot](https://i.imgur.com/KAYN2C8.png "Screenshot")
![Screenshot](https://i.imgur.com/mwzP5Ed.png "Screenshot")
![Screenshot](https://i.imgur.com/DbrngQR.png "Screenshot")

## Getting Started

Clone repository, npm install, npm start

### Prerequisites

Node.js NPM

### Installing

Clone or copy repository to server

```
git clone https://github.com/codyirving/extrafood.git
```

Run npm install to install dependencies.

```
npm install
```

Run npm start to start application.

```
npm start
```

## Running the tests

```
npm test
```

### Break down into tests

Smoke tests only

## Deployment

If deploying site publicly it is recommended to use a certificate to enable https.

## Built With

- [Node](node.js)
- [Express](express)
- [React](react)
- [Redux](redux)

## Authors

- **Cody Irving** - _Initial work_ - [codyirving](https://github.com/codyirving)

See also the list of [contributors](https://github.com/codyirving/gardenmanager/contributors) who participated in this project.

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

repository: codyirving/extrafood

repo_name: codyirving/extrafood


text:
# Minimal Oauth client to interact with BitBucket rest api

This script was almost copied from [ayush-sharma DevOps tools](https://github.com/ayush-sharma/infra_helpers)

## Requirements:

 - Python >= 3
 - requests
 - requests-oauthlib

## installation (I suggest to setup a virtualenv)

```
pip install -r requirements.txt
```

## Setup and Usage

 - Go Bitbucket account settings -> OAuth -> Add Consumer

Set

 - Repositories = Read
 - Account = Write
 - Callback URL = https://localhost
 - This is a Private consumer = True

Once created take the account_id, key and secret and set the following variables in your environment:

```
 - BB_ACCOUNT_ID
 - BB_OAUTH_ID
 - BB_OAUTH_SECRET
```

Whenever command you'll have to:

 - Browse the given URL in your browser
 - copy the url generated by the BB 2FA from the navigation bar and feed the script with it

Some tips on usage:

List repos

	$ BB_ACCOUNT_ID=id BB_OAUTH_ID=key BB_OAUTH_SECRET=secret python bbcli.py --operation listrepos --filereport

Get group info:

	$ BB_ACCOUNT_ID=id BB_OAUTH_ID=key BB_OAUTH_SECRET=secret python bbcli.py  --operation groupinfo --group foode

Set all repos permission ( IMPORTANT: if no group exist in the repos it will be created ):

        $ BB_ACCOUNT_ID=id BB_OAUTH_ID=key BB_OAUTH_SECRET=secret python bbcli.py  --operation permissions --repoall --group foo  --grant read

Set repo permission example:

	$ BB_ACCOUNT_ID=id BB_OAUTH_ID=key BB_OAUTH_SECRET=secret python bbcli.py  --operation permissions --group foo --repo bar --grant read

# Migration Operations

Collect backup infos for each group with

	$ BB_ACCOUNT_ID=moldiscovery BB_OAUTH_ID={key} BB_OAUTH_SECRET={secret} python bbcli.py --operation groupinfo --group groupname1  --filereport
	$ BB_ACCOUNT_ID=moldiscovery BB_OAUTH_ID={key} BB_OAUTH_SECRET={secret} python bbcli.py --operation groupinfo --group groupname2  --filereport
	$ ..

Named report files will be created on the execution with format `group_groupname_info.csv` .

We're now ready to run for each users group ( few so it's not automatic ) this command:

	$ BB_ACCOUNT_ID=id BB_OAUTH_ID=key BB_OAUTH_SECRET=secret python bbcli.py  --operation permissions --group foo --grant read
	$ BB_ACCOUNT_ID=id BB_OAUTH_ID=key BB_OAUTH_SECRET=secret python bbcli.py  --operation permissions --group bar --grant read
	..

At the end all groups will have raed-only access to their repos

# Fail Back to previous group permissions

It is possible to restore the group permissions as before the migration by issuing

	$ BB_ACCOUNT_ID=moldiscovery BB_OAUTH_ID={key} BB_OAUTH_SECRET={secret} python bbcli.py --operation restoregroupsgrant --group groupname --backupfilepath pathto/group_groupname_info.csv

## ISSUES

Due to the lack of endpoints in BB API1.0 and 2.0 it's not possibile to change user permissions over repoistories, this must be done manually or just do
not give user specific permissions on repos, use groups for any user and you'll be fine

repository: moldiscovery/bbapiclient

gha_language: Python

repo_name: moldiscovery/bbapiclient


text:
# User Story snippets and highlighting

A simple package which extends the atom editor with syntax highlighting and snippets for user stories. Pretty much work in progress.

## Highlighting
The format currently supported follows the textbook style format.
```
As a <ROLE> I want <GOAL> so that <REASON>.
```

You can deviate a bit from the version above. All examples below would be recognized by the parser:

```
# Some feature
As a USER I would like to have syntax highlighting for user stories so that I can better visually parse them.
The user would like to have syntax highlighting for user stories so that he can visually parse them.
a user would like to have syntax highlighting
```

The representation in atom using the solarized-dark syntax theme:
![sample image](https://raw.githubusercontent.com/fschaper/atom-language-story/master/support/sample.jpg)

## Snippets

Currently three expansions are offered:
- `asn` will expand to `As an {ROLE} I want {GOAL} so that {REASON}.`
- `asa` in turn will expand to `As a {ROLE} I want {GOAL} so that {REASON}.`
- `ast` expands to `As the <ROLE>, I want <GOAL> so that <REASON>.`

## Autocomplete

There is autocomplete support for the users role.

## Reference Material

- [Martin Fowler on User Stories](http://martinfowler.com/bliki/UserStory.html)

repository: fschaper/atom-language-story

gha_language: CoffeeScript

repo_name: fschaper/atom-language-story


text:
# opengl_framework

A simple 2D openGL Framework written in C++

My ambition was to get familiar with modern C++ development, and to better understand the secrets of openGL development.

The project in itself is in development, and might never actually get finished.

## Presentation

The framework resolve around several blocks :

* A `Ogl_Wrapper` object that deals with OpenGL itself, shader loading, GLFW Window management etc
* A `Ogl_world` object that manages the world and all the elements inside.
* A `Physics` object that manages the physics engine, wrapping world elements with velocity and acceleration parameters.

## Installation

You first need cmake, and C++ compilation tools if you dont have it already :
``` bash
sudo apt install cmake make g++
```

This repository does not include OpenGL.

You can install OpenGL and the needed libraries with the following command
``` bash
sudo apt install libx11-dev libgl1-mesa-dev libglu1-mesa-dev libxrandr-dev libxext-dev libxcursor-dev libxinerama-dev
```

Then type the following commands to build the project :

```bash
mkdir build
cd build
cmake ..
cp -r ../include/* /usr/local/include
sudo make install
cp ../src/*.shader .
```

Then launch tests from the build dir :
```bash
./tests/pong_exe
```

And it should work fine.


text:
# Oracle APEX DynamicAction Plugin - Filesize Checker
This plugin checks/validates the max size of an file input field. The validation is handled on client side via Javascript.
If the input file is greater than max. allowed size a Javascript alert is thrown and the file item is cleared.

## Changelog
#### 1.1 - Added different alert types (simple JS alert and Apex dialog)
#### 1.0 - Initial Release

## Install
- Import plugin file "dynamic_action_plugin_de_danielh_filesizechecker.sql" from source directory into your application
- (Optional) Deploy the CSS/JS file from "server" directory on your webserver and change the "File Prefix" to webservers folder.

## Plugin Settings
The plugin settings are highly customizable and you can change:
- Max size (in byte) - Maximum allowed size of a file in Byte. Default is 1MB (1048576 bytes)
- File Input Item - Choose the file input item for this action
- Alert text - Alert text if the file size is greater than allowed max. size
- Alert type - Choose between simple JS alert or Apex 5 dialog window
- Alert Text (no Browser Support) - Alert text if the browser doesn´t support this feature.

## How to use
Create a new Dynamic Action with event "on change" on your file input item. As action choose "Filesize Checker".

## Demo Application
https://apex.oracle.com/pls/apex/f?p=APEXPLUGIN

## Preview
![](https://github.com/Dani3lSun/apex-plugin-filesizechecker/blob/master/preview.png)
---


text:
---
layout: default
---

# 1997-05-10 - Re: Wine Politics Again!

## Header Data

From: Blanc<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: d90c6369419f8209793dad62c87fbbdcc4eb353b10e23c96c039aec304974107

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1997-05-10 20:57:40 UTC

Raw Date: Sun, 11 May 1997 04:57:40 +0800

## Raw message

```
{% raw  %}From: Blanc<EMAIL_ADDRESS>Date: Sun, 11 May 1997 04:57:40 +0800
To<EMAIL_ADDRESS>Subject: Re: Wine Politics Again!
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

>From<EMAIL_ADDRESS>
>At 12:35 AM 5/10/97 -0700, Blanc wrote:

>>Timothy must be drunk; I can't believe he said this.   Because he wouldn't
>>spend so much time writing sensible things of Truth & Light, if he thought
>>the better thing to do for achieving libertarian values was to kill so
>>indiscriminately with a bomb.    After all, he subscribes to utmost
>>discrimination.   So I think right now he's less in the engagement of
>>Reason and more under the influence of maybe some Bud Light.
>
>He didn't say it was a better thing to do.  He said he was coming to
understand McVeigh's actions.
.................................................................

He didn't explicity say it was the better thing to do.    But when there is
a decision to be made about a course of action to take, and there are
choices available and you select one over another,  you have evidenced
which one you think is the better.

>Tim is helping (in his way) to convince others of the facts of the matter.
 Dramatic statements carry the message better.

Lately Tim has been making extremely dramatic death statements:   "Kill
them all...they are unworthy of life.", "... I
pray for the deaths of these criminals.",  "Washington is a cancer than can
only be cured with a few megatons of
nuclear disinfectant.", "May they all be vaporized.", etc.

These are definitely dark in mood and understandable; I also have violently
negative & despairing emotions about these people.   I just wouldn't ever
think of involving those who are innocent bystanders and happened to be in
the wrong place at the wrong time.

This is the same kind of flaw which collectivists make when they set up
groups, governments, any kind of organization: they take a broad sweep of
the population, without being particular about any exceptions to their
rules or their plans.

It has always been the defining element in what is different about the U.S.
from other countries, that individuals receive more attention and
recognition as single entities, with their own defining characteristics,
than anywhere else in the world.   We are more free to descriminate, to
think of people as responsible for their own actions and as deserving of
just consequences for them.   It muddies this concept, to lump a large
aggregate of people into one and treat them all as being the same entity;
it takes the mind from being able to think in terms of specifics, into
thinking instead in broad considerations which overlook the particulars.

Technology delivers to the single person the possibility of efficacy on
their level, as compared to having to wait for some overseeing body of
authorities to deliver solutions from their stock of tools & means.
Technology also makes it possible to be even more precise about cause &
effect - so that the tools one uses can be of benefit only to the user
without affecting anyone else who is not interested in participating, or in
being affected by, what anyone else may be doing.

I know that critical times call for critical action, but I just don't
expect from anarchist libertarian cypherpunks that they would "throw
caution to the wind" (so to speak) and forget how to think about events and
actions in terms of specifics and utter precision.

    ..
Blanc
    ..
Blanc

{% endraw %}
```

## Thread

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

+ Return to "[Blanc <blancw@cnw.com>](/authors/blanc_blancw_at_cnw_com_)"

+ 1997-05-10 (Sun, 11 May 1997 04:57:40 +0800) - Re: Wine Politics Again! - _Blanc<EMAIL_ADDRESS>


text:
## Task 1

Make a function that takes in a single parameter (true/false) and
returns a new Promise. If the paramter is true resolve the promise with the return string 'success', if the parameter is false reject the promise with the return string 'error'.

> ! Hint: check the pptx for clues on how to create a promise.

Example:

```javascript
function myProm() {
  //...
}

const promise = new myProm(true);
promise.then((data) => {
  console.log(data); //-> outputs 'success'
});

const promise2 = new myProm(false);
promise2.then(/*...*/).catch((error) => {
  console.log(error); //-> outputs 'error'
});
```

## Task 2

Extend your function from task 1 and make it recieve a object like

```javascript
{
  name: "yourname",
  age: 32
}
```

If the age is bigger than 40 resolve the promise with the object with the added property text: 'Wohaa, you´re old. If the age is less then 40 but bigger than 0 resolve the promise with the text: 'Wow, you're so young and pretty'
If the age is less then 0, reject the promise with the text: 'Invalid age'
Example result from resolve:

```javascript
  {
    name: "yourname",
    age: 32,
    text: 'Wow, your so young and pretty'
  }
```

## Task 3

Make a function that takes in a single parameter and returns
a new promise.

Using setTimeout, after 500 milliseconds the promise will either
resolve or reject. If the input parameter is a string, the promise
resolves with the same string uppercased. If the input is anything
but a string it rejects with the same input.

The output in the end should always print out 'I`m done'

> ! Hint: check if there some way to always execute code after a promise.

## Task 4 (bonus)

Research if there is some way to make sure multiple promises are resolved/rejected and set up some code that does both Task 2 and Task 3 and only prints out success (and the data) if both are successfull.

repository: thomasbrunstrom/academy-async

repo_name: thomasbrunstrom/academy-async


text:
# Install Intel® Distribution of OpenVINO™ toolkit for Windows* from Docker* Image {#openvino_docs_install_guides_installing_openvino_docker_windows}

The Intel® Distribution of OpenVINO™ toolkit quickly deploys applications and solutions that emulate human vision. Based on Convolutional Neural Networks (CNN), the toolkit extends computer vision (CV) workloads across Intel® hardware, maximizing performance. The Intel® Distribution of OpenVINO™ toolkit includes the Intel® Deep Learning Deployment Toolkit.

This guide provides the steps for creating a Docker* image with Intel® Distribution of OpenVINO™ toolkit for Windows* and further installation.

## System Requirements

**Target Operating Systems**

- Windows Server Core*

**Host Operating Systems**

- Windows 10*, 64-bit Pro, Enterprise or Education (1607 Anniversary Update, Build 14393 or later) editions
- Windows Server* 2016 or higher

## Build a Docker* Image for CPU

To build a Docker image, create a `Dockerfile` that contains defined variables and commands required to create an OpenVINO toolkit installation image.

Create your `Dockerfile` using the following example as a template:

<details>
  <summary>Click to expand/collapse</summary>

~~~
# escape= `
FROM mcr.microsoft.com/windows/servercore:ltsc2019

# Restore the default Windows shell for correct batch processing.
SHELL ["cmd", "/S", "/C"]

USER ContainerAdministrator

# Setup Redistributable Libraries for Intel(R) C++ Compiler for Windows*

RUN powershell.exe -Command `
    Invoke-WebRequest -URI https://software.intel.com/sites/default/files/managed/59/aa/ww_icl_redist_msi_2018.3.210.zip -Proxy %HTTPS_PROXY%  -OutFile "%TMP%\ww_icl_redist_msi_2018.3.210.zip" ; `
    Expand-Archive -Path "%TMP%\ww_icl_redist_msi_2018.3.210.zip" -DestinationPath "%TMP%\ww_icl_redist_msi_2018.3.210" -Force ; `
    Remove-Item "%TMP%\ww_icl_redist_msi_2018.3.210.zip" -Force

RUN %TMP%\ww_icl_redist_msi_2018.3.210\ww_icl_redist_intel64_2018.3.210.msi /quiet /passive /log "%TMP%\redist.log"

# setup Python
ARG PYTHON_VER=python3.7

RUN powershell.exe -Command `
  Invoke-WebRequest -URI https://www.python.org/ftp/python/3.7.6/python-3.7.6-amd64.exe -Proxy %HTTPS_PROXY% -OutFile %TMP%\\python-3.7.exe ; `
  Start-Process %TMP%\\python-3.7.exe -ArgumentList '/passive InstallAllUsers=1 PrependPath=1 TargetDir=c:\\Python37' -Wait ; `
  Remove-Item %TMP%\\python-3.7.exe -Force

RUN python -m pip install --upgrade pip
RUN python -m pip install cmake

# download package from external URL
ARG package_url=http://registrationcenter-download.intel.com/akdlm/irc_nas/16613/w_openvino_toolkit_p_0000.0.000.exe
ARG TEMP_DIR=/temp

WORKDIR ${TEMP_DIR}
ADD ${package_url} ${TEMP_DIR}

# install product by installation script
ARG build_id=0000.0.000
ENV INTEL_OPENVINO_DIR C:\intel

RUN powershell.exe -Command `
    Start-Process "./*.exe" -ArgumentList '--s --a install --eula=accept --installdir=%INTEL_OPENVINO_DIR% --output=%TMP%\openvino_install_out.log --components=OPENVINO_COMMON,INFERENCE_ENGINE,INFERENCE_ENGINE_SDK,INFERENCE_ENGINE_SAMPLES,OMZ_TOOLS,POT,INFERENCE_ENGINE_CPU,INFERENCE_ENGINE_GPU,MODEL_OPTIMIZER,OMZ_DEV,OPENCV_PYTHON,OPENCV_RUNTIME,OPENCV,DOCS,SETUPVARS,VC_REDIST_2017_X64,icl_redist' -Wait

ENV INTEL_OPENVINO_DIR C:\intel\openvino_${build_id}

# Post-installation cleanup
RUN rmdir /S /Q "%USERPROFILE%\Downloads\Intel"

# dev package
WORKDIR ${INTEL_OPENVINO_DIR}
RUN python -m pip install --no-cache-dir setuptools && `
    python -m pip install --no-cache-dir -r "%INTEL_OPENVINO_DIR%\python\%PYTHON_VER%\requirements.txt" && `
    python -m pip install --no-cache-dir -r "%INTEL_OPENVINO_DIR%\python\%PYTHON_VER%\openvino\tools\benchmark\requirements.txt" && `
    python -m pip install --no-cache-dir torch==1.4.0+cpu torchvision==0.5.0+cpu -f https://download.pytorch.org/whl/torch_stable.html

WORKDIR ${TEMP_DIR}
COPY scripts\install_requirements.bat install_requirements.bat
RUN install_requirements.bat %INTEL_OPENVINO_DIR%

WORKDIR ${INTEL_OPENVINO_DIR}\deployment_tools\open_model_zoo\tools\accuracy_checker
RUN %INTEL_OPENVINO_DIR%\bin\setupvars.bat && `
    python -m pip install --no-cache-dir -r "%INTEL_OPENVINO_DIR%\deployment_tools\open_model_zoo\tools\accuracy_checker\requirements.in" && `
    python "%INTEL_OPENVINO_DIR%\deployment_tools\open_model_zoo\tools\accuracy_checker\setup.py" install

WORKDIR ${INTEL_OPENVINO_DIR}\deployment_tools\tools\post_training_optimization_toolkit
RUN python -m pip install --no-cache-dir -r "%INTEL_OPENVINO_DIR%\deployment_tools\tools\post_training_optimization_toolkit\requirements.txt" && `
    python "%INTEL_OPENVINO_DIR%\deployment_tools\tools\post_training_optimization_toolkit\setup.py" install

WORKDIR ${INTEL_OPENVINO_DIR}

# Post-installation cleanup
RUN powershell Remove-Item -Force -Recurse "%TEMP%\*" && `
    powershell Remove-Item -Force -Recurse "%TEMP_DIR%" && `
    rmdir /S /Q "%ProgramData%\Package Cache"

USER ContainerUser

CMD ["cmd.exe"]
~~~

</details>

> **NOTE**: Replace direct link to the Intel® Distribution of OpenVINO™ toolkit package to the latest version in the `package_url` variable and modify install package name in the subsequent commands. You can copy the link from the [Intel® Distribution of OpenVINO™ toolkit download page](https://software.seek.intel.com/openvino-toolkit) after registration. Right click the **Offline Installer** button on the download page for Linux in your browser and press **Copy link address**.
> **NOTE**: Replace build number of the package in the `build_id` variable according to the name of the downloaded Intel® Distribution of OpenVINO™ toolkit package. For example, for the installation file `w_openvino_toolkit_p_2020.3.333.exe`, the `build_id` variable should have the value `2020.3.333`.

To build a Docker* image for CPU, run the following command:
~~~
docker build . -t <image_name> `
--build-arg HTTP_PROXY=<http://your_proxy_server.com:port> `
--build-arg HTTPS_PROXY=<https://your_proxy_server.com:port>
~~~

## Install additional dependencies
### Install CMake
To add CMake to the image, add the following commands to the `Dockerfile` example above:
~~~
RUN powershell.exe -Command `
    Invoke-WebRequest -URI https://cmake.org/files/v3.14/cmake-3.14.7-win64-x64.msi -Proxy %HTTPS_PROXY% -OutFile %TMP%\\cmake-3.14.7-win64-x64.msi ; `
    Start-Process %TMP%\\cmake-3.14.7-win64-x64.msi -ArgumentList '/quiet /norestart' -Wait ; `
    Remove-Item %TMP%\\cmake-3.14.7-win64-x64.msi -Force

RUN SETX /M PATH "C:\Program Files\CMake\Bin;%PATH%"
~~~

### Install Microsoft Visual Studio* Build Tools
You can add Microsoft Visual Studio Build Tools* to Windows* OS Docker image. Available options are to use offline installer for Build Tools
(follow [Instruction for the offline installer](https://docs.microsoft.com/en-us/visualstudio/install/create-an-offline-installation-of-visual-studio?view=vs-2019) or
to use online installer for Build Tools (follow [Instruction for the online installer](https://docs.microsoft.com/en-us/visualstudio/install/build-tools-container?view=vs-2019).
Microsoft Visual Studio Build Tools* are licensed as a supplement your existing Microsoft Visual Studio* license.
Any images built with these tools should be for your personal use or for use in your organization in accordance with your existing Visual Studio* and Windows* licenses.

## Run the Docker* Image for CPU

To install the OpenVINO toolkit from the prepared Docker image, run the image with the following command:
~~~
docker run -it <image_name>
~~~

## Examples
* [winserver2019_runtime dockerfile](https://docs.openvinotoolkit.org/downloads/winserver2019_runtime.dockerfile) - Can be used to build OpenVINO™ runtime image containing minimal dependencies needed to use OpenVINO™ in production environment.
* [winserver2019_dev dockerfile](https://docs.openvinotoolkit.org/downloads/winserver2019_dev.dockerfile) - Can be used to build OpenVINO™ developer image containing full OpenVINO™ package to use in development environment.

## Additional Resources

* Intel® Distribution of OpenVINO™ toolkit home page: [https://software.intel.com/en-us/openvino-toolkit](https://software.intel.com/en-us/openvino-toolkit)

* OpenVINO™ toolkit documentation: [https://docs.openvinotoolkit.org](https://docs.openvinotoolkit.org)

* Intel® Distribution of OpenVINO™ toolkit Docker Hub* home page: [https://hub.docker.com/u/openvino](https://hub.docker.com/u/openvino)


text:
# Contribution

This section is dedicated to those of you, who want to improve Hydrosphere.

## Prerequisites

To set up a development environment clone Serving repository.

```sh
git clone https://github.com/Hydrospheredata/hydro-serving
```

For the development you'll probably need working model examples.

```sh
git clone https://github.com/Hydrospheredata/hydro-serving-example
```

To upload serving examples to Serving, you'll need `hs` cli-tool.

```sh
pip install hs
```

Add new local cluster.

```sh
hs cluster add --name local --server http://localhost/
```

## Development

Run PostgreSQL, Sidecar and UI containers.

```sh
cd hydro-serving
sbt manager/devRun
```

Removing containers is done with:

```sh
sbt manager/cleanDockerEnv
```

## Model uploading

Go to the `claims` model example and upload it.

```sh
cd hydro-serving-example/model/claims
hs upload
```

You can see the uploaded model from [http://localhost/](http://localhost/).

repository: TrendingTechnology/hydro-serving

repo_name: TrendingTechnology/hydro-serving