text:
# aws-kms-test
The [AWS Key Management Service (AWS KMS)](http://docs.aws.amazon.com/kms/latest/developerguide/overview.html) is a managed service
that makes it easy for you to create and control the encryption keys used to encrypt your data.

## Prerequisites
To use AWS KMS, you need:

- An AWS account,
- Create a Customer Master Key (CMK) in AWS KMS,
- The AWS SDK for Java (already setup in SBT)
- Download [Java Cryptography Extension (JCE) Unlimited Strength ](http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html)
  - go to $JAVA_HOME/jre/lib/security
  - overwrite `US_exports_policy.jar` and `local_policy.jar` from the zip
  - launch your application again

## AWS KMS API
The [AWS KMS API](http://docs.aws.amazon.com/kms/latest/developerguide/programming-top.html) allows to perform
the following actions:

- Create, describe, list, enable, and disable keys.
- Create, delete, list, and update aliases.
- Encrypt, decrypt, and re-encrypt content.
- Set, list, and retrieve key policies.
- Create, retire, revoke, and list grants.
- Retrieve key rotation status.
- Update key descriptions.
- Generate data keys with or without plaintext.
- Generate random data.

## AWS Encryption SDK
The [AWS Encryption SDK](http://docs.aws.amazon.com/encryption-sdk/latest/developer-guide/introduction.html) is an encryption library that helps make it easier for you to implement encryption best practices
in your application. It enables you to focus on the core functionality of your application, rather than on how to best encrypt
and decrypt your data.

There is an [AWS Encryption SDK for Java](http://docs.aws.amazon.com/encryption-sdk/latest/developer-guide/java.html) available
and is also available on [github](https://github.com/awslabs/aws-encryption-sdk-java).

The AWS Encryption SDK provides an encryption library that optionally integrates with AWS KMS as a master key provider,
`com.amazonaws.encryptionsdk.kms.KmsMasterKeyProvider`. The AWS Encryption SDK builds on the AWS SDKs to do the following things:

- Generate, encrypt, and decrypt data keys
- Use those data keys to encrypt and decrypt your raw data
- Store the encrypted data keys with the corresponding encrypted data in a single object

**Note:** You can also use the AWS Encryption SDK with no AWS integration by defining a custom master key provider.

The AWS Encryption SDK provides encryption and decryption for data that you can store anywhere. The AWS Encryption SDK
uses the Advanced Encryption Standard (AES) algorithm. The SDK supports 256-bit, 192-bit, and 128-bit encryption keys.

When AWS KMS is the master key provider, the SDK uses the AWS KMS GenerateDataKey API operation to generate each data key
in both plaintext and encrypted forms. It uses the Decrypt operation to decrypt the data key. AWS KMS encrypts and decrypts
the data key by using the customer master key (CMK) that you specified when configuring the master key provider. For every
encryption invocation, the AWS Encryption SDK generates a new Data Key for the given CMK. The result of the encryption is an encrypted
message that contains the encrypted data key and the encrypted payload. The AWS Encryption SDK parses the encrypted message,
automatically reads the encrypted data key, contacts KMS with the given CMK Arn to decrypt the data key, and decrypts the payload.
For more information read: [How the AWS Encryption SDK Works](http://docs.aws.amazon.com/encryption-sdk/latest/developer-guide/how-it-works.html).

When you encrypt data, the SDK encrypts the data key and stores the encrypted key along with the encrypted data in the
encrypted message that it returns. When you decrypt data, the AWS Encryption SDK extracts the encrypted data key from the
encrypted method, decrypts it, and then uses it to decrypt the data. You can just store the encrypted message and just manage
access to, and the lifecycle of the CMK ARN.

The overhead that AWS Encryption SDK has over the payload, is just 1kB.

It is possible to use multiple `KmsMasterKeyProvider` by combining them into one using the
`com.amazonaws.encryptionsdk.multi.MultipleProviderFactory` provider. Each single KmsMasterKeyProvider is initialized
with a different CMK, eg. each key from a different region in order to decrypt the message with any of the CMK. This way
a key to decrypt is always available and the message can always be decrypted.

The AWS Encryption SDK can encrypt raw bytes (byte arrays), I/O streams (byte streams), and Strings.

## How does the AWS Encryption SDK store encrypted data keys with their encrypted data?
The encryption operations in the AWS Encryption SDK return an encrypted message, a single data structure that contains
the encrypted data and its encrypted data keys. The message format consists of at least two parts: a header and a body.
In some cases, the message format consists of a third part known as a footer. The message header contains the encrypted
data keys and information about how the message body is formed. The message body contains the encrypted data. The message
footer contains a signature that authenticates the message header and message body. For more information,
see [AWS Encryption SDK Message Format Reference](http://docs.aws.amazon.com/encryption-sdk/latest/developer-guide/message-format.html)
and [How the AWS Encryption SDK Works](http://docs.aws.amazon.com/encryption-sdk/latest/developer-guide/how-it-works.html)

## Concepts

## Customer Master Keys (CMK)
The primary resources in AWS KMS are customer master keys (CMKs). CMKs are either customer managed or AWS managed.
You can use either type of CMK to protect up to 4 kilobytes (4096 bytes) of data directly. Typically you use CMKs to
protect data encryption keys (or data keys) which are then used to encrypt or decrypt larger amounts of data outside of
the service. CMKs never leave AWS KMS unencrypted, but data keys can. AWS KMS does **not** store, manage, or track your data keys.

## Data Keys
You use data keys to encrypt large data objects within your own application outside AWS KMS. When you make a
GenerateDataKey API request, AWS KMS returns a plaintext copy of the data key and a ciphertext that contains the data
key encrypted under the specified CMK. You use the **plaintext data key** in your application **to encrypt data**,
and you typically store the encrypted data key **alongside** your encrypted data.

To decrypt data in your application, you **pass the encrypted data key with a Decrypt API request**. AWS KMS uses
your CMK to decrypt the data key into plaintext, and then returns it to you. You use the plaintext data key to decrypt
your data and then remove the plaintext data key from memory as soon as practical after use.

repository: dnvriend/aws-kms-test

repo_name: dnvriend/aws-kms-test


text:
# Changelog
All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [0.1.0] - 2019-12-19
### Added
- ELE-247: Add quick start function. This function instantiates Core
  and registers the following plugins with provided configuration:
  - `cache`
  - `cache_driver`
  - `dom_events`
  - `sayt`
  - `sayt_driver`
  - `search`
  - `search_driver`
- ELE-249: Add `gb_tracker` plugin to the quick start function.

license: MIT

repository: groupby/elements-logic

branch_name: refs/heads/master

extension: md

gha_language: TypeScript

gha_license_id: MIT

license_type: permissive

repo_name: groupby/elements-logic


text:
Using ORM framework of your choice, create models classes created in Homework 6 (Teachers, Students, Homework and others).
- Target database should be sqlite (filename main.db localted in current directory)
- ORM framework should support migrations.

Utilizing that framework capabilities, create
 - a migration file, creating all necessary database structures.
 - a migration file (separate) creating at least one record in each created database table
 - (*) optional task: write standalone script (get_report.py) that retrieves and stores the following information into CSV file report.csv
     for all done (completed) homeworks:
         Student name (who completed homework)
         Creation date
         Teacher name who created homework

Utilize ORM capabilities as much as possible, avoiding executing raw SQL queries.

branch_name: refs/heads/main

extension: rst

gha_language: Jupyter Notebook


text:
# :metal: qulture-challenge

Repository made to show my knowledge of react native, based on the challenge proposed by Qulture.Rocks.

# :iphone: Mobile preview

![](mobile-preview.gif)

:rocket: [Best resolution](https://drive.google.com/file/d/1zcPremDnEI00YQQSPs43QtOu3j057O7v/view?usp=sharing)

# :fire: Used technologies

- React Native + Hooks
- Redux + Hooks
- Redux Thunk
- Styled Components
- Formik
- Reactotron
- React Navigation
- Jest + Enzime
- Prettier
- Eslint

# :wrench: Running mobile locally

- You must have the react-native enviroment seted up in your machine.
- Enter the directory.
- Run `yarn` or `npm install`.
- Than run `react-native run-android or run-ios`.

_OBS:_ For ios you need to enter the ios folder and run the `pod install` command.

# :exclamation: Possible improvements

- Delete a collaborator.
- API pagination.
- Collaborator filter.
- Timeline + Dashboard.
- Storybook documentation

# :man: Contributors

- @GleidsonDaniel

repository: GleidsonDaniel/qulture-challenge

gha_language: JavaScript

repo_name: GleidsonDaniel/qulture-challenge


text:
# Cyclic Rotation

An array A consisting of N integers is given. Rotation of the array means that each element is shifted right by one index, and the last element of the array is moved to the first place.

For example, the rotation of array
`A = [3, 8, 9, 7, 6] is [6, 3, 8, 9, 7] (elements are shifted right by one index and 6 is moved to the first place).`

repository: ric-v/codility-trials

repo_name: ric-v/codility-trials


text:
# CAGR Calculator

A CAGR (Compound Annual Growth Rate) calculator.

It's the result of my very first steps with the Elm language.

See it in action: [https://cakebaker.github.io/cagr-calculator/](https://cakebaker.github.io/cagr-calculator/)

repository: cakebaker/cagr-calculator

repo_name: cakebaker/cagr-calculator


text:
## Iteration 1-2

### Update
- after hours of discussion with my teammates, we think it will be much more effective
for both customer and us to make a web application which customer interacts on our app.

(customers will have some nice formatted app to deal with +
they can just push some button to send notification email +
we will encounter fewer corner cases which might come from Google Spreadsheet API dependency +
comprehend the whole project better by working on testing in the user’s perspective).

#### Functions we implemented / rspec tested
- Sending an email
- Making Google Spreadsheet API call to fetch data from existing sheet


text:
# tumblr-scraper

This project was created as a black box, from scratch reimplementation of [Liru/tumblr-downloader](https://github.com/Liru/tumblr-downloader), recreating and improving upon its features.

## Features

* Downloads all photos and videos of a blog, including those inlined into posts
* Automatically stops scraping a blog where it left off the last time
* Allows filtering out reblogs
* Uses Tumblr's v2 API, which is more robust and significantly faster
* Simulates Tumblr's private API to even scrape private blogs if needed
* All downloads are parallelized

## TODOs

* Documentation (up until now this strictly has been a private project)
* Crawling of >5000 posts per day will lead to rate limiting
* Continuing a previously failed crawl/scrape is not supported

  Setting the `before` field in the config allows you to scrape backwards starting at a date in the past.

  That way you can manually, iteratively scrape a huge blog in "sane" chunks (e.g. first everything before 2014, then 2015, 2016, ...).
* Support for `youtube-dl` would be nice

repository: lhecker/tumblr-scraper

repo_name: lhecker/tumblr-scraper


text:
# @startupjs/babel-plugin-startupjs-utils

Additional transformations for startupjs configs and other stuff

## Usage

For internal usage only.

## Features

1. Enables observer-level caching of styles and model if `observerCache` is passed in babel options

## Licence

MIT

repository: startupjs/startupjs

repo_name: startupjs/startupjs


text:
# Express
Express, is a web application framework for Node.js, released as free and open-source software under the MIT License. It is designed for building web applications and APIs. It has been called the de facto standard server framework for Node.js.

[Installation steps](https://expressjs.com/en/starter/installing.html) for Express

To know about more popular frameworks that are built on Express, refer [here](https://expressjs.com/en/resources/frameworks.html)

repository: navyadevineni/myapp

repo_name: navyadevineni/myapp


text:
---
layout: default
---

# 1994-06-16 - Re: I'm getting all the mail twice!

## Header Data

From<EMAIL_ADDRESS>(Timothy C. May)

To<EMAIL_ADDRESS>(Vinod Valloppillil)

Message Hash: 9f34885d46b8f5a51b14b68726599a59d375f3ec16cfe382602f84c24877b229

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1994-06-16 18:30:02 UTC

Raw Date: Thu, 16 Jun 94 11:30:02 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Timothy C. May)
Date: Thu, 16 Jun 94 11:30:02 PDT
To<EMAIL_ADDRESS>(Vinod Valloppillil)
Subject: Re: I'm getting all the mail twice!
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

>
> 	For some reason, I'm getting all cypherpunks mail twice.  I'm posting
> to the general group address in case there's anyone else who might be
> getting hit twice as well.
>
> Vinod

And I'm answering in public for the same reason. (I'm also seeing a
delay in getting mail, at NaughtCom, so I apologize if others have
already answered this.)

Eric Hughes described this scenario a few days ago: you may be
subscribed twice to the Cypherpunks list if you manually subbed and
then were also subbed when the old sub list was restored, and you used
two different addresses.

Vinod should see if the duplicate messages are being sent to two
different addresses, etc. The unsub via majordomo from the one he
doesn't want to see.

If this is not the case, then my explanation here is not the right
one.

--Tim May

--
..........................................................................
Timothy C. May         | Crypto Anarchy: encryption, digital money,
<EMAIL_ADDRESS>     | anonymous networks, digital pseudonyms, zero
408-688-5409           | knowledge, reputations, information markets,
W.A.S.T.E.: Aptos, CA  | black markets, collapse of governments.
Higher Power: 2^859433 | Public Key: PGP and MailSafe available.
"National borders are just speed bumps on the information superhighway."

{% endraw %}
```

## Thread

+ Return to [June 1994](/archive/1994/06)

+ Return to<EMAIL_ADDRESS>(Timothy C. May)](/authors/tcmay_at_netcom_com_timothy_c_may_)"
+ Return to "[Vinod Valloppillil <t-vinodv@microsoft.com>](/authors/vinod_valloppillil_tvinodv_at_microsoft_com_)"

+ 1994-06-16 (Thu, 16 Jun 94 10:33:07 PDT) - [I'm getting all the mail twice!](/archive/1994/06/29b1b1220e171610456707e326e5f837911bd61878c12617bdf6fdb69c2b55c5) - _Vinod Valloppillil<EMAIL_ADDRESS>  + 1994-06-16 (Thu, 16 Jun 94 11:30:02 PDT) - Re: I'm getting all the mail twice! -<EMAIL_ADDRESS>(Timothy C. May)_


text:
# BusInOut example

This example shows how to use the BusInOut interface to create an artificial bus of pins and read from and write to them.

**Note**: Pay special attention to the ordering of the pins in the initialization.


text:
---
title: Scientific computing in 10 years
layout: post
---
Greg Wilson, being the gloomy jaded pessimist he is,
[thinks leading-edge programmers will be doing scientific computing in JavaScript in 10 years](http://third-bit.com/2017/05/22/numerical-javascript.html).
I disagree—I don't know what these programmers will be using then,
but to the extent that they will be building on currently mainstream technologies
I think it will continue being R and Python, rather than JavaScript.
We [placed a bet on it](https://twitter.com/gvwilson/status/866750475374403585);
this post is here for reference.

Going for him,
Greg has the [most popular language today](https://insights.stackoverflow.com/survey/2017#technology-programming-languages),
which, from a humble and rushed start in our browsers,
continues to shift shape and burrow in the most [unlikely](http://johnny-five.io/) [places](https://docs.mongodb.com/manual/tutorial/write-scripts-for-the-mongo-shell/),
and to prove all of its naysayers wrong.
Against that,
I have technologies that have ingrained themselves in the scientific community,
which have [fast](http://www.numpy.org/),
[usable](http://jupyter.org/),
and [sophisticated](https://www.tensorflow.org/) modules that took many years to build and get right,
and which offer newcomers a different career path and paradigm,
spiraling out of data and formulas
(rather than out of the browser)
into the rest of the world.

Whoever wins the bet,
it should be a fun dinner in 2027,
and I'm looking forward to it.

repository: jorgearanda/cuevano

repo_name: jorgearanda/cuevano


text:
# IPv6

## Primary changes from IPv4
- Expanded addressing Capabilities
- Header format simplification
- Improved support for extensiosn and options
- Flow label Capability

Documentation: [RFC2460](https://www.ietf.org/rfc/rfc2460.txt)

In short, IPv6 basically consists of an IPv6 header, then numerous optional extension headers appended after it, each serves different purposes and information.

Here are some of the main headers discussed in [RFC2460](https://www.ietf.org/rfc/rfc2460.txt) and what I found interesting in their protocol:

## IPv6 Extension Headers
The contents and semantics of each header determines whether or not to proceed to the next header. Therefore, they must be processed strictly in the order they appear in the packet.

There is a *recommended* extension layer order for each packet, but nodes are required to process extension headers in any order, with an exception that Hop-by-hop header must follow immediately after the IPv6 header.

### Hop-by-Hop Options header
The Hop-by-Hop Options header contains information that must be examined and processed by every node along a packet's delivery path. It **must** immediately follow the IPv6 header.

### Destination Options header
For options to be processed by the first destination that appears in the IPv6 destination address field plus subsequent destinations listed in the next header (Used before routing header or Upper-layer header).

### Routing (Type 0) header
The routing header contains a vector of addresses to route to after the packet has arrived to the destination (probably a router). Assuming that the packet is in the correct format (and parameters). The router node should masquerade the packet's destination address with the addresses in the routing header, and send it through another interface.

### Fragment header
The fragment header is used by an IPv6 source to send a packet larger than it would fit in the path MTU to its destination. Different to IPv4, this process is done purely on the source side.

## Packet Size Issues
IPv6 requires that every link in the internet have a MTU of 1280 octets or greater. It is recommended to have MTU greater than 1500 octets, to accommodate possible encapsulation (i.e., tunnelling) without incurring IPv6-layer fragmentation.

Path MTU Discovery [RFC-1981] is beneficial for nodes implementing IPv6.

## Flow Labels
The 20-bit flow label in the IPv6 header is used by a source to label sequences of packets for which it requests special handling by the IPv6 routers, such as non-default quality of service or "real-time" service.

## Traffic Classes
The 8-bit traffic class field in the IPv6 is used for originating nodes and/or forwarding routers to identify and distinguish between different classes or priorities of IPv6 packets.

## Upper-layer checksums Issue
Any transport or other uppper-layer protocol that includes the addresses from the IP header in its checksum computation must be modified for use over IPv6.

repository: MatrixAI/Emergence

gha_language: Haskell

repo_name: MatrixAI/Emergence


text:
Active Redis
============

Active Redis is a Python library for interacting with Redis data structures
using common Python classes. It supports nested objects by automatically
mapping and loading keys. The Active Redis API is extensible, as well,
allowing users to define new data structures and their behaviors.

Note that this library is still under development and currently
lacks tests.

### Usage
```python
from active_redis import ActiveRedis

activeredis = ActiveRedis()

# Create a new dict with the key 'foo_dict'.
foodict = activeredis.dict('foo_dict')
foodict['foo'] = []

# Store a JSON serialized list ['bar'] at key 'foo_dict' field 'foo'.
foodict['foo'] = ['bar']

print len(foodict) # 1

# Even once the list has been serialized, we can still append new
# values to the list and it will be automatically re-serialized.
# Active Redis internally wraps and monitors the list for changes.
foodict['foo'].append('baz')

# Create a new list with the key 'foo_list'.
foolist = activeredis.list('foo_list')

# Append the dict 'foo_dict' to the list.
# This will RPUSH an Active Redis reference to 'foo_dict'.
foolist.append(foodict)

print foolist[0]['foo'] # ['bar', 'baz']

# We can load the objects using the same keys.
del foodict
foodict = activeredis.dict('foo_dict')
print foodict['foo'] # ['bar', 'baz']

del foolist
foolist = activeredis.list('foo_list')
print foolist[0]['foo'] # ['bar', 'baz']

foolist[0]['foo'].reverse()
print foolist[0]['foo'] # ['baz', 'bar']

# If we want to actually delete the keys, call the delete() method.
# This will delete all referenced keys as well.
foolist.delete()

try:
  foodict['foo'] # Not happening.
except KeyError:
  print "foodict['foo'] is gone!"
else:
  print "foodict['foo'] is not gone!"

# Finally, if key names are irrelevant (such as in the case of
# a job queue) Active Redis can automatically generate unique keys.
fooset = activeredis.set()
fooset.add('foo')
fooset.add('bar')

# Event complex operations are supported via server-side Lua scripting.
barset = activeredis.set()
barset.add('bar')
barset.add('baz')

fooset &= barset
```

repository: kuujo/active-redis

repo_name: kuujo/active-redis


text:
# ReactiveUI-TreeView
I took the liberty of using a fork of condron's simple ReactiveUI TreeView "showcase", to show some memory and performance issues I've been running into using WPF TreeView and ReactiveUI. These kinds of problems with the TreeView have not been apparent to me before switching to RxUI. To replicate the problems, try following these steps:

1. The "Joe" node has a 1000 child nodes. Try expanding it and look at memory usage. On my machine there is a ~120mb increase, and it takes ~5 seconds to perform the expansion.
2. Try collapsing the node, and look at memory use. On my machine, there is no memory freed up. I would expect (or at least aim for) that the memory use would get back to what it was when I started the app.
3. Try pressing the "Clear" button. This clears the "Family" SourceList, and puts a single new node in it. Again this does not do anything to release memory.

I'm out of ideas how to mitigate these issues. I was thinking of using WhenActivated, but not sure how deactivation would get triggered with the TreeNodes. Also I think it would be a bummer to have to write a lot of custom deactivation logic for this. Or is there something that I and condron have been doing wrong?

ORIGINAL README:
Sample project for a WPF TreeView using ReactiveUI

Uses User Controls for item templates.

Added dynamic insertion of any type inheriting from TreeItem

Added IsSelected and IsExpanded Support

Added Expand path support

repository: vierkens/ReactiveUI-TreeView

repo_name: vierkens/ReactiveUI-TreeView


text:
Chapter 7 Transaction behavior
---

Most of the transaction behavior are exactly same, however the below stuff is not.

### 7.1 Handled Statement Failure.

```
create table t (a int primary key, b int);
begin;
insert into t values(1,1);
insert into t values(1, 1);
commit;
```

Oracle : commit can succeed. t has 1 row after that.

PostgreSQL: commit failed due to the 2nd insert failed. so t has 0 row.

### 7.2 DML with Subquery

Case 1:

```
create table dml(a int, b int);
insert into dml values(1, 1), (2,2);

-- session 1:
begin;
delete from dml where a in (select min(a) from dml);

--session 2:
delete from dml where a in (select min(a) from dml);

-- session 1:
commit;
```

In Oracle:  1 row deleted in sess 2. so 0 rows in the dml at last.

In PG    :  0 rows are deleted in sess 2, so 1 rows in the dml at last.

Oracle probably detects the min(a) is changed and rollback/rerun the statement.

The same reason can cause the below difference as well.

```
create table su (a int, b int);
insert into su values(1, 1);

- session 1:
begin;
update su set b = 2 where b = 1;

- sess 2:
select * from su where a in (select a from su where b = 1) for update;

- sess 1:
commit;
```

In oracle, 0 row is selected. In PostgreSQL, 1 row (1, 2) is selected.

A best practice would be never use subquery in DML & SLEECT ... FOR UPDATE. Even in Oracle, the behavior is inconsistent as well. Oracle between <IP_ADDRESS> and <IP_ADDRESS> probably behavior same as Postgres, but other versions not.

repository: orafce/orafce

gha_language: C

gha_license_id: NOASSERTION

repo_name: orafce/orafce


text:
---
title: Ai Lesson 2 - Year 9
layout: post
author: zak.pickard
permalink: /ai-lesson-2---year-9/
source-id: 1pdKJnrCt62v2V09_Oa04tOzcyRdAIhJcZBY8h_A3uLk
published: true
---

    Title:
    Repl.it
    Date
    04/04/17

    Starting Point
    Repl.it, 6 different questions

    Target For this lesson?
    To get as far as I possibly can

    Did I reach my target?
(add details to "Lesson
    Yes I managed to complete all tasks set

    Lesson Review

    How did I learn? What strategies were effective?

    Our homework from the previous week was to add 3 extra questions to our AI, I managed to complete this task with ease as it was just copying the 'resp' and ‘print’ functions all over again. However, in the lesson I made very little progress as none of the computers I tried worked until we had 15 minutes left. So for homework I am going to complete worksheet 3 and 4.

    What limited my learning? Which habits do I need to work ?

    In that lesson I did virtually no work as none of the computers I tried worked. However, I did manage to get halfway through worksheet 3 of python. Next time if my computer doesn’t work I now know how to fix it.

    What will I change for next time? How will I improve my learning?

    Next lesson I will immediately fix my computer to ensure that I make sufficient progress.


text:
# NodeBB FusionAuth OpenID Connect

This plugin is developed and supported by FusionAuth but it is intended to work with any OpenID Connect identity provider.

If you find any issue or a missing feature, please open an issue.

## Features

* OpenID Connect Authentication
 * Authorization Code Grant
* Hot reloading of the authentication strategy
 * The configuration with the exception of the `Email claim` can be loaded without restarting NodeBB.

## Developing

1. Run `npm link` in this directory
1. Go to your NodeBB directory and run `npm link nodebb-plugin-fusionauth-oidc`
1. Run `./nodebb build`
1. Run `./nodebb dev`

## Installation

1. Launch NodeBB
1. Go to the admin portal
1. Select `Extend > Plugins` from the menu
1. Click `Find Plugins` from the sub-menu
1. Search for `fusionauth-oidc`
![Search](./readme-images/search.png)
1. Click the `Install` button on the `nodebb-plugin-fusionauth-oidc` result
1. Click `Installed` from the sub-menu
1. Find the `nodebb-plugin-fusionauth-oidc` plugin and click `Activate`
1. Rebuild and restart NodeBB
1. Refresh the page to regenerate the menu

## Configuring

To configure the OpenID Connect plugin, perform the following steps to navigate to the configuration panel.

1. Select `Plugins > OpenID Connect` from the menu
1.

If your OpenID Connect identity provider supports discovery, then you only need to enter the Client Id, Client Secret and Discovery base URL. If this is not available to you or discovery is not successful, you may also enter each endpoint manually .

Once you complete this configuration and save the form, you will need to restart NodeBB for the configuration to take effect.

![Plugin Settings](./readme-images/plugin-settings.png)

| Field | Description |
| ----- | ----------- |
| Client ID | The unique Client Id provided to you by your IdP.  |
| Client secret | The client secret provided to you by your IdP.  In some cases this may not be provided to you if the IdP allows for non-confidential clients. |
|Discovery URL | When provided, this URL will be used to find the OpenID Connect discovery document. This URL will be appended with `.well-known/openid-configuration`. If this URL returns a JSON discovery document the remaining endpoints will be automatically resolved when you press the Save button. |
|Authorization endpoint | The fully qualified URL to the Authorization endpoint. |
|Token endpoint | The fully qualified URL to the Token endpoint. |
|Userinfo endpoint | The fully qualified URL to the Userinfo endpoint. |
|Logout endpoint | The fully qualified URL of the OpenID Connect logout endpoint. If configured, the browser will be redirected to this URL when you click logout in NodeBB.  |
|Email claim | The name of the claim found in the response from the Userinfo endpoint that identifies the user's email address. This is generally `email` and is the default value. |
|Roles claim | If present, on login we will check this claim for the value `"admin"` and if present, give the user access to the admin panel. The claim value can either be a string or array of strings. Anything else will be treated as the user having no roles. |

This plugin will work with any OpenID Connect identity provider. If you are using FusionAuth, the values needed for this configuration will be found in your Application OAuth configuration. For more information, review the [OAuth configuration](https://fusionauth.io/docs/v1/tech/core-concepts/applications#oauth) tab of the Application configuration in the FusionAuth documentation.

If your provider requires a callback url then use `https://<domain>/auth/fusionauth-oidc/callback`

### Additional Configuration

If you want to skip the login page and always use the configured OpenID Connect identity provider for authentication you will need to disable Login Login and Local Registration.

#### To disable Local Login:
1. Select `Manage > Privileges` from the menu
1. Uncheck the appropriate boxes under the `Local Login` column in the `Group Privileges` table
![Local Login](./readme-images/logal-login.png)

#### To disable Local Registration:
1. Select `Settings > User` from the menu
1. Scroll down to the `User Registration` section and set `Registration Type` to `No Registration`
1. Click the Save icon
![Local Registration](./readme-images/local-registration.png)

Once both Local Login and Local Registration have been disabled, the default login page will be skipped and the user will be automatically redirected to the OpenID Connect login page.

#### Recovery
If you need to login locally you can manually add the following parameter `/login?local=1` to your URL and you will be taken to the default login page.

#### Developer Notes

If you make changes to the plugin you will need to rebuild and reload. You can do this manually or via the UI.


text:
## Presentations

1. "**My IE Career**" by **Steven Myles**.  [Texas Tech University][ttu]
  [Department of Industrial, Manufacturing & Systems Enginering][ttuimse]
  [IE 2401][ie2401] guest presentation, 25 April 2023
2. "[**Storytelling for Engineers**][storytelling]" by **Steven Myles**.
  [University of Houston][uh] [Cullen College of Engineering][cullen]
  [PROMES][promes] [Maximizing Your Power Weekend 2012][mypw], 7--8 September
  2012
3. "**[University of Houston Engineering Summer Camp][uhcamp] - Young Engineers
  Panel Discussion**," [Hewlett-Packard Company][hp], 21 June 2012
4. "[**Projecting Outsourced Contact Center Agent Availability**][posccaa],"
  by **Steven Myles**, Viroj Buraparate, and Sunil Kumar G. [University of
  Pennsylvania][upenn] [Wharton][wharton] [Financial Institutions Center][fic]
  [Contact Center Forum 2008][ccforum], 28--29 February 2008
5. "[**Forecasting and Planning Diagnostic Techniques for Service Operations**][informs07pres],"
  by **Steven Myles**, Viroj Buraparate, and Atul Dhawan.  [INFORMS 2007][informs07],
  4--7 November 2007
6. "[**Inventory Control for Automated Drug Dispensing Machines: A Service Level
  Policy**][informs07pres]," by [John E. Kobza][jek], **Steven Myles**, Sean Dunagan, Garrett
  Heath, and Surya D. Liman. [INFORMS 2007][informs07], 4--7 November 2007
7. "[**Optimization Strategies for Resolving Inventory Problems in Customer Service
  Repair Centers**][informs05pres]," by **Steven Myles**, Viroj Buraparate, and
  Terrell Thruston. [INFORMS 2005][informs05], 13--16 November 2005
8. "[**Optimal Call Center Capacity Allocation Model**][informs05pres]," by Will
  Lin, Atul Dhawan, **Steven Myles**, and [Saravanan Venkatachalam][saravanan].
  [INFORMS 2005][informs05], 13--16 November 2005

[ttu]: https://www.ttu.edu/
[ttuimse]: https://www.depts.ttu.edu/imse/
[ie2401]: https://catalog.ttu.edu/preview_course_nopop.php?catoid=19&coid=110250
[storytelling]: https://stevemyles.site/blog/2012/09/09/storytelling-for-engineers/
[uh]: https://www.uh.edu/
[cullen]: https://www.egr.uh.edu/
[promes]: http://promes.egr.uh.edu/
[mypw]: https://stevemyles.site/blog/2012/09/09/uh-maximizing-your-power-weekend/
[uhcamp]: https://www.egr.uh.edu/camps
[posccaa]: https://stevemyles.site/blog/2008/02/29/projecting-outsourced-contact-center-agent-availability/
[upenn]: https://www.upenn.edu/
[wharton]: https://www.wharton.upenn.edu/
[fic]: https://fic.wharton.upenn.edu/fic/
[ccforum]: https://web.archive.org/web/20100623190502/http://fic.wharton.upenn.edu/fic/call%20center%2008/agenda.htm
[informs07pres]: https://stevemyles.site/blog/2007/10/30/informs-2007-presentations/
[jek]: https://ise.utk.edu/people/john-e-kobza/
[informs07]: https://web.archive.org/web/20140731003202/http://meetings2.informs.org/Seattle07/
[informs05pres]: https://stevemyles.site/blog/2005/11/11/informs-2005-presentations/
[informs05]: https://web.archive.org/web/20170524053146/http://meetings2.informs.org/NO2005/
[saravanan]: https://engineering.wayne.edu/profile/saravanan.venkatachalam/

repository: scumdogsteev/cv

gha_language: HTML

repo_name: scumdogsteev/cv


text:
---
title: Assignments Not Appearing on Front End
taxonomy:
    category: docs
    tag: [gantry5]
---

In general, assigning an outline to a specific menu item (or page, category, etc.) should make tie that outline to the assigned pages on the front end without issue. However, some third-party plugins (WordPress) and/or system plugins (Joomla) can interfere with these assignments.

So, if you have assigned an outline to a specific area of your site, and aren't seeing this reflected on the front end, a great place to start troubleshooting is to make sure you aren't running a third-party plugin that could be interfering with how Joomla (and ultimately Gantry) handle page assignments.

One common Joomla system plugin we've seen this issue with is `System - JCK Modal`. If you believe this might be the problem, disable it and refresh your desired page.

branch_name: refs/heads/develop


text:
With templates, we break our biochemistry analogy to get into language
that makes more sense to clients and final output.
Templates are comprised mostly of organisms combined together to form
page-level objects.

Templates provide context for these relatively abstract molecules and
organisms, which is helpful for designers and clients alike.

Templates mostly focus on content structure (such as character length,
image size, etc) rather than the actual content.

---

This lesson is going to have a few more steps than the previous few.

First, we're going to make a few empty organisms, to really show how templates are structured.
We'll need a header and a footer organism. Don't worry about the content in these files,
just name them `02-header.mustache` and `03-footer.mustache`.
Be sure to save them inside the `ORGANISMS` folder!

Now, make a new folder for your templates: `templates`

Next, name your template `01-products.mustache`

This template is going to need a few things:
  A partial for the header: `{{> organisms-header }}`
  A partial for the product grid: `{{> organisms-product-grid }}`
  A partial for the footer: `{{> organisms-footer }}`
  Wrapper divs around each partial.

repository: panalbish/pattern-lab-workshop

repo_name: panalbish/pattern-lab-workshop


text:
---
title: "Python Tuples (With Examples)"
description: "Learn to create and use tuple data type in Python 3 with examples."

Similar to lists, Tuples can also store different objects.
Tuples in Python are written as a series of items/objects in a parenthesis.

### Characteristics of Tuples

1. Similar to strings and lists, tuples are **ordered collections of objects**. They maintain a left-to-right order of their content.
2. Similar to lists, they can store different kinds of objects.
3. Similar to strings and lists, the object(s) in the tuple can be accessed by their index or slicing.
4. Similar to strings, **Tuples are immutables**. They don't support any in-place change operations.
5. Because tuples are immutable, **you cannot change the size of a tuple without making a copy**.

### How to create a tuple in Python?

Below are various ways to create different types of tuples in Python.

**Code**

```python3
# Empty Tuple
x = ()
print(x)

# One item Tuple
x = (1,) # Notice the trailing comma
print(x)

# Multiple items tuple
x = (1, 2, 3, 4)
print(x)

# Nested Tuples
x = ((1, 2), 3, 4)
print(x)

# Tuple from a list
x = tuple([1, 2, 3, 4])
print(x)

# Tuple from a string
x = tuple('Pylenin')
print(x)

# Tuple from a dictionary
x = tuple({"name":"Pylenin", "language":"Python"})
print(x)
```

**Output**

```bash
()
(1,)
(1, 2, 3, 4)
((1, 2), 3, 4)
(1, 2, 3, 4)
('P', 'y', 'l', 'e', 'n', 'i', 'n')
('name', 'language')
```

You can also create tuples **without using parenthesis**.

**Code**

```python3
x = 1, 2, 3, 4

print(x)
```

**Output**

```bash
(1, 2, 3, 4)
```

In the context of the above assignment statement,
Python recognizes this as a tuple, even though it doesn't have parentheses.

#### Syntax peculiarity of Tuples

To create a single element tuple, make sure **to add a trailing comma**. Otherwise, Python will treat it as an individual data type.

**Code**

```python3
x = ("Pylenin")
print(type(x))

x = ("Pylenin",)
print(type(x))
```

**Output**

```bash
<class 'str'>
<class 'tuple'>
```

### Concatenating Tuples

Similar to strings and lists, you can use the `+` or `*` operator to concatenate lists.

**Code**

```python3
# Using + operator
x = (1, 2, 3)
y = (4,)
x += y
print("x is now ", x)

# Using * operator
x = (1, 2, 3)
x *= 2
print("x is now ", x)
```

**Output**

```bash
x is now  (1, 2, 3, 4)

x is now  (1, 2, 3, 1, 2, 3)
```

Notice how the ids have changed after both concatenation operations.

### Access elements of a tuple

The process of accessing elements from a tuple,
works similar to strings and lists.

You can access individual elements of a tuple using **indexing**
and a range of elements using **slicing**.
In Python tuples, index starts from 0 and keeps increasing by 1
with every element in the tuple.
This is called Positive Indexing(or indexing from the beginning).
If there are __**n**__ elements in a tuple, the 1st element will have
index of **0** and the last element will have index **n-1**.

**Python also allows negative indexing of tuples(indexing from the end).**
If there are __**n**__ elements in a list, the last element will have index
of **-1** and the first element will have index __**-n**__.

Let's look at the image below for better understanding.

![Indexing of Tuples in Python](/img/python-tuples/indexing-tuples.png)

**Code**

```python3
my_tuple = (1, 2, 3, 4, 5)

# first character
print('my_tuple[0] =', my_tuple[0])

# last character
print('my_tuple[-1] =', my_tuple[-1])

# second character
print('my_tuple[1] =', my_tuple[1])

# second last character
print('my_tuple[-2] =', my_tuple[-2])
```

**Output**

```bash
my_tuple[0] = 1
my_tuple[-1] = 5
my_tuple[1] = 2
my_tuple[-2] = 4
```

If you try to access an element out of range, it will raise an `IndexError`.

Also, the index must be an **integer**. You can't use floats or other types for indexing. This will result in `TypeError`.

**Code/Output**

```python3
my_tuple = (1, 2, 3, 4, 5)

print(my_tuple[10])
>>> IndexError: list index out of range

print(my_tuple[3.5])
>>> TypeError: tuple indices must be integers or slices, not float
```

### Slicing of Tuples

Similar to strings and lists, you can access a range of elements
from a tuple using **slicing**.

Basically, you have to specify the starting index and the end index,
separated by a colon(`:`), to return a range of elements from the tuple.

#### Slicing Tuples with Positive Index

![Slicing Tuples with positive index in Python](/img/python-tuples/slicing-tuples-with-positive-index.png)

**Remember** - The last index is not included.

Let's say you want to access the 1st and the 2nd index from a tuple.
In that case, **your end index will be 3**.

**Code**

```python3
my_tuple = (1, 2, 3, 4, 5)

print(my_tuple[1:3])
```

**Output**

```bash
(2, 3)
```

If you leave out the start index, the range will start at the first element.

**Code**

```python3
my_tuple = (1, 2, 3, 4, 5)

# leave out the first index
print(my_tuple[:3])
```

**Output**

```bash
(1, 2, 3)
```

If you leave out the end index, the range will go to the end.

**Code**

```python3
my_tuple = (1, 2, 3, 4, 5)

# leave out the end index
print(my_tuple[1:])
```

**Output**

```bash
(2, 3, 4, 5)
```

So, if you leave out both the start and end index,
**you will get a replica of the original tuple**.

**Code**

```python3
my_tuple = (1, 2, 3, 4, 5)

# leave out the start and end index
print(my_tuple[:])
```

**Output**

```bash
(1, 2, 3, 4, 5)
```

#### Slicing Tuple with Negative Index

You can also use negative index for slicing.
Just use the negative index counterpart of your
positive index to slice a tuple.

![Slicing Tuples with negative index in Python](/img/python-tuples/slicing-tuples-with-negative-index.png)

**Code**

```python3
my_tuple = (1, 2, 3, 4, 5)

# Slicing with Positive Index
print(my_tuple[1:3])
# Slicing with Negative Index
print(my_tuple[-4:-2])
```

**Output**

```bash
(2, 3)
(2, 3)
```

#### Mixing positive and negative indices for slicing tuples

You can also mix positive and negative indices
while slicing a tuple.

**Code**

```python3
my_tuple = (1, 2, 3, 4, 5)

print(my_tuple[1:-1])
print(my_tuple[-3:5])
```

**Output**

```bash
(2, 3, 4)
(3, 4, 5)
```

Let's understand the above example using the below image.

![Mixing positive and negative indices for slicing tuples in Python](/img/python-tuples/slicing-tuple-with-positive-negative-index.png)

#### Using steps in slicing

You can also include **steps** while slicing a tuple.
The step allows you to take every `nth` element while slicing.

**Syntax**

```bash
tuple[start:stop:step]
```

**Code**

```python3
my_tuple = (1, 2, 3, 4, 5)

# Get every second element
# from beginning to end
print(my_tuple[::2])

# Get every second element
# starting at index 1 till end
print(my_tuple[1::2])

# Get every second element
# starting at index 1 upto -2 index
print(my_tuple[1:-2:2])
```

**Output**

```bash
(1, 3, 5)
(2, 4)
(2,)
```

#### Reversing a tuple

Negative step changes the slice **to be built from the tail of the tuple**.
So, it goes from the last element to the first element.
This way, we get a **reversed tuple**.

**Code**

```python3
my_tuple = (1, 2, 3, 4, 5)

print(my_tuple[::-1])
```

**Output**

```bash
(5, 4, 3, 2, 1)
```

When using a negative step, the start and stop values have to be
provided from right to left (usually it is from left to right).

**Code**

```python3
my_tuple = (1, 2, 3, 4, 5)

# Reverse the list
# without the last element
print(my_tuple[-2::-1])

# Reverse the list
# without the first and last element
print(my_tuple[-2:0:-1])
```

**Output**

```bash
(4, 3, 2, 1)
(4, 3, 2)
```

### Deleting a tuple

Because tuples are immutable, you cannot delete specific elements of a tuple

**Code**

```python3
my_tuple = (1, 2, 3, 4, 5)

del my_tuple[0]
```

**Output**

```bash
TypeError: 'tuple' object doesn't support item deletion
```

However, it is possible to delete the entire tuple object.

**Code**

```python3
my_tuple = (1, 2, 3, 4, 5)

del my_tuple
print(my_tuple)
```

**Output**

```bash
NameError: name 'my_tuple' is not defined
```

### Commonly used methods with tuples

#### How to sort tuples?

Python doesn't provide all the methods that come with lists, strings or dictionaries.
For example, if you want to sort a tuple in increasing or decreasing order, you have to first convert it into a mutable object like list to get access to sorting methods.

**Code**

```python3
my_tuple = (1, 2, 3, 4, 5)

my_list = list(my_tuple)

# sort in ascending order
my_list.sort()
print(tuple(my_list))

# sort in descending order
my_list.sort(reverse=True)
print(tuple(my_list))
```

**Output**

```bash
(1, 2, 3, 4, 5)
(5, 4, 3, 2, 1)
```

#### count() and index()

Similar to lists, you can also count the index and number of occurences of an element in tuple.

**Code**

```python3
my_tuple = (1, 2, 3, 4, 5)

print(my_tuple.count(1))
print(my_tuple.index(1))
```

**Output**

```bash
1
0
```

### Tuple Swap

Let's say you want to interchange the values of two variables.

Ideally, you would need a 3rd temporary variable to achieve the objective.

**Code**

```python3
x = 10
y = 20
# Create a temp variable z
z = x
x = y
y = z

print(x, y)
```

**Output**

```bash
20 10
```

However, you can easily do this with Python without creating a 3rd temporary variable. The underlying concept is called a Tuple Swap.

**Code**

```python3
x = 10
y = 20

x, y = y, x
print(x, y)
```

**Output**

```bash
20 10
```

#### How Tuple Swap works?

Let's understand the mechanism behind Tuple Swap.

We know from the [section on creating tuples](https://www.pylenin.com/blogs/python-tuples/#how-to-create-a-tuple-in-python) that, Python can create a tuple without parenthesis.

**Code**

```python3
x = 1, 2, 3
print(x)
```

**Output**

```bash
(1, 2, 3)
```

Now notice the below code.

```python3
LHS    RHS
x, y = y, x
```

Python considers the `y, x` part as a tuple. It sees it as `(20, 10)`.

So the above assignment changes to `x, y = (20, 10)`

Now, Python unpacks the iterable into values of x and y.

So the values become interchanged. Check out this article on [unpacking iterables in Python](https://www.pylenin.com/blogs/unpacking-iterables-in-python/) to see how unpacking works.

### Lists vs Tuples

The major difference between lists and tuples is that tuples are immutable.
So a tuple can't be changed through another reference elsewhere in the program. However, lists can be altered at any stage of the program.

There are also other noticeable differences like:-

1. Tuples can't be copied. `tuple(my_tuple)` returns you the same tuple. Lists can be copied.
2. Tuples occupy a smaller memory compared to lists as they are immutable. **This makes tuples a bit faster.**
3. Tuples are of fixed lengths. So you can't add or remove elements from a tuple.
4. You can't apply a lot of methods on Tuples. For example - To sort, you first have to convert a tuple to list.

If you're defining a constant set of values on which you are only going to iterate through, use a tuple instead of a list. **You can always convert it to a list later, when you need to.**

repository: pylenin/purple-blue

repo_name: pylenin/purple-blue


text:
---
layout: page
title: Guitar Solo Transcription
permalink: research/solo-transcription/
subtitle: Guitar Solo Transcription on Real-world Recordings
---

*September, 2018*

This is part of the [SoloLa project](https://musicai.citi.sinica.edu.tw/project/SoloLa){:target="_blank"}, which aims at creating a complete system for transcribing guitar solo from audio signal to accurate symbolic notation, and this subproject designed the core algorithm of it. Instead of playing each note separately, guitar solo usually contains lots of inter-note playing techniques, e.g., bend, vibrato, slide. The employment of these playing techniques makes it difficult to transcribe notes using general note tracking algorithms, which only analyze the fundamental frequency of the audio signal but not the precise variation of frequency through time. However, these variations are possible locations for the playing techniques. By analyzing the playing techniques, we have proved to get more detailed symbolic notation (sheet music) for guitarists as well as improving the accuracy of note tracking.

To accomplish this goal, we introduced a new model called Technique-Embedded Note Tracking, or TENT, primarily designed for transcribing guitar solo. The whole algorithm is explained in [our journal paper](https://transactions.ismir.net/articles/10.5334/tismir.23){:target="_blank"}. Here we only show the flowchart and some demo of the algorithm.


text:
---
layout: post
title: Consent Page
date: 2015-09-27
categories: consent
---

{:center: style="text-align: center"}

# CONSENT TO PARTICIPATE IN NON-BIOMEDICAL RESEARCH
{:center}

Software Game Character Training Experiments
{:center}

You are asked to participate in a research study conducted by Cynthia Breazeal (Associate Professor), Jin Joo Lee (Ph.D. candidate) and Nick DePalma (Ph.D. candidate) at the Massachusetts Institute of Technology (M.I.T.). Results of this study will contribute to the Ph.D. thesis research of Jin Joo Lee and/or Nick DePalma  You were selected as a possible participant in this study because you have volunteered to label data online with our system and you are over the age of 18 and are eligible to consent. You should read the information below, and ask questions about anything you do not understand, before deciding whether or not to participate.

## PARTICIPATION AND WITHDRAWAL

Your participation in this study is completely voluntary and you are free to choose whether to be in it or not. If you choose to be in this study, you may subsequently withdraw from it at any time without penalty or consequences of any kind.  The investigator may withdraw you from this research if circumstances arise which warrant doing so. This may happen if foul language is used or if it is found that the participant is undermining the study through intentional deceit.

## PURPOSE OF THE STUDY

We are investigating Machine Learning applications for software computer games.

## PROCEDURES

If you volunteer to participate in this study, we would ask you to do the following things:

You will be asked to interact with a tangram game or scene in which a virtual robotic agent is jointly interacting. You will be able to communicate with the character through the use of the keyboard and the mouse. You will be told when the study ends and will then be asked a series of questions about your experience. In some cases, you will have the opportunity to voluntarily exit at any time but will still be required to fill out the questionnaire. The complete study is estimated to take less than one hour of your time.

## POTENTIAL RISKS AND DISCOMFORTS

We are unaware of any potential risks in this experiment. To reiterate, you may exit at any time you feel discomfort and we would like to request that you report any discomfort immediately to one of the investigators through our contact information below.

## POTENTIAL BENEFITS

Your participation will help us to build software agents and robots that are more responsive and sociable learning partners.

## PAYMENT FOR PARTICIPATION

Every participant will receive, $0.10 for doing the experiment. You can receive up to an additional $1 based on the quality of your response.

## CONFIDENTIALITY

Any information that is obtained in connection with this study and that can be identified with you will remain confidential and will be disclosed only with your permission or as required by law.

While we do not record any identifying data from you, the participant, any information that is obtained in connection with this study will remain confidential and will be disclosed only with your permission or as required by law.

Every participant's session with this online system is anonymized using globally unique identifiers in conjunction with unique identifiers that relate to the study itself. We never will ask for your name, address, or any identifying information. Data is stored in a database that we use to train our robots and will only be used to generate robotic behavior. Any other uses of the data will require further consent of the participant.

## IDENTIFICATION OF INVESTIGATORS

If you have any questions or concerns about the research, please feel free to contact:

Nick DePalma (Ph.D. candidate)

617 452 5603

MIT Media Lab

E15-485

Cambridge, MA 02139

<EMAIL_ADDRESS>

Associate Professor, Cynthia Breazeal

617 452 5601

MIT Media Lab

E15-468

Cambridge, MA 02139

<EMAIL_ADDRESS>

## EMERGENCY CARE AND COMPENSATION FOR INJURY

If you feel you have suffered an injury, which may include emotional trauma, as a result of participating in this study, please contact the person in charge of the study as soon as possible.

In the event you suffer such an injury, M.I.T. may provide itself, or arrange for the provision of, emergency transport or medical treatment, including emergency treatment and follow-up care, as needed, or reimbursement for such medical services.  M.I.T. does not provide any other form of compensation for injury. In any case, neither the offer to provide medical assistance, nor the actual provision of medical services shall be considered an admission of fault or acceptance of liability. Questions regarding this policy may be directed to MIT’s Insurance Office,<PHONE_NUMBER>. Your insurance carrier may be billed for the cost of emergency transport or medical treatment, if such services are determined not to be directly related to your participation in this study.

## RIGHTS OF RESEARCH SUBJECTS

You are not waiving any legal claims, rights or remedies because of your participation in this research study.  If you feel you have been treated unfairly, or you have questions regarding your rights as a research subject, you may contact the Chairman of the Committee on the Use of Humans as Experimental Subjects, M.I.T., Room E25-143B, 77 Massachusetts Ave, Cambridge, MA 02139, phone 1-617-253 6787.

# RESEARCH SUBJECT AGREEMENT

I understand the procedures described above. By clicking on the *Agree* Button below, you are agreeing that you are of legal age to consent (18 years or older) and that you agree to the above terms.

| [Agree]({{site.baseurl}}{% post_url 2015-09-27-Pick-Rand %}){: #agreeBut} | [Leave Immediately](http://www.google.com){: #declineBut} |

repository: haewon-mit/turkjs

extension: markdown

repo_name: haewon-mit/turkjs


text:
# How to contribute

## Set up

### Create virtual environment

#### With virtualenv

```bash
# create a virtual environment and "activate" it
virtualenv -p /usr/bin/python3.8 envs/dataviz_python
source envs/dataviz_python/bin/activate

# install in this environment all the Python packages
# listed in the requirements.txt file
pip install -r requirements.txt
```

#### With conda

The first time

```
conda env create -n dataviz_python -f ./binder/environment.yml
```

To update the environment after changes were made to `./binder/environment.yml`

```
conda env update -n dataviz_pythonv -f ./binder/environment.yml
```

## Download the required data

<!-- TODO improve datalad install instruction -->

We are using the fact that the openneuro datasets can be accessed through their
siblings on github:

https://github.com/OpenNeuroDatasets

For more info see the handbook:
http://handbook.datalad.org/en/latest/basics/101-180-FAQ.html#how-does-datalad-interface-with-openneuro

```bash
datalad clone https://github.com/OpenNeuroDatasets/ds003542.git inputs/ds003542/
datalad get inputs/ds003542/sub-01/func/sub-01_task-compL1_run-1*
datalad get inputs/ds003542/sub-01/anat/
```


text:
# IMPORTANT!

I'm a user of the excellent Dr. Muscle app for weight-training, if you're into strength training, I advise you to check it out at dr-muscle.com

The user community of Dr Muscle have been asking for some charts to illustrate how they're progressing so I decided to get in touch with Carl Juneau (the CEO of Dr. Muscle) to ask about getting access to the APIs so I start an open source effort to present the dashboards, and this little project was born.

It's still very much a WIP - if you're interested in contributing, let me know. Pull Requests welcome!

## What does it use?

Everything is written using the VueJS framework with Buefy for UI components

## Project setup

```
npm install
```

### Compiles and hot-reloads for development

```
npm run serve
```

### Compiles and minifies for production

```
npm run build
```

### Lints and fixes files

```
npm run lint
```

repository: rcoundon/dr-muscle-dashboard

gha_language: Vue

repo_name: rcoundon/dr-muscle-dashboard


text:
# About

Builds a Docker image whose default shell is zsh. In addition, oh-my-zsh and zsh-git-prompt are installed.

This is for readers of my blog post titled [Haskell deep dive: zsh-git-prompt](http://blog.pangyanhan.com/posts/haskell-deep-dive-zsh-git-prompt.html) to try out zsh and zsh-git-prompt if they do not have them installed.

You can either build it from source, or just pull it from Docker Hub.

## More about the image

- The entrypoint is `/bin/bash`. The user is root
- It is based on the [haskell:8.2.1](https://hub.docker.com/_/haskell/) image, which is in turn based on the [debian:jessie](https://hub.docker.com/_/debian/) image. So if you need to install anything, use apt-get
- cd to `~/zsh-git-prompt` and you should see some additional info about the git repo in the prompt. cd back to the home directory and you should not see any git related information because we're not in a git repo

## Download from Docker Hub

```
docker run -it --rm --name zsh-git-prompt yanhan/zsh-git-prompt:0.1.0
```

which is actually equivalent to just running the [run.sh](/run.sh) script in this repository.

## Building from source

```
./build.sh
```

## Running

```
./run.sh
```

## License

[3-Clause BSD License](/LICENSE), Copyright (c) 2019 Yan Han Pang

repository: yanhan/zsh-git-prompt-docker

repo_name: yanhan/zsh-git-prompt-docker


text:
---
layout: post
title: "RIL RNA-seq Data Sets"
date: 2017-02-09
author: Jinliang Yang, Wenbin Mei
categories: [RNA-seq]
tags: [RIL, QTL, pheno]
comments: true
archive: false
---

Some RNA-seq data sets for RIL popualtions.

------

### 1. RNA-Seq for the intermated B73xMo17 recombinant inbred line population

- **From**: [Li et al., 2013](http://journals.plos.org/plosgenetics/article?id=10.1371/journal.pgen.1003202).
- **Tissue**: pooled 14 dys seedlings, including the shoot apex
- **SRA Study ID**: [SRP017111](https://trace.ncbi.nlm.nih.gov/Traces/sra/?study=SRP017111)
- **Data Size**: 105 recombinant inbred lines (RILs) from the IBM population; 2.5 billion reads; 620 Gbp; and 380 Gb in size

### 2. RNA-seq for the 103 RILs of a B73 x H99 RIL population

- **From**: [Baute et al., 2015](http://genomebiology.biomedcentral.com/articles/10.1186/s13059-015-0735-9).
- **Tissue**: sampled the first 0.5 cm of the most basal part of leaf 4 three days after appearance.
- **SRA Study ID**: [ERP011069](https://trace.ncbi.nlm.nih.gov/Traces/sra/?study=ERP011069)
- **Data Size**: 408 Gbp; and 265 Gb in size
- **Phenotypic data**: [additional files](https://static-content.springer.com/esm/art%3A10.1186%2Fs13059-015-0735-9/MediaObjects/13059_2015_735_MOESM3_ESM.xlsx) from the paper

### 3. RNA-seq for the RILs in the MAGIC population

- **From**: [Dell’Acqua et al., 2015](https://genomebiology.biomedcentral.com/articles/10.1186/s13059-015-0716-z).
- **Tissue**: extraction the most basal 0.5 cm of the fourth leaf during the steady state growth phase, that is, 3 days after the tip of the fourth leaf emerged from the pseudostem cylinder.
- **SRA Study ID**: [ERP012784](https://www.ncbi.nlm.nih.gov/Traces/study/?WebEnv=NCID_1_50963555_<IP_ADDRESS>_5555_1486660269_3544543543_0MetA0_S_HStore&query_key=61)
- **Data Size**: 334.20 Gbp; and 221.87 Gb in size

### 4. RNA-seq for the 88 intermated B73 3 Mo17 (IBM) Syn10 doubled haploid (DH) lines

- **From**: [Thatcher et al., 2014](http://www.plantcell.org/content/26/9/3472.long).
- **Tissue**: Two 0.6-cm leaf sections from 5-week-old seedlings were harvested from three plants of each genotype, pooled, and flash-frozen in liquid nitrogen.
- **SRA Study ID**: [SRP041704](https://www.ncbi.nlm.nih.gov/Traces/study/?WebEnv=NCID_1_50963555_<IP_ADDRESS>_5555_1486660269_3544543543_0MetA0_S_HStore&query_key=72)
- **Data Size**: 157.63 Gbp; and 93.01 Gb in size

gha_language: CSS


text:
# Learning from personal longitudinal dialog data
This is a project to allow people to convert their Google Hangouts, Facebook Messenger, iMessage, Instagram, and SMS Backup (Android Application) messages into a single format and explore this data. Code exists to set up and run experiments to predict common next messages, response times, and relationship attributes.

## Publication

More details of experiments run with this code can be found in the [paper about predicting speaker attributes](https://arxiv.org/abs/1904.11610) and the [paper about predicting common messages and response time](http://sentic.net/personal-longitudinal-dialog-data.pdf).

If you use this code please cite our two papers:

```
@inproceedings{Welch19LookWhosTalking,
    author = {Welch, Charles and P{\'e}rez-Rosas, Ver{\'o}nica and Kummerfeld, Jonathan K. and Mihalcea, Rada},
    title = {Look Who's Talking: Inferring Speaker Attributes from Personal Longitudinal Dialog},
    booktitle = {Proceedings of the 20th International Conference on Computational Linguistics and Intelligent Text Processing (CICLing)},
    address = {La Rochelle, France},
    year = {2019}
}

@article{Welch19LearningFromPersonal,
    author = {Welch, Charles and P{\'e}rez-Rosas, Ver{\'o}nica and Kummerfeld, Jonathan K. and Mihalcea, Rada},
    title = {Learning from Personal Longitudinal Dialog Data},
    journal = {IEEE Intelligent systems},
    volume = {34},
    number = {4},
    publisher = {IEEE},
    year = {2019}
}
```

## Prerequisites
The code must be run with Python3 (tested with 3.6.4). Install the following Python packages:

```zsh
pip install msgpack nltk termcolor beautifulsoup4 numpy prettytable python-dateutil tqdm pandas seaborn visdom
```

You may also have to download packages within NLTK. To generate dot files and LaTeX reports you need to install:

```zsh
# Ubuntu
sudo apt-get install latexmk texlive texlive-latex-extra graphviz
# Mac
brew install latexmk texlive texlive-latex-extra graphviz
```

If you want to run prediction experiments you must install pytorch. This is not necessary if you are just generating and looking at statistics. To install pytorch go to [the pytorch website](http://pytorch.org/) and select your OS, package manager, Python version and CUDA version to get the install command(s).

Also, if you want to run experiments you need to scikit and download the [Common Crawl GloVe embeddings](http://nlp.stanford.edu/data/glove.840B.300d.zip) and change your EMBEDDING_LOCATION in the utils.py file to point to where you have them downloaded.

To get the psycholinguistic categories of words and use them as features in the model you will need to acquire the [LIWC 2015 lexicon](https://liwc.wpengine.com/). The file provided is empty.

## To download your data
You can download Google Hangouts data from [their takeout page](https://takeout.google.com/settings/takeout) and Facebook data if you follow [their download instructions](https://www.facebook.com/help/302796099745838). Both services will take some time to generate an archive of your data. Your iMessage data is probably stored in ~/Library/Messages/chat.db. Instagram has a link to download your data on their [privacy and security page](https://www.instagram.com/accounts/privacy_and_security/).

I have noticed that Google Hangouts sometimes does not download all of your messages if you select other things to download at the same time. I click the 'Select None' button and then click the Google Hangouts button to make sure that is the only one I am downloading.

## Generating Statistics

```python
my_name = 'Charlie Welch', '+12345678900', 'cfwelch'
prefix = 'charlie'

GOOGLE_PATH = '/path/to/Hangouts.json'
FACEBOOK_PATH = '/path/to/facebook/messages/'
IMESSAGE_PATH = '/path/to/imessage-chat/chat.db'
INSTAGRAM_PATH = '/path/to/instagram/messages.json'
```

1. Edit the preceding lines in utils.py

    Edit my_name to the name you use with your social media accounts. This a comma separated list of the way your name shows up in each messenger. prefix is used for directory names so you can just change that to 'firstname' (Note: This exists in case you want to separate your workspace to work with multiple peoples data. In order to do this you just need to change the names whenever you switch). The Facebook, iMessage, Instagram, and Google paths should be changed to wherever your data is. These are also comma separated lists in case you have multiple accounts. If you do not have a path you can leave it as an empty string.

    Note: There is a variable named DATA_DIR. This is the name of a directory that will automatically be created and where generated data files will be placed. It is not the location of your downloaded data.

2. Run user_annotator.py

    This script will loop over your Google, iMessage, Instagram, and Facebook files and ask you if the names of people are correct. If you talk to someone on both platforms you will want to change the name so that it combines the files when it is doing the analysis. The script will then ask you questions about each person in your dataset. These are questions that I thought would be interesting, which split people into different groups like family, co-workers, classmates, etc.

    When you are naming people you can view random samples of conversation with that person to try and figure out who it is if you aren't sure. If it ends up being difficult, you may have to search for the name or conversation on the appropriate platform to figure out who it is. If the conversation is with an automated service or is spam you can filter these messages so that the scripts will ignore them. Your options are presented at each step.

    The user annotator saves a JSON file in the people folder at each step. If the script fails or is closed you can resume where you left off. If you make a mistake you can edit the JSON file directly.

3. Run the message_formatter.py script to convert your data into a common format using the names from the user_annotator.

4. Run the data merger with 'python people_merger.py'. This combines multiple files from the same person to make processing faster.

5. Run the augmentor with 'python augmentor.py -all'. This will add LIWC category, frequency, response time, style matching, and stopword counts to all data files.

6. Run 'python get_stats.py -all' which will create spreadsheets in the stats folder and print some output. You can change the START_TIME variable in utils.py to change the time range of messages to look at. It will include all messages sent from this time until the current time. There are separate flags if you do not want to generate all of the information but you will need all of it to generate LaTeX reports.

## Running the model
1. To run the model you first have to run 'python make_splits.py -g -t task' which will create a folder with the data required for the task, which can be user attribute (ua), common utterance (cu), or response time (rt) prediction.
2. Next you need to run 'python create_experiment.py -t task' which will take the data and convert it into a format that can be read into the model. This output can be transferred to another machine to run the experiment and contains no vocabulary file so the data is not readable.
3. (Optional) Move the tar file to the machine you want to run on and extract the files.
4. Run the main program. For user attribute prediction use 'python main.py -ua -sa (family or romantic or age or country or gender or school or work) -aur -als -atv -afq -atc -asv -alv -asu -agv' and it will log and print the output of running the model. The '-sa' flag tells it to build a single-attribute model with the specificed attribute. Each of the flags that start with 'a' tells the model which set of features to add. See 'python main.py --help' for details on each. To run response time prediction instead use 'python main.py -rt' and to run common utterance prediction simply leave out the 'rt' and 'ua' flags. Features can be used similarly with any of the three prediction tasks.

## Data format
The code does not currently support formats other than Google Hangouts, iMessage, Instagram, and Facebook, but if a converter is written the other scripts will read all of the files from the data folder. The converted files should be separated by underscores and the first part should be the format name.

The common message file format is a binary msgpack object which contains:
```python
conversation[b'with'] = 'First Last'     # <type 'str'>
conversation[b'messages'] = message_list # <type 'list'>
```

The message list object contains:
```python
message_list[i][b'user'] = 'Speaker Name'            # <type 'str'>
message_list[i][b'date'] = 'ISO 8601 formatted date' # <type 'str'>
message_list[i][b'text'] = 'message text'            # <type 'str'>
```

## Augmented format
After running the augmentor you will have additional useful fields attached to messages. These are used by other scripts but you can use them for whatever you want:
```python
message_list[i][b'liwc_counts'] = [cat1_count, cat2_count] # <type 'list'> of <type 'int'>
message_list[i][b'liwc_words'] = [['liwc_cat1_word1', 'liwc_cat1_word2'], ['liwc_cat2_word1', 'liwc_cat2_word2']] # <type 'list'> of <type 'list'> of <type 'str'>
message_list[i][b'words'] = num_words # <type 'int'>

message_list[i][b'stopword_count'] = num_words # <type 'int'>
message_list[i][b'turn_change'] = tc # <type 'bool'>
message_list[i][b'response_time'] = num_seconds # <type 'int'>

message_list[i][b'lsm'] = style_matching_score # <type 'int'>

message_list[i][b'all_freq'] = all_time_count # <type 'int'>
message_list[i][b'month_freq'] = month_count # <type 'int'>
message_list[i][b'week_freq'] = week_count # <type 'int'>
message_list[i][b'day_freq'] = day_count # <type 'int'>
```

## Generated Statistics
If you run get_stats.py it will create a lot of files in your stats folder. This is what each file contains:

 * day_of_week_stats.csv -- Breakdown of groups and how much you converse with them each by the day of the week.
 * hour_of_day_stats.csv -- Breakdown of groups and how much you converse with them each hour of the day.
 * liwc_grouped.csv -- Incoming/outgoing normalized counts of each LIWC category with each group of people aggregated over time.
 * liwc_person.csv -- Counts of each LIWC category in conversations with each person.
 * liwc_person_normalized.csv -- Normalized counts of each LIWC category in conversations with each person.
 * month_season_dists.txt -- Number of messages exchanged in each month and each season.
 * msgs_aggregate.csv -- Number of people spoken to and messages exchanged per each month bin.
 * msgs_over_time_by_person.csv -- Number of messages exchanged with each person per each month bin.
 * response_time_bins.txt -- Bins of your response time to other people by seconds. The left number is seconds and right number is number of responses that fall in that bin.
 * total_messages_per_category.csv -- For each group shows the incoming and outgoing number of words (I(W) and O(W)) and messages (I(M) and O(M)) as well as the totals (T(W) and T(M)).
 * total_messages_per_person.csv -- Incoming and outgoing messages and words for each person you speak to as well as the ratios (Out ratio of 10, for instance would mean that you use an average of 10 words per message when speaking to this person).
 * total_uniques.txt -- Total unique tokens and messages by you or others.
 * freq_by_stat/group_messages_per_month.csv -- Number of messages exchanged with each group over each month bin.
 * freq_by_stat/group_resp_time_per_month.csv -- Your average response time to each group per each month bin.
 * freq_by_stat/group_words_per_month.csv -- Number of words exchanged with each group over each month bin.
 * freq_by_stat/group_wpm_per_month.csv -- Average words per message exchanged with each group over each month bin.
 * freq_by_stat/messages_per_month.csv -- Number of messages exchanged with each person over each month bin.
 * freq_by_stat/words_per_month.csv -- Number of words exchanged with each person over each month bin.
 * freq_by_stat/wpm_per_month.csv -- Average words per message exchanged with each person over each month bin.
 * liwc_by_category/* -- Spreadsheets for each LIWC category that show normalized counts for that category for each person per month bin.
 * liwc_by_group/* -- Spreadsheets for each LIWC category that show normalized counts for that category for each group per month bin.
 * liwc_by_person/* -- Spreadsheets for each person that show normalized counts for each LIWC category per month bin. This includes a spreadsheet for yourself so that you can look at how your way of speaking changes over time.

## Adding user attributes

You can add user attributes by editing the user_annotator.py script. There are two dictionaries named tag_set and tag_description listed at the top of the file. Edit tag_set to have the attribute name and a list of options for values of that attribute and edit the tag_description to contain instructions for the user. After you've done this, if you rerun the annotator it will ask you to annotate people who do not already have this attribute annotated.


text:
---
id: meeting-minutes-20200423
title: 2020.4.23 Agenda
sidebar_label: 2020.4.23
---

## Logistics
### Day & Time
* Thursday, April 23rd. 11am ET

## Attendees
* Vijaeyesh Chandel (GS)
* Ffion Wiggins (GS)
* Ted Sanborn (ISDA)
* Irina Yermakova (ISDA)
* Ajith Dharwar (DB)
* Paul Brine (DB)
* Aitana Myohl (FINOS)

## Agenda

### Roll Call

### Housekeeping
* Review and approve [4/16 FX Options WG Meeting Minutes](https://github.com/finos/alloy/blob/master/meeting-minutes/fx-options-wg/2020.4.16-fx-options-wg-meeting.md) _- Meeting minutes were approved_

### Agenda Item #1
* Review example Fx scenarios and compare classes against model - Ted
### Agenda Item #2
* Review proposed 'Participants' class for buyer/seller and agree with group whether to proceed with its addition to the model - Ajith
### Agenda Item #3
* Demo how to navigate through various code formats - Vijay
### AOB

### Action items

repository: rtenhove/alloy

repo_name: rtenhove/alloy


text:
---
layout: post
title: Getting a Permanent Residence (PR) in the UK
---

On 23rd September, 2021, I received the confirmation letter from the Home Office, UK regarding the approval of my
Permanent Residence (PR) a.k.a Indefinite Leave to Remain (ILR) a.k.a Settled status:

<object data="{{ site.baseurl }}/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/ilrsucess.pdf" width="750px" height="750px">
    <embed src="{{ site.baseurl }}/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/ilrsucess.pdf">
</object>
_Download this pdf_ [here](https://datashines.github.io/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/ilrsucess.pdf)

And subsequently on 29th September, 2021 I received my Biometric Residence Permit (BRP) card. In this blog post, I am
going to elaborately specify the steps and attach the various documents that I gathered to make my application. Hope this
will be helpful for folks who are, soon to or in process of, making their ILR applications.

##  Rules for eligibility

For people who live and work in the UK, they can be eligible for an ILR in any duration between 2 to 5 years depending on the
type of visa. A majority of expat workers have a tier-2 visa which requires 5 years. However for different types of tier-1 visas,
the time can be 2 or 3 years. These rules are subject to updates and best to check them out at
the [government website](https://www.gov.uk/indefinite-leave-to-remain).

#### My case
I arrived to the UK in September 2018, and lived for about a year on tier-2 visa. Subsequently got my tier-1 exceptional
talent visa in 2019. You can read all the details about my tier-1 visa application story in my
[previous blog post](https://datashines.github.io/How-I-received-my-Tier-1-Exceptional-Talent-UK-visa/). With a tier-1
exceptional talent visa, you need 3 years until you are eligible for the ILR. However, these 3 years can be inclusive
of your time spent under tier-2 as well. Therefore for me, instead of becoming eligible for my ILR in 2022, I was already
eligible by September 2021. And that is when I made my application.

## Life in the UK test

Before even going into the whole - gathering of various documents - phase, I saw that there are 2 strict requirements for this application.
One of them is - having a thorough knowledge and understanding of life in the UK. [This](https://www.gov.uk/life-in-the-uk-test) is the
official website for life in the UK test, where you can know more about it and more importantly book a test. It costs 50£. You'll have
to answer 24 multiple choice type questions in 45 minutes. You must score 75% or above, i.e. at least 18 questions should be answered correctly.
One good thing is that once you pass this test, the scorecard is valid indefinitely. Hence, you can work on this test anytime before your ILR
application eligibility date and get past this checkpoint.

#### My case
I used this [wonderful resource (free)](https://lifeintheuktestweb.co.uk/test-1/) to prepare for the test. I have to admit that I
over-prepped to only realise that the actual test was not that difficult. I prepped slowly and steadily over 1.5 months wherein I
first went through the reading material given in the resource. And then I started practising the mock tests. My suggestion would be
to focus more on practising the mock tests and less on mugging the texts, because at least for me, the actual test literally had
questions straight-up from the mock tests. Just make sure you are consistently scoring above 90% or so across mock tests and at that
point you'll be good to go. The test appointments can be busy, hence, make sure to book one well within time. In reality you'll most certainly
not need 45 minutes to finish. It took less than 5 minutes in my case.

{% include display_ad_horizontal_1.html %}

## English language requirement
This is the second critical requirement for the ILR application. There are different ways of proving your English language ability. Two
of the most popular routes are
- Using university degrees ensuring English was the main language of education, or
- Taking one of those English language tests (IELTS).

Please go through the [official website](https://www.gov.uk/english-language) to understand what might be applicable for you.

#### My case
Thankfully, while applying for my tier-2 visa in 2018, I had to prove my English language ability. For that, I had used my
University degrees both from Undergrad as well as Grad Uni. Essentially, I had received a certificate from NARIC (the then government
body for certifying English language levels) certifying my language levels. And I was able to re-use that certificate again
this time for my ILR application.

## ILR Application

Once past the above two requirements, you will need to get a list of documents ready to submit alongside the ILR application.
You can use [this official link](https://visas-immigration.service.gov.uk/product/set-o) to apply for the ILR.
The application fee usually is 2389£. This regular fee means that you
will get a decision anytime within 6 months of applying. If you go for a priority or a super-priority service, which
cost an additional 500£ or 800£ respectively, then you will get a decision within 5 or 1 working days respectively. I
went with the priority service. Adding to these costs, finally you will need to book your biometric appointment which will cost anywhere
between 60£ to 200£. So for me, the overall ILR application cost including the life in the UK test (50£) was around 3100£ to 3200£.

While using the above link, besides providing details such as passport info, you will have to provide your travel history ever since
you first entered the UK. Make sure to
gather all the entry and exit dates to and from the UK, to the places you went to and a short text providing the reasons for travel.
Also, make sure you haven't spent more than 180 days outside of the UK in any window of 365 days. Because if so, then the clock for
counting the years until ILR eligibility resets. In my case, I had violated this rule but it was due to extraordinary circumstances
during COVID-19. The Home Office applies discretion in such exceptional cases as they did in mine.

Once past these steps of the application, you will have to make the application fee payment. You will then receive instructions to
a portal where you have to submit your documents before 2 days of the chosen biometric appointment date.

I am going to now list the various documents that I uploaded in the portal, starting with a cover letter, which itself summarised
and listed the various documents that I provided in my application.

#### Cover Letter

<object data="{{ site.baseurl }}/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/Cover-Letter.pdf" width="750px" height="750px">
    <embed src="{{ site.baseurl }}/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/Cover-Letter.pdf">
</object>
_Download this pdf_ [here](https://datashines.github.io/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/Cover-Letter.pdf)

#### Passport with visa stamps (sample from my old passport)

<object data="{{ site.baseurl }}/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/passport_old_with_visa_pages.pdf" width="750px" height="750px">
    <embed src="{{ site.baseurl }}/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/passport_old_with_visa_pages.pdf">
</object>
_Download this pdf_ [here](https://datashines.github.io/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/passport_old_with_visa_pages.pdf)

#### Consent to let HMRC conduct verification checks

<object data="{{ site.baseurl }}/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/family_consent_signed.pdf" width="750px" height="750px">
    <embed src="{{ site.baseurl }}/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/family_consent_signed.pdf">
</object>
_Download this pdf_ [here](https://datashines.github.io/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/family_consent_signed.pdf)

#### Previous Biometric Residence Permits (tier 1 and tier 2)
(self explanatory)

#### Tier 1 Visa Endorsement Letter
<object data="{{ site.baseurl }}/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/HomeOfficeLetter.pdf" width="750px" height="750px">
    <embed src="{{ site.baseurl }}/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/HomeOfficeLetter.pdf">
</object>
_Download this pdf_ [here](https://datashines.github.io/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/HomeOfficeLetter.pdf)

#### Payslips from last 6 months
(self explanatory)

#### Bank statements from last 6 months
(self explanatory)

#### Letter from employer confirming authenticity of payslips
<object data="{{ site.baseurl }}/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/PayslipAuthenticityLetter.pdf" width="750px" height="750px">
    <embed src="{{ site.baseurl }}/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/PayslipAuthenticityLetter.pdf">
</object>
_Download this pdf_ [here](https://datashines.github.io/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/PayslipAuthenticityLetter.pdf)

#### P60s from last 3 years (sample from 2020)
<object data="{{ site.baseurl }}/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/P60-2020.pdf" width="750px" height="750px">
    <embed src="{{ site.baseurl }}/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/P60-2020.pdf">
</object>
_Download this pdf_ [here](https://datashines.github.io/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/P60-2020.pdf)

#### Employment contract
(self explanatory)

#### Reference letter from employer stating tech-related role and earnings
<object data="{{ site.baseurl }}/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/Reference_Letter_From_Employer.pdf" width="750px" height="750px">
    <embed src="{{ site.baseurl }}/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/Reference_Letter_From_Employer.pdf">
</object>
_Download this pdf_ [here](https://datashines.github.io/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/Reference_Letter_From_Employer.pdf)

#### Documents related to life events
(this section is specific for every person, and hence my documents won't be helpful, take your own judgement)

#### NARIC language level certificate
<object data="{{ site.baseurl }}/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/NARIC_English_Language_Certificate.pdf" width="750px" height="750px">
    <embed src="{{ site.baseurl }}/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/NARIC_English_Language_Certificate.pdf">
</object>
_Download this pdf_ [here](https://datashines.github.io/data/2021-10-31-Getting-a-Permanent-Residence-(PR)-in-the-UK/NARIC_English_Language_Certificate.pdf)

#### Degree certificates
(self explanatory)

## Conclusion

Start preparing for your ILR application roughly 3-4 months before date of eligibility. Reserve some time to get through the life in the UK test.
Ensure you have evidence to demonstrate English language fluency. Also ensure your travel history doesn't have long gaps (more than 180 days in
a moving 365 days window). And finally, gather all the necessary documents as specified on the
[government website](https://visas-immigration.service.gov.uk/product/set-o). Be prepared to spend anywhere between 3000£ to 3500£ in the process.
And that shall be it. You shall receive your biometric card within 6 months, or 5 days or a day of your biometric appointment date depending on
whether you chose super-priority, priority or regular service respectively.

I hope this was useful. Thanks for reading !!

gha_language: SCSS


text:
# Treval
React frontend for travel web application

## Docker installation

Build Dockerfile image via:

```bash
docker build . -t <name of image>
```

To view application:

Note that the Dockerfile will run the application thus head over to localhost at port 3000

## Installation

Use the package manager [yarn](https://classic.yarnpkg.com/en/docs/install#windows-stable) to install Treval.

```bash
yarn install
```

## Usage

```JavaScript
yarn start
```

## Preview

https://user-images.githubusercontent.com/26885287/116465746-7d54dc80-a822-11eb-9596-c6658d83fc4a.mp4

## License
[MIT](https://choosealicense.com/licenses/mit/)


text:
# Computer setup

This public repository contains the scripts necessary to bootstrap a macOS, Linux, or Windows machine into a One More Game workstation.

## Setup Host (Windows)

Our Windows Desktop PCs come imaged with Win10 Professional. Upon first login using an @onemoregame.com online account, our auto-provisioning processes should kick in and deploy the common components needed for development on OMG projects. The rest of this document

## Setup Host (macOS/Linux)

No additional setup required.

## Install & Configure Software (Windows)

Again, this step is only necessary if auto-provisioning tools are not working or unavailable. This step will setup your Windows machine with some useful development tools to get started.

1. Login to Windows with the desired user
1. Run the software setup script

   ```batch
   "%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe" -NoProfile -InputFormat None -ExecutionPolicy Bypass -Command "iex ((New-Object System.Net.WebClient).DownloadString('https://raw.githubusercontent.com/PlayOneMoreGame/computer-setup/master/scripts/win-host-setup.ps1'))"
   ```

1. Restart your command prompt

1. Run Windows Update and reboot when necessary
1. Run the `Ubuntu` application to start WSL and create a username and password for your WSL user
1. Run the following command to configure WSL as an OMG workstation

   ```shell
   $ curl -fsSL https://raw.githubusercontent.com/PlayOneMoreGame/computer-setup/master/scripts/unix-host-setup.sh | bash
   ```

1. Follow the onscreen instructions to finish configuring your WSL installation

## Install & Configure Software (macOS/Linux)

Run the following command in your shell to setup a macOS or Linux host:

```bash
$ curl -fsSL https://raw.githubusercontent.com/PlayOneMoreGame/computer-setup/master/scripts/unix-host-setup.sh | bash
```

## Post-installation (Windows)

We recommend configuring your computer using the [PlayOneMoreGame/dotfiles](https://github.com/PlayOneMoreGame/dotfiles) repository, which configures, among other things, sane defaults for bash across Windows/WSL/Mac/Linux, and allows for running X-Windows (GUI) programs from WSL.

### Windows Issues

If you're endeavoring to change the powershell scripts on Github and it is not working, remember that Powershell performs web-request caching, which you'll need to disable it; for example:

```powershell
iwr https://raw.githubusercontent.com/PlayOneMoreGame/computer-setup/master/scripts/win-software-setup.ps1 -UseBasicParsing -Headers @{ "Pragma"="no-cache"; "Cache-Control"="no-cache"; } | iex
```

(from https://www.reddit.com/r/PowerShell/comments/8qd9sm/invokewebrequest_pulling_stale_data_from_github/e0ialgd/)

# Intune
This collection of scripts are used within Intune packages to handle automated provisioning for @onemoregame.com AAD domain member computers. Any time we change the contents of these scripts we must re-generate the Intune packages containing them and upload the updated versions to Intune.

## Rebuilding Intune packages
Use the `make-intune-<module>` make commands to rebuild intune packages. This will create .intunewin files in the ./intune subdirectory.

## URLs
Intune packages updated via Make can be uploaded at the following Intune endpoints.

intune/PS_lib.intunewin        : https://endpoint.microsoft.com/#blade/Microsoft_Intune_Apps/SettingsMenu/2/appId/fbcf8019-96bc-4a22-8095-468762a8995b
intune/PS_bootstrap.intunewin  : https://endpoint.microsoft.com/#blade/Microsoft_Intune_Apps/SettingsMenu/2/appId/9687a2ba-ae27-40f0-8e4b-efee9ff14032
intune/PS_developer.intunewin  : https://endpoint.microsoft.com/#blade/Microsoft_Intune_Apps/SettingsMenu/2/appId/7c7a8a24-610d-4151-a45b-878d2fcdce3e
intune/PS_programmer.intunewin : https://endpoint.microsoft.com/#blade/Microsoft_Intune_Apps/SettingsMenu/2/appId/bb89067e-a95a-409e-9c11-3cd00accd5a0

repository: PlayOneMoreGame/computer-setup

gha_language: PowerShell

repo_name: PlayOneMoreGame/computer-setup


text:
### [CVE-2019-10779](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-10779)
![](https://img.shields.io/static/v1?label=Product&message=stroom%3Astroom-app&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=Cross-site%20Scripting&color=brighgreen)

### Description

All versions of stroom:stroom-app before 5.5.12 and all versions of the 6.0.0 branch before 6.0.25 are affected by Cross-site Scripting. An attacker website is able to load the Stroom UI into a hidden iframe. Using that iframe, the attacker site can issue commands to the Stroom UI via an XSS vulnerability to take full control of the Stroom UI on behalf of the logged-in user.

### POC

#### Reference
- https://snyk.io/vuln/SNYK-JAVA-STROOM-541182

#### Github
- https://github.com/ARPSyndicate/cvemon
- https://github.com/RepublicR0K/CVE-2019-10779
- https://github.com/developer3000S/PoC-in-GitHub
- https://github.com/hectorgie/PoC-in-GitHub

repository: trickest/cve

repo_name: trickest/cve


text:
# SoapySDR.jl

This is a Julia wrapper for [SoapySDR](https://github.com/pothosware/SoapySDR/wiki) to enable SDR processing in Julia.
It features a high level interface to interact with underlying SDR radios.

# QuickStart

These examples assume that the SDR is an xtrx and that it is the only
device attached. Subsitute the driver for your SDR and check settings
as appropriate.

TX:
```
# Open first TX-capable channel on first device
channel = Devices()[1].tx[1]

# Configure channel with appropriate parameters
channel.bandwidth = 800u"kHz"
channel.frequency = 30u"MHz"
channel.gain = 42u"dB"
channel.sample_rate = 2.1u"MHz"

# Open a (potentially multichannel) stream on this channel
stream = SoapySDR.Stream(ComplexF32, [channel])
SoapySDR.activate!(stream)

# Write out random noise
Base.write(stream, (randn(ComplexF32, 10000),))
```

RX:
```
# Open first RX-capable channel on first device
channel = Devices()[1].tx[1]

# Configure channel with appropriate parameters
channel.bandwidth = 800u"kHz"
channel.frequency = 30u"MHz"
channel.gain = 42u"dB"
channel.sample_rate = 2.1u"MHz"

# Open a (potentially multichannel) stream on this channel
stream = SoapySDR.Stream(ComplexF32, [channel])
SoapySDR.activate!(stream)

# Collect data
Base.read(stream, 10000)
```

# API Guide

The entry point of this package is the Devices() object, which will list
all devices known to SoapySDR on the current system. Note that you may
also have to load a driver for your particular SDR in order to register
it with SoapySDR. Here we will use XTRX:

```
julia> using SoapySDR, xtrx_jll

julia> Devices()
[1] :addr => "pcie:///dev/xtrx0", :dev => "pcie:///dev/xtrx0", :driver => "xtrx", :label => "XTRX: pcie:///dev/xtrx0 (10Gbit)", :media => "PCIe", :module => "SoapyXTRX", :name => "XTRX", :serial => "", :type => "xtrx"
```

Devices may be selected ust by indexing:
```
julia> device = Devices()[1]
21:11:54.675118 DEBUG:  xtrxllpciev0_discovery:264 [PCIE] pcie: Found `pcie:///dev/xtrx0`
21:11:54.688916 DEBUG:  xtrxllpciev0_discovery:264 [PCIE] pcie: Found `pcie:///dev/xtrx0`
[INFO] Make connection: 'pcie:///dev/xtrx0'
21:11:54.688990 INFO:   [XTRX] xtrx_open(): dev[0]='pcie:///dev/xtrx0'
21:11:54.689031 INFO:   [CTRL] PCI:/dev/xtrx0: RFIC_GPIO 0x000300
21:11:54.706207 INFO:   [CTRL] PCI:/dev/xtrx0: XTRX Rev4 (04000113)
21:11:54.706246 INFO:   [BPCI] PCI:/dev/xtrx0: RX DMA STOP MIMO (BLK:0 TS:0); TX DMA STOP MIMO @0.0
21:11:54.706251 INFO:   [PCIE] PCI:/dev/xtrx0: Device `pcie:///dev/xtrx0` has been opened successfully
CPU Features: SSE2+ SSE4.1+ AVX+ FMA+
21:11:54.820272 INFO:   [CTRL] PCI:/dev/xtrx0: RFIC_GPIO 0x000304
21:11:54.920458 INFO:   [CTRL] PCI:/dev/xtrx0: FPGA V_GPIO set to 3280mV
21:11:54.920509 INFO:   [CTRL] PCI:/dev/xtrx0: LMS PMIC DCDC out set to VA18=1880mV VA14=1480mV VA12=1340mV
21:11:54.924038 INFO:   [CTRL] PCI:/dev/xtrx0: FPGA V_IO set to 1800mV
21:11:54.934544 INFO:   [CTRL] PCI:/dev/xtrx0: RFIC_GPIO 0x000306
21:11:54.945459 INFO:   [LSM7] PCI:/dev/xtrx0: LMS VER:7 REV:1 MASK:1 (3841)
21:11:54.945515 INFO:   [CTRL] PCI:/dev/xtrx0: RFIC_GPIO 0x00031e
[INFO] Created: `pcie:///dev/xtrx0`
SoapySDR xtrxdev device (driver: xtrxsoapy) w/ 2 TX channels and 2 RX channels
```

The channels on the device are then available on the resulting object
```
julia> device.tx
2-element SoapySDR.ChannelList:
 Channel(xtrxdev, Tx, 0)
 Channel(xtrxdev, Tx, 1)

julia> device.rx
2-element SoapySDR.ChannelList:
 Channel(xtrxdev, Rx, 0)
 Channel(xtrxdev, Rx, 1)

julia> device.tx[1]
TX Channel #1 on xtrxdev
  Selected Antenna [TXH, TXW]: TXW
  Bandwidth [ 800 kHz .. 16 MHz, 28..60 MHz ]: 0.0 Hz
  Frequency [ 30 MHz .. 3.8 GHz ]: 0.0 Hz
    RF [ 30 MHz .. 3.8 GHz ]: 0.0 Hz
    BB [ -00..00 Hz ]: 0.0 Hz
  Gain [0.0 dB .. 52.0 dB]: 0.0 dB
    PAD [0.0 dB .. 52.0 dB]: 0.0 dB
  Sample Rate [ 2.1..56.2 MHz, 61.4..80 MHz ]: 0.0 Hz
  DC offset correction: (0.0, 0.0)
  IQ balance correction: (0.0, 0.0)
```

To send or receive data, start a stream on a particular channel:
```
julia> stream = SDRStream(ComplexF32, [device.rx[1]])
21:15:44.166249 INFO:   [BPCI] PCI:/dev/xtrx0: RX DMA STOP MIMO (BLK:0 TS:0); TX DMA SKIP MIMO @0.0
21:15:44.166307 INFO:   [LSM7] PCI:/dev/xtrx0: 0x0124[00, 00]
21:15:44.166759 INFO:   [BPCI] PCI:/dev/xtrx0: RX DMA STOP MIMO (BLK:0 TS:0); TX DMA SKIP MIMO @0.0
21:15:44.166769 INFO:   [LMSF] PCI:/dev/xtrx0: Auto RX band selection: LNAL
21:15:44.166772 INFO:   [LMSF] PCI:/dev/xtrx0: Set RX band to 2 (L)
21:15:44.166971 INFO:   [CTRL] PCI:/dev/xtrx0: RX_ANT: 1 TX_ANT: 0
21:15:44.166973 INFO:   [LMSF] PCI:/dev/xtrx0: DC START
21:15:44.167022 INFO:   [LSM7] PCI:/dev/xtrx0:  5c1=0000
21:15:44.167039 INFO:   [LSM7] PCI:/dev/xtrx0:  5c1=0000
21:15:44.167056 INFO:   [LSM7] PCI:/dev/xtrx0:  5c1=0000
21:15:44.167099 INFO:   [LSM7] PCI:/dev/xtrx0:  5c1=0000
21:15:44.167116 INFO:   [LSM7] PCI:/dev/xtrx0:  5c1=0000
21:15:44.167147 INFO:   [LSM7] PCI:/dev/xtrx0:  5c1=0000
21:15:44.167187 INFO:   [LSM7] PCI:/dev/xtrx0:  5c1=0000
21:15:44.167206 INFO:   [LSM7] PCI:/dev/xtrx0:  5c1=0000
21:15:44.167236 INFO:   [LSM7] PCI:/dev/xtrx0:  5c1=0000
21:15:44.167268 INFO:   [LSM7] PCI:/dev/xtrx0:  5c1=0000
21:15:44.167335 INFO:   [LSM7] PCI:/dev/xtrx0:  TX[0]=0000
21:15:44.167416 INFO:   [LSM7] PCI:/dev/xtrx0:  TX[1]=0000
21:15:44.167506 INFO:   [LSM7] PCI:/dev/xtrx0:  TX[2]=0000
21:15:44.167573 INFO:   [LSM7] PCI:/dev/xtrx0:  TX[3]=0000
21:15:44.167621 INFO:   [LSM7] PCI:/dev/xtrx0:  RX[0]=0000
21:15:44.167671 INFO:   [LSM7] PCI:/dev/xtrx0:  RX[1]=0000
21:15:44.167719 INFO:   [LSM7] PCI:/dev/xtrx0:  RX[2]=0000
21:15:44.167777 INFO:   [LSM7] PCI:/dev/xtrx0:  RX[3]=0000
Stream on xtrxdev
```

These may then be accessed using standard IO functions:
```
julia> SoapySDR.activate!(stream)

julia> Base.read(stream, 10_000)
```


text:
# docker-tcpdump
Docker scripts to build an image to run tcpdump

https://github.com/moncho/docker-tcpdump
https://husobee.github.io/http/tcpdump/docker/2016/11/30/troubleshooting-http-docker-tcpdump.html
https://hub.docker.com/r/kaazing/tcpdump/~/dockerfile/
https://blog.cpanel.com/the_admins_toolbox_vol_1_-_tcpdump_and_you/
https://danielmiessler.com/study/tcpdump/
https://hub.docker.com/r/kaazing/tcpdump/
https://hub.docker.com/r/kaazing/tcpdump/
https://jerrygamblin.com/2016/05/28/a-docker-container-to-capture-all-traffic-from-host/
https://github.com/manell/wireshark

repository: oehrlis/docker-tcpdump

repo_name: oehrlis/docker-tcpdump