text:
# Translation Service

Welcome to Translation Service on Exercism's JavaScript Track.
If you need help running the tests or submitting your code, check out `HELP.md`.
If you get stuck on the exercise, check out `HINTS.md`, but try and solve it without using those first :)

## Introduction

The [`Promise`][promise-docs] object represents the eventual completion (or failure) of an
asynchronous operation and its resulting value.

The methods [`promise.then()`][promise-then], [`promise.catch()`][promise-catch], and [`promise.finally()`][promise-finally] are used to associate further action with a promise that becomes settled.

For example:

```javascript
const myPromise = new Promise(function (resolve, reject) {
  let sampleData = [2, 4, 6, 8];
  let randomNumber = Math.ceil(Math.random() * 5);
  if (sampleData[randomNumber]) {
    resolve(sampleData[randomNumber]);
  } else {
    reject('An error occured!');
  }
});

myPromise
  .then(function (e) {
    console.log(e);
  })
  .catch(function (error) {
    throw new Error(error);
  })
  .finally(function () {
    console.log('Promise completed');
  });
```

## Methods

These methods are available on `Promise.prototype`

**then**

> The `.then()` method takes up to two arguments; the first argument is a callback function for the resolved case of the promise, and the second argument is a callback function for the rejected case. Each `.then()` returns a newly generated promise object, which can optionally be used for chaining.[^1]

```javascript
const promise1 = new Promise(function (resolve, reject) {
  resolve('Success!');
});

promise1.then(function (value) {
  console.log(value);
  // expected output: "Success!"
});
```

**catch**

> A `.catch()` is just a `.then()` without a slot for a callback function for the case when the promise is resolved. It is used to handle rejected promises.[^2]

```javascript
const promise1 = new Promise((resolve, reject) => {
  throw 'An error occured';
});

promise1.catch(function (error) {
  console.error(error);
});
// expected output: An error occured
```

**finally**

> When the promise is settled, i.e either fulfilled or rejected, the specified callback function is executed. This provides a way for code to be run whether the promise was fulfilled successfully or rejected once the Promise has been dealt with.[^3]

```javascript
function findDataById(id) {
  return new Promise(function (resolve, reject) {
    let sampleData = [1, 2, 3, 4, 5];
    if (sampleData[id]) {
      resolve(sampleData[id]);
    } else {
      reject(new Error('Invalid id'));
    }
  });
}

findDataById(4)
  .then(function (response) {
    console.log(response);
  })
  .catch(function (err) {
    console.error(err);
  })
  .finally(function () {
    console.log('Promise completed');
  });
```

---

[^1]: `then`, MDN. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/then
[^2]: `catch`, MDN. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch
[^3]: `finally`, MDN. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/finally

[promise-docs]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
[promise-catch]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch
[promise-then]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/then
[promise-finally]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/finally

## Instructions

In this exercise, you'll be providing a `TranslationService` that provides basic translation services to free members, and advanced translation to premium members with quality assurances.

**The API**

You have found an outer space translation API that fulfills any translation `request` in a reasonable amount of time.
You want to capitalize on this.
The space translators are extremely fickle and hate redundancy, so they also provide _API storage_ satellites where you can `fetch` past translations without bothering them.

**_Fetching a translation_**

`api.fetch(text)` fetches a translation of `text` from the _API storage_ and returns a `promise` that provides two values:

- `translation`: the actual translation
- `quality`: the quality expressed as a number

If a translation is not found in the _API storage_, the API throws a `NotAvailable` error.
Translations can be added using the `api.request` method.
If 'text' is not translatable, the API throws an `Untranslatable` error.

```javascript
api.fetch('jIyaj');
// => Promise({ resolved: 'I understand' })
```

**_Requesting a translation_**

Some translations are sure to exist, but haven't been added to the _API storage_ yet. That's the difference between `NotAvailable` ( not in storage, but can be requested ) and `Untranslatable` ( cannot be translated ).

`api.request(text, callback)` requests that a translation of `text` be performed and added into the _API storage_.
On completion the `callback` function is called.

- On success `callback` is passed `undefined`: this indicates the translation was successful and is accessible using the `api.fetch` method.
- On failure `callback` is passed an `error`: this indicates something went wrong.
  The outspace API is _unstable_, which means that the API fails often.
  If that happens, it is okay to `api.request` again.

```javascript
api.request('majQa’');
// => Promise({ resolved: undefined })
```

**⚠ Warning! ⚠**

```exercism/caution
The API works its magic by teleporting in the various translators when a `request` comes in.
This is a very costly action, so it shouldn't be called when a translation *is* available.
Unfortunately, not everyone reads the manual, so there is a system in place to kick-out bad actors.

If an `api.request` is called for `text` is available, the API throws an `AbusiveClientError` for this call, **and every call after that**.
Ensure that you *never* request a translation if something has already been translated.
```

## 1. Fetch a translation, ignoring the quality

The free service only provides translations that are currently in the _API storage_.

Implement a method `free(text)` that provides free members with translation that already exist in the _API storage_.
Ignore the quality and forward any errors thrown by the API.
``

- Returns the translation if it can be retrieved, regardless of its quality
- Forwards any error from the translation API
- Uses the `api.fetch` method (`api.fetch` returns a `promise`)

```javascript
service.free('jIyaj');
// => Promise<...> resolves "I understand."

service.free("jIyajbe'");
// => Promise<...> rejects Error("Not yet translated")
```

## 2. Fetch a batch of translations, all-or-nothing

Implement a method `batch([text, text, ...])` for free members that translates an array of text using the free service, returning all the translations, or a single error.

- Resolves with all the translations (in the same order), if they are all available
- Rejects with the first error that is encountered
- Rejects with a `BatchIsEmpty` error if no texts are given

```javascript
service.batch(['jIyaj', "majQa'"]);
// => Promise<...> resolves ["I understand.", "Well done!"]

service.batch(['jIyaj', "jIyajbe'"]);
// => Promise<...> rejects new Error("Not yet translated")

service.batch([]);
// => Promise<...> rejects BatchIsEmpty()
```

## 3. Request a translation, retrying at most 2 times

