text:
---
title: Greg Maxwell - Replacing PGP (2020-11-25)
speaker: Greg Maxwell
transcript_by: Michael Folkson
---

Name: Greg Maxwell

Topic: Replacing PGP with Bitcoin public key infrastructure

Location: Reddit

Date: November 25th 2020

https://www.reddit.com/r/Bitcoin/comments/k0rnq8/pgp_is_replaceable_with_the_bitcoin_public_key/gdjv1dn?utm_source=share&utm_medium=web2x&context=3

# Is PGP replaceable with Bitcoin public key infrastructure?

This is true in the same sense that PGP can also be replaced with some fancy functions on a school kids graphing calculator.

Yes you can construct some half-assed imitation of pgp using stuff from Bitcoin, but you probably shouldn't.

If all you really want is some file signing thing without any key certification or encryption, I suggest looking into openbsd's signify. Bitcoin is not a buzzword.

PGP does vastly more than just sign a file with a key and verify it. If that is all you need to do then PGP is indeed overkill, but the alternative you should probably consider is a tool made for that purpose, such as "signify".

Using Bitcoin because bitcoin just feels like buzzword following to me.

PGP addresses many things that aren't addressed by narrow tools. For example, PGP does both symmetric and asymmetric encryption. PGP manages key rings (tracking whos keys are who). PGP manages key authentication (how do you know the key you are using is a real one, not an imposter), PGP can encode binary messages to cross non-binary clear channels, and so on.

Bitcoin's message signing was a mostly informal tool created for some narrow purposes where holders of bitcoin needed to sign short messages connected to those Bitcoin. Sure, you can apply it more broadly, but there are tools made for that.

