text:
# distxargs, A parallel distributed version of xargs -P.

`distxargs` is a easy-to-use parallel execution of cli commands, basically a **distributed version of `xargs -P` **.

* Runs cli commands in a parallel way on host computers via ssh.
* Selects a host to run a cli command, depending on the number of running process on it at that time (a dynamic scheduling).
* Can put a distinct limitation of max processes to each host.

## Installation

To install `disxargs`:

```
python3 -m pip install git+https://github.com/tos-kamiya/distxargs
```

A cli script `distxargs` will be installed.

To uninstall:

```
python3 -m pip uninstall distxargs
```

## Configuration of hosts

`distxargs` requires that each host can be connected using `ssh` command **without password** . If you are not sure about that, set up the hosts with the following instruction.

### SSH configuration for localhost

As for `localhost`, you can make it so with the following steps:

(1) If you do not have a public key for ssh (that is, a file `~/.ssh/id_rsa.pub`), generate it:

```
ssh-keygen -t rsa
(...Press enter for each line...)
```

(2) Add it to the authorized-key list:

```
cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
chmod og-wx ~/.ssh/authorized_keys
```

(refer https://stackoverflow.com/questions/7439563/how-to-ssh-to-localhost-without-password )

### SSH configuration for other hosts

As for the other hosts,

(1) Ensure you can login to the host with `ssh`:

```
ssh username@hostname
```

If the host does not ask password, you already have established a password-less connection to the host, so skip the following steps:

(2) Ensure you have a public key for ssh. If you do not have, make the key with the step (1) for localhost.

(3) Add the public key to an authorized-key list of the host.

```
ssh-copy-id username@hostname
```

If successfully done, you can now login to the host without password with `ssh`.

## CLI usage

`distxargs` has a limited (and slightly modified) subset of CLI options/arguments of command `xargs`

```
Usage:
  distxargs [options] (-n MAX_ARGS|-L MAX_ARGS) (-P<EMAIL_ADDRESS>FILE) <command>...

Options:
  -a FILE           Read arguments from file.
  -P<EMAIL_ADDRESS>    Specify max count of processes of a host.
  -I REPLACE_STR    Replace the string in command with arguments.
  -n MAX_ARGS       Max count of arguments passed to a process.
  -L MAX_ARGS       Same as `-n`, but arguments are separated by new line.
  -t                Show command line on command execution.
  -c FILE           Configuration file. [default: ./conf.distxargs.yaml]
  --localhost-only  Run commands only on localhost.
  --generate-sample-config-file
```

### Example

Runs `echo` commands total 5 times on 2 computers (hosts).
The `localhost` runs up to one process at a time.

To prepare the configuration file, run the following command:

```
distxargs --generate-sample-config-file
```

And then edit the configuration and save to a file `./conf.distxargs.yaml`:

```
default:
  user_name: "toshihiro"

hosts:
- host_name: "localhost"
  max_processes: 1
- host_name: "node01"
  max_processes: 2
```

Then the command line of the above example will become:

```
echo alice bob charlie dave eve | distxargs -c. -n1 -t -I '{}' echo hello, '{}'!
```

The configuration is a local one, that is, supposed to saved to each working directory.

However, alternatively, you can make a default (global) configuration file by saving a configuration file to a path `~/.confg/distxargs/conf.distxargs.conf` .

In case of use the default configuration file, add option `-c~` to the command line:

```
echo alice bob charlie dave eve | distxargs -c~ -n1 -t -I '{}' echo hello, '{}'!
```

## License

MIT License.

repository: tos-kamiya/distxargs

repo_name: tos-kamiya/distxargs


text:
# SharkRF IP Connector Protocol

This is the protocol used by [SharkRF openSPOT](https://www.sharkrf.com/products/openspot/)'s UDP API to allow 3rd party developers to create their own applications which communicate using openSPOT.

The protocol is designed for simplicity: strings are closed with zeroes, and packets have redundant fields. For example: call info can be extracted from raw DMR frames, but the protocol includes them in the packets separately, so 3rd party developers don't need to deal with call tracking.

You can find a demo client and server application in this repo. The server is a very simple implementation, it can only handle one client at a time. However, handling multiple clients could be added easily.

Note that openSPOT doesn't use call information sent to it in the packets. It always extracts all required info from raw data streams.

Pull requests are welcome!

## Protocol Description

### Login process

Client has to start the connection with the login process. If NAK is received or timeout happens during the process, client has to retry logging in later. At least 5 seconds should be kept between retries, as server ignores frequent auth requests.

<!--
Client->Server: Login
Server->Client: Token
Note left of Client: Token is used to generate HMAC
Client->Server: Auth
Note right of Server: If authorized,\nthe server replies with ACK,\notherwise NAK
Server->Client: ACK
Note over Client: Client is now logged in.
-->
![Login Process Diagram](https://raw.githubusercontent.com/sharkrf/srf-ip-conn/master/img/login.svg?sanitize=true)

Max. password length is 32 characters. Server limits auth tries for only one in every 5 seconds. Packets with invalid HMAC are ignored.

### Config update (optional)

Client can optionally update it's config information.

<!--
Client->Server: Config
Server->Client: ACK
-->
![Config Process Diagram](https://raw.githubusercontent.com/sharkrf/srf-ip-conn/master/img/config.svg?sanitize=true)

### Ping

Client should ping the server periodically at least once every 30 seconds (5 seconds is recommended to keep firewalls open) after the last packet has sent to the server. No need to send ping if client transmits in this 5 second timeframe. The server ends the connection after 30 seconds of client inactivity.

<!---
Client->Server: Ping
Server->Client: Pong
-->
![Ping Process Diagram](https://raw.githubusercontent.com/sharkrf/srf-ip-conn/master/img/ping.svg?sanitize=true)

### Data

Data packets can be sent in both directions.

<!--
Client->Server: Data
Client->Server: Data
Server->Client: Data
Client->Server: Data
Server->Client: Data
-->
![Data Diagram](https://raw.githubusercontent.com/sharkrf/srf-ip-conn/master/img/data.svg?sanitize=true)

### Closing the connection

Both participants can close the connection gracefully.

<!--
Client->Server: Close
Server->Client: ACK
-->
![Close Process Diagram 1](https://raw.githubusercontent.com/sharkrf/srf-ip-conn/master/img/close-client.svg?sanitize=true)
<!--
Server->Client: Close
-->
![Close Process Diagram 2](https://raw.githubusercontent.com/sharkrf/srf-ip-conn/master/img/close-server.svg?sanitize=true)

## Packet Structure

The protocol uses UDP as transport layer. Server listens on port 65100 by default.

UDP packet (*srf_ip_conn_packet_t*) structure:

Header | Payload
--- | ---

See [srf-ip-conn/common/srf-ip-conn-packet.h](https://github.com/sharkrf/srf-ip-conn/blob/master/srf-ip-conn/common/srf-ip-conn-packet.h) for used packet structures. Byte order is big-endian.

license: MIT

repository: sharkrf/srf-ip-conn

branch_name: refs/heads/master

extension: md

gha_language: C

license_type: permissive

repo_name: sharkrf/srf-ip-conn


text:
TCPONG
=================================
[![Build Status](https://travis-ci.org/sakajunquality/tcpong.svg?branch=master)](https://travis-ci.org/sakajunquality/tcpong)
[![codecov](https://codecov.io/gh/sakajunquality/tcpong/branch/master/graph/badge.svg)](https://codecov.io/gh/sakajunquality/tcpong)
[![Go Report Card](https://goreportcard.com/badge/github.com/sakajunquality/tcpong)](https://goreportcard.com/report/github.com/sakajunquality/tcpong)
[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/sakajunquality/tcpong/master/LICENSE)
[![Maintenance](https://img.shields.io/maintenance/yes/2017.svg)]()
![image](./image.png)

Overview
------------
Ping over TCP

Installation
------------
```
$ go get github.com/sakajunquality/tcpong
```

Usage
------------
#### Normal output,
```
$ tcpong host port
```

## Future Perspectives
- Testing
- CI
- UDP supprt
- Additionl options

Contributing
-----
Always welcome for contributing

License & Authors
-----------------
- Author:: @sakajunquality
- License:: MIT

repository: sakajunquality/tcpong

gha_language: Go

repo_name: sakajunquality/tcpong


text:
# Responsive Tool

Arwes has some utilities to handle responsive functionalities. You can use the
`createResponsive` module and create your tool.

```javascript
import { createTheme, createResponsive } from 'arwes';

const myTheme = createTheme();
const responsive = createResponsive({
  getTheme: () => myTheme
});

// To know in what breakpoint the viewport is at:
const state = responsive.get();
// `{ medium: true, status: 'medium' }`
// if device is on medium breakpoint, for example.

// To listen for breakpoint changes:
const listener = responsive.on(state => console.log(state));

// To turn it off:
responsive.off(listener);
```

You need to provide the [Design System](/docs/design-system) theme for it to know
about the breakpoints.

In a component you can use it the same way:

```javascript
import React from 'react';
import ReactDOM from 'react-dom';
import { ThemeProvider, createTheme,
  withStyles, createResponsive } from 'arwes';

class MyComponentClass extends React.Component {
  constructor () {
    super(...arguments);
    this.responsive = createResponsive({
      getTheme: () => this.props.theme
    });
  }
  render () {
    const { status } = this.responsive.get();
    return <div>Responsive status: {status}</div>;
  }
}

const MyComponent = withStyles()(MyComponentClass);

const App = () => (
  <ThemeProvider theme={createTheme()}>
    <MyComponent />
  </ThemeProvider>
);

ReactDOM.render(<App />, document.querySelector('#root'));
```

So the component can render `Responsive status: large` when viewport is in
breakpoint large when it is mounted.

repository: Yvanovitch/arwes

gha_license_id: MIT

repo_name: Yvanovitch/arwes


text:
## Overview

In the era of covid, the opportunity to network professionally has been significantly diminished. Networking events, conferences, talks, workshops, meetups, informational interviews, hackathons, etc. all have moved online or have completely disappeared in 2020. These online events are great, but they are not just the same when it comes to professional networking. There is no longer a way to meet like-minded people who are actually interested in meeting us to help us grow ourselves and our networks.

That’s why we created GitConnected. What sets GitConnected apart from other apps like LinkedIn is everyone who signs up is an active participant: they all want to meet other like-minded people. How many times have you sent or received a connection request on LinkedIn from a complete stranger who you never hear from again? To get connected, users create profiles and log in to search people they’re interested in meeting, just like we already do on LinkedIn, however, unlike LinkedIn, people on GitConnected actually want to meet and network with you.

We want to bring 1-on-1 professional networking online and help people connect through genuine, authentic meetings based on professional backgrounds, interests and aspirations.

We’ve set up the basic database for users, companies, and tech interests. We want people to be able to connect with people based on tech interests: say, someone is interested in meeting a product designer in the financial technology industry or a software engineer in the blockchain industry.

Our current features are just creating a user profile and searching people based on jobs and/or companies.

## Beta Stage

Team GitConnected will strive to continuously release updates and additional features.

1. If you would like to contribute to this project:

   - Please feel free to submit a PR

2. If you happen to come across any issues while tinkering with the application:
   - Please report the bug/issue by submitting a ticket located in the Issues Tab within this repository

## Getting Started

1.  Clone GitConnected to your local machine and point to the Git-Connected directory:

        git clone https://github.com/gconnected/Git-Connected.git

        cd Git-Connected

2.  Install all required dependencies with the following script:

        npm install

3.  Run the following script to open GitConnected on http://localhost:8080:

        npm run dev

## Main Features

### User Register / Login Landing Page

Users will be greeted with a landing page that will allow first-time users to register an account or returning users to login to access GitConnected's features.

First-time users that register on GitConnected will be led to a profile setup page that will request the user to input their information so that their data can be stored in the database. This will allow other networking professionals to be able to search for the new user from the Search Bar Page.

### Networking Search Bar Page

After signing in or registering, the user will have access to the search bar and will be able to look up any available networking professionals based on two requirements: Company Name & Job Title

## Built With

- React
- Node.JS
  - Express
- PostgreSQL

## Core Team

Tyler Morgan

Tommy Song

Nicholas Shay

Sophia Pak

## License

This project is licensed under the MIT License

repository: sophiapak/Git-Connected

repo_name: sophiapak/Git-Connected


text:
### Welcome!

Super happy that you're interested in contributing :)

To learn how to work with the project check out our [Development Process](https://github.com/TrangPham/django-admin-confirm/blob/main/docs/development_process.md)

#

### Found a Bug?

- Check if there's already an issue open.
  - If there is one, please comment on it so that we know the bug is affecting more people and/or versions.

- If there isn't one open, feel free to open a bug report

### Have a Feature Request?

- Check if there's already an issue open.
  - Comment or +1 on the issue so we can prioritize this feature

- If there isn't one open, feel free to open a feature request

### Looking for ways to contribute?

- Check out issues tagged `good first issue` for a good place to start
- Feel free to contribute to our documentation
- Or help improve our testing. Check out our [testing notes](https://github.com/TrangPham/django-admin-confirm/blob/main/docs/testing_notes.md)

repository: ballke-dev/django-admin-confirm

branch_name: refs/heads/main

gha_license_id: NOASSERTION

repo_name: ballke-dev/django-admin-confirm


text:
# Lichen spodophaeus Wahlenb. SPECIES

#### Status
SYNONYM

#### According to
Index Fungorum

#### Published in
in Acharius, Method. Lich. 37 (1803)

#### Original name
Lichen spodophaeus Wahlenb.

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Lecanoromycetes/Lecanorales/Lecanoraceae/Lecanora/Lecanora poliophaea/ Syn. Lichen spodophaeus/README.md

repo_name: mdoering/backbone


text:
---
title: Using custom connectors in MVVM
page_title: Using custom connectors in MVVM
description: Using custom connectors in MVVM.
slug: raddiagram-using-custom-connectors-in-mvvm
tags: create,custom,shape,connectors,mvvm,graphsource
published: True
position: 18
---

# Using custom connectors in MVVM

This tutorial will guide you through the task of populating RadDiagramShape with custom connectors in MVVM scenario.

To populate the __RadDiagramShape__ with custom connectors in MVVM scenario you can create an attached property. Then bind the value of this property to a collection from your view model. In the property changed callback of the attached property you have access to the shape and its __Connectors__ collection. Using this you can add new connectors to the collection.

To implement this scenario you can create a collection which holds the custom connectors in your view model.

#### __[C#] Example 1: Creating collection with custom connectors__
{{region raddiagram-using-custom-connectors-in-mvvm-0}}
	public class ConnectorProxy
	{
		public string Name { get; set; }
		public System.Windows.Point Position { get; set; }
	}
	public class Node : NodeViewModelBase
	{
		private ObservableCollection<ConnectorProxy> myConnectors = new ObservableCollection<ConnectorProxy>();

		public Node()
		{
			//Add connectors.
			this.MyConnectors.Add(new ConnectorProxy() { Name = "FirstConnector", Position = new Point(0, 0.3) });
			this.MyConnectors.Add(new ConnectorProxy() { Name = "SecondConnector", Position = new Point(1, 0.3) });
			this.MyConnectors.Add(new ConnectorProxy() { Name = "ThirdConnector", Position = new Point(0.5, 0.8) });
		}

		public ObservableCollection<ConnectorProxy> MyConnectors
		{
			get
			{
				return this.myConnectors;
			}
		}
	}
	public class Link : LinkViewModelBase<NodeViewModelBase>
	{
	}
	public  class MyGraphSource : ObservableGraphSourceBase<Node, Link>
	{
		public MyGraphSource()
		{
			Node shape1 = new Node() {Content = "Shape1", Position=new Point(80,120) };
			this.AddNode(shape1);
		}
	}
{{endregion}}

The next step is to create the attached property.

#### __[C#] Example 2: Creating attached property__
{{region raddiagram-using-custom-connectors-in-mvvm-1}}
	public static class AttachedProperties
	{
		public static IEnumerable<ConnectorProxy> GetConnectors(DependencyObject obj)
		{
			return (IEnumerable<ConnectorProxy>)obj.GetValue(ConnectorsProperty);
		}

		public static void SetConnectors(DependencyObject obj, IEnumerable<ConnectorProxy> value)
		{
			obj.SetValue(ConnectorsProperty, value);
		}

		public static readonly DependencyProperty ConnectorsProperty =
			DependencyProperty.RegisterAttached("Connectors", typeof(IEnumerable<ConnectorProxy>), typeof(AttachedProperties), new PropertyMetadata(null, OnConnectorsChanged));

		private static void OnConnectorsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
		{
			var shape = d as RadDiagramShape;
			// You can also check if the collection is INotifyCollectionChanged if you want to change the connectors runtime.
			// var connectors = e.NewValue as INotifyCollectionChanged
			var connectors = e.NewValue as ObservableCollection<ConnectorProxy>;
			if (shape != null && connectors != null)
			{
				foreach (var item in connectors)
				{
					//Note: the item.Name should be a valid x:Name
					shape.Connectors.Add(new RadDiagramConnector() { Name = item.Name, Offset = item.Position });
				}
			}
		}
	}
{{endregion}}

Finally, you can create an implicit style and bind the attached property to the custom collection and define a RadDiagram control in the view.

#### __[C#] Example 3: Setting the attached property in XAML__

{{region raddiagram-using-custom-connectors-in-mvvm-2}}
	<Window.Resources>
		<local:MyGraphSource x:Key="Source"/>
		<DataTemplate x:Key="contentTemplate">
		    <TextBlock Text="{Binding Content}" />
		</DataTemplate>
		<Style TargetType="telerik:RadDiagramShape">
		    <Setter Property="Position" Value="{Binding Position, Mode=TwoWay}" />
		    <Setter Property="common:AttachedProperties.Connectors" Value="{Binding MyConnectors}" />
		</Style>
	</Window.Resources>
	<Grid>
		<telerik:RadDiagram GraphSource="{StaticResource Source}"
								ShapeTemplate="{StaticResource contentTemplate}"
								ConnectionTemplate="{StaticResource contentTemplate}">
		</telerik:RadDiagram>
	</Grid>
{{endregion}}

#### __Figure 1: Custom connectors in RadDiagramShape__
![Custom Connectos](images/raddiagram-howto-custom-connectors.PNG)

## See Also
 * [Shapes]({%slug raddiagrams-features-shapes%})
 * [Use MVVM in RadDiagram]({%slug raddiagrams-howto-mvvm%})
 * [Iterate Over the Diagram Items]({%slug raddiagrams-howto-iterate-over-the-diagram-items%})

repository: telerik/xaml-docs

gha_language: JavaScript

repo_name: telerik/xaml-docs


text:
# [SMOT](https://arxiv.org/abs/2010.16031)

**SMOT: Single-Shot Multi Object Tracking**

by Wei Li, Yuanjun Xiong, Shuo Yang, Siqi Deng and Wei Xia

## Introduction

In this, we release code and models from the paper [Single-Shot Multi Object Tracking (SMOT)](https://arxiv.org/abs/2010.16031), to perform multi-object tracking. SMOT is a new tracking framework that converts any single-shot detector (SSD) model into an online multiple object tracker. **You can track any object as long as the detector can recognize the category, no training is required.** We also want to point out that, SMOT is very efficient, its runtime is close to the runtime of the chosen detector.

## Installation

For installation, follow the instruction of GluonCV. Optionally, if you would like to perform evaluation on MOT17 data and obtain metrics, please install `motmetrics` as `pip install motmetrics`.

## Demo on a video

Want to get multi-person tracking results on a video? Try this

```
python demo.py VIDEOFILE --input-type video --network-name ssd_512_mobilenet1.0_coco --use-pretrained --custom-classes person
```

- `VIDEOFILE` is the path to your demo video. It can also be the path to a folder of a sequence of images, but in this case, please remember to change the following `--input-type` to `images`.

- `--input-type` indicates the input type. It can be either `video` or `images`.

- `--network-name` is the detector you want to use. We use `ssd_512_mobilenet1.0_coco` here due to its good tradeoff between tracking accuracy and efficiency. You can find other detetors in our model zoo that suits your use case.

- `--use-pretrained` indicates you want to use the pretrained weights from GluonCV model zoo. If you don't specify `--use-pretrained`, please use `--param-path` to pass in your detector pretrained weights.

- `--custom-classes` indicates which object category you want to track. You can also track multiple categories at the same time, e.g., `--custom-classes person car dog`.

- The tracking visualization results will be saved to `./smot_vis`, but you can change the directory by specifing `--save-path`.

## Eval on exisiting datasets

We provide evaluation code on MOT17 to have some numerical results in case you need a comparison.

First of all, please download MOT17 data from its [official website](https://motchallenge.net/data/MOT17.zip).

Second, assume you unzip the data into `MOT17_DATA` folder, please proprocess the data into our format for easier evaluation,

```
python preprocess.py --mot-folder MOT17_DATA --mot-save-folder ./jsons/ --mot-save-npy ./npys/
```

The transformed data in json format will be saved to `./jsons` and its npy format will be saved to `./npys`. We only need the npy format data for evaluation.

Third, generate predictions using SMOT,

```
python demo.py MOT17_DATA/MOT17-02-FRCNN/img1/ --input-type images --network-name ssd_512_mobilenet1.0_coco --use-pretrained --custom-classes person --use-motion --save-path ./pred
```

Since MOT data is stored in image sequences, we need to change `input-type` to `images`. `use-motion` can be used optionally to improve the tracking performance. The predictions will be saved in npy format to the path `./pred`.

Finally, run evaluation on the predictions and ground-truth, the results will be printed to console in a table.

```
python eval.py --gt-dir ./npys/ --pred-dir ./pred/
```

For more information, please check `eval.py`.

## Citation

```
@inproceedings{li2020smot,
  title={SMOT: Single-Shot Multi Object Tracking},
  author={Wei Li, Yuanjun Xiong, Shuo Yang, Siqi Deng, Wei Xia},
  booktitle={arXiv preprint arXiv:2010.16031},
  year={2020}
}
```

repository: dmlc/gluon-cv

gha_language: Python

repo_name: dmlc/gluon-cv


text:
# JSAI-isAI Workshops for Stringologist
## [JSAI-isAI Workshops 2014](https://dblp.org/db/conf/jsai/jsai2014.html)
  1. [Finding Ambiguous Patterns on Grammar Compressed String.](https://doi.org/10.1007/978-3-662-48119-6_25)

repository: stringologytimes/StringologyTimes

gha_language: TypeScript

repo_name: stringologytimes/StringologyTimes


text:
This is a fork of Chart.js by Nick Downie, http://www.chartjs.org.t

Chart.js
=======
*Simple HTML5 Charts using the canvas element* [chartjs.org](http://www.chartjs.org)

Documentation
-------
You can find documentation at [chartjs.org/docs](http://www.chartjs.org/docs).

License
-------
Chart.js was taken down on the 19th March. It is now back online for good and IS available under the [MIT license](http://opensource.org/licenses/MIT).

Fork
-------

A few features have been added. See relevant samples pages for a demo. See also [http://www.brittle-star.com/http://www.brittle-star.com/code/a-stem-fork-of-chart-js/](http://www.brittle-star.com/code/a-stem-fork-of-chart-js/)

### box-and-whisker plots (special case of bar charts)

A new chart type, implemented as a child of Bar charts.

CAYdenberg:

> Box plots seperate the data into 4 quartiles, which are represented
> in a "box-and-whisker" arrangement. The best way to calculate the quartiles is by
> using the chart calculator, and pass the entire population as an array. Alternatively,
> the "breakpoints" of each quartiles can be passed in the data object as [q0, q1, q2, q3, q4]

spilliams:

> The standard usage of box-and-whisker plots arranges data into the 4 quartiles. If any outliers are present in the standard data set, they **are included** in the box and/or whiskers.
> If you wish to introduce outliers separate from that dataset, provide them in an `outliers` option of the dataset. You may style them using configuration options. See the demo for code samples.
> (This allows "outliers" to be placed inside the box, in order to compare, for instance, one particular student's score next to the distribution of the rest of the class)

### scatter charts

A new chart type, implemented as a child of Line charts.

CAYdenberg:

> This is a scatter plot as a opposed to a line graph. X and Y data is
> supplied seperately as two different arrays: xVal : [] and data : []. These arrays
> should therefore be the same length. Labels (values on the x-axis) can now be supplied
> seperately from the actual data. Alternatively, the axis can be specified by the xScale
> information in the options.

### support for error bars in bar and line charts

Bar charts support error bars.

Line charts support error bars.

CAYdenberg:

> This is still a "line graph" in the
> traditional sense: X points are not supplied directly, but instead the x-axis
> represents a series of categories that are evenly spaced.

### a Chart Calculator

CAYdenberg:

> I have also added a Chart calculator, in
> which an array is passed in place of a single datapoint. The position of
> the data point is calculated from the average (or median) of the data in
> the array and the error bars are calculated as range or Standard
> Deviaiton.

### fill color functions

Added by spilliams

A dataset's `fillColor` option can now contain a function instead of just a static value. This is intended to allow individual bars (in the same dataset) of a bar chart to have different colors. It also enables bars to have different colors based on animation percentage.

Applies to bar charts and box-and-whisker plots, but no other chart type (yet).

### fill color arrays

Added by spilliams

If a dataset's `fillColor` option is an array, the context cycles through the array in an orderly fashion, recursing over each element (so `fillColor` could be an array of arrays, or a mixed array of strings and functions).

Applies to bar charts and box-and-whisker plots, but no other chart type (yet).

### value labels

Added by spilliams

There is now a feature to add value labels to a bar chart or box-and-whisker plot.


text:
---
title: "Sample size for a study of reproducibility"
author: "Steve Simon"
source: "http://blog.pmean.com/sample-size-reproducibility/"
date: "2014-06-16"
category:
- Blog post
tags:
- Measuring agreement
- Sample size justification
output: html_document
---

Dear Professor Mean: I am using a risk stratification tool for patients
presenting to the ED with chest pain. This has been a well validated
tool in the ED, but I want to show that the scores are reproducible
irrespective of the grade of doctor or assessment nurse calculating the
score. I'm going to collect a convenience sample of patients presenting
to the ED, and after I get informed consent, I will have those patients
assessed separately by a triage-trained nurse, an intern doctor, a
registrar and a consultant. I will calculation agreement using the
intraclass correlation coefficient (ICC). My question is: How do I
calculate the sample size in this context?

<!---More--->

There is no formal hypothesis in this setting, so you can't really do a
power calculation. Well, maybe you could but it would be a rather forced
and artificial setting.

What you want here is a confidence interval for the intraclass
correlation coefficient (ICC). And you want that confidence interval to
be reasonably narrow. An ICC with a confidence interval that goes from
0.06 to 0.91 is pretty worthless.

So dig out the formula for the confidence interval for ICC and find a
sample size that makes your interval reasonably narrow. Make sure that
you plug in a plausible value for? ICC and not zero.

The formula for this confidence interval is very messy, so you will
almost certainly be better off using a simulation approach. Set up a
dozen or so plausible scenarios for your research that include both weak
and strong measures of association and also include a range of marginal
distributions. Run these simulations and show that at your proposed
sample size, all the 95% confidence intervals under all the scenarios
are reasonably narrow. Then pick one of the scenarios to present to the
IRB or anyone else reviewing your research.

Now the actual research will probably compute some statistics that are
far more sophisticated than a simple confidence interval for single ICC.
You might want to compare one ICC to another ICC. Or you might want to
estimate the source of disagreement if the ICC is too small (e.g., the
nurses rate more harshly than the doctors). But don't worry too much
about this. If you get a nice narrow interval for a simple ICC, then
everything else will probably also have reasonably good precision and/or
power.

You can find an [earlier version][sim1] of this page on my [blog][sim2].

[sim1]: http://blog.pmean.com/sample-size-reproducibility/
[sim2]: http://blog.pmean.com

repository: pmean/build-website

repo_name: pmean/build-website


text:
# Native Gesture Navigation
Navigation puts you in control of the animation. Add a PanResponder and move the scene around in response to gestures.

## Run
Follow React Native's Getting Started guide to set up your development environment. Once you've cloned the repository, you can install the dependencies with `npm install` or `yarn`.

Then run `react-native run-ios` or `react-native run-android` to start the example on your chosen device. All the code is shared between iOS and Android. Swipe scenes to the right to navigate back.

repository: jmagrippis/navigation

repo_name: jmagrippis/navigation


text:
---
title: 'Observability: 3 things about it.'
date: "2020-01-14T19:25:00.000Z"
description: "Observability is not a new concept. Indeed, it comes from the world of engineering and control theory.
As per definition, **observability** is a measure of how well ..."
---

!['observability_logo'](./observability_logo.jpg)

Observability is not a new concept. Indeed, it comes from the world of engineering and control theory.
As per definition, **observability** is a measure of how well internal states of a system can be inferred from knowledge of its external outputs.

So this means that your old monolith application must now expose its internal status, metrics, have tracking details about exceptions or crashes, and a lot more, to define it as "**observable**."

As you can see, observability comes with a lot of different aspects, and it may be unclear at first glance. In this article, I will try to explain it simply and efficiently. We will consider what's the difference from monitoring, the **Three Pillars of Observability**, and finally, the existing standard tools.

## 1 - Observability vs. Monitoring: what's the difference?

!['monitoring_vs_observability'](./monitoring_vs_observability.png)

We have now convinced our organization to move towards **observability**.
But from different departments, a question arises: what's the difference between observability and monitoring?

Well, to answer that question, let's remind us of what monitoring is.
As the word suggests, "monitoring" is an action.
It's the action that one system performs against another to check if it works just fine. Our monitoring system should just answer two simple questions: "What?" and "Why?".
These two simple questions can be answered, combining blackbox and whitebox monitoring.

As I have quoted above, **observability** "is a measure of how well internal states of a system can be inferred from knowledge of its external outputs." and so can be viewed as a superset of monitoring with more specifications and details about our system.

Furthermore, when we think about monitoring, we think about something that is failure-driven, it's built to prevent incidents, and it helps engineers to solve them as quickly as possible.
But when it comes to observability, it is not failure-driven. Instead, engineers might use it to debug systems, perform test analysis, run production inspections, and so on.

Then, **why do we need both?**

Think about this: A developer from your company changes some critical code path to introduce a new cool feature. Unfortunately, this causes a malfunction in the final product function. Your well-engineered monitoring system can return what is broken and why (**which is essential**). However, it will not give you details such as single-process tracing, load testing results, system profiling, or exceptions, and that's not because it's not good enough but only because it's not what is supposed to do. Indeed,  the monitoring system is only returning our developer just a memory usage alert and the related non-working service. Wouldn't it be great to have a detailed tracing with the related memory usage to understand where the memory leak is? Or, some testing results to compare other environments with production?
Here is where observability comes to help, and that's why it can be considered as a superset of monitoring.

We also need to acknowledge that when it comes to standard IT infrastructures, there is a lot of monitoring systems that come with out of the box features to provide a bit of observability on the OS, hardware, or even services level.
And sometimes, as we will consider later, the business doesn't even need to go further than that.

On the other hand, when we're talking about: custom software, sophisticated web platforms, or distributed systems, having an observable implementation might provide some essential information for the product and so the business.

Nowadays, we see products becoming more and more complex with new features and new reliability standards.
From an engineering point of view, IT infrastructures are evolving into new patterns such as microservices, polyglot persistence, containers to decoupling the big old monolith into small systems, which is optimal for products but a little bit complicated for engineers.
The amount of available tools is also increasing drastically; there are so many platforms and different ways for empowering humans to do cool new stuff.
To successfully deliver and run your product under these conditions, you need **observability**.

## 2 - The Three Pillars of Observability

!['three_pillars_observability'](./three_pillars_observability.jpg)

### Metrics

From Cindy's Book (Distributed Systems Observability):
"Metrics are a numeric representation of data measured over intervals of time. Metrics can harness the power of mathematical modeling and prediction to derive knowledge of the behavior of a system over intervals of time in the present and future.
Since numbers are optimized for storage, processing, compression, and retrieval, metrics enable longer retention of data as well as easier querying. This makes metrics perfectly suited to building dashboards that reflect historical trends. Metrics also allow for a gradual reduction of data resolution. After a certain period of time, data can be aggregated into daily or weekly frequency."

Metrics help us to define and measure SLO's on our services, measure everything that happens in our distributed system.
As per the definition, an observable system must also be a measurable system.

### Distributed Tracing

Distributed tracing it's becoming more and more critical as we move towards micro-* architectures, where all those little systems work together to satisfy scaling and reliability requirements.

Distributed tracing helps engineers to identify bottlenecks across vast infrastructures.

It can also be a critical component when it comes to performance analysis and improvements in your product.

### Logging

Your infrastructure is always producing logs. It doesn't matter if they are warning, info, error, or critical logs. They're always happening.
With a growing complex distributed system is essential that you keep an eye on your logs. Doing so might be very tiring if you don't have the right infrastructure to ingest, elaborate, and show logs to you.

For that reason, there are multiple tools that help you to gather logs and have smart management of them.
By tracing requests, you can easily see where bottlenecks are, but with logging, you can debug them and provide insights on how to resolve bugs, improve the product performance, and so on.

## 3 - My recommended observability tools.

Let's get to the practice. Here's a list of my favorite observability tools and a short description of them.

### Tracing:

#### Jaeger

Jaeger, inspired by Dapper and OpenZipkin, is a distributed tracing system released as opensource by Uber Technologies. It is used for monitoring and troubleshooting microservices-based distributed systems, including:

- Distributed context propagation

- Distributed transaction monitoring

- Root cause analysis

- Service dependency analysis

- Performance/latency optimization

Source: www.jaegertracing.io

#### Linux eBPF

eBPF is useful for debugging the kernel and carrying out performance analysis; programs can be attached to tracepoints, kprobes, and perf events. Because eBPF programs can access kernel data structures, developers can write and test new debugging code without having to recompile the kernel. The implications are obvious for busy engineers debugging issues on live, running systems. It's even possible to use eBPF to debug user-space programs by using Userland Statically Defined Tracepoints.
The power of eBPF flows from two advantages: it's fast, and it's safe. To fully appreciate it, you need to understand how it works.

Source: lwn.net/Articles/740157

### Metrics:

#### Prometheus

Prometheus is an open-source systems monitoring and alerting toolkit originally built at SoundCloud.
Prometheus's main features are:
a multi-dimensional data model with time series data identified by metric name and key/value pairs
PromQL, a flexible query language to leverage this dimensionality
no reliance on distributed storage; single server nodes are autonomous
time-series collection happens via a pull model over HTTP
pushing time series is supported via an intermediary gateway
targets are discovered via service discovery or static configuration
multiple modes of graphing and dashboarding support

Source:  prometheus.io

### Logging:

#### Elastic Stack

Elasticsearch, Logstash, and Kibana (formerly known as the ELK Stack, now renamed to the Elastic Stack with the addition of Beats) deliver actionable insights in real-time for almost any type of structured and unstructured data source, at any scale. From centralizing infrastructure logs, traces, and metrics to deliver a great end-user experience to keeping a pulse on your fleet of smart devices using real-time telemetry - the possibilities are endless with the Elastic Stack.
Thousands of organizations worldwide are using the Elastic Stack for various mission-critical use cases, and we'd like to show you how you can get started with it for yours.
Whether you call it the ELK Stack or the Elastic Stack, this introductory webinar will offer a live demo of the key features of Elasticsearch, Kibana, Beats, and Logstash.

Highlights include:
Ingesting data into Elasticsearch, including a look at how modules simplify that experience
Exploring and searching your data via Kibana, including building custom visualizations
Keeping track of changes via machine learning-based anomaly detection and alerting
Demonstrating the value of bringing logs and metrics into a single platform

Source: www.elastic.co/webinars/introduction-elk-stack

#### Bonus:

**Stackdriver** is Google Cloud’s embedded observability suite designed to monitor, troubleshoot, and improve cloud infrastructure, software, and application performance.
Stackdriver enables you to:

- Efficiently build and run workloads, keeping applications performant and available.

- Collect signals across Google Cloud internal and external apps, platforms, and services.

- Analyze and monitor your operational telemetry.

- Set up appropriate performance and availability indicators.

- Use built-in observability to troubleshoot and improve your applications.

- Automate ops using both out-of-the-box tools and tools customized through programmatic interfaces.

**Key Features:**
*Real-time log management and analysis.*
Stackdriver Logging is a fully managed service that performs at scale and can ingest application and system log data, as well as custom log data from thousands of VMs. Stackdriver Logging allows you to analyze and export selected logs to long-term storage in real-time.

*Built-in observability at scale.*
Stackdriver Monitoring provides visibility into the performance, uptime, and overall health of cloud-powered applications. Stackdriver collects metrics, events, and metadata from Google Cloud Services, hosted uptime probes, application instrumentation, and a variety of common application components.

*Application performance management tools.*
Stackdriver Application Performance Management (APM) includes tools to help you reduce latency and cost, so you can run more efficient applications. With Trace, Debugger, and Profiler, you gain insight into how your code and services are functioning and troubleshoot if needed.

Source: cloud.google.com/stackdriver/

#### Recommended resources:

[**(BOOK) Distributed Systems Observability**](https://www.oreilly.com/library/view/distributed-systems-observability/9781492033431/)

[**(VIDEO) An episode of SRE implements DevOps Video**](https://www.youtube.com/watch?v=SoZZzB-yTOk)

[**(VIDEO) What's Next for Observability**](https://www.youtube.com/watch?v=MkSdvPdS1oA&feature=emb_logo)

## Conclusion

Observability is an amazing topic, and I'm sure we will see more and more about it during this year.
I hope this article made clear the argument and introduced it properly.
If you have any questions, feel free to contact me on [Twitter](https://twitter.com/isham_araia).

Stay tuned :)


text:
# First-time user init script for WSL2 distros

Based on how DistroLauncher-based distros does their thing, you can now painlessly add a first time user without using DistroLauncher for that purpose.

## How does it work?

DistroLauncher-based distros always execute on the following sequence:

- Ask you for your first time username and password
- If already initiated, just run using that user.

However, we don't have that liberty if we use standard `wsl --import`, so here's a little sample!

## Using

First of all, put the shell script in the appropriate place, somewhere in `/usr/bin/` or similar, then simply add it on `$HOME/.bashrc` on the `root` user.

You will have to figure out how to prevent re-executing the script yourself. A good way to do this is to comment out the line where this script is getting initialized after the successful invocation of this script first time.

A sample version of this would be [`firstrun.sh`](https://github.com/sr229/wslinit/blob/master/firstrun.sh) located in this repository.

## Copyright

Copyright 2020 © Ayane Satomi. Licensed under MIT.


text:
# About

## License
Doublit is licensed under the [MIT license](https://opensource.org/licenses/MIT).

## Contributing
If you find any mistakes in the software or in the documentation, you can contribute to improving doublit on github : [https://github.com/gealex/doublit/issues](https://github.com/gealex/doublit/issues)

## Author
Alexandre Geiswiller - [alexandre.geiswiller@gmail.com](mailto:alexandre.geiswiller@gmail.com).

## Acknowledgements
This library was inspired by [Mockery](http://docs.mockery.io) and [PhpUnit Doubles](https://phpunit.readthedocs.io/en/7.1/test-doubles.html).

repository: gealex/doublit

repo_name: gealex/doublit


text:
# zx_system_num_cpus

## NAME

system_num_cpus - get number of logical processors on the system

## SYNOPSIS

```
#include <zircon/syscalls.h>

uint32_t zx_system_get_num_cpus(void);
```

## DESCRIPTION

**system_get_num_cpus**() returns the number of CPUs (logical processors)
that exist on the system currently running.  This number cannot change
during a run of the system, only at boot time.

## RETURN VALUE

**system_get_num_cpus**() returns the number of CPUs.

## ERRORS

**system_get_num_cpus**() cannot fail.

## NOTES

## SEE ALSO
[system_get_physmem](system_get_physmem.md).


text:
Compressive Sensing
===================

### Goal

Reconstruct a signal from a sparse representation. It's like compression but before
you would do the actual regular compression.

Example: Take a picture with fewer pixels.

### Main Theorem

Fix a signal length *n* and a sparsity level *k*. Let A be an m x n matrix with
m = Theta(k log(n/k)) rows, with each of its m*n entries chosen independently from
the standard Gaussian distribution. With high probability over the choice of A, every k-sparse signal z
can be efficiently recovered from b = Az.

k-sparse meaning it has at most k non-zero entries.

repository: domluna/notes

repo_name: domluna/notes


text:
Calling the Microsoft Graph API for OneDrive for Business
==============================================

## Overview

OneDrive for Business is a feature of Office 365. It exposes a RESTful HTTP API which we can consume using the Microsoft Graph SDK for Android.

## Objectives

-   Learn how to communicate with OneDrive for Business using the **Microsoft Graph SDK for Android**

## Prerequisites

-   [Git version control tool][git-scm]
-   [Android Studio][android-studio]
-   Android API Level 23 installed [using the Android SDK Manager][sdk-manager]
-   Complete the [\\\O3654\O3654-4 Android\01 AAD Prereqs](../01 AAD Prereqs) module.
-   Complete the [\\\O3654\O3654-4 Android\02 ADAL](../02 ADAL) module.

[git-scm]: http://git-scm.com
[android-studio]: http://developer.android.com/sdk/installing/studio.html
[sdk-manager]: http://developer.android.com/tools/help/sdk-manager.html

## Exercises

The hands-on lab includes the following exercises:

-   [**Exercise 1**](#exercise1) Prepare the Android test application and add the Microsoft Graph SDK for Android
-   [**Exercise 2**](#exercise2) Enumerating Files and Folders
-   [**Exercise 3**](#exercise3) Creating Files and Folders

## Exercise 1: Prepare the Android test application

In this exercise we will add the Microsoft Graph SDK for Android to the included "O365 Test App".

### Task 1 - Preparing the test app

In this task we'll get the test application up and running.

01. Make a copy of the Android lab test app template, found in the
    [O365TemplateApp\src](O365TemplateApp/src) directory.

    Name this copy "OneDriveApp". E.g. in PowerShell

    ```powershell
    PS C:\> $lab_dir = ".\path\to\the\lab"
    PS C:\> $work_dir = ".\path\to\your\projects\dir"
    PS C:\> cp -Recurse "$lab_dir\O365TemplateApp\src\" "$work_dir\OneDriveApp"
    ```

02. Launch Android Studio

03. From the **File** menu, select **Import Project**.

    > **Note:** If this is your first time launching Android Studio, you may
    select **Import Project** from the Android Studio launcher.

04. Find and select the **OneDriveApp** folder.

05. Click **OK** to import the project.

    ![Screenshot of the previous step](img/0010_import_onedrive_app.png)

    Wait for Android Studio to finish importing the test project

06. Open the `app/src/main/res/values/strings.xml` resource file.

	![](img/0011_open_strings_xml.png)

07. Find the string resource named **app_name**, and change it to **O365 OneDrive Test App**.

    ![Screenshot of the previous step](img/0015_edit_app_name.png)

    This resource is used in a number of places, including as the App's name in the Launcher.

08. Open the `app/src/main/java/Constants.java` class.

    ![Screenshot of the previous step](img/0020_open_constants_class.png)

09. This class hosts a number of static constants which we must update.

    -   **RESOURCE:** Set this to "https://graph.microsoft.com/"

    -   **CLIENT_ID:** Set to the Client ID obtained in the Prerequisites module

    -   **REDIRECT_URI:** Set to the Redirect URI configured in AD in the Prerequisites module

10. Finally, let's test out the app and your changes.
    Start up the application in the Emulator with **Run > Debug App**.

    ![Screenshot of the previous step](img/0025_app_launch_screen.png)

11. Tap the **Sign in** button. Sign in using credentials for a user in your Office 365 Tenant. If successful, the blank `MainActivity` will be launched.

In this task you have created and configured the Office 365 Test App - this will serve as the base on which you will build out the rest of the lab.

### Task 2 - Add the Microsoft Graph SDK to the app

In this task you will add the **Microsoft Graph SDK** to the app and then configure it.

01. Open the `app/build.gradle` file.

    ![Screenshot of the previous step](img/0030_app_build_gradle.png)

02. Find the `dependencies` section. Currently it has a reference to the ADAL.

03. Add the following block of code to the `dependencies` section:

    ```groovy
    // Base OData stuff
    compile 'com.microsoft.services:odata-engine-core:0.11.0'
    compile 'com.microsoft.services:odata-engine-android-impl:0.11.0@aar'

    // MSGraph SDK
    compile 'com.microsoft.graph:msgraph-sdk-android:0.9.2'

    // MSGraph SDK Android MSA Auth for Android Adapter
    compile 'com.microsoft.graph:msa-auth-for-android-adapter:0.9.0'
    ```

    E.g.

    ![Screenshot of the previous step](img/0034_update_app_gradle_file.png)

04. Click **Sync Now**.

    ![Screenshot of the previous step](img/0035_start_gradle_sync.png)

05. Open the `MainActivity` class. It can be found under `app/src/main/java`.

06. Make sure you import the following classes.

	```java
	import android.app.Activity;
	import android.app.AlertDialog;
	import android.app.ProgressDialog;
	import android.content.DialogInterface;
	import android.graphics.Bitmap;
	import android.graphics.BitmapFactory;
	import android.os.Bundle;
	import android.view.View;
	import android.widget.EditText;
	import android.widget.ImageView;
	import android.widget.TextView;

	import java.io.BufferedReader;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.UnsupportedEncodingException;
	import java.util.List;

	import com.microsoft.graph.concurrency.ICallback;
	import com.microsoft.graph.extensions.DriveItem;
	import com.microsoft.graph.extensions.File;
	import com.microsoft.graph.extensions.Folder;
	import com.microsoft.graph.extensions.GraphServiceClient;;
	import com.microsoft.graph.extensions.IDriveItemCollectionPage;
	import com.microsoft.graph.extensions.IDriveItemCollectionRequest;
	import com.microsoft.graph.extensions.IGraphServiceClient;
	import com.microsoft.graph.core.ClientException;
	import com.microsoft.graph.core.IClientConfig;
	import com.microsoft.graph.core.DefaultClientConfig;
	import com.microsoft.graph.authentication.MSAAuthAndroidAdapter;
	import com.microsoft.graph.authentication.IAuthenticationAdapter;
	import com.microsoft.graph.http.IHttpRequest;
	import com.microsoft.graph.options.HeaderOption;
	```

07. Add the following member fields to the top of the class:

    ```java
    private IGraphServiceClient graphServiceClient;
    ```

08. Add the following code to the end of the `onCreate` function.

    ```java
    final IAuthenticationAdapter authenticationAdapter = new MSAAuthAndroidAdapter(getApplication()) {
        @Override
        public String getClientId() {
            return Constants.CLIENT_ID;
        }

        @Override
        public String[] getScopes() {
            return new String[] {
                    "https://graph.microsoft.com/File.ReadWrite",
                    "offline_access",
                    "openid"
            };
        }
        @Override
        public void authenticateRequest(final IHttpRequest request) {
            for (final HeaderOption option : request.getHeaders()) {
                if (option.getName().equals(AUTHORIZATION_HEADER_NAME)) {
                    return;
                }
            }
            if (mAccessToken != null && mAccessToken.length() > 0){
                request.addHeader(AUTHORIZATION_HEADER_NAME, OAUTH_BEARER_PREFIX + mAccessToken);
                return;
            }
            super.authenticateRequest(request);
        }
    };
    final IClientConfig mClientConfig = DefaultClientConfig.createWithAuthenticationProvider(authenticationAdapter);
    graphServiceClient  = new GraphServiceClient
            .Builder()
            .fromConfig(mClientConfig)
            .buildClient();
    ```

    >**Note:** The variable `mAccessToken` is obtained by `LaunchActivity` using the Active Directory Authentication Library.

## Exercise 2: Enumerating Files and Folders

In this exercise we will take a look at enumerating Files and Folders.

### Task 1 - Basic enumeration

01. Open the MainActivity layout file found at `app/src/main/res/layout/activity_main.xml`.

    This layout file contains an empty `LinearLayout` view, configured to stack its child views vertically.

02. Add the following element to `LinearLayout` element of `activity_main.xml`:

    ```xml
    <Button
        android:id="@+id/retrieve_files_button"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Retrieve Files" />
    ```

03. Return to the `MainActivity` class, and add the following code to the `onCreate` function:

    ```java
    findViewById(R.id.retrieve_files_button).setOnClickListener(
        new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                startRetrieveFiles(null);
            }
        }
    );
    ```

04. Add the following functions to the `MainActivity` class.

    ```java
    private class ErrorHandler implements Runnable {
        private ProgressDialog progress;
        private Throwable throwable;
        ErrorHandler(ProgressDialog progress, Throwable throwable) {
            this.progress = progress;
            this.throwable = throwable;
        }
        public void run() {
            progress.dismiss();
            showErrorDialog(throwable);
        }
    }

    private void showErrorDialog(Throwable t) {
        new AlertDialog.Builder(this)
                .setTitle("Whoops!")
                .setMessage(t.toString())
                .setPositiveButton("OK", null)
                .show();
    }

    private void startRetrieveFiles(final DriveItem folder) {

        //Show a "work-in-progress" dialog
        final ProgressDialog progress = ProgressDialog.show(
                this, "Working", "Retrieving Files"
        );

        IDriveItemCollectionRequest itemsRequest = null;
        if (folder == null) {
            //Get the files in the root folder
            itemsRequest = graphServiceClient.
                    getMe().
                    getDrive().
                    getRoot().
                    getChildren().
                    buildRequest();
        }
        else {
            //Get the files in this folder
            itemsRequest = graphServiceClient.
                    getMe().
                    getDrive().
                    getItems(folder.id).
                    getChildren().
                    buildRequest();
        }

        itemsRequest.get(new ICallback<IDriveItemCollectionPage>() {
            @Override
            public void success(IDriveItemCollectionPage driveItemsPage) {
                final List<DriveItem> driveItems = driveItemsPage.getCurrentPage();
                //Transform the results into a collection of strings
                final String[] items = new String[driveItems.size()];
                for (int i = 0; i < driveItems.size(); i++) {
                    DriveItem item = driveItems.get(i);
                    items[i] = "(" + (item.folder != null ? "Folder" : "File") + ") " + item.name;
                }
                //Launch a dialog to show the results to the user
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        progress.dismiss();
                        new AlertDialog.Builder(MainActivity.this)
                                .setTitle("Files")
                                .setItems(items, new DialogInterface.OnClickListener() {
                                    @Override
                                    public void onClick(DialogInterface dialogInterface, int i) {
                                        //The user picked a file - figure out if it is a file or folder
                                        DriveItem item = driveItems.get(i);
                                        if (item.folder == null) {
                                            //download the file contents
                                            //TODO: startDownloadFile(item);
                                        } else {
                                            //download the child files
                                            startRetrieveFiles(item);
                                        }
                                    }
                                })
                                .setPositiveButton("OK", null)
                                .show();
                    }
                });
            }

            @Override
            public void failure(ClientException ex) {
                runOnUiThread(new ErrorHandler(progress, ex));
            }
        });
    }
    ```

05. Launch the app in the debugger with **Run > Debug App**. Sign in with a user from your Office 365 Tenant, and click **Retrieve Files**.

    ![Screenshot of the previous step](img/0040_retrieve_files.png)

06. Here's a list of the Files and Folders in the user's root OneDrive folder.

    Try clicking on a "(Folder)" in the list - the code will then enumerate the contents of that Folder.

In this task we will call the Microsoft Graph APIs to enumerate the User's Files and Folders. There is a lot of boilerplate code here, so let's take a look at the interesting parts:

First we have to note that the function `startRetrieveFiles()` has two functions:

- Enumerate the files in the root folder (pass the argument `null`)
- Enumerate the files in the given folder (pass an instance of `DriveItem`)

```java
//Get the files in the root folder
itemsRequest = graphServiceClient.
        getMe().
        getDrive().
        getRoot().
        getChildren().
        buildRequest();
```

Here we are using `getChildren()` to enumerate the files and folders in the **root** folder.

```java
//Get the files in this folder
itemsRequest = graphServiceClient.
	    getMe().
	    getDrive().
	    getItems(folder.id).
	    getChildren().
	    buildRequest();
```

Here we are using `getItems()` to retrieve a single item from by its Id. In this case the item is a folder, so we use `getChildren()` to enumerate the items in that folder.

The `buildRequest()` function creates a query request, which is used to execute the query.

We starts the query asynchronously with a `<callback>`, which is a handle to the eventual result(**Success** or **Failure**) of the API call.

```java
itemsRequest.get(new ICallback<IDriveItemCollectionPage>() {
    @Override
    public void onSuccess(List<DriveItem> result) {
            //Handle success (e.g. 200, 201)
    }
    @Override
    public void onFailure(Throwable t) {
            //Handle failure (e.g. 404, 500)
        }
});
```

> **Note:** The callback will be executed on a background thread. If your code needs to update the User Interface (e.g. update a view or print a warning), then you must dispatch a **Runnable** back to the UI thread using Activity.runOnUiThread`:

```java
runOnUiThread(new Runnable() {
    @Override
    public void run() {
        //this code runs on the UI thread
    }
});
```

Alternatively, we could use the `get()` function on the **Future** object. This will block the thread until the underlying API call completes and the result is returned.

```java
try {
    graphServiceClient.
        getMe().
        getDrive().
        getRoot().
        getChildren().
        buildRequest().
		get();
}
catch (ClientException e) {
    //handle error
}
```

> **Warning: do not do this on the UI thread!** You could use an `AsyncTask` to run this code on a background thread.

Finally, take note of this block of code in the middle of the function which looks something like this:

```java
DriveItem item = driveItems.get(i);
if (item.getFolder() == null) {
    //process the item as a File
	//TODO: startDownloadFile(item);
}
else {
    //process the item as a Folder
	startRetrieveFiles(item);
}
```

Here we inspect the type of the `Item` and try to determine how to handle it. If the user selects a Folder, we enumerate its contents.

### Task 2 - Getting the contents of a file

In this task we'll go through the steps required to download a file.

01. Return to the `MainActivity` class and find the following line:

    ```java
    //TODO: startDownloadFile(item);
    ```

    Replace it with the following:

    ```java
    startDownloadFile(item);
    ```

02. Next, add the following functions to the `MainActivity` class:

    ```java
    private void startDownloadFile(final DriveItem file) {
        //Show a "work-in-progress" dialog
        final ProgressDialog progress = ProgressDialog.show(
                this, "Working", "Retrieving File Contents"
        );
        new Thread() {
            @Override
            public void run() {
                try {
                    //Get the contents of the file
                    InputStream stream = graphServiceClient.
                            getMe().
                            getDrive().
                            getItems(file.id).
                            getContent().
                            buildRequest().
                            get();
                    final View view = getFileView(stream);

                    //Launch a dialog to show the results to the user
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            progress.dismiss();
                            new AlertDialog.Builder(MainActivity.this)
                                    .setTitle("File Contents")
                                    .setView(view)
                                    .setPositiveButton("OK", null)
                                    .show();
                        }
                    });
                }
                catch (final Throwable t){
                    runOnUiThread(new ErrorHandler(progress, t));
                }
            }}.start();
    }

    private View getFileView(InputStream result) {
        Bitmap bitmap = BitmapFactory.decodeStream(result);

        if (bitmap != null) {
            ImageView imageView = new ImageView(this);
            imageView.setImageBitmap(bitmap);
            return imageView;
        }

        String utf8String = null;
        try {
            utf8String = getStringFromInputStream(result);
        }
        catch (Exception e) {
            e.printStackTrace();
        }

        TextView textView = new TextView(this);
        textView.setText(utf8String);

        return textView;
    }

    private static String getStringFromInputStream(InputStream is) {
        BufferedReader br = null;
        StringBuilder sb = new StringBuilder();

        String line;
        try {

            br = new BufferedReader(new InputStreamReader(is));
            while ((line = br.readLine()) != null) {
                sb.append(line);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return sb.toString();

    }
    ```

    These three functions download and attempt to render a user-selected file.

05. Launch the app in the debugger with **Run > Debug App**. Sign in with a user from your Office 365 Tenant, and click **Retrieve Files**.

06. Pick a file from the list.

    ![Screenshot of the previous step](img/0045_pick_an_image_file.png)

07. Here I picked an image file, and the app has successfully downloaded and rendered it:

    ![Screenshot of the previous step](img/0050_image_file.png)

The interesting piece of code is the following statement:

```java
//Get the contents of the file
InputStream stream = graphServiceClient.
        getMe().
        getDrive().
        getItems(file.id).
        getContent().
        buildRequest().
        get();
```

Here we are navigating the API in the same manner as before, using `getItems()` to get a reference to the file.

Next, we use `getContent()` to build a query request to retrieve the actual contents of the file. Executing the query request will retrieve an **InputStream**.

## Exercise 3: Creating Files and Folders

In this exercise we will take a look at creating Files and Folders and uploading
content.

### Task 1 - Creating a Folder

01. Open the the MainActivity layout file found at `app/src/main/res/layout/activity_main.xml`.

02. Add the the following element to `LinearLayout` element of `activity_main.xml`:

    ```xml
    <Button
        android:id="@+id/create_folder_button"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Create a Folder" />
    ```

03. Return to the `MainActivity` class, and add the following code to the `onCreate` function:

    ```java
    findViewById(R.id.create_folder_button).setOnClickListener(
        new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                showCreateFolderDialog();
            }
        }
    );
    ```

04. Add the following functions to the `MainActivity` class.

    ```java
    private void showCreateFolderDialog() {
        final EditText input = new EditText(this);

        //Prompt the user for a new folder name
        new AlertDialog.Builder(this)
                .setTitle("Create a Folder")
                .setMessage("Please enter a folder name")
                .setView(input)
                .setPositiveButton("OK", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        String newFolderName = input.getText().toString();
                        startCreateFolder(newFolderName);
                    }
                })
                .setNegativeButton("Cancel", null)
                .show();
    }

    private void startCreateFolder(String newFolderName) {
        //Show a "work-in-progress" dialog
        final ProgressDialog progress = ProgressDialog.show(
                this, "Working", "Creating Folder"
        );

        //Create a new folder entity
        DriveItem  item = new DriveItem();
        Folder folder = new Folder();
        item.folder = folder;
        item.name = newFolderName;

        //Create the folder via the API
        graphServiceClient.
                getMe().
                getDrive().
                getRoot().
                getChildren().
                buildRequest().
                post(item, new ICallback<DriveItem>() {
                    @Override
                    public void success(final DriveItem driveItem) {
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                progress.dismiss();
                                new AlertDialog.Builder(MainActivity.this)
                                        .setTitle("Success")
                                        .setMessage("Created folder " + driveItem.name)
                                        .setPositiveButton("OK", null)
                                        .show();
                            }
                        });
                    }

                    @Override
                    public void failure(final ClientException ex) {
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                progress.dismiss();
                                showErrorDialog(ex);
                            }
                        });
                    }
                });
    }
    ```

05. Launch the app in the debugger with **Run > Debug App**. Sign in with a user from your Office 365 Tenant, and click **Create a Folder**.

06. Fill out the dialog and click **OK**.

    ![Screenshot of the previous step](img/0055_create_new_folder.png)

These functions prompt the user for a Folder name, and then create a folder through the Microsoft Graph.

```java
//Create a new folder entity
DriveItem  item = new DriveItem();
Folder folder = new Folder();
item.folder = folder;
item.name = newFolderName;

//Create the folder via the API
graphServiceClient.
        getMe().
        getDrive().
        getRoot().
        getChildren().
        buildRequest().
        post(item, <callback>);
```

The code creates a simple `Folder` model, and then adds it to the `root` folder. We post the request by the API asynchronously with a `<callback>` which will handle the **success** or **failure** of the call.

### Task 2 - Creating a File

01. Open the MainActivity layout file found at `app/src/main/res/layout/activity_main.xml`.

02. Add the following element to `LinearLayout` element of `activity_main.xml`:

    ```xml
    <Button
        android:id="@+id/create_file_button"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Create a File" />
    ```

03. Return to the `MainActivity` class, and add the following code to the `onCreate` function:

    ```java
    findViewById(R.id.create_file_button).setOnClickListener(
        new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                showCreateFileDialog();
            }
        }
    );
    ```

04. Add the following functions to the `MainActivity` class.

    ```java
    private void showCreateFileDialog() {

        final EditText input = new EditText(this);

        //Prompt the user for a new folder name
        new AlertDialog.Builder(this)
                .setTitle("Create a File")
                .setMessage("Please enter a file name")
                .setView(input)
                .setPositiveButton("OK", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        String newFileName = input.getText().toString();
                        startCreateFile(newFileName);
                    }
                })
                .setNegativeButton("Cancel", null)
                .show();
    }

    private void startCreateFile(String newFileName) {

        //Show a "work-in-progress" dialog
        final ProgressDialog progress = ProgressDialog.show(
                this, "Working", "Creating File"
        );

        DriveItem item = new DriveItem();
        File file = new File();
        item.file = file;
        item.name = newFileName;

        //Create the file via the API
        graphServiceClient.
                getMe().
                getDrive().
                getRoot().
                getChildren().
                buildRequest().
                post(item, new ICallback<DriveItem>() {
                    @Override
                    public void success(final DriveItem driveItem) {
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                progress.dismiss();
                                uploadFileContent(driveItem);
                            }
                        });
                    }

                    @Override
                    public void failure(final ClientException ex) {
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                progress.dismiss();
                                showErrorDialog(ex);
                            }
                        });
                    }
                });
    }

    private void uploadFileContent(final DriveItem file) {

        //Show a "work-in-progress" dialog
        final ProgressDialog progress = ProgressDialog.show(
                this, "Working", "Uploading Data"
        );

        //Upload some file content
        String content = "This is some file content!";

        byte[] bytes = new byte[0];
        try {
            bytes = content.getBytes("UTF-8");
        }
        catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        //Upload the file content
        graphServiceClient.
                getMe().
                getDrive().
                getItems(file.id).
                getContent().
                buildRequest().
                put(bytes, new ICallback<DriveItem>() {
                    @Override
                    public void success(DriveItem driveItem) {
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                runOnUiThread(new Runnable() {
                                    @Override
                                    public void run() {
                                        progress.dismiss();
                                        new AlertDialog.Builder(MainActivity.this)
                                                .setTitle("Success")
                                                .setMessage("Created file " + file.name)
                                                .setPositiveButton("OK", null)
                                                .show();
                                    }
                                });
                            }
                        });
                    }

                    @Override
                    public void failure(final ClientException ex) {
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                progress.dismiss();
                                showErrorDialog(ex);
                            }
                        });
                    }
                });
    }
    ```

05. Launch the app in the debugger with **Run > Debug App**. Sign in with a user from your Office 365 Tenant, and click **Create a File**.

06. Fill out the dialog and click **OK**.

    ![Screenshot of the previous step](img/0060_create_new_file.png)

These functions prompt the user for a File name, and then create a folder through the API for OneDrive. Finally, they upload some UTF-8 encoded data.

```java
//Create a new file entity
DriveItem item = new DriveItem();
File file = new File();
item.setFile(file);
item.setName(newFileName);

//Create the file via the API
graphServiceClient.
	    getMe().
	    getDrive().
	    getRoot().
	    getChildren().
	    buildRequest().
	    post(item, <callback>)
```

This code creates a simple `File` model, and then adds it to the `root` folder. We post the request by the API asynchronously with a `<callback>` which will handle the **success** or **failure** of the call.

```java
String content = "This is some file content!";

byte[] bytes = content.getBytes("UTF-8");

//Upload the file content
graphServiceClient.
        getMe().
        getDrive().
        getItems(file.id).
        getContent().
        buildRequest().
        put(bytes, <callback>)
```

This code uploads new content to an existing file on the server - in this case the file we just created.

## Conclusion

By completing this hands-on lab you have learned:

1. How to add the Microsoft Graph SDK to an Android project
2. How to query for files and folders
3. How to create a new folder
4. How to create a new file

As an exercise, try using Android Studio's built-in auto complete functionality to explore the `GraphServiceClient` API and implement other functionality like:

-   Deleting a folder
-   Creating a file in a subfolder

path: /O3654/O3654-4 Android/04 O365 OD SDK/hands-on-lab.md


text:
# universial_facial_entry
A facial recognition system that can serve as a general purpose entry way for identity verification

# Requirements
- `keras` with backend as your choice (tf in my case)
- A uvcvideo device or any video inputs supported by OpenCV
- `OpenCV` python (3.4.5), numpy, etc.
- Public face library (I used ORL)
- Ability to read and understand this easy code :）

# Results
- With an asian target face, system generates a confident model with in 5 epoch.

Tested with Linux Mint 18.3 and should work cross all platforms.

# Inspired by and partly ported from:
- Donny-Hikari/FaceLock
- Hironsan/BossSensor


text:
---
layout: post
title: "Just Saying"
description: "Late night thoughts...summed up in 690 words."
author: Debashish Reang
thumbnail: "/assets/images/just_saying.png"
comments: true
tags: [thoughts]
draft: true
---
Hey! I hope you're doing well and that you are keeping yourself and your loved ones safe. Please go out only when it's absolutely necessary and follow proper safety mesaures. You are awesome.

This whole quaratine have taken a toll on my thought process. While I try to keep myself engaged and listen to and read about positive events, I cannot help but notice all the other negativity going around. And then there are the life experiences. Over the course of the day, chances are that a few good and a few bad events will happen.

I wanted to talk about these things that have been bothering me a lot. I don't have definitive answers to any of these.  Feel free to get back to me via email or Twitter DMs if you have anything to say on these.

Just to be clear, I love this country and what its people stands for. I don't mean to criticise this great nation and its awesome people in any way. But, I also believe in the Constitution and the idea of democracy. Therefore, I must point out a few things that I think we're doing incorrectly.

There are many wrong thing going on in the country, with its rape, poverty, and everything else. But, the moment you can't get into IIT Bombay CSE, you're like, "That's it, motherfucker! I'll write about you on Facebook." I don't think any of you have any real commitment for progress or upliftment of these marginalized communities.  You're just saying, "Let's get rid of reservations because inequity isn't as bad as it used to be."

extension: markdown


text:
### Education
UNIVERSITY OF VIRGINIA, Charlottesville, VA
Master of Science, Statistics, May 2009

TEXAS A&M UNIVERSITY, College Station, TX
Bachelor of Science, Mechanical Engineering, August 1996

### Publications
Association of Low-Frequency and Rare Coding-Sequence Variants with Blood Lipids and Coronary Heart Disease in 56,000 Whites and Blacks, [The American Journal of Human Genetics (2014)](http://dx.doi.org/10.1016/j.ajhg.2014.01.009)

Strategies to design and analyze targeted sequencing data: The Cohorts for Heart and Aging Research in Genomic Epidemiology (CHARGE) targeted sequencing study. [Circulation: Cardiovascular Genetics (2014)  7(3):335–343](http://circgenetics.ahajournals.org/content/7/3/335.long)

Associations between lipoprotein(a) levels and cardiovascular outcomes in blacks and white subjects: the Atherosclerosis Risk in Communities (ARIC) Study. [Circulation. 2012;125:241–249](http://circ.ahajournals.org/content/early/2011/11/29/CIRCULATIONAHA.111.045120)

### NRG Energy, Houston, TX
#### (2016 - Present)
#### Marketing Analyst
Responsible for performing data mining, statistical modeling, business intelligence, and production support for retail energy segment marketing.  Analyzed enrollment, conversion rate, customer usage, customer credit, cost of acquisition, gross margin, marketing return, and net present value by channel and product.  Applied advanced statistical techniques to develop targeted models to predict enrollment, usage, length of tenure, default rate, and tracking performance of models.

* Modeled the customer referral program to determine the price point for the referral payout rate.  This led to an increase in customer count by over ten thousand in the first 6 months while maintaining margin and increasing tenure of referral customers.

* Analyzed the effect of allowing customers with past due bills to re-enroll into any program before paying their past due bill.  As a result of this analysis the business decision was made to close the loophole which allowed enrollment agents to re-enroll customers with past due bills before repayment was cleared.  Estimated annual savings is over one million dollars.

* Performed survival analysis on the Average Monthly Billing program which revealed an attrition benefit for customers enrolled in this program.  It was shown that the increased customer lifetime value continued to justify the increased overhead of maintaining the program.

* Automated recurring business metrics reports (weekly, monthly, and quarterly) from  SAS / Excel into R and Python, resulting in increased accuracy, better timeliness, and the ability to automate the running and scheduling allowing analysts to focus on current business issues and requests.

### UNIVERSITY OF TEXAS SCHOOL OF PUBLIC HEALTH, Houston, TX
#### (2010 - 2016)
#### Senior Statistician
Performed statistical analysis, modeling, and bioinformatics in next-generation DNA sequence data, epidemiology, and clinical trials as an adjunct to various faculty research groups.  Responsible for the design of statistically valid research studies, the application of advanced statistical methods for conducting analysis and preparing reports.

* Researched and presented potential solutions to our data storage and data structure needs with a focus on reducing the time of analysis and memory utilization.  This resulted in more than 90% reduction of in memory usage while simultaneously reducing the computation time by 75%.

* Performed statistical analysis and modeling of bioinformatics in next-generation DNA sequence data using a variety of statistical techniques (linear regression, multiple regression, logistic regression, survival models, mixed effects models, principal component analysis and permutation testing, etc).

* Created a customizable base seqMeta pipeline for a cloud computing application hosted on DNAnexus.

* Maintainer of the R package seqMeta on The Comprehensive R Archive Network (CRAN).

* Created an integrated R and Python program to translate data between both the Variant Call Format (VCF) and the genotype matrix / SNP information format.

* Developed a quality control and automated reporting system for next-generation sequence data.  This resulted in early detection of errors from the sequencing centers, and identification of outliers in the data.

* Collaborated with investigators in grant development including statistical design of studies, sample size requirements, power calculations, and statistical methodology.  This included writing the bioinformatics and statistical methods portion of grant proposals.

* Mentored statistical analysts and students in the application of statistical methodologies, interpretation of results and programming techniques.

* Served as statistical and computational representative on the cross-functional teams in the strategic planning, development and execution of new methodologies and algorithms.

### UNIVERSITY OF VIRGINIA, Charlottesville, VA
#### (2007 - 2009)
#### Instructor
* Introduction to Statistical Analysis (STAT 212) - Introduction to the probability and statistical theory underlying the estimation of parameters and testing of statistical hypotheses, including those arising in the context of simple and multiple regression models.

* Statistical Laboratory (Stat 398/598) - This undergraduate/graduate course is part of the applied statistics curriculum.  Topics include statistical software usage in data analysis and general programming methodologies. Primarily focused on R, S-Plus, and SAS.

#### Teaching Assistant
* Applied Linear Models (Stat 512) - Topics include linear regression models, inference in regression analysis, model validation, selection of independent variables, multicollinearity, influential observations, autocorrelation in time series data, polynomial regression, and nonlinear regression.

* Sample Surveys (Stat 518) - Discussion of the main design and estimation techniques used in sample surveys: simple random sampling, stratification, cluster sampling, double sampling, post-stratification, ratio estimation.

### CAPITAL ONE FINANCIAL, Richmond, VA
#### (Summer 2008)
#### Senior Statistician
* Modeled historical credit card transaction data for real time fraud detection system.
* Aggregated data from several Oracle databases into SAS for data cleaning, model fitting, model selection, and forecasting.

* Determined statistical methodology and performed analysis for detecting transaction fraud.

* Created automated reports of important historical factors which could be monitored by various business units.

* Wrote and modified SAS programs for the purpose of reporting, summarizing, analyzing, and validating financial data.

### MEDICAL AUTOMATION SYSTEMS, Charlottesville, VA
#### (2006 - 2008)
#### Test Systems Software Engineer / Quality Analyst
* Architected and implemented a new software quality tracking system to ensure compliance with FDA standards.

* Developed standardized procedures and best practices for software testers to follow when generating test cases, test plans and test reports.

* Developed SQL queries to automate verifying medical software with the medical device specification.

* Created training material for new quality assurance system.

* Developed an Excel report, which accessed a SQL database to generate pre/post testing reports.

* Customized Mercury Software quality tracking system to ensure compliance with business processes and applicable government regulations.

### UNIVERSITY OF VIRGINIA MEDICAL CENTER, Charlottesville, VA
#### (2005 - 2006)
#### Database Administrator
* Administered Microsoft SQL Servers

* Installed new servers and maintained existing servers.

* Project lead on database password security audit.

* Assisted in implementing a new patient monitoring and tracking system.

### HEWLETT PACKARD, Houston, TX
#### (1999 - 2005)
#### Systems Software Engineer
* Designed, developed and maintained over 40 test utilities and test tools for HP Proliant system ROM (BIOS) testing.

* Developed and executed test plans, reported and tracked problems and coordinated problem resolution.

* Project lead on HP Proliant ML 330 G3, ML350 G4, and ML580 G3.

#### Systems Engineer

* Developed data protection and disaster recovery solutions with all Compaq

* Researched and developed testing strategies and test plans for Enterprise Backup Solutions (EBS).

* Responsible for hiring, mentoring, assigning and reviewing work of interns.

* Trained “Must-Win” pre-sales engineering team and 3rd level support.

* Presented to over 1000 CIO’s and industry leaders at Compaq’s National Storage Days conference.

* Authored EBS with VERITAS Backup Exec Mixed Media Whitepaper, EBS with VERITAS Backup Exec User Guide, and EBS with VERITAS Backup Exec for Microsoft and Novell Clusters Tech Note

### ABB VETCO GRAY, Houston, TX
#### (1997 - 1999)
#### Mechanical Design Engineer
* Designed, tested, analyzed, and documented risers, riser handling tools, and guideline winch skid.

* Supplied shop and assembly drawings of various pressure-containing sub-sea equipment on Pro/E and AutoCAD systems

* Supplied analysis and design documentation for multiple large-scale projects.

* 	Wrote design and test reports and purchase specifications.

### STEWART & STEVENSON SERVICES, Houston, TX
#### (1996 - 1997)
#### Mechanical Product Engineer
* Designed risers, sub-sea blowout preventers, gate valves, actuators, and sub-sea Christmas trees.

* Supplied interface, bid, shop, and assembly drawings on a Pro/E system.

* Supplied technical analysis and design documentation for various certifying organizations.


text:
# nekobot

Connects to a Twitch chat and listens to command to switch scene from broadcaster and/or moderators.

### Prerequisites

- [NodeJS](https://nodejs.org/en/) - NodeJS v.10 and above
- [OBS-Websocket Plugin](https://obsproject.com/forum/resources/obs-websocket-remote-control-of-obs-studio-made-easy.466/)

### Installing

Run npm install to download dependencies.

```
npm i
```

Configure OBS.

```
Tools -> Websocket server settings
Check "Enable Websocket server"
Check "Enable authentication" [RECCOMENDED]
Enter a password
```

rename the .envtemplate to .env and configure .env file

```
TWITCH_CHANNEL="" // <-- Your twitch username

COMMAND_COOLDOWN=5 // <-- Command cooldown options in seconds

OBS_URL="localhost:4444" // <-- OBS Plugin url. "localhost:4444" is the default

OBS_PASSWORD="" // <-- OBS Plugin password
```

Configure line 11 on bot.js if you want to use the "!scene <scene name>" command to a different command name

```
const COMMAND_NAME = "!scene"; // Command to type in chat.
```

To run bot.js in command prompt / terminal

```
node bot.js
```

The bot will automatically exit when OBS is closed or if you disable the websocket plugin


text:
---
title: Ayan's Repository
type: "participant"
name: "Ayan Shukla"
portfolio: ""
github-link: "https://github.com/Ayan4"
linkedin-link: "https://www.linkedin.com/in/ayanshukla/"
looking-for: "job"
description: "Proficient with HTML & CSS | Learning JS and React | Aspiring developer"
---

Hi! I am Ayan, a Website Designer.

### introduction

Hi ! i am ayan, i started learning website designing as a hobby and as i progressed i found myself highly fond of making this look visually appealing, hence i decided to give web development a try and here i am, on an endless journey of learning new and exciting technologies everyday.

## why are you taking this challenge?

This challenge is the perfect opportunity for me as a developer to grow and hone my front-end development skills, and obviously the end goal is to get a job.

## something interesting about you?

Apart from an aspiring developer, i can also produce electronic dance music.

### help I need?

I would very much appreciate help around JavaScript and React

### how to contact me?

- [Twitter](https://twitter.com/AyanShukla4)
- [LinkedIn](https://www.linkedin.com/in/ayanshukla/)

### projects

not a lot of projects are done. I will keep updating it with real links as soon as i finish them.

### blogs

Haven't done any projects and blogs yet, I will keep updating my blogs as and when done.


text:
# Application form for starting/continuing a SIG

## What is/will be the name of the SIG?
<!--  Pick a name that reflects the goal of the SIG.
      Make it specific enough to be meaningful,
      but broad enough to give you room  to shift focus when necessary.  -->
Soft Skills SIG (SSS)
## Which two persons will act as SIG Leads?
<!--  Please make sure to have two SIG leads to reduce bus factor.
      SIG leads are allowed to write the hours dedicated to organizing
      SIG activities under the R&D budget. Please mention in the notes the
      name of your SIG:
        Account: 000104
        Project: 020203
        Hour type: 00071
        Notes: Hours for X SIG
       -->
- Pablo Lopez-Tarifa
- Willem van Hage
- Jens Wehner

## What is SIG’s mission?
<!--  help text goes here  -->
To increase the soft skills level at the Netherlands eScience Center.

## What is the GitHub repository of the SIG use?
<!--  Please transfer your SIG existing repo to this GitHub organization  -->
[https://github.com/nlesc-sigs/soft-skills](https://github.com/nlesc-sigs/soft-skills)

## What is the Office group that the SIG uses?
<!--  help text goes here  -->
[Soft-Skill SIG channel](https://teams.microsoft.com/l/team/19%3ab6082594f90a4f7d9b9b4521f5b7eb91%40thread.tacv2/conversations?groupId=c373a0f6-88c9-47d6-b318-cd998d7efa51&tenantId=aa3aeacc-6307-42b2-ac05-787dd5c32574)

## SIG outcomes in the period October 2020 - April 2021 (for existing SIGs)
<!--  As a simple list of activities in this period is enough.  -->
During this period we have profited from the Soft-Skill knowledge that we already have at the eScience Center. We have organised several topic sessions where knowledgeable presenters have shared with us their expertise:

* 08/10/2020 Session about self-doubt and malicious syndromes derived (e.g. impostor syndrome).
* 19/11/2020 Session devoted to “Coaching from the Line manager perspective”, by Nico & Yifat.
* 10/12/2020 [Session on Networking](https://nlesc.sharepoint.com/:w:/r/sites/soft-skills/_layouts/15/Doc.aspx?sourcedoc=%7B5B390B65-0109-42BC-95AA-AE6D1801F8AC%7D&file=Networking_session.docx&action=default&mobileredirect=true), by Carlos.
* 11/02/2021 [Session on Leadership I](https://nlesc.sharepoint.com/:w:/s/soft-skills/EUPYokIZNMBCqUElnLpgyDcBJEq8xp8QovU5XpmnqKQaMA?e=1f3pVS), by Joris.
* 04/03/2021 Session providing and receiving Feedback, by Sarah ([here](https://nlesc.sharepoint.com/:b:/s/soft-skills/EV0wi7cV2HJJk7aWI823EFcBZDiq9XeK5cdyvrPoTZzg0Q?e=lCepTe ) are the slides).
* 25/03/2021 [Session on Leadership II] (https://web.microsoftstream.com/video/96d526e2-bf1e-4169-87ca-ac502cf285ec), by Rob.

## Plans for the period until the end of April 2021
<!--  help text goes here  -->
For the next period, we will keep focused on topic sessions, this time also asking for external training. These are the planned sessions:

* 15/04/2021 Session on public speaking: "*How to be more comfortable in front of an audience*", by Jens.
* 06/05/2021 Session on cultural awareness by Nicole Kienhuis, an intercultural trainer. We have plans to
* 27/05/2021 Session on presentations skills and slide designing, by Pablo R.
* 17/06/2021 Session on providing and receiving Feedback (II) this time more focusing on RES-oriented tasks, like how to provide/receive feedback via Teams, pull request or article review.

## What are the expected outputs of the SIG?
<!--  Think of internal as well as external dissemination targets -->
Our main focus for the next period is to continue providing a comfortable place for people to share knowledge and experience on Soft Skills. We would like to identify organisation areas linked to soft-skills that might need improvement or training.

repository: nlesc-sigs/propose-a-sig

repo_name: nlesc-sigs/propose-a-sig


text:
# Code 301 Reading Notes

**what this web site is about?**
```
This Site Will Contain  all future Repo For 301 Class

```

## Table of Contents

| Read-01       | [Read Link ](https://aghyadalbalkhi-asac.github.io/reading-notes-301/Read-01)  |
|-------------------------|----------------------------------------------------------------------------------------------------|
| Read-02       | [Read Link ](https://aghyadalbalkhi-asac.github.io/reading-notes-301/Read-02)  |
| Read-03       | [Read Link ](https://aghyadalbalkhi-asac.github.io/reading-notes-301/Read-03)  |
| Read-04       | [Read Link ](https://aghyadalbalkhi-asac.github.io/reading-notes-301/Read-04)  |
| Read-05       | [Read Link ](https://aghyadalbalkhi-asac.github.io/reading-notes-301/Read-05)  |
| Read-06       | [Read Link ](https://aghyadalbalkhi-asac.github.io/reading-notes-301/Read-06)  |
| Read-07       | [Read Link ](https://aghyadalbalkhi-asac.github.io/reading-notes-301/Read-07)  |
| Read-08       | [Read Link ](https://aghyadalbalkhi-asac.github.io/reading-notes-301/Read-08)  |
| Read-09       | [Read Link ](https://aghyadalbalkhi-asac.github.io/reading-notes-301/Read-09)  |
| Read-10       | [Read Link ](https://aghyadalbalkhi-asac.github.io/reading-notes-301/Read-10)  |
| Read-11       | [Read Link ](https://aghyadalbalkhi-asac.github.io/reading-notes-301/Read-11)  |
| Read-12       | [Read Link ](https://aghyadalbalkhi-asac.github.io/reading-notes-301/Read-12)  |
| Read-13       | [Read Link ](https://aghyadalbalkhi-asac.github.io/reading-notes-301/Read-13)  |
| Read-14       | [Read Link ](https://aghyadalbalkhi-asac.github.io/reading-notes-301/Read-14)  |

## Contact Info :
**Please Feel Free To Contact Me When You Need help ^_^**
* [www.facebook.com/aghyadalbalkhi](www.facebook.com/aghyadalbalkhi)
* Email<EMAIL_ADDRESS>


text:
# City Rhythm

![Screenshot](/screenshot.png)

A game made for [Ludum Dare 41](https://ldjam.com/events/ludum-dare/41/$75136).
The theme was "Combine 2 Incompatible Genres" and the two genres I tried to combine is rhythm + city builder.

You can play the [web version](http://wheerd.de/ld41/) or download the [Windows version](https://github.com/wheerd/ludum-dare-41/releases/tag/v0.2).

The game was made using [Unity Version 2017.4.1f1](https://unity3d.com/).
The music was made with [BeepBox](https://www.beepbox.co/).
Texts were made using [Cool Text](https://cooltext.com/).