Implement a premium user method `request(text)`, that _requests_ a translation be added to the _API storage_.
The request should automatically retry if a failure occurs.
It should perform no more than **3 calls** for the same request (_don't upset the space translators!!!_).

- If `api.request` does not return an error, resolve with `undefined`
- If `api.request` returns an error, retry at most two times
- If you run out of retries, reject with the last error received

```javascript
service.request("jIyajbe'");
// => Promise<...> resolves (with nothing), can now be retrieved using the fetch API
```

## 4. Fetch a translation, inspect the quality, or request it

Implement a premium user method `premium(text, quality)` to fetch a translation.
If a translation is `NotAvailable`, request the translation and fetch it after its been added to the _API storage_.
The method should only return the translation if it meets a certain `quality` threshold.

- If `api.fetch` resolves, check the quality before resolving
- If `api.fetch` rejects, _request_ the translation instead
- If `api.request` rejects, forward the error

```javascript
service.premium("jIyajbe'", 100);
// => Promise<...> resolves "I don't understand."

```

**N.B.**

```exercism/note
The correct translation of `'arlogh Qoylu'pu'?` is **How many times has it been heard?**.
```

## Source

### Created by

- @SleeplessByte

### Contributed to by

- @AndrewLawendy

repository: ErikSchierboom/exercism

repo_name: ErikSchierboom/exercism


text:
# Portfolio

#### HTML Website about Eric Halliday, 11/06/2019

### By Eric Halliday

## Description

 This page is a landing site for Eric Halliday's coding portfolio. It contains information about Eric, his background, and his interests, and it also provides links to some of his current projects.

## Setup

  * Simply clone this repository:

    https://github.com/emh221/portfolio.git

  * Copy the full path of the index.html within the project.

  * Paste the full path into your web browser and press Enter.

  or

  * Load the webpage from github pages by typing this url into your browser and hitting return:

    https://emh221.github.io/portfolio/

## Technologies Used

  HTML

  CSS

  Bootstrap

### Legal

  Copyright (c) 2019 Eric M Halliday

  This Software is licensed under the MIT license.

license: MIT

branch_name: refs/heads/main

extension: md

license_type: permissive


text:
Super easy Javascript implicit popup
====================================

The start_page.html contains a simple form.

- User clicks the authenticate button
- a pop up asks them to log into ORCID
- Once logged in the pop up sends them to return_page.html
- orcid_popup.html tells start_page.html their ORCID ID
- start_page.html updates the form with information and closes the popup.

To test locally
---------------
- start a webserver in this directory
  - use `python -m SimpleHTTPServer 8080` or
  - use `http-server` (`npm install http-server -g` to install)
- visit http://localhost:8080/start_page.html
- test
- update to use your credentials and the live service.  Details in the html file.
- test

To use in your own system
-------------------------

- Copy the code from start_page.html into your page
- Host the code from return_page.html on your server
- Update the files to use your client id and the live ORCID server
- Add the URL of your return_page.html to your client setup in ORCID
- Done.

Notes
-----

- The example uses bootstrap to make itself pretty.  This is not required to make it work.
- This can be done without the popup with a simple redirect (see the js-orcid-jwt example).

repository: yothenberg/orcid-openid-examples

branch_name: refs/heads/master

repo_name: yothenberg/orcid-openid-examples


text:
# Roadmap

## Summary.
Anoncoin was created in June 2013 as the first cryptocurrency with built-in support for I2P and Tor. The goal of the project was to create an anonymous peer-to-peer electronic cash system that is resistant to crackdowns from hostile entities.

Anoncoin's creator, Meeh, returned to the project in October 2017 with a small team of new developers. The project is currently in active development, and next release is expected in January 2018. This document will describe the current goals of the Anoncoin project and give an overview of planned features and releases.

## Anoncoin 0.9.7, released 13. June 2018.
* PoW changed to double GOST R 34.11-2012 hashing algorithm, mined with CPU/GPU.
* First step on the way for the release of Anoncash later this year.
* [Read release notes and download the wallet here.](https://github.com/Anoncoin/anoncoin/releases)

## Anoncash
* Anoncash is the next generation of private digital cash, created by the Anoncoin core team, more information coming soon.

## Project history.
Anoncoin was created in June 2013 as the first cryptocurrency with built-in support for I2P and Tor. Anoncoin was released in an entirely transparent manner and with a fair initial coin distribution. Though there was a small pre-mine of 4200 ANC for technical reasons, these coins were returned to the community through a public faucet, bounties, and give-a-ways.

Anoncoin was originally a fork of the Litecoin source code, and it now includes most aspects of Bitcoin Core 0.10. in addition to specific privacy-focused Anoncoin features.

Anoncoin was initially planning to implement Zerocoin in a trustless manner using RSA UFOs. Using RSA UFOs to implement the Zerocoin protocol turned out to be impractical, and we do not want to use a trusted setup. Instead, we want to take a different direction moving forward.

Anoncoin's founder returned to the project in October 2017 together with a small group of new developers. The project is currently in active development. The new team released Anoncoin 0.9.7 on July 13, 2018. The next release will be Anoncash, the next generation of private digital cash.

repository: Anoncoin/project

repo_name: Anoncoin/project


text:
# Datalogger loader

A utility to trail the Campbell datalogger TOA5 files and make the number of rows and the battery voltage available for scraping into
http://prometheus.io/, metrics are available on port 9094.

##Usage

    go build
    raingauge-loader < example.json


text:
# JWLoadingHUD

[![CI Status](https://img.shields.io/travis/10126121<EMAIL_ADDRESS>[![Version](https://img.shields.io/cocoapods/v/JWLoadingHUD.svg?style=flat)](https://cocoapods.org/pods/JWLoadingHUD)
[![License](https://img.shields.io/cocoapods/l/JWLoadingHUD.svg?style=flat)](https://cocoapods.org/pods/JWLoadingHUD)
[![Platform](https://img.shields.io/cocoapods/p/JWLoadingHUD.svg?style=flat)](https://cocoapods.org/pods/JWLoadingHUD)

## Example

To run the example project, clone the repo, and run `pod install` from the Example directory first.

## Requirements

## Installation

JWLoadingHUD is available through [CocoaPods](https://cocoapods.org). To install
it, simply add the following line to your Podfile:

```ruby
pod 'JWLoadingHUD'
```

## Author

jw10126121<EMAIL_ADDRESS>
## License

JWLoadingHUD is available under the MIT license. See the LICENSE file for more info.


text:
# GGR-cwl

[![Join the chat at https://gitter.im/alexbarrera/GGR-cwl](https://badges.gitter.im/alexbarrera/GGR-cwl.svg)](https://gitter.im/alexbarrera/GGR-cwl?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

CWL tools and workflows associated with the Genomics of Gene Regulation (GGR) project

GGR pipelines created using the [Common Workflow Language](http://www.commonwl.org/) `v1.0` specification.
The workflows are parametrized with values that best suit the GGR samples, but they can be easily tailored for specific needs.

For a detail User Guide to the CWL workflows, please see the [wiki](https://github.com/Duke-GCB/GGR-cwl/wiki).

If you need help navigating the files generated by the pipelines, have a look at the [processed files cheatsheet](v1.0/processed_output_files_help.tsv).

## [ChIP-seq](v1.0/ChIP-seq_pipeline):

### Pipelines
* [SE](v1.0/ChIP-seq_pipeline/pipeline-se.cwl)
* [SE - w/control](v1.0/ChIP-seq_pipeline/pipeline-se-with-control.cwl)
* [PE](v1.0/ChIP-seq_pipeline/pipeline-pe.cwl)
* [PE - w/control](v1.0/ChIP-seq_pipeline/pipeline-pe-with-control.cwl)

### Steps
* 01 - Fastq QC step:
    * [Fastq QC step - SE](v1.0/ChIP-seq_pipeline/01-qc-se.cwl)
    * [Fastq QC step - PE](v1.0/ChIP-seq_pipeline/01-qc-pe.cwl)
* 02 - Trimming reads step:
    * [Trimming step - SE](v1.0/ChIP-seq_pipeline/02-trim-se.cwl)
    * [Trimming step - PE](v1.0/ChIP-seq_pipeline/02-trim-pe.cwl)
* 03 - Mapping step:
    * [Mapping step - SE](v1.0/ChIP-seq_pipeline/03-map-se.cwl)
    * [Mapping step - PE](v1.0/ChIP-seq_pipeline/03-map-pe.cwl)
* 04 - Peak calling step:
    * [Peak calling step](v1.0/ChIP-seq_pipeline/04-peakcall.cwl)
    * [Peak calling step - with control](v1.0/ChIP-seq_pipeline/04-peakcall-with-control.cwl)
* 05 - Quantification step:
    * [Quantification step](v1.0/ChIP-seq_pipeline/05-quantification.cwl)
    * [Quantification step - with control](v1.0/ChIP-seq_pipeline/05-quantification-with-control.cwl)

## [DNase-seq](v1.0/DNase-seq_pipeline):

### Pipelines
* [SE](v1.0/DNase-seq_pipeline/pipeline-se.cwl)

### Steps
* 01 - Mapping step:
    * 01 - [Mapping step - SE](v1.0/DNase-seq_pipeline/01-map-se.cwl)
* 02 - Peak calling step:
    * 02 - [Peak calling step](v1.0/DNase-seq_pipeline/02-peakcall.cwl)
* 03 - Quantification step:
    * 03 - [Quantification step](v1.0/DNase-seq_pipeline/03-quantification.cwl)

## [RNA-seq](v1.0/RNA-seq_pipeline):

### Pipelines
* [SE - Unstranded](v1.0/RNA-seq_pipeline/pipeline-se-unstranded.cwl)
* [SE - Unstranded - w/sjdb](v1.0/RNA-seq_pipeline/pipeline-se-unstranded-with-sjdb.cwl)
* [SE - Stranded](v1.0/RNA-seq_pipeline/pipeline-se-stranded.cwl)
* [SE - Stranded - w/sjdb](v1.0/RNA-seq_pipeline/pipeline-se-stranded-with-sjdb.cwl)
* [SE - Revstranded](v1.0/RNA-seq_pipeline/pipeline-se-revstranded.cwl)
* [SE - Revstranded - w/sjdb](v1.0/RNA-seq_pipeline/pipeline-se-revstranded-with-sjdb.cwl)
* [PE - Unstranded](v1.0/RNA-seq_pipeline/pipeline-pe-unstranded.cwl)
* [PE - Unstranded - w/sjdb](v1.0/RNA-seq_pipeline/pipeline-pe-unstranded-with-sjdb.cwl)
* [PE - Stranded](v1.0/RNA-seq_pipeline/pipeline-pe-stranded.cwl)
* [PE - Stranded - w/sjdb](v1.0/RNA-seq_pipeline/pipeline-pe-stranded-with-sjdb.cwl)
* [PE - Revstranded](v1.0/RNA-seq_pipeline/pipeline-pe-revstranded.cwl)
* [PE - Revstranded - w/sjdb](v1.0/RNA-seq_pipeline/pipeline-pe-revstranded-with-sjdb.cwl)

### Steps
* 00 - Genome files generation for STAR and RSEM:
    * 00 - [Preprocessing step](v1.0/RNA-seq_pipeline/00-preprocessing.cwl)
* 01 - Fastq QC step:
    * 01 - [Fastq QC step - SE](v1.0/RNA-seq_pipeline/01-qc-se.cwl)
    * 01 - [Fastq QC step - PE](v1.0/RNA-seq_pipeline/01-qc-pe.cwl)
* 02 - Trimming reads step:
    * 02 - [Trimming step - SE](v1.0/RNA-seq_pipeline/02-trim-se.cwl)
    * 02 - [Trimming step - PE](v1.0/RNA-seq_pipeline/02-trim-pe.cwl)
* 03 - Mapping step:
    * 03 - [Mapping step - SE](v1.0/RNA-seq_pipeline/03-map-se.cwl)
    * 03 - [Mapping step - SE - w/sjdb](v1.0/RNA-seq_pipeline/03-map-se-with-sjdb.cwl)
    * 03 - [Mapping step - PE](v1.0/RNA-seq_pipeline/03-map-pe.cwl)
    * 03 - [Mapping step - PE - w/sjdb](v1.0/RNA-seq_pipeline/03-map-pe-with-sjdb.cwl)
* 04 - Quantification step:
    * 04 - [Quantification step - SE - Unstranded](v1.0/RNA-seq_pipeline/04-quantification-se-unstranded.cwl)
    * 04 - [Quantification step - SE - Stranded](v1.0/RNA-seq_pipeline/04-quantification-se-stranded.cwl)
    * 04 - [Quantification step - SE - Revstranded](v1.0/RNA-seq_pipeline/04-quantification-se-revstranded.cwl)
    * 04 - [Quantification step - PE - Unstranded](v1.0/RNA-seq_pipeline/04-quantification-pe-unstranded.cwl)
    * 04 - [Quantification step - PE - Stranded](v1.0/RNA-seq_pipeline/04-quantification-pe-stranded.cwl)
    * 04 - [Quantification step - PE - Revstranded](v1.0/RNA-seq_pipeline/04-quantification-pe-revstranded.cwl)

## [ATAC-seq](v1.0/ATAC-seq_pipeline):

### Pipelines
* [SE](v1.0/ATAC-seq_pipeline/pipeline-se.cwl)
* [SE - Blacklist Removal](v1.0/ATAC-seq_pipeline/pipeline-se-blacklist-removal.cwl)
* [PE](v1.0/ATAC-seq_pipeline/pipeline-pe.cwl)
* [PE - Blacklist Removal](v1.0/ATAC-seq_pipeline/pipeline-pe-blacklist-removal.cwl)

### Steps
* 01 - Fastq QC step:
    * [Fastq QC step - SE](v1.0/ATAC-seq_pipeline/01-qc-se.cwl)
    * [Fastq QC step - PE](v1.0/ATAC-seq_pipeline/01-qc-pe.cwl)
* 02 - Trimming reads step:
    * [Trimming step - SE](v1.0/ATAC-seq_pipeline/02-trim-se.cwl)
    * [Trimming step - PE](v1.0/ATAC-seq_pipeline/02-trim-pe.cwl)
* 03 - Mapping step:
    * [Mapping step - SE](v1.0/ATAC-seq_pipeline/03-map-se.cwl)
    * [Mapping step - SE - Blacklist Removal](v1.0/ATAC-seq_pipeline/03-map-se-blacklist-removal.cwl)
    * [Mapping step - PE](v1.0/ATAC-seq_pipeline/03-map-pe.cwl)
    * [Mapping step - PE - Blacklist Removal](v1.0/ATAC-seq_pipeline/03-map-pe-blacklist-removal.cwl)
* 04 - Peak calling step:
    * [Peak calling step - SE](v1.0/ATAC-seq_pipeline/04-peakcall-se.cwl)
    * [Peak calling step - PE](v1.0/ATAC-seq_pipeline/04-peakcall-pe.cwl)
* 05 - Quantification step:
    * [Quantification step](v1.0/ATAC-seq_pipeline/05-quantification.cwl)

## [STARR-seq](v1.0/STARR-seq_pipeline):

### Pipelines
* [PE](v1.0/STARR-seq_pipeline/pipeline-pe.cwl)
* [PE - UMIs](v1.0/STARR-seq_pipeline/pipeline-pe-umis.cwl)

### Steps
* 01 - Fastq QC step:
    * [Fastq QC step - PE](v1.0/STARR-seq_pipeline/01-qc-pe.cwl)
* 02 - Trimming reads step:
    * [Trimming step - PE](v1.0/STARR-seq_pipeline/02-trim-pe.cwl)
* 03 - Mapping step:
    * [Mapping step - PE](v1.0/STARR-seq_pipeline/03-map-pe.cwl)
    * [Mapping step - PE - UMIs](v1.0/STARR-seq_pipeline/03-map-pe-umis.cwl)
* 04 - Quantification step:
    * [Quantification step](v1.0/STARR-seq_pipeline/04-quantification.cwl)

----------------------------------------------------------------------------------------------------------
##### Workflow differences legend
Depending on the experiments, there might be small differences in the workflows which will be determined by:

- All
    - Type of read:
        - SE: Single End reads
        - PE: Paired-End reads
- ChIP-seq only
    - With or without control. If a control sample is available `-with-control` or not.
- RNA-seq only
    - Strand specificity:
        - Unstranded: reads are not strand-specific, is not possible to know from which DNA strand they come.
        - Stranded: reads are strand-specific and can be map to the Watson and Crick strands.
        - Reverse Stranded: reads come from cDNA, which switches the mapping of the forward and reverse strand.
    - Custom SJDB: By default the STAR 2-pass mapping strategy is implemented in which a first pass of STAR is run to generate a large pool of novel splice junctions (referred as SJDB). These junctions are used to generate a genome index which is employed in the mapping step. However, this 2-pass strategy can be skipped, using a custom genome index Because typically this genome would be created with a precomputed SJDB, this option is denoted with `-with-sjdb`.
- ATAC-seq only
    - Blacklist removal: whether or not to mask out blacklisted regions.

repository: Duke-GCB/GGR-cwl

gha_language: Common Workflow Language

gha_license_id: MIT

repo_name: Duke-GCB/GGR-cwl


text:
# Targo Tap
Tap the tiles that are the same number of the center box's number!

# Targo Tap Releases
All indev releases are in the repo under indev_releases. Android Studio folders are under a seperate folder in that same parent folder.

#Links
## Google Play Link
https://play.google.com/store/apps/details?id=com.devaprise.targo_tap
## Khan Academy Port
https://www.khanacademy.org/computer-programming/targo-tap-ka-version/5712947721666560

repository: Devaprise/Targo-Tap

repo_name: Devaprise/Targo-Tap


text:
---
layout: default
---

# 1994-04-08 - RE: RMorality and Ethics (was Pseudonym's and Reputation)

## Header Data

From<EMAIL_ADDRESS>(Curtis D. Frye)

To: Blanc Weber<EMAIL_ADDRESS>Message Hash: 7bf5e38b938f4b5fe4c23bd004358d34bf3a339a142afe6f909a281bfb2b2ddd

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-04-08 19:54:08 UTC

Raw Date: Fri, 8 Apr 94 12:54:08 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Curtis D. Frye)
Date: Fri, 8 Apr 94 12:54:08 PDT
To: Blanc Weber<EMAIL_ADDRESS>Subject: RE: RMorality and Ethics (was Pseudonym's and Reputation)
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Blanc Weber says:
>
>>*** Morality is the ablility to differentiate between right and wrong,
>>without denotation.  Thus, each situation defines an eidetic decision
>>and implementation which would be the application of an ethical standard
>>based on past experience.  Therefore, endogenous morality is quite tangible,
>>while exogenous morality is most likely unethical, and detrimental to the
>>purity of being. ***
>
>I couldn't understand this paragraph very well, as it is too cryptic.
>

Attempted translation:  Morality is both individual and situational, and
must not be externally imposed as the imposition would violate individual
sovereignty.

--
Best regards,

Curtis D. Frye
<EMAIL_ADDRESS>or<EMAIL_ADDRESS>"Here today, gone ?????^H^H^H^H^HFriday, April 8th"

{% endraw %}
```

## Thread

+ Return to [April 1994](/archive/1994/04)

+ Return to<EMAIL_ADDRESS>(Curtis D. Frye)](/authors/cfrye_at_ciis_mitre_org_curtis_d_frye_)"