The original message signing is slowly drifting into unmaintained status -- in part because it can't serve its original purpose anymore because just signing with a single key means it can't reflect modern coin ownership. There are [newer proposals](https://github.com/bitcoin/bips/blob/master/bip-0322.mediawiki) that import all of Bitcoin script for their signing, restoring the original intent of the signmessage. But those tools will be less well suited for "sign some file" purposes.

repository: ottosch/bitcointranscripts

repo_name: ottosch/bitcointranscripts


text:
# We are Collecting Failures

If you find a colorization failure, it can be helpful to us that you upload the sketch and your reference image [here](https://github.com/lllyasviel/style2paints/issues/7).

For example, the hair in this image is blured and colored not so well.

<img src="https://raw.githubusercontent.com/lllyasviel/style2paints/master/images/9.jpg"/>

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# custom-terraform-provider-

- Followed this [tutorial](https://learn.hashicorp.com/tutorials/terraform/provider-setup?in=terraform/providers)
- Check all the branches to see the step by step process

## Intuitions

- Terraform searches for plugins in the format of `terraform-<TYPE>-<NAME>`  // remember this one, your binary should be in this convention always
- Here, the plugin is of type "provider" and of name "articleserver".
- To verify things are working correctly, execute the recently created binary, by:
    - `go build -o terraform-provider-articleserver`
    - `./terraform-provider-articleserver`
- All Terraform resources must have a schema. This allows the provider to map the JSON response to the schema.
- Format go code by `go fmt ./...`
- Now that you’ve implemented read and created the articles data source, verify that it works.
    - First, confirm that you are in the root directory of this project
    - `go build .`
    - Create the appropriate subdirectory within the user plugins directory for the articleserver provider if it doesn't exist already:
        - `mkdir -p ~/.terraform.d/plugins/hashicorp.com/edu/articleserver/0.2/linux_amd64`
    - Next, move the binary to the appropriate subdirectory within your user plugins directory:
        - `mv terraform-provider-articleserver ~/.terraform.d/plugins/hashicorp.com/edu/articleserver/0.2/linux_amd64`
- Navigate to the `custom-terraform-provider-articleserver/examples` directory. Here you can use your custom provider by terraform

# Related Resources

- [ ] [Source Addresses](https://www.terraform.io/docs/language/providers/requirements.html#source-addresses)
- [ ] [Provider Requirements](https://www.terraform.io/docs/language/providers/requirements.html)
- [x] [Creating a Terraform Provider for Just About Anything](https://www.youtube.com/watch?v=noxwUVet5RE)
- [x] [101 - Getting started with Terraform and Custom Providers](https://www.youtube.com/watch?v=G1pdNwwYXzk)

branch_name: refs/heads/main

gha_language: Go


text:
# Driver's License Number Encoder

## About

Up until [as recently as 2018](https://www.king5.com/article/news/local/washington-drivers-license-numbers-change-tuesday/281-587296223), Washington state issued driver's license numbers based on the driver's name and birthdate. The algorithm was widely known and had the potential for abuse: if you knew someone's full name and date of birth, you could get their license number! Thankfully, it's now a secure randomly generated number, but let's use their algorithm as a basis for [exploring some concepts in JavaScript](https://drive.google.com/file/d/1FrzGH4SMEscvGplEMh_CRChfsR2vVReI/view?usp=sharing)!

## Getting started

This repository contains a very simple web page. It doesn't work right now, but by the end of the lesson, you will have a functioning drivers license number encoder!

1. To download the source code, find "Download ZIP" in the "Code" dropdown.

2. Extract your zip file into your working folder -- `C://source/dln-encoder-main`.

3. If you don't already have a preferred text editor, download Visual Studio Code for your machine [here](https://code.visualstudio.com/download).

4. Use your text editor to open the `dln-encoder-main` folder.

5. Open a web browser (you will be using this for verifying your work throughout the lesson).

6. Type the location of your index file `C://source/dln-encoder-main/src/index.html` into the browser.

7. Make sure you can see a form with name and birthday input, and a "submit" button. (Don't panic! Your submit button shouldn't do anything yet. :) )

8. Use your knowledge of javascript to fill in the stubbed methods in `src/index.html`.

## The Algorithm

Thankfully, since Marist college [published the algorithm](http://web.archive.org/web/20061206063841/http://www.academic.marist.edu/mwa/wsdln.htm) long ago, we do not have to derive this algorithm ourselves!

Here is what they found:

1) The first five characters are the first five letters of the individual's surname (last name). If an individual's last name contains 4 or fewer letters, the symbol * is used to fill in the remaining spaces.
2) The sixth character is the individual's first initial.
3) The seventh character is the individual's middle initial. The symbol * is used if an individual does not have a middle name.
4) The next two characters are obtained by computing subtracting the individual's year-of-birth (YOB) from 100. In other words, 100 - YOB.
5) The tenth character is the [check digit](#The-Check-Digit-Scheme). (To be calculated after all other characters are found.)
6) The eleventh character is the month-of-birth code. It assigns a character according to the code presented in the table below. (The alternate codes are used to avoid collisions in the case two individuals end up with the same driver's license number -- but don't worry about this during our lesson today!)

|Month|Code|Alternate Code|
|---------|-----|---------------|
|January|B|S|
|February|C|T|
|March|D|U|
|April|J|1|
|May|K|2|
|June|L|3|
|July|M|4|
|August|N|5|
|Septebmer|O|6|
|October|P|7|
|November|Q|8|
|December|R|9|

7) The last character is the code for the day of the month on which the individaul was born. The day-of-month-born code is presented in the table below.

|Day|Code|
|---|----|
|1|A|
|2|B|
|3|C|
|4|D|
|5|E|
|6|F|
|7|G|
|8|H|
|9|Z|
|10|S|
|11|J|
|12|K|
|13|L|
|14|M|
|15|N|
|16|W|
|17|P|
|18|Q|
|19|R|
|20|O|
|21|1|
|22|2|
|23|3|
|24|4|
|25|5|
|26|2|
|27|7|
|28|8|
|29|9|
|30|T|
|31|U|

## The Check Digit Scheme

Consider the twelve character driver's license number a1a2a3a4a5a6a7a8a9a10a11a12.

The check digit a10 is created by first assigning digits to the non-digit characters in the identification number using the table below and then performing the following calculation:

a10 = |a1-a2+a3-a4+a5-a6+a7-a8+a9-a11+a12| (mod 10)

|Character|Digit|
|---------|----|
|*|0|
|A|1|
|B|2|
|C|3|
|D|4|
|E|5|
|F|6|
|G|7|
|H|8|
|I|9|
|J|1|
|K|2|
|L|3|
|M|4|
|N|5|
|O|6|
|P|7|
|Q|8|
|R|9|
|S|2|
|T|3|
|U|4|
|V|5|
|W|6|
|X|7|
|Y|8|
|Z|9|

## Examples
|Driver Information|License Number|
|---|---|
|Joseph Marshall Pollan: October 19, 1970|POLLAJM304PR|
|Tracy Holland: April 25, 1945|HOLLAT*554J5|
|Alexander William Moe: July 4, 1976|MOE**AW240MD|

## The Key
https://github.com/j-f-zhang/dln-encoder-key

license: MIT

repository: j-f-zhang/dln-encoder

repo_name: j-f-zhang/dln-encoder


text:
# geroz

geroz-e wraps `exec.Cmd` and allows user to propagate signals to the underlying process with ease.

## Usage

The following example is the simplest signal propagator.

```go
import (
    "log"
    "os"

    "github.com/kyslik/geroz"
)

func main() {
    // initialize command `*exec.Cmd`
    c, e := geroz.NewCommand()
    if e != nil {
        log.Fatalf("failed to initialize command: %v\n", e)
    }

    // start `c`
    c, e = geroz.StartCommand(c)
    if e != nil {
        log.Fatalf("failed to start command: %v\n", e)
    }

    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    // set up propagating signals to the process `c`
    go geroz.PropagateSignals(ctx, c)

    // wait for the process to exit (blocking)
    _, e := geroz.WaitCommand(c)
    if e != nil {
        log.Fatalf("failed to wait for command to finish: %w\n", e)
    }
}
```

For more examples see directory [examples](./examples).

## TODO

- [ ] make a test pass when using `go test -race`
- [ ] implement catching zombie processes - <https://github.com/ramr/go-reaper>

repository: Kyslik/geroz

repo_name: Kyslik/geroz


text:
# Minimizing Bundle Size

For convenience, React Router exposes its full API on the top-level `react-router` import. However, this causes the entire React Router library and its dependencies to be included in client bundles that include code that makes any imports from the top-level CommonJS bundle.

There are two options for minimizing client bundle size by excluding unused modules.

## Import from `react-router/lib`

Bindings exported from `react-router` are also available in `react-router/lib`. When using CommonJS models, you can import directly from `react-router/lib` to avoid pulling in unused modules.

Assuming you are transpiling ES2015 modules into CommonJS modules, instead of

```js
import { Link, Route, Router } from 'react-router'
```

use

```js
import Link from 'react-router/lib/Link'
import Route from 'react-router/lib/Route'
import Router from 'react-router/lib/Router'
```

The public API available in this manner is defined as the set of imports available from the top-level `react-router` module. Anything not available through the top-level `react-router` module is a private API, and is subject to change without notice.

## Use a Bundler with ES2015 Module Support

React Router offers a ES2015 module build under `es6/` and defines a `jsnext:main` entry point. If you are using a bundler that supports ES2015 modules and tree-shaking such as webpack 2 or Rollup, you can directly import from `react-router`, as long as you are correctly resolving to the ES2015 module build.

gha_language: JavaScript

gha_license_id: MIT


text:
# Apple Dictionary Tools
Tools for extracting data from Apple dictionary files (used by the Dictionary application).
**Note:** I have a bit more info in my recent blog post: [Progress on accessing data from Apple Dictionaries](https://jadedtuna.github.io/apple-dictionary/)

# Usage
General usage would be to first compile the code with `make` and then run

`./dedict path/to/Body.data | ./strip | ./checkxml.py > dictionary.xml`

or if you want to convert it to sqlite3 database directly

`./dedict path/to/Body.data | ./strip | ./checkxml.py | ./appledict2sqlite3.py`

which will create a file called `dictionary.db`. The sizes can vary, but on my
machine I got ~192MB for dictionary.xml and ~250MB dictionary.db. These tools have
been tested only with the New Oxford American Dictionary but they should work without
any problems with other dictionaries.

# Code
Some of the code has been taken from https://gist.github.com/josephg/5e134adf70760ee7e49d
and modified to fix errors and make it more useful.

repository: JadedTuna/apple-dictionary

gha_language: C

repo_name: JadedTuna/apple-dictionary


text:
# Hanoi Demo

This demo shows the Hanoi release of EdgeX with the following devices:

- Comet Systems T0310 temperature probe (Modbus RTU)
- Patlite Signal Tower (SNMP)
- Moisture sensor

*The device services customizations are included with this demo.  See the original device service repositories (below) for updates to the device service code*

- [Device Service Modbus](https://github.com/edgexfoundry/device-modbus-go)
- [Device Service SNMP](https://github.com/edgexfoundry/device-snmp-go)
- [Device Service GPIO Moisture](https://github.com/jpwhitemn/device-gpio-moist-go)

It also demonstrates getting data to InfluxDB (via MQTT and Telegraf) for visual display.  This requires a custom application service to get export the EdgeX sensor data out into InfluxDB line protocol format and sent to an MQTT topic where it is picked up by Telegraf and inserted into InfluxDB.

![image](./app-service-influx.png)

*The custom application service code is available at the original repository below*

- [Application Service InfluxDB export](https://github.com/jpwhitemn/app-service-influx)

## Starting

To run the demo, perform the following operations:

1. Start Mosquitto Broker (mosquitto -c *your config path/file*)
2. Start InfluxDB and Telegraf
3. Start EdgeX (Hanoi) using Docker Compose (docker-compose up -d in the ./compose/ folder). This Compose file has been modified for this demo (removal of security protections and non-use device services)
4. Start the device services and app service running on the same host using the start.sh script in this directory
5. Start the moisture device service running on a Raspberry Pi 3
6. Configure the rules on a new install/start

To stop the demo, perform the following operations:
1. Stop the device services and application service
2. Stope EdgeX using Docker Compose (docker-compose down in the ./compose/ folder)
3. Optionally stop Mosquitto, Telegraf and InfluxDB

## Rules Setup

### Create the stream

Send the following POST to the Kuiper Rules Engine
<IP_ADDRESS>:48075/streams (with content type set to application/json)

``` JSON
	{
	  "sql": "create stream watches() WITH (FORMAT=\"JSON\", TYPE=\"edgex\")"
	}
```

### Create the rules to monitor the temperature probe and control the Patlite Red Light

**Create the rule to turn on the patlite**

Send the following POST to the Kuiper Rules Engine (replace command IDs as appropriate).

``` JSON

	{
	  "id": "probe-out-of-position",
	  "sql": "SELECT ProbeTemperature FROM watches WHERE ProbeTemperature < 900",
	  "actions": [
	    {
	      "rest": {
	        "url": "http://edgex-core-command:48082/api/v1/device/c4bfef8c-273f-414b-9481-c2ad5e801d15/command/66046772-d3e6-45b4-a267-bf71354a26c3",
	        "method": "put",
	        "retryInterval": -1,
	        "dataTemplate": "{\"RedLightControlState\":\"2\",\"RedLightTimer\":\"0\"}",
	        "sendSingle": true
	      }
	    },
	    {
	      "log":{}
	    }
	  ]
	}

```

**Create the rule to turn off the patlite**

Send the following POST to the Kuiper Rules Engine (replace command IDs as appropriate).

``` JSON
	{
	  "id": "probe-in-position",
	  "sql": "SELECT ProbeTemperature FROM watches WHERE ProbeTemperature >= 900",
	  "actions": [
	    {
	      "rest": {
	        "url": "http://edgex-core-command:48082/api/v1/device/c4bfef8c-273f-414b-9481-c2ad5e801d15/command/66046772-d3e6-45b4-a267-bf71354a26c3",
	        "method": "put",
	        "retryInterval": -1,
	        "dataTemplate": "{\"RedLightControlState\":\"1\",\"RedLightTimer\":\"0\"}",
	        "sendSingle": true
	      }
	    },
	    {
	      "log":{}
	    }
	  ]
	}
```

### Create the rules to monitor the moisture sensor and control the Patlite Amber (yellow) Light

**Create the rule to turn off the patlite**

Send the following POST to the Kuiper Rules Engine (replace command IDs as appropriate).

``` JSON
	{
	"id": "moisture-not-detected",
	"sql": "SELECT MoistureState FROM watches WHERE MoistureState < 1",
	"actions": [
		{
		"rest": {
			"url": "http://edgex-core-command:48082/api/v1/device/c4bfef8c-273f-414b-9481-c2ad5e801d15/command/f5f7b4ad-74ab-4f02-a341-e384646ae250",
			"method": "put",
			"retryInterval": -1,
			"dataTemplate": "{\"AmberLightControlState\":\"1\",\"AmberLightTimer\":\"0\"}",
			"sendSingle": true
		}
		},
		{
		"log":{}
		}
	]
	}
```

**Create the rule to turn on the patlite**

Send the following POST to the Kuiper Rules Engine (replace command IDs as appropriate).

``` JSON
	{
	"id": "moisture-detected",
	"sql": "SELECT MoistureState FROM watches WHERE MoistureState >= 1",
	"actions": [
		{
		"rest": {
			"url": "http://edgex-core-command:48082/api/v1/device/c4bfef8c-273f-414b-9481-c2ad5e801d15/command/f5f7b4ad-74ab-4f02-a341-e384646ae250",
			"method": "put",
			"retryInterval": -1,
			"dataTemplate": "{\"AmberLightControlState\":\"2\",\"AmberLightTimer\":\"0\"}",
			"sendSingle": true
		}
		},
		{
		"log":{}
		}
	]
	}
```

## Setup the export

Export to a Mosquitto Topic (in this case on another server).
1. Install Mosquitto
2. Configure Mosquitto to receive messages from off box (outside localhost)
	```
		# in a special edgex.conf in /etc/mosquitto/conf.d
		per_listener_settings true

		port 1883

		listener 1884
		allow_anonymous true
		#password_file /etc/mosquitto/conf.d/passwords.txt
	```
3. Add a passwords.txt to /etc/mosquitto/conf.d and use mosquitto's passwd encryption tool to encrypt
4. Add an application configuration service to the compose file (using MQTT Profile), and provide overrides to the standard configuration (values subject to your configuration/users/etc.)
``` yml
	environment:
	BINDING_PUBLISHTOPIC: events
	CLIENTS_COMMAND_HOST: edgex-core-command
	CLIENTS_COREDATA_HOST: edgex-core-data
	CLIENTS_DATA_HOST: edgex-core-data
	CLIENTS_METADATA_HOST: edgex-core-metadata
	CLIENTS_NOTIFICATIONS_HOST: edgex-support-notifications
	CLIENTS_RULESENGINE_HOST: edgex-kuiper
	CLIENTS_SCHEDULER_HOST: edgex-support-scheduler
	CLIENTS_VIRTUALDEVICE_HOST: edgex-device-virtual
	DATABASES_PRIMARY_HOST: edgex-redis
	EDGEX_PROFILE: mqtt-export
	EDGEX_SECURITY_SECRET_STORE: "false"
	MESSAGEBUS_SUBSCRIBEHOST_HOST: edgex-core-data
	REGISTRY_HOST: edgex-core-consul
	SERVICE_HOST: edgex-app-service-configurable-mqtt
	SERVICE_PORT: 48101
	Writable_Pipeline_Functions_MQTTSend_Addressable_Address: <IP_ADDRESS>
	Writable_Pipeline_Functions_MQTTSend_Addressable_Port: 1884
	Writable_Pipeline_Functions_MQTTSend_Addressable_Protocol: tcp
	Writable_Pipeline_Functions_MQTTSend_Addressable_Topic: edgex/EdgeXEvents
```

repository: jpwhitemn/EdgeXHanoiDemo

repo_name: jpwhitemn/EdgeXHanoiDemo


text:
# I've purchased an Akko keyboard and will be using that in my Linux environment from now on. I will continue to maintain the repo but should something happen, I'm unlikely to notice. Make sure to submit PRs with descriptions of the issue!
---

# Enable Function Keys On The Keychron K2 Mechanical Keyboard Under Linux

Below, you'll find the steps required to create a systemd command that will run at boot to disable the media keys and restore f1-f12 functionality.

## Step 1

Open a terminal window and enter the following command:

`sudo nano /etc/systemd/system/keychron.service`

## Step 2

Paste the following into the window:

```
[Unit]
Description=The command to make the Keychron K2 work

[Service]
Type=oneshot
ExecStart=/bin/bash -c "echo 0 > /sys/module/hid_apple/parameters/fnmode"

[Install]
WantedBy=multi-user.target
```

Press `ctrl+o` and then `ctrl+x` to exit.

## Step 3

In the terminal, type the following:

`systemctl enable keychron`

## Step 4

That's it! A reboot, and you'll see that the function keys have been re-enabled.
Alternatively, run this command to see the changes right away:
`systemctl start keychron`

## Closing Remarks

If you want to simply drag/drop the file that you create manually in the steps provided, I have it under the scripts folder in this repo. Download it and drop it in `/etc/systemd/system/`, doing Step 3 at the end.


text:
---
layout: work
title: Beam bench
date: 2021-09-30
description: Bench style seating in ash or walnut with a natural wax/oil finish, stainless steel fittings and rescued leather cover by Elvis & Kresse. Ideal for the modern home.
tags:
  - work
  - elvis & Kresse
  - matthewburt
type:
  - buy
retailer:
  - new art centre
  - elvis & kresse
  - matthew burt
  - jaggedart
menus:
  - work
  - toBuy
order: 60
stock: 4
stockdate: 2020-06-25
price:
awards:
  - The Furniture Makers’ Company, Bespoke Guild Mark no. 250
design-date: 1999-01-01
summary: Bench style seating with Elvis & Kresse rescued leather cover.
social: beam bench seating
houzzcategory: Upholstered Benches
storeprice:
  - type:
    cost: 3,000
thumbnail: //images.quru.com/image?src=/kwf/KWFBeamBench/Katie%20Walker%20Furniture%20-%20Beam%20Bench.jpg&right=0.67188&left=0.0625&top=0.05093&bottom=0.9537&width=175&height=175&fill=auto
headimage: //images.quru.com/image?src=kwf/KWFBeamBench/Katie%20Walker%20Furniture%20-%20Beam%20Bench.jpg
stripimage: //images.quru.com/image?src=/kwf/KWFBeamBench2012.jpg&bottom=0.83568&top=0.25822&autocropfit=1&fill=auto
otherimages:
  - //images.quru.com/image?src=kwf/KWFBeamBench/KWF+Beam+Bench+-+ash+under.jpg
  - //images.quru.com/image?src=kwf/KWFBeamBench/KWF+Beam+Bench+-+ash.jpg
  - //images.quru.com/image?src=kwf/KWFBeamBench/KWF+Beam+Bench+-+cover+detail.jpg
  - //images.quru.com/image?src=kwf/KWFBeamBench/KWF+Beam+Bench+-+leather+details.jpg
  - //images.quru.com/image?src=kwf/KWFBeamBench/KWF+Beam+Bench+-+walnut+end.jpg
  - //images.quru.com/image?src=kwf/KWFBeamBench/KWF+Beam+Bench+-+at+Tonge.jpg
style: red
---
_1370mm long x 500mm wide x 460mm high. (54” x 19¾” x 18”)_

Bench style seating available in ash or walnut with a natural wax/oil finish, stainless steel fittings and rescued leather cover by Elvis & Kresse.

Price with leather cover as shown, leather available in three colourways - Black, Caramel or Shiraz. Other fabrics/leather covers also available subject to a variation in price.

Other woods, sizes and finishes can be made to order.

This piece was awarded The Furniture Makers’ Company, Bespoke Guild Mark no. 250.

The Beam bench is part of the Beam range. Its structure relies on the central beam to both hold the inner legs and connect the inner legs with the outer legs giving it a lighter more playful feel. Originally conceived for gallery seating, Beam Bench is sized for a domestic setting – hallway seating and at the foot of the bed are popular positions. The lightness of its curves and the playfulness of the jointing are now further highlighted by the modular, rescued leather covering added by Elvis & Kresse. The leather cover is held in place by removable stainless steel tubes making it easy to change the cover, swapping colourways with the seasons.

In 2005 Kresse Wesling had a chance meeting with the London Fire Brigade and a very emotional response to their damaged, decommissioned fire hose. It was too heroic and too beautiful for landfill. Somebody had to do something, and those somebodies were Elvis & Kresse (Kresse and her partner James ‘aka Elvis’ Henrit).

They mounted a rescue, and over the last 15 years have saved all of London’s hoses, transforming them into a range of luxury accessories and donating 50% of the profits to the Fire Fighters Charity. From the first day Elvis & Kresse had a unique DNA: rescue, transform, donate.

They are now tackling their greatest ever challenge, the 800,000 tonnes of leather off-cuts generated each year by the global leather industry. Even when the patterns for leather goods are carefully planned to maximise the hides, the process inevitably creates small off cuts. These are high quality, unused, freshly tanned and dyed leather, but fall to the workshop floor as seemingly unusable pieces. Elvis & Kresse has designed a system that transforms these fragments into components, which are then hand woven into a new kind of hide that is unrestricted by size or shape.


text:
# Diabetes

(From Wikipedia) Diabetes mellitus (DM), commonly known as diabetes, is a group of metabolic disorders characterized by high blood sugar levels over a prolonged period. Symptoms of high blood sugar include frequent urination, increased thirst, and increased hunger. If left untreated, diabetes can cause many complications. Acute complications can include diabetic ketoacidosis, hyperosmolar hyperglycemic state, or death. Serious long-term complications include cardiovascular disease, stroke, chronic kidney disease, foot ulcers, and damage to the eyes.

## Therapeutic Areas

* Diabetes

## Tags

* None

repository: himschoota/PhenotypeLibrary

path: /OHDSI Gold Standard Phenotype Library/Books/Diabetes/README.md

repo_name: himschoota/PhenotypeLibrary


text:
## Contributing

We expect contributors to abide by our underlying
[code of conduct](https://github.com/twimbit/Monday-Wordpress-Integration/blob/master/CODE_OF_CONDUCT.md). All conversations and discussions on GitHub (issues, pull requests) must be respectful and harassment-free.

If you feel another member of the community has violated our Code of Conduct, you may anonymously contact the team https://twimbit.typeform.com/to/M4MlG5uy.

Remember that communication is the lifeblood of any Open Source project. We are all working on this together, and we are all benefiting from this software. It's very easy to misunderstand one another over asynchronous, text-based
conversations: When in doubt, assume everyone within this project has the best intentions.

We are all humans trying to work together to improve the community. Always be kind and appreciate the need for trade-offs. ❤

Before making your first pull request or issue, give our this a full read:

## Contributing to Monday Wordpress integration project

We expect contributors to abide by our underlying [code of conduct](https://github.com/twimbit/Monday-Wordpress-Integration/blob/master/CODE_OF_CONDUCT.md). All discussions about this project must be respectful and harassment-free.

Remember that communication is the lifeblood of any Open Source project. We are all working on this together, and we are all benefiting from this software.

It's very easy to misunderstand one another in asynchronous, text-based conversations. When in doubt, assume everyone has the best intentions.

If you feel anyone has violated our Code of Conduct, you should anonymously contact the team with our [abuse report form.](https://twimbit.typeform.com/to/M4MlG5uy)

### Where to contribute
All [issues](https://github.com/twimbit/Monday-Wordpress-Integration/issues).

PRs without an associated issue may still be merged, but the core team will focus on changes that solve existing issues. We strongly encourage creating an issue before working on a PR!

When in doubt, ask a [core team member](https://github.com/twimbit/Monday-Wordpress-Integration/blob/master/README.md#Credits-) by mentioning us on the issue.

### How to contribute
- Fork the project and clone it to your local machine. Follow the installation guide!
- Create a branch with your GitHub username and the ID of the issue, for example: git checkout -b USERNAME/some-new-feature-1234
- Code and commit your changes. Bonus points if you write a good commit message: git commit -m 'Add some feature'
- Push to the branch: git push -u origin USERNAME/some-new-feature-1234
- Create a pull request for your branch. 🎉

## Contribution guidelines

### Create an issue

Nobody's perfect. Something doesn't work? Something could be better? Check to see if the issue already exists, and if it does, leave a comment to get our attention! If the issue doesn't already exist, feel free to create a new one. A core team member will triage incoming issues.

Please note: core team members may update the title of an issue to reflect the discussion.

### Create a pull request

- Try to keep the pull requests small. A pull request should try its very best to address only a single concern.
- For work in progress pull requests, please use the [Draft PR](https://github.blog/2019-02-14-introducing-draft-pull-requests/) feature.
- Make sure all tests pass and add additional tests for the code you submit.
- Document your reasoning behind the changes. Explain why you wrote the code in the way you did. The code should explain what it does.
- If there's an existing issue, reference to it by adding something like References/Closes/Fixes/Resolves #123, where 123 is the issue number. [More info here.](https://github.blog/2013-05-14-closing-issues-via-pull-requests/)
- Please fill out the PR Template when making a PR.
- All commits in a pull request will be squashed when merged.
Please note: a core team member may close your PR if it has gone stale or if we don't plan to merge the code.

### Pull request reviews

All community pull requests are reviewed by our core team.

- All contributors must sign the CLA.
- All required checks are expected to pass on each PR.
    - In the case of flaky or unrelated test failures, a core team member will restart CI.
- We require 2 approvals from core team members for each PR.
- Requested Changes must be resolved (with code or discussion) before merging.
- If you make changes to a PR, be sure to re-request a review.
- Style discussions are generally discouraged in PR reviews; make a PR to the linter configurations instead.
- Your code will be deployed shortly after it is merged.

### A note on "force pushing"
After you submit your pull request, one of the members of the core team will review your code.

Please avoid force pushing unless you need to rebase with the master branch.

If feedback is provided, any changes should be contained in new commits. Please don't force push or worry about squashing your commits.

Force pushing (despite being useful) has some drawbacks. GitHub doesn't always keep the review history, which results in lost context for the reviewers.

We squash every PR before merging, so there is no need to force push!

### The bottom line
We are all humans trying to work together to improve the community. Always be kind and appreciate the need for tradeoffs. ❤

repository: jenksed/Monday-Wordpress-Integration

repo_name: jenksed/Monday-Wordpress-Integration


text:
---
layout: "post.11ty.js"
title: "Around the Web – 201708118"
date: "2017-08-19"
tags:
  - "Around the Web"
  - "Blog"
  - "Lightning"
  - "Salesforce"
  - "SalesforceDeveloper"
  - "SalesforceDX"
slug: "around-web-201708118"
---

And now for somethings to read over the weekend, if you have some spare time that is.

## [Winter is coming! (To Lightning!) - Developer Relations](https://developer.salesforce.com/blogs/developer-relations/2017/08/winter-coming-lightning.html)

You know what they say — time flies when you're having fun! And we've been having a lot of fun since Lightning Experience launched two short years ago. This blog post covers several enhancements in the Winter '18 release which might affect…

## [Get Started with Salesforce DX! | Salesforce Developers](https://developer.salesforce.com/events/webinars/get-started-salesforce-dx)

VP, Product Management, Salesforce Salesforce DX is the modern way to manage and develop Salesforce apps across the entire lifecycle, and helps teams build together and deliver continuously. Whether you're an individual developer or working as part…

## [Visual Studio Code July 2017](https://code.visualstudio.com/updates/v1_15)

Welcome to the July 2017 release of Visual Studio Code. There are a number of significant updates in this version that we hope you will like, some of the key highlights include: Large file support - Improved performance for large files, no size…

## [Why you should work remotely](https://dev.to/gshotwell/why-you-should-work-remotely)

My last job was as a data scientist at Upworthy, which is a 100% remote company. Prior to starting the position I was worried about whether I could be happy and productive on a remote team. I wondered how project planning would work, whether it…

## [Lightning Best Practice: Adding Pagination to Lists](https://saramorgan.net/2017/08/13/lightning-best-practice-adding-pagination-to-lists/)

What happens to a Lightning Component that displays a list of data without pagination? It is probably doomed to suffer from performance problems and who wants to build a component that is doomed? Certainly not you, right? It's possible that…

## [Modern Application Development with Salesforce DX and AutoRABIT - Developer Relations](https://developer.salesforce.com/blogs/developer-relations/2017/06/tdx_autorabit.html?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A%20SforceBlog%20%28Salesforce%20Developers%20Blog%29)

Modern Application Development (MAD) is driven at its core by an integrated technology stack, DevOps enabled framework, and a cloud-and mobile-ready infrastructure. This blog post reviews MAD flows, and how AutoRABIT can help you quickly develop…

## [Announcing .NET Core 2.0](https://blogs.msdn.microsoft.com/dotnet/2017/08/14/announcing-net-core-2-0/)

.NET Core 2.0 is available today as a final release. You can start developing with it at the command line, in your favorite text editor, in Visual Studio 2017 15.3, Visual Studio Code or Visual Studio for Mac. It is ready for production workloads…

## [Summer '17: Lightning Updates](https://developer.salesforce.com/events/webinars/summer-17-lightning-updates)

The Summer '17 release opens up new possibilities for Salesforce development. In this webinar, we'll fire up the Developer Console and dive into topics including Lightning Data Service and standard overrides. As we love to live dangerously, we'll…

## [An In-Depth Look at Lightning Component Events - Developer Relations](https://developer.salesforce.com/blogs/developer-relations/2017/08/depth-look-lightning-component-events.html)

This post presents the specificities of Lightning component events (in opposition to application events). This event type is the most commonly used in the Lightning Component framework; yet, it's also the most complex. Few Lightning developers know…

## [Winter '18 Prerelease](https://www.salesforce.com/form/signup/prerelease-winter18-partner.jsp)

Winter ’18 Pre-Release (for Partners). Register today for early access to the brand-new features. Sign up, and we’ll send login information for your new Winter ’18 trial account.

## Till Next Week

Want to share something? Let me know by leaving a comment below or emailing [brett<EMAIL_ADDRESS> or following and tell me on [Twitter/BrettMN](https://twitter.com/BrettMN).

Don’t forget to sign up for [**The Weekly Stand-Up!**](https://wipdeveloper.wpcomstaging.com/newsletter/) to receive free the [WIP Developer.com](https://wipdeveloper.wpcomstaging.com/) weekly newsletter every Sunday!

repository: BrettMN/wipdeveloper-wordpress-archive

repo_name: BrettMN/wipdeveloper-wordpress-archive


text:
---
name: Ember
baseFileName: ember
filter:
  - /ember\./
  - /ember-template-compiler/
repo: emberjs/ember.js
initialVersion: 3.17.0 # Manually update, see https://libraries.io/npm/ember-source throughout
initialReleaseDate: 2020-03-05 # Manually update
lastRelease: 3.17.3 # Manually update
futureVersion: 3.17.4 # Manually update
channel: release
date: 2020-04-13 # Manually update, is today's date
changelogPath: CHANGELOG.md
debugFileName: .debug.js
ignoreFiles:
 - ember.js
---
# Install Ember %s:
<br>
npm install --save-dev ember-source@~%s


text:
# NeuralTransformer for code summarization task

## 1) vanilla Transformer (Sin Positional Encoding)

running with float32

```shell
# train
CUDA_VISIBLE_DEVICES=0,1,2,3 nohup python -m run.summarization.neural_transformer.train -f vanilla/python_wan/python > run/summarization/neural_transformer/vanilla/python_wan/python.log 2>&1 &
CUDA_VISIBLE_DEVICES=0,1,2,3 python -m run.summarization.neural_transformer.eval -f vanilla/python_wan/python
```

## 2) RPE Transformer (Relative Positional Encoding)

running with float32

```shell
# train
CUDA_VISIBLE_DEVICES=0,1,2,3 nohup python -m run.summarization.neural_transformer.train -f relative/python_wan/python > run/summarization/neural_transformer/relative/python_wan/python.log 2>&1 &
CUDA_VISIBLE_DEVICES=0,1,2,3 python -m run.summarization.neural_transformer.eval -f relative/python_wan/python -o run/summarization/neural_transformer/relative/python_wan/python.txt

# CSN(feng)
# train
CUDA_VISIBLE_DEVICES=0,1,2,3 nohup python -m run.summarization.neural_transformer.train -f relative/csn_feng/ruby > run/summarization/neural_transformer/relative/csn_feng/ruby.log 2>&1 &
CUDA_VISIBLE_DEVICES=0,1,2,3 nohup python -m run.summarization.neural_transformer.train -f relative/csn_feng/go > run/summarization/neural_transformer/relative/csn_feng/go.log 2>&1 &
CUDA_VISIBLE_DEVICES=0,1,2,3 nohup python -m run.summarization.neural_transformer.train -f relative/csn_feng/php > run/summarization/neural_transformer/relative/csn_feng/php.log 2>&1 &
CUDA_VISIBLE_DEVICES=0,1,2,3 nohup python -m run.summarization.neural_transformer.train -f relative/csn_feng/python > run/summarization/neural_transformer/relative/csn_feng/python.log 2>&1 &
CUDA_VISIBLE_DEVICES=0,1,2,3 nohup python -m run.summarization.neural_transformer.train -f relative/csn_feng/java > run/summarization/neural_transformer/relative/csn_feng/java.log 2>&1 &
CUDA_VISIBLE_DEVICES=0,1,2,3 nohup python -m run.summarization.neural_transformer.train -f relative/csn_feng/javascript > run/summarization/neural_transformer/relative/csn_feng/javascript.log 2>&1 &

# evaluation
python -m run.summarization.neural_transformer.eval -f relative/csn_feng/ruby
python -m run.summarization.neural_transformer.eval -f relative/csn_feng/go
python -m run.summarization.neural_transformer.eval -f relative/csn_feng/php
python -m run.summarization.neural_transformer.eval -f relative/csn_feng/python
python -m run.summarization.neural_transformer.eval -f relative/csn_feng/java
python -m run.summarization.neural_transformer.eval -f relative/csn_feng/javascript
```

## 3) learned Transformer (Learned Positional Encoding)

running with float32

```shell
# train
CUDA_VISIBLE_DEVICES=0,1,2,3 nohup python -m run.summarization.neural_transformer.train -f learned/python_wan/python > run/summarization/neural_transformer/learned/python_wan/python.log 2>&1 &
CUDA_VISIBLE_DEVICES=0 nohup python -m run.summarization.neural_transformer.train -f learned/python_wan/python > run/summarization/neural_transformer/learned/python_wan/python.log 2>&1 &
CUDA_VISIBLE_DEVICES=0,1,2,3 python -m run.summarization.neural_transformer.eval -f learned/python_wan/python
```

repository: keiouok/naturalcc

repo_name: keiouok/naturalcc


text:
# moode-lcd
LCD Display 16x2 driver daemon for moodeaudio 3.4

Copyright (c) 2015, 2019 Giorgio L. Rutigliano
(www.iltecnico.info, www.i8zse.eu, www.giorgiorutigliano.it)

This is free software released under MIT License
Requires RPLCD library by Danilo Bargen (https://github.com/dbrgn/RPLCD)

This script is a daemon designed to drive a standard 16x2 LCD display based
on HD44780 controller and interfaced via I2C bus.
It shows on first line the name of source played (or BT device name).
On the second line there are three numbers: Board load (00..99), WiFi Signal (0..9)
and CPU temperature (degrees celtius).

It can be started from /etc/rc.local
Tested with moodeaudio 3.4 and raspberry pi-zero.

Please notice that standard LCD display modules must be run from 5V power line,
while Raspberry PI GPIO runs at 3.3V and are not 5V tolerant. It is possible to
connect 5V devices to RPI GPIO as long as there are no pullup resistor on it.
Standard LCD I2C inteface boards are fitted with pullup resistor, that must be
removed to avoid damages to Raspberry. It is better to measure voltage on SDA and
SCL lines before connect them to RPI and check that voltage is ok: it should be near
zero V.

repository: grutig/moode-lcd

repo_name: grutig/moode-lcd


text:
# Windows-Drivers-Backup
Backup and Restore Device Drivers in Windows Using Command Prompt Or Windows PowerShell
How to Backup and Restore Device Drivers in Any Windows OS

If you clean install Windows, you will need to install drivers for each device in the system. Some of these device drivers may no longer be available from the manufacturer, or you misplaced a backup of the driver installation file from the manufacturer.

It would be a good idea to back up your device drivers before doing a clean install to make it easy to restore any of these drivers as needed afterwards.

This tutorial will show you how to back up and restore all 3rd party device drivers on your Windows PC.

# You must be signed in as an administrator to be able to backup and restore drivers.
# Contents

# 1 Option One   : To Back Up All Device Drivers in Command Prompt/
# 2 Option Two   : To Back Up All Device Drivers in PowerShell/
# 3 Option Three : To Restore a Device Driver Backup in Device Manager/
# 4 Option Four  : To Restore All Device Drivers in Command Prompt/

# OPTION ONE
To Back Up All Device Drivers in Command Prompt

For more usage details about the dism /export-driver command, see: DISM Driver Servicing (.inf) Command-Line Options - Microsoft Hardware Dev Center

For more usage details about the PnPUtil command, see: PnPUtil Command Syntax - Microsoft Hardware Dev Center

1 Open an elevated command prompt.

2 Type either command below you want to use into the elevated command prompt, and press Enter.

# dism /online /export-driver /destination:"full path of folder"

OR

# pnputil /export-driver * "full path of folder"

Substitute full path of folder in the command above with the actual full path of the already existing folder (ex: "F:\Drivers Backup") you want to export all 3rd party device drivers into. If this folder doesn't currently exist, you will need to create it first before running the command.

# For example: dism /online /export-driver /destination:"F:\Drivers Backup"

3 When exporting has finished, you can close the elevated command prompt if you like.

4 The device drivers will now be exported into the specified folder location (ex: "F:\Drivers Backup") as your backup.

# OPTION TWO
To Back Up All Device Drivers in PowerShell

For more usage details about the Export-WindowsDriver command, see: Export-WindowsDriver - Microsoft Windows IT Pro Center

1 Open an elevated PowerShell.

2 Enter the command below into the elevated PowerShell, and press Enter. (see screenshots below)

# Export-WindowsDriver -Online -Destination "full path of folder"

Substitute full path of folder in the command above with the actual full path of the already existing folder (ex: "F:\Drivers Backup") you want to export all 3rd party device drivers into. If this folder doesn't currently exist, you will need to create it first before running the command.

# For example: Export-WindowsDriver -Online -Destination "F:\Drivers Backup"

3 When exporting has finished, you can close the elevated PowerShell if you like.

4 The device drivers will now be exported into the specified folder location (ex: "F:\Drivers Backup") as your backup.

# OPTION THREE
To Restore a Device Driver Backup in Device Manager

1 Open Device Manager.

2 Right click or press and hold on the device (ex: "Intel(R) RealSense(TM) 3D Camera (Front F200) Depth") you want to restore a driver backup for, and click/tap on Update driver.

3 Click/tap on Manually install a driver.

4 Follow the steps below to select the folder (ex: "F:\Drivers Backup") containing the backup of your device drivers from Option One or Option Two above. (see screenshots below)

  1) Click/tap on the Browse button.

  2) Navigate to and select the folder (ex: "F:\Drivers Backup") containing the backup of device drivers.

  3) Click/tap on OK.

  4) Check the Include subfolders box.

  5) Click/tap on Next.

5 Device Manager will now search for and install the device driver if it's newer than what is currently installed.

6 When you have finished restoring driver backups, you can close Device Manager if you like.

# OPTION FOUR
To Restore All Device Drivers in Command Prompt

For more usage details about the PnPUtil command, see: PnPUtil Command Syntax - Microsoft Hardware Dev Center

1 Open an elevated command prompt.

2 Type the command below into the elevated command prompt, and press Enter.

# pnputil /add-driver "full path of folder\*.inf" /subdirs /install /reboot

Substitute full path of folder in the command above with the actual full path of the folder (ex: "E:\Drivers Backup") you exported all 3rd party device drivers into.

# For example: pnputil /add-driver "E:\Drivers Backup\*.inf" /subdirs /install /reboot

The /reboot option in the command will automatically restart the computer if needed to complete the operation of importing the drivers.

Be sure you save and close anything open before running this command.

3 When importing has finished, you can close the elevated command prompt if you like.

repository: ErDreamBuild/Windows-Drivers-Backup

repo_name: ErDreamBuild/Windows-Drivers-Backup


text:
This isn't finished yet. It's barely even started.

Cloning
=======

This project contains multiple git submodules. After cloning this repo, you'll need to run `git submodule update --init` to get them.

In the absence of a working login mechanism, when you run the app for the first time it will break near where you're supposed to insert your token. Remember to run it once and then revert the file so you don't accidentally check in a token. They're easy to revoke, but they're also SCM clutter.

Submodules
----------
* Peter Hosey's [ISO 8601 Date Formatter](https://github.com/boredzo/iso-8601-date-formatter)
* Mattt Thompson's [AFNetworking](https://github.com/AFNetworking/AFNetworking)
* [Debugger](https://github.com/numist/Debugger)
* [UIImageView-NDVAnimatedGIFSupport](https://github.com/numist/UIImageView-NDVAnimatedGIFSupport), as made famous by [Nathan de Vries](https://github.com/atnan/UIImageView-NDVAnimatedGIFSupport)

License
=======
TMBO: The App! is available under the MIT license. See the LICENSE file for more info.

repository: jimjkelly/tmbo-ios

repo_name: jimjkelly/tmbo-ios


text:
# Contributing to LogKit

The LogKit Project welcomes contributions from the community! Please review this document to understand how to participate in the project.

## Security Issues

Please do **not** file public issues for security concerns. Instead, please email your report privately to<EMAIL_ADDRESS>This will allow us to fix the issue and release an update before exposing the issue. Once an update has been released, we will work with you to publish the issue and get the credit you deserve.

## Other Contributions

We welcome pull requests, issues, and discussion from the community. Please be detailed!

Before creating a new issue, please have a search through the issue tracker to be sure it doesn't already exist. If it does, please leave a comment letting us know that you are also experiencing that issue, and adding any additional detail that could help. This will assist us in prioritizing issues, and fixing them as quickly as possible.

## Conduct

To participate in the LogKit Project, you must follow the [Code of Conduct][conduct].

## License

By participating, you agree that all contributions to the LogKit Project will be licensed under LogKit's permissive [ISC License][ISC] or, alternatively, under the [MIT License][MIT], at the LogKit Project's discretion.

[conduct]: https://github.com/logkit/logkit.github.io/blob/master/CONDUCT.md
[ISC]: http://opensource.org/licenses/isc-license
[MIT]: http://opensource.org/licenses/MIT


text:
# ACHIEVE MOBILE APP

## Achieve

This is the front end of Achieve, a social goal making app that allows users to create goals and add friends to track each other’s progress built with Svelte-Native. This app was created as part of our final project for the Northcoders coding bootcamp. Team members: Harry York, John Andre, Lee Broadhurst.

## Setup

1. Fork this repository to your own GitHub account

2. Clone your fork of this repository to your local machine and `cd` into it:

```
$ git clone <your fork's URL>
$ cd NC-Final-Project-Frontend
```

## Dependencies

install dependencies using the CLI.

```
$ npm i
```

## Preview App

To preivew this app you will need to download NativeScript Playground and NativeScript Preview on your phone. Once installed use the `ns preview` command as for a normal NativeScript application and you will be presented with a QR code. Scan this code using NativeScript Playground to view you app.

## Requires

```
TypeScript 4.0.2
```

repository: chrisroughley/NC-Final-Project-Frontend

repo_name: chrisroughley/NC-Final-Project-Frontend


text:
# Lean-GIHH
This project contains the source code of Lean-GIHH, a hyper-heuristic for the HyFlex framework.

Lean-GIHH is a simpler variant of GIHH (aka Adap-HH), winner of the CHeSC 2011 competition.
It was derived in [1] from the original by means of Accidental Complexity Analysis (ACA),
a technique for reducing algorithmic complexity, without loss of performance.
The implementation of Lean-GIHH provided in the src directory counts 288 lines of code (as determined using the cloc tool) as opposed to the 2324 lines of code in the original implementation (see links).

Feel free to use Lean-GIHH in your own research.
If you do, we kindly ask you to acknowledge this, by citing the following article:

[1] Steven Adriaensen, and Ann Nowé. "Case Study: An Analysis of Accidental Complexity in a State-of-the-art Hyper-heuristic for HyFlex."
Evolutionary Computation (CEC), 2016 IEEE Congress on. IEEE, 2016.

@inproceedings{adriaensen2016case,

  title={Case Study: An Analysis of Accidental Complexity in a State-of-the-art Hyper-heuristic for HyFlex},

  author={Adriaensen, Steven and Now{\'e}, Ann},

  booktitle={Evolutionary Computation (CEC), 2016 IEEE Congress on},

  year={2016},

  organization={IEEE}

}

**Content**:
- src/LeanGIHH.java: Source code of the Lean-GIHH hyper-heuristic
- src/CircularBuffer.java: An auxiliary data-structure used by LeanGIHH.
- src/ExampleRun.java: Usage example.
- lib/chesc.jar: CHeSC HyFlex framework
- LeanGIHH-eclipse.zip: Archive to import as project in Eclipse IDE

See the extensive documentation in these files for more details.

**Links**:
- CHeSC 2011 competition website: [http://www.asap.cs.nott.ac.uk/external/chesc2011/](http://www.asap.cs.nott.ac.uk/external/chesc2011/)
- Original version of GIHH by Mustafa Misir: [https://code.google.com/p/generic-intelligent-hyper-heuristic/](https://code.google.com/p/generic-intelligent-hyper-heuristic/)

repository: Steven-Adriaensen/Lean-GIHH

repo_name: Steven-Adriaensen/Lean-GIHH


text:
# Kubernetes
### Notes from Kubernetes: Up and Running
#### chapter 4. Common kubectl commands

In this chapter basic kubernetes API will be covered
##### Namespaces
Namespaces ogranizes objects in the cluster.
Default kubectl namespace is `default`
to switch namespace you should pass `--namespace` option

##### Contexts
Used for mor permament namespace changes.
Context changes recorded in _$HOME/.kube/config_
This file also stores authentication and cluster address info.

u can create context with another namespace:

```
$ kubectl config set-context <context-name> --namespace=custom-namespace
```

and use it

```
$ kubectl config use-context my-context
```

##### Kubernetes API objects

All objects in Kubernetes has REST reprsentation.
Each object has unique HTTP path.
`kubectl` command makes HTTP request to these URLS to access objects that reside at these paths.

##### CRUD on Kubernetes objects

object represented by JSON or YAML, which are used for CRUD as parameters or outputs.

```
$ kubectl apply -f obj.yaml
```

You can also edit service using interactive mode by typing
```
kubectl edit <resource-name><obj-name>
```

It will download current revision of file from cluster, launch editor and after you save file upload it back to cluster.

for deleting service defined in file you should provide either file

```
kubectl delete -f obj.yaml
```

or object name
```
kubectl delete <resource-name> <object-name>
```

##### Annotating
to label you object use `kubectl label` command

#### Logs and terminal

Logs can be seen using this command `kubectl logs <pod-name>`

terminal can be accessed by `kubectl exec -it <pod-name> -- /bin/bash`

You also can send i receive files by using `kubectl cp` command

To send:
```
$ kubectl cp /path/to/local/file <pod-name>:/path/to/remote/file
```

To receive:
```
$ kubectl cp <pod-name>:/path/to/remote/file /path/to/local/file
```

repository: addmeaning/kubernetes-notes

repo_name: addmeaning/kubernetes-notes


text:
## 459. Repeated Substring Pattern

#### Description

[link](https://leetcode.com/problems/repeated-substring-pattern/)

---

#### Solution

- First char of input string is first char of repeated substring
- Last char of input string is last char of repeated substring
- Let S1 = S + S (where S in input string)
- Remove 1 and last char of S1. Let this be S2
- If S exists in S2 then return true else false
- Let i be index in S2 where S starts then repeated substring length i + 1 and repeated substring S[0: i+1]

---

#### Code

O(1) O(1)

```python
class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        if not str:
            return False

        ss = (s + s)[1:-1]
        return ss.find(s) != -1
```

repository: ProHiryu/leetcode

repo_name: ProHiryu/leetcode


text:
# CSC 317 Term Project

## Purpose

The purpose of this repository is to store all the code for your web application. This also includes the history of all commits made and who made them. Only code submitted on the master branch will be graded.

Please follow the instructions below and fill in the information requested when prompted.

## Student Information

|               | Information   |
|:-------------:|:-------------:|
| Student Name  | Truman Tang     |
| Student ID    | 921448369       |
| Student Email |<EMAIL_ADDRESS>  |

# Build/Run Instructions

## Build Instructions
1. cd csc317-termproject-doomphd
2. npm install

## Run Instructions
1. cd application
2. nodemon

repository: doomphd/PhotoApp

repo_name: doomphd/PhotoApp


text:
# DSP IIR Realtime C++ filter library

An infinite impulse response (IIR) filter library for
Linux, Mac OSX and Windows
which implements Butterworth, RBJ, Chebychev filters
and can easily import coefficients generated by Python (scipy).

The filter processes the data sample by sample for realtime
processing.

It uses templates to allocate the required memory so that
it can run without any malloc / new commands.
Memory is allocated at compile time
so that there is never any risk of memory leaks.

This library has been further developed from Vinnie Falco's
great original work which can be found here:

https://github.com/vinniefalco/DSPFilters

Bernd Porr -- http://www.berndporr.me.uk


text:
# webcrypto-liner
[![license](https://img.shields.io/badge/license-MIT-green.svg?style=flat)](https://raw.githubusercontent.com/PeculiarVentures/webcrypto-liner/master/LICENSE)
[![npm version](https://badge.fury.io/js/webcrypto-liner.svg)](https://badge.fury.io/js/webcrypto-liner)
![test](https://github.com/PeculiarVentures/webcrypto-liner/workflows/test/badge.svg)

[![NPM](https://nodei.co/npm/webcrypto-liner.png)](https://nodei.co/npm/webcrypto-liner/)

A polyfill for WebCrypto that "smooths out" the rough-edges in existing User Agent implementations.

Though WebCrypto is well [supported across browsers](http://caniuse.com/cryptography), several browsers still have prefixed and buggy implementations. Additionally, they do not always support the same algorithms, for example, Edge does not support SHA1 or ECC while both Firefox and Chrome do.

**NOTE**: If you are not familiar with how to use the various capabilities of WebCrypto see [this great example  page](https://github.com/diafygi/webcrypto-examples).

## Browsers support

| [](http://godban.github.io/browsers-support-badges/)
 Edge | [](http://godban.github.io/browsers-support-badges/)
Firefox | [](http://godban.github.io/browsers-support-badges/)
Chrome | [](http://godban.github.io/browsers-support-badges/)
Safari |
| --------- | --------- | --------- | --------- |
| last 2 versions| last 2 versions| last 2 versions| last 2 versions| last 2 versions| last 2 versions| last 2 versions

## Information

`webcrypto-liner` is a wrapper for WebCrypto designed to address these issues, at the same time it was designed to be modular so that it can also be used for testing the addition of new algorithms to WebCrypto in the future.

Intentionally `webcrypto-liner` does not implement any cryptography though it does consume libraries that do. We strongly recommend you read "[What’s wrong with in-browser cryptography?](https://tonyarcieri.com/whats-wrong-with-webcrypto)" before using this library.

The libraries `webcrypto-liner` relies on include:

| Package                                                    | Description                                                                            | Size   | Optional    |
|------------------------------------------------------------|----------------------------------------------------------------------------------------|--------|-------------|
| [asmcrypto.js](https://github.com/vibornoff/asmcrypto.js/) | A [performant](https://medium.com/@encryb/comparing-performance-of-javascript-cryptography-libraries-42fb138116f3) JavaScript implementation of popular cryptographic utilities with performance in mind. | 131 KB | Yes |
| [elliptic](https://github.com/indutny/elliptic)            | Fast Elliptic Curve Cryptography in plain javascript                                   | 130 KB | Yes  |
| [webcrypto-core](https://github.com/PeculiarVentures/webcrypto-core)            | A input validation layer for WebCrypto polyfills 1    | 25 KB | No  |

1 This library is compiled into webcrypto-liner.

`webcrypto-liner` will always try to use a native implementation of webcrypto, or a prefixed version of webcrypto, before it falls back to a Javascript implementation of a given algorithm. We have no control over the corresponding implementation and what it does, for example, it may not use `window.crypto.getRandomValues` even if it is available and the mechanism it uses to gather randomness may be both insecure and weak.

We have done no security review or take a position on the security of these third-party libraries. **YOU HAVE BEEN WARNED**.

To keep `webcrypto-liner` as small as possible (right now it is ~11kb without dependencies) it was designed to be modular, so if you do not need ECC support, do not include `elliptic` as a dependency and it will not be loaded.

If you do not load any of the dependencies that provide cryptographic implementations `webcrypto-liner` will work as an interoperability layer, very similar to [webcrypto-shim](https://github.com/vibornoff/webcrypto-shim).

`webcrypto-liner` supports the following algorithms and key lengths:

| Capability                | Details                                       |
|---------------------------|-----------------------------------------------|
| Encryption/Decryption     | RSA-OAEP, [DES-CBC](https://github.com/PeculiarVentures/webcrypto-docs/blob/master/DES_CBC.md)1, [DES-EDE3-CBC](https://github.com/PeculiarVentures/webcrypto-docs/blob/master/DES_EDE3_CBC.md)1, AES-ECB 1, AES-CBC, AES-ECB and AES-GCM |
| Sign/Verify               | RSA-PSS, RSASSA_PKCS1-v1_5 and ECDSA          |
| Hash                      | SHA-1, and SHA-256, SHA-512                   |
| Derive Key/Bits           | ECDH, PBKDF2                                  |
| Keywrap                   | AES-GCM, AES-CBC, AES-ECB 1, [DES-CBC](https://github.com/PeculiarVentures/webcrypto-docs/blob/master/DES_CBC.md)1, [DES-EDE3-CBC](https://github.com/PeculiarVentures/webcrypto-docs/blob/master/DES_EDE3_CBC.md)1        |
| ECC Curves                | P-256, P-384, P-521, and [K-256](https://github.com/PeculiarVentures/webcrypto-core/blob/master/spec/EC_K_256.md)2 (secp256k1)    |
| RSA Key Lengths           | 1024, 2048, 3072, and 4096                    |
| AES Key Lengths           | 128, 192 and 256                              |

1 Mechanism is not defined by the WebCrypto specifications. Use of mechanism in a safe way is hard, it was added for the purpose of enabling interoperability with an existing system. We recommend against its use unless needed for interoperability.

2 K-256 (secp256k1) curve is not defined by the WebCrypto specifications.

You can see the `webcrypto-liner` in use in the [`pv-webcrypto-tests` page](https://peculiarventures.github.io/pv-webcrypto-tests/).

## Using

```html
<head>
  <!-- Crypto providers are optional -->
  <script src="https://cdnjs.cloudflare.com/ajax/libs/babel-polyfill/7.7.0/polyfill.min.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/asmCrypto/2.3.2/asmcrypto.all.es5.min.js"></script>
  <script src="https://cdn.rawgit.com/indutny/elliptic/master/dist/elliptic.min.js"></script>
  <!-- Crypto -->
  <script src="webcrypto-liner.shim.js"></script>
</head>
<body>
  <script>
    crypto.subtle.generateKey({name: "AES-GCM", length: 192}, true, ["encrypt", "decrypt"])
      .then(function(key){
        return crypto.subtle.encrypt({
            name: "AES-GCM",
            iv: new Uint8Array([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]),
            tagLength: 128
          }, key, new Uint8Array([1,2,3,4,5]))
      })
      .then(function(enc){
        console.log(new Uint8Array(enc));
      })
      .catch(function(err){
        console.log(err.message); // Chrome throws: 192-bit AES keys are not supported
      })
  </script>
</body>
```

## Dependencies
typescript
```
npm install typescript --global
```

## Installation
The module has been designed to be useful in ES6 and ES5 projects. The default is ES5 with commonjs, to install and build you would run:

```
npm install
npm run build
```

## FAQ
- **Do I need to use a promise library?** - No, not if your browser supports promises.
- **Do I need to include asmcrypto.js?** No, not unless you want to use the algorithms it exposes.
- **Do I need to include elliptic.js?** No, not unless you want to use the algorithms it exposes.
- **How are random numbers generated?** We use two libraries for crypto operations in Javascript, [asymcrypto](https://github.com/vibornoff/asmcrypto.js/blob/bffc0674c7756dff16c69c5665b9eea2e0409736/src/random/globals.js#L4) and [ellipticjs](https://github.com/indutny/elliptic/blob/cbace4683a4a548dc0306ef36756151a20299cd5/dist/elliptic.js#L7464) both rely on [window.crypto.getRandomValues](http://caniuse.com/#feat=getrandomvalues) where available. `asymcrypto` also has a fallback mechanism where it generates its own random numbers if not present.
- **How big is the total package?** Right now, if you include all optional dependencies (minfied) the package is ~300 KB, if you include only ECC or only RSA support that is lowered to about 180 KB. Additionally you will see GZIP compression provide about 30% savings above and beyond that. If you use `webcrypto-liner` as just an interopability shim and do not use any of the optional third-party libraries it will be under 44 KB in size.
- **Will it work in Node?** No. It is compiles to pure Javascript but uses the `window` object so it wont work in Node at this time. With some minor changes it should also be able to work in Node also but you really should be using [node-webcrypto-ossl](https://github.com/PeculiarVentures/node-webcrypto-ossl) on Node instead.

## Related
 - [@peculiar/webcrypto](https://github.com/PeculiarVentures/webcrypto)
 - [node-webcrypto-p11](https://github.com/PeculiarVentures/node-webcrypto-p11)
 - [node-webcrypto-ossl](https://github.com/PeculiarVentures/node-webcrypto-ossl)
 - [pv-webcrypto-tests](https://peculiarventures.github.io/pv-webcrypto-tests)
 - [webcrypto-core](https://peculiarventures.github.io/webcrypto-core)
 - [WebCrypto Examples](https://github.com/diafygi/webcrypto-examples)

repository: PeculiarVentures/webcrypto-liner

gha_language: TypeScript

repo_name: PeculiarVentures/webcrypto-liner


text:
Generic control toolbox  [![Build Status](https://travis-ci.org/diogoalmeida/generic_control_toolbox.svg?branch=master)](https://travis-ci.org/diogoalmeida/generic_control_toolbox)
========
This ROS package defines libraries that are generic to the control algorithms
used in my research, in an attempt to maximize code re-usability.

[ROS-wiki page](https://wiki.ros.org/generic_control_toolbox)

[Tutorials](https://wiki.ros.org/generic_control_toolbox/Tutorials)

## Dependencies

This is a ROS package and relies on a ROS instalation. Assuming the "full" version of your ROS distro, this package depends on the package ``realtime_tools``:
```
  $ sudo apt-get install ros-<distro>-realtime-tools
```
where you should replace ``<distro>`` with the ROS distribution name (e.g., ``indigo``).

Tested in ROS indigo and kinetic.

## Implementing a controller

To implement a controller you inherit from the ``ControllerTemplate`` class and implement the pure virtual methods. This will enhance your controller with an actionlib interface.

#### Example
Create a package named ``my_controller``, which should define an actionlib action file (``Example.action``) as in the [actionlib tutorial](http://wiki.ros.org/actionlib_tutorials/Tutorials/SimpleActionServer%28ExecuteCallbackMethod%29). In the class definition file, you should have something like

```cpp
// Other includes
#include <my_controller/ExampleAction.h>
#include <generic_control_toolbox/controller_template.hpp>

class MyController : public generic_control_toolbox::ControllerTemplate<ExampleAction,
                                                                        ExampleGoal,
                                                                        ExampleFeedback,
                                                                        ExampleResult>
{
public:
  MyController(const std::string &action_name);

  // destructor, other public methods/members

private:
  sensor_msgs::JointState controlAlgorithm(const sensor_msgs::JointState &current_state, const ros::Duration &dt);
  bool parseGoal(boost::shared_ptr<const ExampleGoal> goal);
  bool init();
  void resetController();

  // other public methods/members
};
```

The ``action_name`` element of the constructor must be passed to the ``ControllerTemplate`` constructor to initialize the actiolib server. An example of an implemented controller using this template can be found in the sarafun_folding_assembly [folding controller](https://github.com/diogoalmeida/sarafun_folding_assembly/blob/e86eb85feb5480039139a14034bf70dd68f10991/include/folding_assembly_controller/folding_controller.hpp) definition.


text:
## Let us consider the following problem to understand MO’s Algorithm.

## We are given an array and a set of query ranges, we are required to find the sum of every query range.
```
Input:  arr[]   = {1, 1, 2, 1, 3, 4, 5, 2, 8};
        query[] = [0, 4], [1, 3] [2, 4]
Output: Sum of arr[] elements in range [0, 4] is 8
        Sum of arr[] elements in range [1, 3] is 4
        Sum of arr[] elements in range [2, 4] is 6
```

- All queries are known beforehead so that they can be preprocessed
- It cannot work for problems where we have update operations also mixed with sum queries.
- MO’s algorithm can only be used for query problems where a query can be computed from results of the previous query. One more such example is maximum or minimum.

Time Complexity Analysis:
The function mainly runs a for loop for all sorted queries. Inside the for loop, there are four while queries that move ‘currL’ and ‘currR’.

How much currR is moved? For each block, queries are sorted in increasing order of R. So, for a block, currR moves in increasing order. In worst case, before beginning of every block, currR at extreme right and current block moves it back the extreme left. This means that for every block, currR moves at most O(n). Since there are O(√n) blocks, total movement of currR is O(n * √n).

How much currL is moved? Since all queries are sorted in a way that L values are grouped by blocks, movement is O(√n) when we move from one query to another quert. For m queries, total movement of currL is O(m * √n)

Please note that a Simple and more Efficient solution to solve this problem is to compute prefix sum for all elements from 0 to n-1. Let the prefix sum be stored in an array preSum[] (The value of preSum[i] stores sum of arr[0..i]). Once we have built preSum[], we can traverse through all queries one by one. For every query [L, R], we return value of preSum[R] – preSum[L]. Here processing every query takes O(1) time.

The idea of this article is to introduce MO’s algorithm with a very simple example. We will soon be discussing more interesting problems using MO’s algorithm.

path: /DATA STRUCTURES/Array/Query Square Root Decomposition/readMe.md


text:
# Project AutoVis: Automatic Visualization via Webcam

AutoVis is a tool for automating visualization of colored reactions.

## Usage

Two computers are needed, one for running the experiment (i.e. taking images using a built-in camera or an external webcam) and one for running the communication manager that detects the accumulation of image data and initiates the data analysis.

### Computer 1: For taking images on the webcam, execute:

`$ python MainExperiment.py`

The user will input the path to the Dropbox directory, reaction ID, duration of webcam, and image-taking frequency.

### Computer 2: For initiating the communication manager, execute:

`$ python MainAnalysis.py`

The user will input the path to the Dropbox directory and reaction ID.

## Installation

To install Autovis, the user needs to install the dependencies listed below.

- For `opencv-python`, we recommend installing via pip: `pip install opencv-python`. For installation on Windows, we recommend following the steps [here](https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_setup/py_table_of_contents_setup/py_table_of_contents_setup.html).

- For `numpy` and `matplotlib`, we recommend installing via pip: `python -m pip install --user numpy matplotlib`. For more detailed instructions, refer to this set of [instructions](https://www.scipy.org/install.html).

- For `seaborn`, we recommend installing via pip: `pip install seaborn`.

Coming soon: we will work on making Autovis pip-installable.

## Dependencies and Versions Used
- python 3.5
- opencv-python <IP_ADDRESS>
- numpy 1.16.4
- matplotlib 2.2.2
- seaborn 0.8.1

## Key functionalities

![Project Components](ps50algo.PNG)

## Authors

AutoVis was written by Physical Sciences 50 (Spring 2018) at Harvard University.


text:
hero-shorten
============

A zero-configuration URL shortener for Heroku. More info coming soon.

The goal is to create a live URL shortener doing only the following:

    git clone git://github.com/kyleslattery/hero-shorten.git
    cd hero-shorten
    heroku create
    git push heroku master

And then be able to access it by going to http://some-sub-domain.heroku.com/-/.

Authentication
--------------
If you would like to password protect the admin section (http://your-shortener/-/), you can set the `ADMIN_USERNAME` and `ADMIN_PASSWORD` heroku env variables by using the `heroku config:add` command:

    heroku config:add ADMIN_USERNAME=someusername ADMIN_PASSWORD=somepassword

To-do
-----
1. Add bookmarklet
2. Add validations to make actual URLs are being submitted

repository: kyleslattery/hero-shorten

repo_name: kyleslattery/hero-shorten


text:
#ArduBreakout

##Building and Uploading
Using `git` clone the repository.

**From the Linux command line or Windows Powershell**

    $ git clone https://github.com/Arduboy/ArduBreakout.git

Open the .ino file in the Arduino IDE, select the **Leonardo** board as the target platform. Compile the source code, and upload to the Arduboy.

repository: arduboychris/ArduBreakout

repo_name: arduboychris/ArduBreakout


text:
---
title: Understand metadata concepts
description: Learn about the need of and types of metadata that allows for easier categorization and organization of assets.
contentOwner: AG
role: User, Admin
feature: Metadata
exl-id: 312fff5f-39c1-48c1-aa99-40feb72c2f59
---
# Understand metadata concepts {#why-we-need-metadata}

Metadata means data about data. In this regard, data refers to your digital asset, say an image. Metadata is critical for efficient asset management.

Metadata is the collection of all the data available for an asset but that is not necessarily contained in that image. Some examples of metadata are:

* Name of the asset.
* Time and date of last modification.
* Size of the asset as it was stored in the repository.
* Name of the folder it is contained in.
* Related assets or applied tags.

The above are the basic metadata properties that [!DNL Experience Manager] can manage for assets, which allows users to see all assets. For example, ordering assets by last modification date is useful when trying to discover recently added assets.

You can add more high-level data to digital assets, for example:

* Type of asset (an image, a video, an audio clip, or a document).
* Owner of the asset.
* Title of the asset.
* Description of the asset.
* Tags assigned to an asset.

More metadata helps you further categorize assets and is helpful as the amount of digital information grows. It is possible to manage a few hundred files based on just the filenames. However, this approach is not scalable. It falls short when the number of people involved and the number of assets managed increase.

With the addition of metadata, the value of a digital asset grows, because the asset becomes,

* More accessible - systems and users can find it easily.
* Easier to manage - you can find assets with the same set of properties easier and apply changes to them.
* Complete - asset carries more information and context with more metadata.

For these reasons, [!DNL Assets] provides you with the right means of creating, managing, and exchanging metadata for your digital assets.

## Types of metadata {#types-of-metadata}

The two basic types of metadata are technical metadata and descriptive metadata.

Technical metadata is useful for software applications that are dealing with digital assets and should not be maintained manually. [!DNL Experience Manager Assets] and other software automatically determine technical metadata and the metadata may change when the asset is modified. The available technical metadata of an asset depends largely on the file type of the asset. Some examples of technical metadata are:

* Size of a file.
* Dimensions (height and width) of an image.
* Bit rate of an audio or video file.
* Resolution (level of detail) of an image.

Descriptive metadata is metadata concerned with the application domain, for example, the business that an asset is coming from. Descriptive metadata cannot be determined automatically. It is created manually or semi-automatically. For example, a GPS-enabled camera can automatically track the latitude and longitude and add geotag the image.

The cost of manually creating descriptive metadata information is high. So, standards are established to ease the exchange of metadata across software systems and organizations. [!DNL Experience Manager Assets] supports all relevant standards for metadata management.

## Encoding standards {#encoding-standards}

There are various ways to embed metadata in files. A selection of encoding standards are supported:

* XMP: used by [!DNL Assets] to store the extracted metadata within the repository.
* ID3: for audio and video files.
* Exif: for image files.
* Other/Legacy: from [!DNL Microsoft Word], [!DNL PowerPoint], [!DNL Excel], and so on.

### XMP {#xmp}

[!DNL Extensible Metadata Platform] (XMP) is an open standard that is used by [!DNL Experience Manager Assets] for all metadata management. The standard offers universal metadata encoding that can be embedded into all file formats. Adobe and other companies support XMP standard as it provides a rich content model. Users of XMP standard and of [!DNL Experience Manager Assets] have a powerful platform to build upon. For more information, see [XMP](https://www.adobe.com/products/xmp.html).

### ID3 {#id}

Data stored in these ID3 tags is displayed when you play back a digital audio file on either your computer or a portable MP3 player.

ID3 tags are designed for the MP3 file format. Additional information on formats:

* ID3 tags work in MP3 and mp3PRO files.
* WAV has no tags.
* WMA has proprietary tags that do not allow open-source implementation.
* Ogg Vorbis uses Xiph Comments embedded in the Ogg container.
* AAC uses a proprietary tagging format.

### Exif {#exif}

Exchangeable image file format (Exif) is the most popular metadata format used in digital photography. It provides a way of embedding a fixed vocabulary of metadata properties in many file formats, such as JPEG, TIFF, RIFF, and WAV. Exif stores metadata as pairs of a metadata name and a metadata value. These metadata name-value-pairs are also called tags, not to be confused with the tagging in [!DNL Experience Manager]. Modern digital cameras create Exif metadata and modern graphics software support it. Exif format is the lowest common denominator for metadata management especially for images.

A major limitation of Exif is that a few popular image file formats such as BMP, GIF, or PNG do not support it.

Metadata fields defined by Exif are typically technical in nature and are of limited use for descriptive metadata management. For this reason, [!DNL Experience Manager Assets] offers mapping of Exif properties into [common metadata schemata](metadata-schemas.md) and into [XMP](xmp-writeback.md).

### Other metadata {#other-metadata}

Other metadata that can be embedded from files include [!DNL Microsoft Word], [!DNL PowerPoint], [!DNL Excel], and so on.

## Understand metadata schemata {#metadata-schemata}

Metadata schemas are predefined sets of metadata property definitions that can be used in various applications. Properties are always associated with an asset, meaning that the properties are 'about' the resource.

You can also design your own metadata schemata if none exists that meet your needs. Do not duplicate existing information. Within an organization, separating schemata makes it easier to share metadata. [!DNL Experience Manager] provides you with a default list of the most popular metadata schemata. The list helps you to jumpstart your metadata strategy and quickly pick the metadata properties that you need.

The supported metadata schemata supported are listed below.

### Standard metadata {#standard-metadata}

* DC - [!DNL Dublin Core] is an important and widely used set of metadata.
* DICOM - Digital Imaging and Communications in Medicine.
* `Iptc4xmpCore` and `iptc4xmpExt` - International Press Communications Standard contains many subject-specific metadata.
* RDF - Resource Description Framework - for generic semantic web metadata.
* XMP - [!DNL Extensible Metadata Platform].
* `xmpBJ` - Basic Job Ticketing.

### Application-specific metadata {#application-specific-metadata}

The application-specific metadata includes technical and descriptive metadata. If you use such metadata, other applications may not be able to use the metadata. For example, a different image-rendering application may not be able to access [!DNL Adobe Photoshop] metadata. You can create a workflow step that changes an application-specific property to a standard property.

* ACDSee - Metadata managed by the [!DNL ACDSee] program. See [www.acdsee.com/](https://www.acdsee.com/).
* Album - [!DNL Adobe Photoshop Album].
* CQ - Used by [!DNL Experience Manager Assets].
* DAM - Used by [!DNL Experience Manager Assets].
* DEX - [!DNL Optima SC Description explorer] is a collection of tools for metadata and file management for Windows operating systems.
* CRS - [Adobe Photoshop Camera Raw](https://helpx.adobe.com/camera-raw/using/introduction-camera-raw.html).
* LR - [!DNL Adobe Lightroom].
* MediaPro - [iView MediaPro](https://en.wikipedia.org/wiki/Phase_One_Media_Pro).
* MicrosoftPhoto and MP - Microsoft Photo.
* PDF and PDF/X.
* Photoshop and psAux - [!DNL Adobe Photoshop].

### Digital Rights Management (DRM) metadata {#digital-rights-management-metadata}

* CC - [!DNL Creative Commons].
* [!DNL XMPRights].
* PLUS - [Picture Licensing Universal System](https://www.useplus.com).
* PRISM - [Publishing Requirements for Industry Standard Metadata](https://www.idealliance.org/prism-metadata).
* PRL - PRISM Rights Language.
* PUR - PRISM Usage Rights.
* `xmpPlus` - Integration of PLUS with XMP.

### Photography-specific metadata {#photography-specific-metadata}

* Exif - Technical information from camera, including GPS position.
* CRS - [!DNL Camera Raw] schema.
* `iptc4xmpCore` and `iptc4xmpExt`.
* TIFF - image metadata (not only for TIFF images).

### Print-specific metadata {#print-specific-metadata}

* PDF and PDF/X - Adobe PDF and third-party applications.
* PRISM - [Publishing Requirements for Industry Standard Metadata](https://www.idealliance.org/prism-metadata).
* XMP - [!DNL Extensible Metadata Platform].
* `xmpPG` - XMP metadata for paged text.

### Multimedia-specific metadata {#multimedia-specific-metadata}

* `xmpDM` - [!DNL Dynamic Media].
* `xmpMM` - Media Management.

## Metadata schemata reference {#metadata-schemata-reference}

The following reference includes information about a particular metadata schemata (in alphabetical order) as well as a list of properties and their definitions.

### Dublin Core {#dublin-core}

Dublin Core metadata provides a standardized set of conventions for describing assets to make them easier to find. In [!DNL Assets], the Dublin Core describes digital assets including video, sound, images, and documents.

The simple Dublin Core Metadata Element Set (DCMES) contains 15 metadata elements as listed in the following table. Each Dublin Core element is optional and can be repeated. You can add or delete Dublin Core metadata information as you would for media type-specific metadata.

In addition to the DCMES, there are other metadata elements created by the Dublin Core Initiative. See the [Dublin Core initiative](https://dublincore.org/) for more information.

|  Property   |                                                       Description                                                        |
| ----------- | ------------------------------------------------------------------------------------------------------------------------ |
| contributor | The person or company responsible for making contributions to the content.                                               |
| coverage    | The geographic location or time period that the asset covers.                                                            |
| creator     | The person or company responsible for creating the content.                                                              |
| date        | Date or period of time associated with the asset.                                                                        |
| description | More information about the asset.                                                                                |
| format      | The file format, physical medium, or dimensions of the asset. [!DNL Experience Manager] uses `dc:format` to denote the MIME type of the asset. |
| identifier  | A unique reference to the asset.                                                                                |
| language    | The language of the asset (for example, `en` for English).                                                                 |
| publisher   | The person or company responsible for making the asset available.                                                        |
| relation    | A related asset.                                                                                |
| rights      | Information about who has the rights to this asset.                                                                      |
| source      | A related asset from which the asset is derived.                                                                         |
| subject     | The topic of the asset.                                                                                |
| title       | A name for the asset.                                                                                |
| type        | The nature or genre of the asset.                                                                                |

### IPTC {#iptc}

The International Press Telecommunications Council (IPTC) is a consortium of news agencies around the world - one of its goals is to develop and maintain technical standards. The IPTC defined a set of photo metadata standards for images that is almost universally accepted among photographers. These metadata standards were part of the broader standard known as the IPTC Information Interchange Model (IIM) created in the 1990s.

Although the IPTC header information has been mostly superseded by XMP, an IPTC core schema and an extension schema are available for XMP. In image programs, both XMP and IPTC properties are synchronized.

## Metadata-driven workflows {#metadata-driven-workflows}

Creating metadata-driven workflows help you automate some processes, which improves efficiency. In a metadata-driven workflow, the workflow management system reads the workflow and as a result performs some pre-defined action. For example, some of the ways you could use metadata-driven workflows:

* The workflow can check whether an image has a title or not. If it does not, the system notifies to add a title.
* The workflow can check whether a copyright notice on an asset allows for distribution or not. So, the system sends the asset to one server or the other.
* A workflow can check for assets without pre-defined, mandatory metadata or assets with *invalid* metadata.

## XMP metadata {#xmp-metadata}

XMP (Extensible Metadata Platform) is the metadata standard used by [!DNL Adobe Experience Manager Assets] for all metadata management. XMP provides a standard format for the creation, processing, and interchange of metadata for a wide variety of applications.

Aside from offering universal metadata encoding that can be embedded into all file formats, XMP provides a rich [content model](#xmp-core-concepts) and is [supported by Adobe](#advantages-of-xmp) and other companies, so that users of XMP in combination with [!DNL Assets] have a powerful platform to build upon.

The [XMP specification](https://www.adobe.com/devnet/xmp.html) is available from Adobe.

### What is XMP? {#what-is-xmp}

Adobe first introduced the XMP standard as part of the Adobe Acrobat software product. Since then, the XMP standard has been widely adopted. [!DNL Assets] natively supports the XMP - the Extensible Metadata Platform spearheaded by Adobe. XMP is a standard for processing and storing standardized and proprietary metadata in digital assets. XMP is designed to be the common standard that allows multiple applications to work effectively with metadata.

Production professionals, for example, use the built-in XMP support within Adobe's applications to pass information across multiple file formats. [!DNL Assets] repository extracts the XMP metadata and uses it to manage the content lifecycle and offers the ability to create automation workflows.

XMP standardizes how metadata is defined, created, and processed by providing a data model, a storage model, and schemas. All of these concepts are covered in this section.

All legacy metadata from EXIF, ID3, or Microsoft Office is automatically translated to XMP, which can be extended to support customer-specific metadata schema, such as product catalogs.

Metadata in XMP consists of a set of properties. These properties are always associated with a
particular entity referred to as a resource; that is, the properties are "about" the resource. In the case of XMP, the resource is always the asset.

### XMP ecosystem {#xmp-ecosystem}

XMP defines a [metadata](https://en.wikipedia.org/wiki/Metadata) model that can be used with any defined set of metadata items. XMP also defines particular [schemas](https://en.wikipedia.org/wiki/XML_schema) for basic properties useful for recording the history of a resource as it passes through multiple processing steps, from being photographed, [scanned](https://en.wikipedia.org/wiki/Image_scanner), or authored as text, through photo editing steps (such as [cropping](https://en.wikipedia.org/wiki/Cropping_%28image%29) or color adjustment), to assembly into a final image. XMP allows each software program or device along the way to add its own information to a digital resource, which can then be retained in the final digital file.

XMP is most commonly serialized and stored using a subset of the [W3C](https://en.wikipedia.org/wiki/World_Wide_Web_Consortium) [Resource Description Framework](https://en.wikipedia.org/wiki/Resource_Description_Framework) (RDF), which is in turn expressed in [XML](https://en.wikipedia.org/wiki/XML).

### Advantages of XMP {#advantages-of-xmp}

XMP has the following advantages over other encoding standards and schemata:

* XMP-based metadata is very powerful and fine-grained.
* XMP lets you have multiple values for one property.
* XMP has standardized encoding, which lets you easily exchange metadata.
* XMP is extensible. You can add additional information into your assets.

The XMP standard is designed to be extensible, allowing you to add custom types of metadata into the XMP data. EXIF, on the other hand, does not - it has a fixed list of properties that cannot be extended.

>[!NOTE]
>
>XMP generally does not allow binary data types to be embedded. To carry binary data in XMP, for example, thumbnail images, they must be encoded in an XML-friendly format such as `Base64`.

### XMP concepts {#xmp-core-concepts}

The following sections describe the core concepts of XMP, including namespaces and schemata, properties and values, and language alternatives.

#### Namespaces and schemata {#namespaces-and-schemata}

An XMP schema is a set of property names in a common XML namespace that includes
the data type and descriptive information. An XMP schema is identified by its XML namespace URI. Using namespaces prevents conflicts between properties in different schemas that have the same name but a different meaning.

For example, the `Creator` property in two independently designed schemas might mean the person who created the asset or it could mean the application that created the asset (for example, Adobe Photoshop).

#### Properties and values {#properties-and-values}

XMP may include properties from one or more of the schemas. For example, a typical subset used by many Adobe applications might include the following:

* Dublin core schema: `dc:title`, `dc:creator`, `dc:subject`, `dc:format`, `dc:rights`.
* XMP basic schema: `xmp:CreateDate`, `xmp:CreatorTool`, `xmp:ModifyDate`, `xmp:metadataDate`.
* XMP rights management schema: `xmpRights:WebStatement`, `xmpRights:Marked`.
* XMP media management schema: `xmpMM:DocumentID`.

#### Language alternatives {#language-alternatives}

XMP lets you add an `xml:lang` property to text properties to specify the language of the text.

## Work with IPTC metadata {#support-for-iptc-metadata}

Learn how [!DNL Adobe Experience Manager Assets] supports the IPTC metadata, Creative ratings, and keywords added to assets through [!DNL Adobe Bridge] and other [!DNL Adobe Creative Cloud] apps.

[!DNL Adobe Experience Manager Assets] supports the IPTC metadata standard that is widely used to describe assets. This way, [!DNL Assets] enhances the acceptance of its images among various parties, including photographers, creative agencies, libraries, museums, and so on.

The default metadata schema for assets now incorporates the IPTC Core and IPTC Extension metadata schemas to define comprehensive metadata properties that allow users to add precise and reliable data about people, locations, and products shown in an image. It also supports dates, names, and identifiers regarding the creation of the image, and a flexible way to express rights information.

The Properties page for assets now includes separate tabs to display the IPTC Core and IPTC Extension metadata in editable fields.

1. From the [!DNL Assets] user interface, select an image.
1. Click **[!UICONTROL Properties]** from the toolbar.
1. Click the **[!UICONTROL IPTC]** tab to view the IPTC metadata for the asset.
1. Edit the IPTC metadata properties, as required.

   ![iptc_tab](assets/keywords-in-iptc-tab.png)

1. Click the **[!UICONTROL IPTC Extension]** tab to view IPTC Extension metadata for the asset.
1. Edit the IPTC Extension metadata properties, as required.
1. Click **[!UICONTROL Save & Close]** to save the changes.

### Creative rating support {#creative-rating-support}

In addition to displaying individual user ratings and aggregate ratings, the Properties page now displays the ratings assigned to assets through Adobe Bridge and other Creative Apps

These ratings are available under **[!UICONTROL Creative Rating]** section within the **[!UICONTROL Advanced]** tab.

This rating is a read-only property and ranges between 1-5. You can search for assets based on their Creative Rating from the Search Panel.

However, this property is currently not indexed to avoid any conflict with custom changes made by users.

### Keyword support {#keyword-support}

The **[!UICONTROL IPTC]** tab of the [!UICONTROL Properties] page also displays keywords added to assets through Adobe Bridge and other Adobe Creative Cloud apps. You can also edit these keywords and add more keywords from the **[!UICONTROL IPTC]** tab.

![keywords](assets/keywords-in-iptc-tab.png)

gha_language: Groovy