+ 1994-04-08 (Fri, 8 Apr 94 12:54:08 PDT) - RE: RMorality and Ethics (was Pseudonym's and Reputation) -<EMAIL_ADDRESS>(Curtis D. Frye)_


text:
# BillingAddress

## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**City** | **string** |  |
**Country** | Pointer to **string** |  | [optional] [default to "PL"]
**Street** | **string** |  |
**Zipcode** | **string** |  |

## Methods

### NewBillingAddress

`func NewBillingAddress(city string, street string, zipcode string, ) *BillingAddress`

NewBillingAddress instantiates a new BillingAddress object
This constructor will assign default values to properties that have it defined,
and makes sure properties required by API are set, but the set of arguments
will change when the set of required properties is changed

### NewBillingAddressWithDefaults

`func NewBillingAddressWithDefaults() *BillingAddress`

NewBillingAddressWithDefaults instantiates a new BillingAddress object
This constructor will only assign default values to properties that have it defined,
but it doesn't guarantee that properties required by API are set

### GetCity

`func (o *BillingAddress) GetCity() string`

GetCity returns the City field if non-nil, zero value otherwise.

### GetCityOk

`func (o *BillingAddress) GetCityOk() (*string, bool)`

GetCityOk returns a tuple with the City field if it's non-nil, zero value otherwise
and a boolean to check if the value has been set.

### SetCity

`func (o *BillingAddress) SetCity(v string)`

SetCity sets City field to given value.

### GetCountry

`func (o *BillingAddress) GetCountry() string`

GetCountry returns the Country field if non-nil, zero value otherwise.

### GetCountryOk

`func (o *BillingAddress) GetCountryOk() (*string, bool)`

GetCountryOk returns a tuple with the Country field if it's non-nil, zero value otherwise
and a boolean to check if the value has been set.

### SetCountry

`func (o *BillingAddress) SetCountry(v string)`

SetCountry sets Country field to given value.

### HasCountry

`func (o *BillingAddress) HasCountry() bool`

HasCountry returns a boolean if a field has been set.

### GetStreet

`func (o *BillingAddress) GetStreet() string`

GetStreet returns the Street field if non-nil, zero value otherwise.

### GetStreetOk

`func (o *BillingAddress) GetStreetOk() (*string, bool)`

GetStreetOk returns a tuple with the Street field if it's non-nil, zero value otherwise
and a boolean to check if the value has been set.

### SetStreet

`func (o *BillingAddress) SetStreet(v string)`

SetStreet sets Street field to given value.

### GetZipcode

`func (o *BillingAddress) GetZipcode() string`

GetZipcode returns the Zipcode field if non-nil, zero value otherwise.

### GetZipcodeOk

`func (o *BillingAddress) GetZipcodeOk() (*string, bool)`

GetZipcodeOk returns a tuple with the Zipcode field if it's non-nil, zero value otherwise
and a boolean to check if the value has been set.

### SetZipcode

`func (o *BillingAddress) SetZipcode(v string)`

SetZipcode sets Zipcode field to given value.

[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)


text:
Installing the K Framework Package
==================================

We currently strive to provide packages for the following platforms:

-   Ubuntu Bionic Beaver (18.04) and Focal Fossa (20.04)
-   Debian Bullseye
-   Arch Linux
-   MacOS X Mojave/Homewbrew
-   Docker Images

Pre-installation Notes
----------------------

-   We **do not** currently support running K natively on Windows. To use K on
    Windows 10, you are encouraged to install the
    [Windows Subsystem for Linux (version 2)](https://docs.microsoft.com/en-us/windows/wsl/install-win10)
    and follow the instructions for installing Ubuntu Bionic.

    If you have already installed WSL, before proceeding, you will need to
    enter the WSL environment. You can do this by:

    1.  opening up the command prompt (accessible by searching `cmd` or
        `command prompt` from the start menu);
    2.  using the `wsl.exe` command to access the WSL environment.

-   To use K in other non-linux environments (e.g. Windows 8 or earlier),
    you will need to use a virtual machine (VM) software. We assume you have:

    1.  Created a virtual machine
    2.  Installed a Linux distribution (e.g. Ubuntu Bionic Beaver) on your
        virtual machine

    Consult your virtual machine software if you need help with the above
    steps. We recommend the free VirtualBox virtual machine software.

    Before proceeding, follow the virtual machine softare UI to start your
    Linux virtual machine and enter the command line environment.

-   WSL and virtual machine users should be aware that, if you use your web
    browser to download the package, you will need to make it accessible to
    the command line environment. For this reason, we recommend downloading the
    package from the command line directly using a tool like `wget`. For
    example, you could copy the package download URL and then type:

    ```
    wget <package-download-url>
    ```

    where `<package-download-url>` is replaced by the URL you just copied.

-   The packages we distribute do **not** include the OCaml backend dependency
    setup. However, we include
    [instructions below](#installing-the-ocaml-backend-optional) on using the
    OCaml backend with the package-installed K.

Downloading Packages
--------------------

Download the appropriate package from the GitHub, via the
[Releases](https://github.com/kframework/k/releases) page.
Releases are generated as often as possible from `master` build.

Installing Packages
-------------------

For version `X.Y.Z`, disto `DISTRO`, and package ID `ID`, the following
instructions tell you how to install on each system. Note that this typically
requires about ~1.4GB of dependencies and will take some time.

-   On Linux systems, K will typically be installed under `/usr`.
-   On macOS/brew, K will typically be installed under `/usr/local`.

### Ubuntu Bionic (18.04)

```sh
sudo apt install ./kframework_X.Y.Z_amd64_bionic.deb
```

### Ubuntu Focal (20.04)

```sh
sudo apt install ./kframework_X.Y.Z_amd64_focal.deb
```

### Debian Bullseye

```sh
sudo apt install ./kframework_X.Y.Z_amd64_bullseye.deb
```

### Arch Linux

```sh
pacman -U ./kframework-git-X.Y.Z-1-x86_64.pkg.tar.zst
```

### MacOS X Mojave/Homebrew

[Homebrew](https://brew.sh/) (or just brew) is a third-party package manager
for MacOS.
If you have not installed brew, you must do so before installing the K
Framework brew package.

With brew installed, do the following to install the K Framework brew package
(with build number `BN`):

```sh
brew install kframework--X.Y.Z.ID.bottle.BN.tar.gz -v
```

Note: the brew package should install on MacOS X Catalina systems even though
the package was built for Mojave.

#### Homebrew Alternate Installation

To directly install the latest K Framework brew package without needing to
download it separately, do the following:

```sh
brew install kframework/k/kframework
```

Or, to streamline future K Framework upgrades, you can `tap` the K Framework
package repository. This lets future installations/upgrades/etc... use the
unprefixed package name.

```sh
brew tap kframework/k
brew install kframework
```

### Docker Images

Docker images with K pre-installed are available at the
[runtimeverification/kframework-k Docker Hub repository](https://hub.docker.com/repository/docker/runtimeverificationinc/kframework-k).

Each release at `COMMIT_ID` has an image associated with it at
`runtimeverificationinc/kframework-k:ubuntu-focal-COMMIT_ID`.
The latest `master` build Docker image can be accessed with `COMMIT_ID` set to
`master`.

To run the image directly:

```sh
docker run -it runtimeverificationinc/kframework-k:ubuntu-focal-COMMIT_ID
```

and to make a Docker Image based on it, use the following line in your
`Dockerfile`:

```Dockerfile
FROM runtimeverificationinc/kframework-k:ubuntu-focal-COMMIT_ID
```

We also create Ubuntu 18.04 images with the `ubuntu-bionic-COMMIT_ID` tags.

Installing the OCaml Backend (Optional)
---------------------------------------

**NOTE**: It is *strongly* recommended that you use the LLVM backend instead of
the OCaml backend. The OCaml backend is being sunsetted.

To use the OCaml backend requires an installation of the OCaml package manager
`opam`. Instructions on installing `opam` are available here:
<https://opam.ocaml.org/doc/Install.html>.
You should install on Windows by following the instructions for the Linux
distribution you installed for Windows Subsystem for Linux.

Once `opam` is installed, you can prepare the installation to run the OCaml
backend by running (for a user-local install):

```sh
k-configure-opam
eval $(opam config env)
```

`k-configure-opam` is in the `k/bin` directory, and the `eval` command sets up
your OCaml environment. You can optionally control where the OCaml dependencies
are installed by setting the `OPAMROOT` environment variable before running the
above commands with `export OPAMROOT=/path/to/opam/root`.

Testing Packages
----------------

The easiest way to test the K package is to copy a K tutorial language and
check if you can compile and run an included example.

1.  Start by copying the K tutorial to some work directory
    (e.g. `$HOME/pl-tutorial`) from the K distribution root. Using a Linux
    package, this command typically will be like:

    ```sh
    $ cp -R /usr/share/kframework/pl-tutorial $HOME/pl-tutorial
    ```

    On macOS/brew, this command typically will be like:

    ```sh
    $ cp -R /usr/local/share/kframework/pl-tutorial $HOME/pl-tutorial
    ```

    This step is needed because sometimes only the `root` user can run the
    examples in the default installation directory.

2.  Now you can try to run some programs:

    ```sh
    $ cd $HOME/pl-tutorial/2_languages/1_simple/1_untyped
    $ make kompile
    $ krun tests/diverse/factorial.simple
    ```


text:
# Overview
This workspace houses simulation software. Any software that can be run ONLY on the platform is
housed elsewhere.

If you are installing this software, you should be able to simulate a car-like robot using the
same commands as the turtlebot simulator. There are significant differences in the kinematic
models of a unicycle (like the turtlebot) and a car-like robot (like the CAT Vehicle), namely
the ability to change orientation without moving (for a unicycle) is not possible for a car-like
robot.

## Goals
The usefulness of this simulator is to experiment with controllers and ideas that must be explored
with realistic limitations in computing power, and latency of communication, all while controlling
a system that obeys physical laws of motion. To this end, our simulator is not intended to
perfectly mirror our physical system, but rather to provide an easy to use (and safe to fail in)
environment that uses the same communication models, functional inputs, and sensor types.

## Limitations
Because our simulation uses Gazebo as its major engine to advance time for the physical system's
state, we are limited by the limitations in Gazebo:
 * Simulation results may not be repeatable
 * Simulations may not run in real time on all hardware platforms
 * The physical system's model will not perfectly mirror the physical vehicle

Among the reasons for an approximate simulation model are that (i) simulation times will increase
the more accurate the Gazebo model becomes; (ii) the costs associated with obtaining accurate
masses and inertias for the physical system are not negligible, but the simulation results are not
repeatable so the goal to perfom this system identification is suspect; and (iii) settings of the
simulation step size and real-time factor are selected in order to provide a representative
behavior of the vehicle, rather than mirror "real life," in order to speed up simulation. If you
reduce the step size by an order of magnitude, it is not clear whether the results are more or
less accurate without significant investment in system identification.

Nonetheless, advice and recommendations to improve the Gazebo model and/or the simulation setup
are welcome, as long as they are accompanied by data that back up the suggestion (or experiments
that would couple physical platform data with simulator data).

# Installation

Step-by-step installation instructions may be found in the internal packages and their README
files. Tutorials for how to download, build, and install the software and run the simulations are
found on the main webpage or are linked from http://csl.arizona.edu

# About
The CAT Vehicle project is housed at the University of Arizona in the Compositional Systems
Laboratory. The project is directed by Dr. Jonathan Sprinkle, and is based on long-term
fundamental research in cyber-physical systems conducted through funding by the National
Science Foundation under award numbers 1262960, 1253334, 1446435, and 1544395. Additional
support from the Air Force Office of Scientific Research is provided under award 1262960.

Any opinions, findings, and conclusions or recommendations expressed in this material are
those of the author(s) and do not necessarily reflect the views of the National Science
Foundation or the Air Force Office of Scientific Research.

# License

The BSD License

Copyright (c) 2015-2016 Arizona Board of Regents
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted
provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this list of conditions
  and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of
  conditions and the following disclaimer in the documentation and/or other materials provided
  with the distribution.

# Authors

Jonathan Sprinkle<EMAIL_ADDRESS>
Individual licenses for re-distributed products do not conflict with the above license. In those
redistributed packages, additional acknowledgments are included.

repository: rggasoto/gary

repo_name: rggasoto/gary


text:
###  • animation-timing-function
**Summary:**

The animation-timing-function CSS property determines whether an animation is running or paused. You can query this property's value to determine whether or not the animation is currently running; in addition, you can set its value to pause and resume playback of an animation.

Resources: **[WebPlatform](http://docs.webplatform.org/wiki/css/properties/animation-timing-function)**, **[MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/animation-timing-function)**

**Syntax:**

Default value: ease

    .animation-timing-function(<single-animation-timing-function>, …)

**Example:**

    div {
     .animation-timing-function(cubic-bezier(0.1, 0.7, 1.0, 0.1));
    }

    // Result
    div {
     -webkit-animation-timing-function: cubic-bezier(0.1, 0.7, 1.0, 0.1);
     -moz-animation-timing-function: cubic-bezier(0.1, 0.7, 1.0, 0.1);
     -opera-animation-timing-function: cubic-bezier(0.1, 0.7, 1.0, 0.1);
     animation-timing-function: cubic-bezier(0.1, 0.7, 1.0, 0.1);
    }

gha_language: CSS


text:
+++
title = "knife role"
draft = false

gh_repo = "chef-workstation"

aliases = ["/knife_role.html", "/knife_role/"]

[menu]
  [menu.workstation]
    title = "knife role"
    identifier = "chef_workstation/chef_workstation_tools/knife/knife_role.md knife role"
    parent = "chef_workstation/chef_workstation_tools/knife"
+++
<!-- markdownlint-disable-file MD024 MD036 -->

{{< readfile file="content/reusable/md/role.md" >}}

{{< readfile file="content/workstation/reusable/md/knife_role_summary.md" >}}

{{< note >}}

To add a role to a node and then build out the run-list for that node,
use the [knife node](/workstation/knife_node/) subcommand and its `run_list add`
argument.

{{< /note >}}

{{< note >}}

{{< readfile file="content/workstation/reusable/md/knife_common_see_common_options_link.md" >}}

{{< /note >}}

## bulk delete

Use the `bulk delete` argument to delete one or more roles that match a
pattern defined by a regular expression. The regular expression must be
within quotes and not be surrounded by forward slashes (/).

### Syntax

This argument has the following syntax:

``` bash
knife role bulk delete REGEX
```

### Options

This command does not have any specific options.

### Examples

The following examples show how to use this knife subcommand:

**Bulk delete roles**

Use a regular expression to define the pattern used to bulk delete
roles:

``` bash
knife role bulk delete "^[0-9]{3}$"
```

## create

Use the `create` argument to add a role to the Chef Infra Server. Role
data is saved as JSON on the Chef Infra Server.

### Syntax

This argument has the following syntax:

``` bash
knife role create ROLE_NAME (options)
```

### Options

This argument has the following options:

`--description DESCRIPTION`

: The description of the role. This value populates the description
    field for the role on the Chef Infra Server.

{{< note >}}

{{< readfile file="content/workstation/reusable/md/knife_common_see_all_config_options.md" >}}

{{< /note >}}

### Examples

The following examples show how to use this knife subcommand:

**Create a role**

To add a role named `role1`, enter:

``` bash
knife role create role1
```

In the \$EDITOR enter the role data in JSON:

``` javascript
{
   "name": "role1",
   "default_attributes": {
   },
   "json_class": "Chef::Role",
   "run_list": ["recipe[cookbook_name::recipe_name]",
                 "role[role_name]"
   ],
   "description": "",
   "chef_type": "role",
   "override_attributes": {
   }
}
```

When finished, save it.

## delete

Use the `delete` argument to delete a role from the Chef Infra Server.

### Syntax

This argument has the following syntax:

``` bash
knife role delete ROLE_NAME
```

### Options

This command does not have any specific options.

### Examples

The following examples show how to use this knife subcommand:

**Delete a role**

``` bash
knife role delete devops
```

Type `Y` to confirm a deletion.

## edit

Use the `edit` argument to edit role details on the Chef Infra Server.

### Syntax

This argument has the following syntax:

``` bash
knife role edit ROLE_NAME
```

### Options

This command does not have any specific options.

### Examples

The following examples show how to use this knife subcommand:

**Edit a role**

To edit the data for a role named `role1`, enter:

``` bash
knife role edit role1
```

Update the role data in JSON:

``` javascript
{
   "name": "role1",
   "description": "This is the description for the role1 role.",
   "json_class": "Chef::Role",
   "default_attributes": {
   },
   "override_attributes": {
   },
   "chef_type": "role",
   "run_list": ["recipe[cookbook_name::recipe_name]",
                "role[role_name]"
   ],
   "env_run_lists": {
   },
}
```

When finished, save it.

## from file

Use the `from file` argument to create a role using existing JSON data
as a template.

### Syntax

This argument has the following syntax:

``` bash
knife role from file FILE
```

### Options

This command does not have any specific options.

{{< note >}}

{{< readfile file="content/workstation/reusable/md/knife_common_see_all_config_options.md" >}}

{{< /note >}}

### Examples

The following examples show how to use this knife subcommand:

**Create a role using JSON data**

To view role details based on the values contained in a JSON file:

``` bash
knife role from file "path to JSON file"
```

## list

Use the `list` argument to view a list of roles that are currently
available on the Chef Infra Server.

### Syntax

This argument has the following syntax:

``` bash
knife role list
```

### Options

This argument has the following options:

`-w`, `--with-uri`

: Show the corresponding URIs.

### Examples

The following examples show how to use this knife subcommand:

**View a list of roles**

To view a list of roles on the Chef Infra Server and display the URI for
each role returned, enter:

``` bash
knife role list -w
```

## show

Use the `show` argument to view the details of a role.

### Syntax

This argument has the following syntax:

``` bash
knife role show ROLE_NAME
```

### Options

This argument has the following options:

`-a ATTR`, `--attribute ATTR`

: The attribute (or attributes) to show.

{{< note >}}

{{< readfile file="content/workstation/reusable/md/knife_common_see_all_config_options.md" >}}

{{< /note >}}

### Examples

The following examples show how to use this knife subcommand:

**Show as JSON data**

To view information in JSON format, use the `-F` common option as part
of the command like this:

``` bash
knife role show devops -F json
```

Other formats available include `text`, `yaml`, and `pp`.

**Show as raw JSON data**

To view node information in raw JSON, use the `-l` or `--long` option:

``` bash
knife role show -l -F json <role_name>
```

and/or:

``` bash
knife role show -l --format=json <role_name>
```

repository: chef/chef-workstation

gha_language: Go

repo_name: chef/chef-workstation


text:
The SportMonks API provides the functionality to add 'filter' parameters to filter the data returned
by a specific endpoint.

Below is an example of retrieving fixtures by a specific date but reducing the returned data to specific leagues:

```go
package main

import (
	"context"
	"fmt"
	"github.com/statistico/statistico-sportmonks-go-client"
	"time"
)

const dateFormat = "2006-01-02"

func main() {
	client := sportmonks.NewDefaultHTTPClient("YOUR_TOKEN_GOES_HERE")

	var includes []string
	filters := make(map[string][]int)
	filters["leagues"] = []int{8, 10}

	date, _ := time.Parse(dateFormat, "2019-03-12")

	fixtures, _, err := client.FixturesByDate(context.Background(), date, includes, filters)

	if err != nil {
		fmt.Printf("%s\n", err)
		return
	}

	for _, fixture := range fixtures {
		// Do something with fixture variable
	}
}
```


text:
[![CI Testing](https://github.com/chembl/ChEMBL_Structure_Pipeline/workflows/CI/badge.svg)](https://github.com/chembl/ChEMBL_Structure_Pipeline/actions?query=workflow%3ACI+branch%3Amaster)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

# ChEMBL Structure Pipeline

ChEMBL protocols used to standardise and salt strip molecules. First used in ChEMBL 26.

Check the [wiki](https://github.com/chembl/ChEMBL_Structure_Pipeline/wiki) and paper[[1]](#1) for a detailed description of the different processes.

## Installation

From source:

    git clone https://github.com/chembl/ChEMBL_Structure_Pipeline.git
    pip install ./ChEMBL_Structure_Pipeline

with pip:

```bash
pip install chembl_structure_pipeline
```

with conda:

```bash
conda install -c conda-forge chembl_structure_pipeline
```

## Usage

### Standardise a compound [(info)](https://github.com/chembl/ChEMBL_Structure_Pipeline/wiki/Work-done-by-each-step#standardize_molblock)

```python
from chembl_structure_pipeline import standardizer

o_molblock = """
  Mrv1810<PHONE_NUMBER>2D

  4  3  0  0  0  0            999 V2000
   -2.5038    0.4060    0.0000 C   0  0  3  0  0  0  0  0  0  0  0  0
   -2.5038    1.2310    0.0000 O   0  5  0  0  0  0  0  0  0  0  0  0
   -3.2182   -0.0065    0.0000 N   0  3  0  0  0  0  0  0  0  0  0  0
   -1.7893   -0.0065    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
  1  2  1  0  0  0  0
  1  3  1  0  0  0  0
  1  4  1  4  0  0  0
M  CHG  2   2  -1   3   1
M  END
"""

std_molblock = standardizer.standardize_molblock(o_molblock)
```

### Get the parent compound [(info)](https://github.com/chembl/ChEMBL_Structure_Pipeline/wiki/Work-done-by-each-step#get_parent_molblock)

```python
from chembl_structure_pipeline import standardizer

o_molblock = """
  Mrv1810<PHONE_NUMBER>2D

  3  1  0  0  0  0            999 V2000
   -5.2331    1.1053    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
   -4.5186    1.5178    0.0000 N   0  3  0  0  0  0  0  0  0  0  0  0
   -2.8647    1.5789    0.0000 Cl  0  5  0  0  0  0  0  0  0  0  0  0
  1  2  1  0  0  0  0
M  CHG  2   2   1   3  -1
M  END
"""

parent_molblock, _ = standardizer.get_parent_molblock(o_molblock)
```

### Check a compound [(info)](https://github.com/chembl/ChEMBL_Structure_Pipeline/wiki/Work-done-by-each-step#checkmolecule)

The checker assesses the quality of a structure. It highlights specific features or issues in the structure that may need to be revised. Together with the description of the issue, the checker process returns a penalty score (between 0-9) which reflects the seriousness of the issue (the higher the score, the more critical is the issue)

```python
from chembl_structure_pipeline import checker

o_molblock = """
  Mrv1810<PHONE_NUMBER>2D

  4  3  0  0  0  0            999 V2000
    2.2321    4.4196    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
    3.0023    4.7153    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
    1.4117    4.5059    0.0000 O   0  0  0  0  0  0  0  0  0  0  0  0
    1.9568    3.6420    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
  1  2  1  1  0  0  0
  1  3  1  0  0  0  0
  1  4  1  0  0  0  0
M  END
"""

issues = checker.check_molblock(o_molblock)
```

## References
[1]
Bento, A.P., Hersey, A., Félix, E. et al. An open source chemical structure curation pipeline using RDKit. J Cheminform 12, 51 (2020). https://doi.org/10.1186/s13321-020-00456-1

gha_language: Python


text:
PuTTY-Color-Schemes
===================

PuTTY Terminal Color Schemes/Themes Gallery

``/reg/`` — Themes for standard PuTTY.
>Just execute .reg file to create new session with colors,
>or edit .reg file and put the name of existing session as regedit path to change colors of your existing session.

``/file/`` — Themes for PuTTY portable forks (with patched winstore.c, not portableApps).
>Put the colours config to the beginning of your session's file

Inspired by russian's [PuTTY](http://putty.org.ru/themes/index.html) colours collection.

repository: bamanzi/themes-pack

repo_name: bamanzi/themes-pack


text:
# mediainfo

> Display metadata from video and audio files.

- Display metadata for a given file in the console:

`mediainfo {{file}}`

- Store the output to a given file along with displaying in the console:

`mediainfo --Logfile={{out.txt}} {{file}}`

- Display the list of metadata attributes that can be extracted:

`mediainfo --Info-Parameters`

repository: chrillebile/tldr

repo_name: chrillebile/tldr


text:
# PlayerCentricIntelligence

# Introduction
Our goal was to shed light on user acquistion, in-game behavior, and app monetization by supplementing PlayFab event data with several complementary sources.

PlayFab's Azure Data Explorer database is vast, so we preferred to bring all other data to _it_, rather than vice-versa.

This project does so with a handful of Azure resources, most notably Data Factory. It also contains sample KQL queries that we used to model data and to validate it against the raw sources.

Note that our solutions begins with a relational database that Fivetran populates from API and S3 sources. We use SQL DW, but a standard Azure SQL DB should be a suitable and lower-cost alternative. You might bypass this by handling all connections through Azure Data Factory's HTTP connector, but we heartily recommend Fivetran as a simpler and more cost-effective alternative to maintaining often-volatile API connections.

# The Data Model

We've included (in _Model.zip_) some sample ADX queries that yield fact and dimension tables. We designed these specifically for the included dashboards, so most will not apply to all apps from all users. However, they do shed some light on how these sources can join to each other.

Speaking of joins, **every source must include PlayFab user IDs**. Otherwise, it may be possible to link users by some combination of device, location, and/or contact info, but that's a difficult and imprecise task.

A conformed model is generally not app-specific, by definition, so we wrote all of those queries to use the _Default_ DB. That's the target of the replication pipeline below. As of writing, ADX does not automatically update tables derived from other DBs, so our pipeline contains a workaround for refreshes (more on that later).

# Getting Started
Exact configuration depends heavily on which sources you use, but the general steps are:

1.	Connect Fivetran or your tool of choice from each raw source to a single, relational store.

2.	Create a data factory with linked services for :

    a)  SQL DW or your source data store of choice
    b)  Your target Azure Data Explorer cluster

3.	For each linked service, create a data set with a similar name. Note our dynamic table name in the ADX connection, which lets us use a single data set for all activities.

4.	In your source data store, create a metadata table/view with each desired object's schema name, object name, and incremental timestamp column name (or NULL). Azure Data Factory will iterate over this list to build commands dynamically.

5.  Create a Logic App and connect it to your target ADX cluster. The app will use the metadata list to query INFORMATION_SCHEMA for object names and columns to populate:
                    `.drop table <name> ifexists`
        followed by `.create table <name> (<columns list>)` to your ADX target.

    Take note of the Logic App's POST URL, since that is how ADF will call it.
    *Note*: our "Lookup_GetColumnsList" maps some data types from SQL DW to ADX. This may need to change depending on your source (or our own potential mapping errors). Additionally, the query itself is a little convoluted due to limited SQL DW syntax, but should work _more or less_ as-is on most platforms. Other SQL implementations may allow for simpler syntax.

6.  If a source object is too large for its initial load, you may need to partition it in SQL DW. We found that a couple million rows per batch is a good starting point.

    a)  Exclude the main object (let's call it `mygame.events`) from the metadata view. If executed, this _would_ yield an ADX table called `mygame_events`.
    b)  Name your partitions something like `mygame.events_1`...`mygame.events_n`. Include them in the metadata view, but with a NULL incremental timestamp field name, which prevents the workflow from trying an incremental refresh.
    c)  Once all partitions are in ADX, consolidate them into `mygame_events` (exactly what the original, single table will be called).
    d)  Remove the partitioned sources from the metadata view, then re-add the original `mygame.events` source to the view, and let the incremental refresh run from there on out.

    If incremental load row counts are slightly off, then check out _exactly_ how the SQL DW and ADX queries pass timestamps. ADX handles datetime values a little differently from T-SQL, so you may need to update our sample syntax for rounding/conversion issues.

7.  Once all raw objects are loaded into ADX, save any _derived_ table definitions as functions. This will facilitate updates in one of two ways:

    * If the derived table comes entirely from the target DB you've just populated, **and** updates are append-only, then create an update policy that uses the function as its query. If multiple raw tables feed the modeled one, be careful which you include in the update policy (for instance, dimensions that are dropped and recreated may trigger undesired appends).
    * If the the derived table is not **both** sourced from this DB alone **and** append-only, then create a second Logic App that uses the function to pass commands like `.set-or-replace <table> <| fn_<table>()>`. To specify tables to update in this manner, you could:

        a) Write a `.show functions | where ...` query that returns just the functions that cross databases or whose names contain "dim" (or whatever else indicates a non-append-only tables). Alternatively, you might want to create a merge-based approach to slowly-changing dimensions. We have not done this and cannot recommend a design pattern yet.

        b) Use an ADF _look-up activity_ to retrieve this.

        c) Feed the _look-up activity_ into a _for each activity_ that in turn calls the second Logic App.

# Build and Test
You'll probably need to modify this pipeline to suit your data and desired behavior. The reasons for some choices are not self-evident in the code, so below is a summary of _why_ we designed the pipeline the way we did.

1.  Your source metadata view should yield something like this:

![](./Images/10_source_metadata_view.png)

2.  Note that our ADX connector uses a parameter (defined in the Parameters tab) for the table name. This lets us recycle the same connection.

![](./Images/11_adx_connection.png)

3.  The pipeline contains four high-level sections:

    * An initial _look-up_ activity gets all objects to extract
    * A *for each* activity iterates over the source object list
    * A second _look-up_ activity gets the ADX functions that define destructive refreshes
    * A second _for each_ activity iterates over the functions list

![](./Images/20_pipeline_summary.png)

4.  To start, retrieve the source object metadata from the view mentioned above, then feed into into a *for each* activity with two inner activities.

![](./Images/21_initial_metadata_lookup.png)
![](./Images/25_for_each_object.png)
![](./Images/26_for_each_object_detail.png)

5.  The first inner activity is a _look up_ that checks whether the source object exists in ADX (with the naming convention _<source schema name>_<source object name>_).

![](./Images/30_check_for_table.png)

6.  After that _look-up_, an *if* condition checks whether an incremental timestamp field exists for that table, and routes it to the next branch depending on the answer.

![](./Images/31_check_for_timestamp.png)
![](./Images/35_if_detail.png)

7.  If the source **has** a matching ADX table with an incremental timestamp, then it gets its latest timestamp from ADX and copies from the source where the source timestamp is greater than the latest ADX timestamp.

![](./Images/40_check_last_timestamp.png)
![](./Images/45_incremental_copy.png)
![](./Images/46_incremental_copy_detail.png)

8.  If the source **does not have** a matching ADX table with an incremental timestamp (i.e., destructive loads or totally new tables), then it retrieves metadata from the source, maps it to ADX types, passes the info to a Logic App that runs ADX control commands, and finally copies the data into ADX.

![](./Images/55_get_object_metadata.png)
![](./Images/56_call_logic_app.png)

![](./Images/60_logic_app_control_1.png)
![](./Images/61_logic_app_control_2.png)
![](./Images/62_logic_app_control_3.png)

![](./Images/57_copy_to_adx.png)
![](./Images/58_copy_to_adx_detail.png)

9.  All raw ADX tables should now be up to date with the source. For the next step, if applicable, make sure you have an ADX table that lists all functions from which to drop and rebuild tables. Consistent function naming (with consistent naming like _fn\_\<table name\>_) is extremely helpful in automating this part.

The _TableName_ dataset parameter we used earlier is unnecessary and a little tricky here, so create a new ADX connection explicitly to your functions list table.

![](./Images/79_function_refresh.png)
![](./Images/65_adx_function_list_connection.png)

10. The pipeline returns to its outermost layer to run another _look-up_ activity against the ADX functions list, then passes the list into a _for each_ activity.

![](./Images/70_get_function_list.png)
![](./Images/80_for_each_function.png)
![](./Images/81_for_each_function_detail.png)

11. The _for each_ activity passes each function name to another Logic App, which strips of the function prefix to generate and issue a `.set-or-replace` command in ADX.

![](./Images/98_logic_app_refresh_1.png)
![](./Images/99_logic_app_refresh_2.png)

repository: PlayFab/PlayerCentricIntelligence

repo_name: PlayFab/PlayerCentricIntelligence


text:
# Personal Tokens's Smart Contracts [![Build Status](https://travis-ci.org/PersonalTokens/solidity.svg?branch=master)](https://travis-ci.org/PersonalTokens/solidity)

This repository hosts source code of on-chain part of [Personal Tokens](https://personaltokens.io).
All smart contracts are located in the contracts folder.

## Development

Requirements:

 * [Node.js](https://nodejs.org/en/)
 * [git](https://git-scm.com/download/)

Setup:

 1. install truffle: `npm install -g truffle`
 2. clone the repository: `git clone https://github.com/PersonalTokens/solidity.git`
 3. change into the root directory: `cd solidity`
 4. install all Node.js requirements from package.json: `npm install`

### Migrating and testing with truffle develop

 * run: `truffle develop`
 * compile: `compile`
 * migrate: `migrate`
 * run tests: `test`

## Contracts

Token contracts are based on [OpenZeppelin framework](https://github.com/OpenZeppelin/openzeppelin-solidity).

### Contract `PersonalToken`

ERC20 compatible token contract, see [wiki for documentation](https://theethereum.wiki/w/index.php/ERC20_Token_Standard).
Used for creation of Personal Tokens by the users of the platform.

### Contract `PersonToken`

ERC20 compatible token contract, see [wiki for documentation](https://theethereum.wiki/w/index.php/ERC20_Token_Standard).
Used by PERSON, utility token which is used on the platform to pay for additional services but It also gives holders ability to withdraw personal tokens from the PERSON FUND.

## About Personal Tokens

[Personal Tokens](https://personaltokens.io) is a platform where you can easily verify and tokenize yourself. We are building an infrastructure for the new emerging economy based on privately issued tokens backed with real people. Using an incentive structure build into tokens we incentivise people to build the value of their own tokens.
We are aiming to build a robust and decentralized platform as possible. Our goal is to deliver as many tools as tokenized people need and to make the token economy as user friendly as possible.

## License

    Copyright (c) 2018 - 2019 Trifinity.io

    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.

     IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.

repository: PersonalTokens/solidity

repo_name: PersonalTokens/solidity


text:
---
title: "Creational-Abstract-Factory"
published: true
tags: DesignPattern
---

Abstract factory pattern has creational purpose and provides an interface for
creating families of related or dependent objects without specifying their
concrete classes. Pattern applies to object and deal with object relationships,
which are more dynamic contrast to Factory Method, Abstract Factory pattern
produces family of types that are related, ie. it has more than one method types
it produces.

## Real world example

Extending our door example from Simple Factory. Based on your needs you might
get a wooden door from a wooden door shop, iron door from an iron shop or a PVC
door from the relevant ship. Plus you might need a guy with different kind of
specialities to fit the door, for example a carpenter for wooden door, welder
for iron door etc. As you can see there is a dependency between the doors now,
wooden door needs carpenter, iron door needs a welder etc.

## In plain words

A factory of factories; a factory that groups the individual but
related/dependent factories together without specifying their concrete classes.

## Wikipedia says

The abstract factory pattern provides a way to encapsulate a group of individual
factories that have a common theme without specifying their concrete classes

## PHP Example

Translating the door example above. First of all we have our `Door` interface
and some implementation for it

```php
interface Door
{
    public function getDescription();
}

class WoodenDoor implements Door
{
    public function getDescription()
    {
        echo 'I am a wooden door';
    }
}

class IronDoor implements Door
{
    public function getDescription()
    {
        echo 'I am an iron door';
    }
}
```

Then we have some fitting experts for each door type

```php
interface DoorFittingExpert
{
    public function getDescription();
}

class Welder implements DoorFittingExpert
{
    public function getDescription()
    {
        echo 'I can only fit iron doors';
    }
}

class Carpenter implements DoorFittingExpert
{
    public function getDescription()
    {
        echo 'I can only fit wooden doors';
    }
}
```

Now we have our abstract factory that would let us make family of related
objects i.e. wooden door factory would create a wooden door and wooden door
fitting expert and iron door factory would create an iron door and iron door
fitting expert.

```php
interface DoorFactory
{
    public function makeDoor(): Door;
    public function makeFittingExpert(): DoorFittingExpert;
}

// Wooden factory to return carpenter and wooden door
class WoodenDoorFactory implements DoorFactory
{
    public function makeDoor(): Door
    {
        return new WoodenDoor();
    }

    public function makeFittingExpert(): DoorFittingExpert
    {
        return new Carpenter();
    }
}

// Iron door factory to get iron door and the relevant fitting expert
class IronDoorFactory implements DoorFactory
{
    public function makeDoor(): Door
    {
        return new IronDoor();
    }

    public function makeFittingExpert(): DoorFittingExpert
    {
        return new Welder();
    }
}
```

And then it can be used as

```php
$woodenFactory = new WoodenDoorFactory();

$door = $woodenFactory->makeDoor();
$expert = $woodenFactory->makeFittingExpert();

$door->getDescription();  // Output: I am a wooden door
$expert->getDescription(); // Output: I can only fit wooden doors

// Same for Iron Factory
$ironFactory = new IronDoorFactory();

$door = $ironFactory->makeDoor();
$expert = $ironFactory->makeFittingExpert();

$door->getDescription();  // Output: I am an iron door
$expert->getDescription(); // Output: I can only fit iron doors
```

As you can see the wooden door factory has encapsulated the `carpenter` and the
`wooden door` also iron door factory has encapsulated the `iron door` and
`welder`. And thus it had helped us make sure that for each of the created door,
we do not get a wrong fitting expert.

## C++ Example

```cpp
#include <iostream>

/*
 * Product A
 * products implement the same interface so that the classes can refer
 * to the interface not the concrete product
 */
class ProductA
{
public:
  virtual ~ProductA() {}

  virtual const char* getName() = 0;
  // ...
};

/*
 * ConcreteProductAX and ConcreteProductAY
 * define objects to be created by concrete factory
 */
class ConcreteProductAX : public ProductA
{
public:
  ~ConcreteProductAX() {}

  const char* getName()
  {
    return "A-X";
  }
  // ...
};

class ConcreteProductAY : public ProductA
{
public:
  ~ConcreteProductAY() {}

  const char* getName()
  {
    return "A-Y";
  }
  // ...
};

/*
 * Product B
 * same as Product A, Product B declares interface for concrete products
 * where each can produce an entire set of products
 */
class ProductB
{
public:
  virtual ~ProductB() {}

  virtual const char* getName() = 0;
  // ...
};

/*
 * ConcreteProductBX and ConcreteProductBY
 * same as previous concrete product classes
 */
class ConcreteProductBX : public ProductB
{
public:
  ~ConcreteProductBX() {}

  const char* getName()
  {
    return "B-X";
  }
  // ...
};

class ConcreteProductBY : public ProductB
{
public:
  ~ConcreteProductBY() {}

  const char* getName()
  {
    return "B-Y";
  }
  // ...
};

/*
 * Abstract Factory
 * provides an abstract interface for creating a family of products
 */
class AbstractFactory
{
public:
  virtual ~AbstractFactory() {}

  virtual ProductA *createProductA() = 0;
  virtual ProductB *createProductB() = 0;
};

/*
 * Concrete Factory X and Y
 * each concrete factory create a family of products and client uses
 * one of these factories so it never has to instantiate a product object
 */
class ConcreteFactoryX : public AbstractFactory
{
public:
  ~ConcreteFactoryX() {}

  ProductA *createProductA()
  {
    return new ConcreteProductAX();
  }
  ProductB *createProductB()
  {
    return new ConcreteProductBX();
  }
  // ...
};

class ConcreteFactoryY : public AbstractFactory
{
public:
  ~ConcreteFactoryY() {}

  ProductA *createProductA()
  {
    return new ConcreteProductAY();
  }
  ProductB *createProductB()
  {
    return new ConcreteProductBY();
  }
  // ...
};

int main()
{
  ConcreteFactoryX *factoryX = new ConcreteFactoryX();
  ConcreteFactoryY *factoryY = new ConcreteFactoryY();

  ProductA *p1 = factoryX->createProductA();
  std::cout << "Product: " << p1->getName() << std::endl;

  ProductA *p2 = factoryY->createProductA();
  std::cout << "Product: " << p2->getName() << std::endl;

  delete p1;
  delete p2;

  delete factoryX;
  delete factoryY;

  return 0;
}
```

## When to use?

- When there are interrelated dependencies with not-that-simple creation logic involved.
- A system should be independent of how its products are created, composed, and
  represented
- A system should be configured with one of multiple families of products
- A family of related product objects is designed to be used together
- You want to provide a class library of products, and you want to reveal just
  their interfaces, not their implementations.

## References

- [https://github.com/kamranahmedse/design-patterns-for-humans#-abstract-factory](https://github.com/kamranahmedse/design-patterns-for-humans#-abstract-factory)
- [https://github.com/JakubVojvoda/design-patterns-cpp/tree/master/abstract-factory](https://github.com/JakubVojvoda/design-patterns-cpp/tree/master/abstract-factory)

gha_language: HTML


text:
---
title: transform.Remarshal
description: Marshals a string of serialized data, or a map, into a string of serialized data in the specified format.
categories: [functions]
menu:
  docs:
    parent: functions
keywords: []
signature: [ transform.Remarshal FORMAT INPUT ]
---

The FORMAT must be one of `json`, `toml`, `yaml`, or `xml`. If the INPUT is a string of serialized data, it must be valid JSON, TOML, YAML, or XML.

{{% note %}}
This function is primarily a helper for Hugo's documentation, used to convert configuration and front matter examples to JSON, TOML, and YAML.

This is not a general purpose converter, and may change without notice if required for Hugo's documentation site.
{{% /note %}}

Example 1
: Convert a string of TOML to JSON.

```go-html-template
{{ $s := `
  baseURL = 'https://example.org/'
  languageCode = 'en-US'
  title = 'ABC Widgets'
`}}
<pre>{{ transform.Remarshal "json" $s }}</pre>
```

Resulting HTML:

```html
<pre>{
   "baseURL": "https://example.org/",
   "languageCode": "en-US",
   "title": "ABC Widgets"
}
</pre>
```

Rendered in browser:

```text
{
   "baseURL": "https://example.org/",
   "languageCode": "en-US",
   "title": "ABC Widgets"
}
```

Example 2
: Convert a map to YAML.

```go-html-template
{{ $m := dict
  "a" "Hugo rocks!"
  "b" (dict "question" "What is 6x7?" "answer" 42)
  "c" (slice "foo" "bar")
}}
<pre>{{ transform.Remarshal "yaml" $m }}</pre>
```

Resulting HTML:

```html
<pre>a: Hugo rocks!
b:
  answer: 42
  question: What is 6x7?
c:
- foo
- bar
</pre>
```

Rendered in browser:

```text
a: Hugo rocks!
b:
  answer: 42
  question: What is 6x7?
c:
- foo
- bar
```

repository: kokizzu/hugo

repo_name: kokizzu/hugo


text:
# openwsman

#### Table of Contents

1. [Overview](#overview)
2. [Module Description - What the module does and why it is useful](#module-description)
3. [Setup - The basics of getting started with openwsman](#setup)
    * [What openwsman affects](#what-openwsman-affects)
    * [Setup requirements](#setup-requirements)
    * [Beginning with openwsman](#beginning-with-openwsman)
4. [Usage - Configuration options and additional functionality](#usage)
5. [Development - Guide for contributing to the module](#development)

## Overview

This puppet module installs and configures openwsman on linux.

## Module Description

Openwsman allows you to remote interact with a Microsoft Windows host using the wsman management protocol.

## Setup

## Usage

class{'wsman':}

## Development

repository: ppouliot/puppet-openwsman

repo_name: ppouliot/puppet-openwsman


text:
# Swift Package Manager

[Swift Package Manager](https://swift.org/package-manager/) is a dependency manager built into Xcode.

If you are using Xcode 11 or higher, go to **File / Swift Packages / Add Package Dependency...** and enter package repository URL **https://github.com/kean/Nuke.git**, then follow the instructions.

To remove the dependency, select the project and open **Swift Packages** (which is next to **Build Settings**). You can add and remove packages from this tab.

> Swift Package Manager can also be used [from the command line](https://swift.org/package-manager/).

# CocoaPods

[CocoaPods](http://cocoapods.org) is a dependency manager for Cocoa projects. You can install it with the following command:

```bash
$ gem install cocoapods
```

To integrate Nuke into your Xcode project using CocoaPods, specify it in your `Podfile`:

```ruby
source 'https://github.com/CocoaPods/Specs.git'
platform :ios, '10.0'
use_frameworks!

target '<Your Target Name>' do
    pod 'Nuke', '~> 8.0'
end
```

Then, run the following command:

```bash
$ pod install
```

# Carthage

[Carthage](https://github.com/Carthage/Carthage) is a decentralized dependency manager that builds your dependencies and provides you with binary frameworks.

You can install Carthage with [Homebrew](http://brew.sh/) using the following command:

```bash
$ brew update
$ brew install carthage
```

To integrate Nuke into your Xcode project using Carthage, specify it in your `Cartfile`:

```ogdl
github "kean/Nuke" ~> 8.0
```

Run `carthage update` to build the framework and drag the built `Nuke.framework` into your Xcode project.

# Manually

If you prefer not to use either of the aforementioned dependency managers, you can integrate Nuke into your project manually.

## Embedded Framework

- Open up Terminal, `cd` into your top-level project directory, and run the following command "if" your project is not initialized as a git repository:

```bash
$ git init
```

- Add Nuke as a git [submodule](http://git-scm.com/docs/git-submodule) by running the following command:

```bash
$ git submodule add https://github.com/kean/Nuke.git
```

- Open the new `Nuke` folder, and drag the `Nuke.xcodeproj` into the Project Navigator of your application's Xcode project.

> It should appear nested underneath your application's blue project icon. Whether it is above or below all the other Xcode groups does not matter.

- Select the `Nuke.xcodeproj` in the Project Navigator and verify the deployment target matches that of your application target.
- Next, select your application project in the Project Navigator (blue project icon) to navigate to the target configuration window and select the application target under the "Targets" heading in the sidebar.
- In the tab bar at the top of that window, open the "General" panel.
- Click on the `+` button under the "Embedded Binaries" section.
- You will see two different `Nuke.xcodeproj` folders each with two different versions of the `Nuke.framework` nested inside a `Products` folder.

> It does not matter which `Products` folder you choose from, but it does matter whether you choose the top or bottom `Nuke.framework`.

- Select the top `Nuke.framework` for iOS and the bottom one for OS X.

> The `Nuke.framework` is automagically added as a target dependency, linked framework and embedded framework in a copy files build phase which is all you need to build on the simulator and a device.

repository: AvdLee/Nuke

filename: Installation Guide.md

repo_name: AvdLee/Nuke


text:
---
layout: "page"
title: ""
path: "/pubs/A16/furtado3.html"
---

Building Partnerships with Business

by Thomas Furtado

Back in the mideighties, I served on a National Commission on
Vocational Education created by the U.S. Department of Education.  It  was
a followup on the group that had produced A Nation at Risk.   We
were tasked to look at how vocational education was serving the  large
numbers of young people who do not go on to college, and how  education
could improve its efforts in this field.  As part of our work  we visited
many different vocational programs across the country.

One of the most memorable moments of that experience for me was a  visit
to the Skyline Center in Dallas.  At that time it had a national
reputation as a high school of the highest quality that required every
student to take vocational education.  A very high percentage of its
graduates went on to the best colleges and universities in the  country,
but all students had to immerse themselves in projects that  taught them
the value of creative manual skills.

I remember having lunch with a group of such students during our  visit.
One of them, a boy with combined SAT's of l550 and an  acceptance at
Harvard, was telling me about his project.  He and  several others had
spent the past year building a fullsize, two passenger plane.
I will never forget how he summed up that  experience:  "It was the most
exciting and the most stimulating thing  that ever happened to me, and it
brought together everything I've  ever learned at school.  I now know what
learning is all about."

I have often thought about that meeting and those words.  Maybe  the
reason they had so much meaning for me is how they echoed  what I have
long believed about education.  We have been so  obsessed with content
instead of process, and we have so often  isolated the content in the
classroom from the context of adult life,  especially the life of work.
One of the most important tools needed  in adult life is the ability to
solve problems.  Not the least of the  subsets of that skill is relating
what we know to a larger context that  gives it meaning and relevance.

Most children begin searching for academic relevance to their lives  as
they move into the middleschool years.  That is when many of  them
begin to question the value of the educational experience.  The  lucky
ones, who love learning for its own sake, aren't deterred when  the
curriculum doesn't seem relevant.  They excel in school anyway,  because
values and support systems at home have given them the  motivation to
succeed.  Two groups, however, frequently have  problems in schools where
memorizing and regurgitating data is the  norm and ultimately a serious
turnoff.

The first group is the obvious onechildren who begin to demonstrate
deteriorating performance and skills, and become marginal students  as
they enter middle school.  For whatever reasonshome  environment,
health, povertythey have fallen behind.  Trying to  relate what
happens in the classroom to what is happening outside  the school, they
see no connection, no relevance.  Why bother?

The second group of affected children may be less obvious to some
observers.  I'm referring to gifted children.  For all the success stories
about them, there are equally compelling stories about school  failures,
marked by isolation, belligerence and boredom.  The  literature suggests
that the boredom is usually the cause of the other  two.  Schools with
programs for these children manage to minimize  the problem, but in
Connecticut this year we have seen budget cuts  in several school
districts that closed down these programs.

I have two very vivid memories about these groups.  The first goes  back
twenty years and it happened at Pratt & Whitney.  We hired a  young man to
work on our jet engine assembly floor.  His task was to  work at the
bench, putting together a small subassembly for the  product.  The
instructions for the process were portrayed on a light  board in front of
him.  The instructions required eighth grade  reading level and he came to
us with a high school diploma from a  good suburban school.  It looked
like a great fit, but it wasn't.  Within  a day his foreman realized that
this young man could not read the  instructions.

We arranged to have his reading tested by a consultant at the local  high
school.  He tested at a fourth grade level.  We moved him out of  the
department into a lesser job, arranged for private tutoring, and  in four
months he was back to the original job, fully competent to  read the
instructions.  Now obviously a private tutor was a big help  in getting
our friend up to speed, but I suggest that the connection  between
learning to read and a job was another big factor.  I  understand that
it's much harder to establish that kind of relevance  in the school, but
we need to make some sort of cooperative effort to  do so.

That leads me to the second recollection on this issue.  Several years
ago, over lunch with a superintendent of schools, we got on the  subject
of gifted children.  He talked about how hard it was to  structure
meaningful experiences for them.  As he went on, we began  to explore how
business could help.  We saw many connections, but  both of us agreed that
we didn't want a haphazard kind of program.   We wanted a structured
approach that would be built into the  curriculum, grade by grade.

He arranged for me to meet with the math and science coordinators  in the
school system.  Would they be willing to let us have outlines of  the
science and math curricula in the middle and high schools?  We  would then
try to find work experiences in our labs and shops that  would match the
curricula.  We would also free up scientists and  engineers to come to the
schools to speak on relevant subjects.  Bus  trips could take the gifted
students to laser labs, sound and wind  tunnels, jet engine testing cells,
etc.

Both coordinators agreed to talk to faculty and get us the curricula
outlines we needed.  The meeting ended on a high note.  It never  regained
that lofty position of collaboration.  After several calls to  the
coordinators over four months time, with very little concrete  answers, I
asked the superintendent what was happening.  When he  got back to me a
few days later, he said, "The faculty have rejected  the idea.  They don't
want business messing with curricula."

What a lost opportunity.  How have we gotten to a situation where  there
is so little trust?  How can we improve things?  It seems to me  that in
the YaleNew Haven experience, there may be a kernel of  hope.
Perhaps what we need to do first is bring individuals from  business and
the schools together in a  common project.  For years  we have brought
vocational education teachers into our shops for the  summer.  Why not do
the same for middle and highschool teachers,  not simply to
give them a job, but rather to explore experiences that  could be woven
into high school curricula?

My last thought is that college faculty could be facilitators in this
process, perhaps visiting the industrial setting with the teachers, and
working with them to create lesson plans.

As adults, most of us spend over half our waking hours at work.   Somehow
we need to let our youngsters in school know that work is  a very valuable
part of our life and that what they learn in school  has relevance to
their future lives.  We don't have to do this in an  exploitative way.
With the right kind of planning and collaboration,  we can make it a
creative learning experience.

Back to
Table of Contents of the Fall 1994 Issue of On Common
Ground


text:
![Alt text](https://raw.githubusercontent.com/jimakker/Sare-aplikazioak-Node.js-rekin-eta-web-irekia/master/irudiak/goiburua.png)

#Linkedin

<https://www.talentbuddy.co/blog/building-with-node-js-at-linkedin/>

* Ruby-tik Node.js-ra

* "From what I have heard from senior folks in the company, the reduction in the number of machines used to host our service was greater than 10:1. "

* "Another problem with Node is the lack of good profiling tools. Getting setup with flame-graphs and analyzing performance problems is not straight-forward and requires lot of time and energy. We are building some automated tools to catch performance regressions but there is a lot of work required in this area. "

* "Besides this, debugging is harder as well since the original stack trace is lost. At Linkedin, one of the engineers came up with trycatch which he later published into npm which can generate long stack traces."

* "One of the major reasons people choose Node.js is the use of Javascript which allows you to write both client side and server side code in the same language. But another side-benefit is that Javascript treats JSON as native objects and also treats functions as first class citizens. "

* "Writing code in Node.js also encourages you to think in certain ways. Node provides an evented system with a single process which executes multiple requests.

* npm

* "I got introduced to functional programming with Node.js fairly early. It took me some time to wrap my head around functions being passed in as parameters to functions and higher order functions returning functions. But once you start thinking of functions as first class citizen, it becomes very easy. "


text:
# OnBoard-Scripts
Python scripts for raspberry pi

# How to transfer files from raspberry pi to local computer
Software needed:

winSCP
Alternative 1 -> https://ninite.com/winscp/ (9/4/2019)
Alternative 2 -> https://winscp.net/eng/download.php (9/4/2019)

Note: The pi and the local computer must be connected to the same
wifi.

1. Open pi terminal
2. Run the following command -> sudo rasi-config
3. Run the following command -> ifconfig
4. copy the ip from the pi.
5. Open winSCP.
6. Enter on host name the ip from the pi.
7. Enter username and password of the pi.
8. The left contains the local data and the right contains the pi
   data.
9. Drag and drop to move files.

Reference: https://www.youtube.com/watch?v=WIOpNuQc068&list=WL&index=207&t=0s