text:
# hubot-youearnedit

[![Build Status](http://img.shields.io/travis/jeffbyrnes/hubot-youearnedit.svg)](https://travis-ci.org/jeffbyrnes/hubot-youearnedit)

A Hubot script to interact with the YouEarnedIt API from a Slack organization.

It should be noted that, as of 2015-10-15, the v1 API that this utilizes
will be shut down. A refactor is currently in-progress to bring this up-to-date with v2 of YouEarnedIt’s API.

See [YouEarnedIt’s API docs](https://docs.google.com/document/d/1wHIlGmkBJy5UH9-FbehlfGUxRoS8EVB7oaL7tUklS5k/edit?usp=sharing) for details.

## Installation

In hubot project repo, run:

```bash
$ npm install hubot-youearnedit --save
```

Then add `hubot-youearnedit` to your `external-scripts.json`:

```json
["hubot-youearnedit"]
```

Finally, set the necessary EnvVars:

```bash
$ heroku config:set \
    HUBOT_SLACK_TOKEN='xyz' \
    HUBOT_YEI_USERNAME='xyz' \
    HUBOT_YEI_PASS='xyz'
```

The Slack API token is needed to search Slack’s list of users, in order to ascertain a user’s email address. This is needed to match to a user in YouEarnedIt, as email is the only likely constant between the two services.

repository: benkimball/hubot-youearnedit

repo_name: benkimball/hubot-youearnedit


text:
# Terra Enzyme Intl

[![NPM version](https://badgen.net/npm/v/@cerner/terra-enzyme-intl)](https://www.npmjs.com/package/@cerner/terra-enzyme-intl)
[![Build Status](https://badgen.net/travis/cerner/terra-toolkit)](https://travis-ci.com/cerner/terra-toolkit)
[![Dependencies status](https://badgen.net/david/dep/cerner/terra-enzyme-intl)](https://david-dm.org/cerner/terra-enzyme-intl)
[![devDependencies status](https://badgen.net/david/dev/cerner/terra-enzyme-intl)](https://david-dm.org/cerner/terra-enzyme-intl?type=dev)

Enzyme helpers for fortifying tests that depend on react-intl by decoupling the need for actual translations. See: [react-intl documentation](https://github.com/yahoo/react-intl/wiki/Testing-with-React-Intl#helper-function-1)

## Getting Started

Install with [npmjs](https://www.npmjs.com):

* `npm install --save-dev @cerner/terra-enzyme-intl`

## Usage

This package adds the following helpers for testing React components with [Jest](https://jestjs.io/) and [Enzyme](https://airbnb.io/enzyme/) that use the [react-intl](https://github.com/yahoo/react-intl) APIs. Your `mount()`ed and `shallow()`ed components need access to the intl context to render properly.

In you Jest config, add the following config

```
 moduleNameMapper: {
    intlLoaders: 'terra-enzyme-intl',
    translationsLoaders: 'terra-enzyme-intl',
 },
```

### shallowWithIntl

The `shallowWithIntl` method is a decorated version of [enzyme's shallow](https://airbnb.io/enzyme/docs/api/shallow.html#shallow-rendering-api) that injects an [IntlProvider](https://formatjs.io/docs/react-intl/components#intlprovider) wrapping component, providing the intl context for either `<Formatted* />` components or `format*()` methods through `injectIntl()`.

See:

* [react-intl documentation](https://formatjs.io/docs/guides/testing/#enzyme)
* [enzyme shallow options](https://airbnb.io/enzyme/docs/api/shallow.html#shallownode-options--shallowwrapper)

#### shallowWithIntl Example

```jsx
import React from 'react';
import { injectIntl } from 'react-intl';
import { shallowWithIntl } from 'terra-enzyme-intl';

const CustomComponent = injectIntl(({
  intl,
  ...otherProps,
}) => (
  <div>
    <FormattedMessage id="TerraEnzymeIntl.helloWorld" />
    <Button text={intl.formatMessage({ id: 'TerraEnzymeIntl.buttonText' })} />
  </div>
));

const shallowWrapper = shallowWithIntl(<CustomComponent />).dive();

expect(shallowWrapper).toMatchSnapshot(); // OK, doesn't depend on real translations

/* EXAMPLE SNAPSHOT BELOW */
<div>
  <FormattedMessage
    id="TerraEnzymeIntl.helloWorld"
  />
  <Button
    text="TerraEnzymeIntl.buttonText"
  />
</div>
```

### mountWithIntl

The `mountWithIntl` method is a decorated version of [enzyme's mount](https://airbnb.io/enzyme/docs/api/mount.html) that injects an [IntlProvider](https://formatjs.io/docs/react-intl/components#intlprovider) wrapping component, providing the intl context for either `<Formatted* />` components or `format*()` methods through `injectIntl()`.

See:

* [react-intl documentation](https://formatjs.io/docs/guides/testing/#enzyme)
* [enzyme mount options](https://airbnb.io/enzyme/docs/api/mount.html#mountnode-options--reactwrapper)

#### mountWithIntl Example

```jsx
import React from 'react';
import { injectIntl } from 'react-intl';
import { mountWithIntl } from 'terra-enzyme-intl';

const CustomComponent = injectIntl(({
  intl,
  ...otherProps,
}) => (
  <div>
    <FormattedMessage id="TerraEnzymeIntl.helloWorld" />
    <Button text={intl.formatMessage({ id: 'TerraEnzymeIntl.buttonText' })} />
  </div>
));

const mountWrapper = mountWithIntl(<CustomComponent />);

expect(mountWrapper).toMatchSnapshot(); // OK, doesn't depend on real translations

/* EXAMPLE SNAPSHOT BELOW */
<div>
  <FormattedMessage
    id="TerraEnzymeIntl.helloWorld"
  />
  <Button
    text="TerraEnzymeIntl.buttonText"
  />
</div>
```

### renderWithIntl

The `renderWithIntl` method is a decorated version of [enzyme's render](https://airbnb.io/enzyme/docs/api/render.html) that injects an [IntlProvider](https://formatjs.io/docs/react-intl/components#intlprovider) wrapping component, providing the intl context for either `<Formatted* />` components or `format*()` methods through `injectIntl()`.

See:

* [react-intl documentation](https://formatjs.io/docs/guides/testing/#enzyme)

#### renderWithIntl Example

```jsx
import React from 'react';
import { injectIntl } from 'react-intl';
import { renderWithIntl } from 'terra-enzyme-intl';

const CustomComponent = injectIntl(({
  intl,
  ...otherProps,
}) => (
  <div>
    <FormattedMessage id="TerraEnzymeIntl.helloWorld" />
    <Button text={intl.formatMessage({ id: 'TerraEnzymeIntl.buttonText' })} />
  </div>
));

const renderWrapper = renderWithIntl(<CustomComponent />);

expect(renderWrapper).toMatchSnapshot(); // OK, doesn't depend on real translations

/* EXAMPLE SNAPSHOT BELOW */
<div>
  TerraEnzymeIntl.helloWorld
  <button
    type="button"
  >
    TerraEnzymeIntl.buttonText
  </button>
</div>
```

### mockIntl

If you have a method that depends on the [react-intl](https://formatjs.io/docs/react-intl/api#the-intl-object) `intl` object, you can pass it the `mockIntl` object.

```js
import { mockIntl } from 'terra-enzyme-intl';

const foo = (id, intl) => {
  if (id) {
    return intl.formatMessage({ id });
  }

  return intl.formatMessage({ id: 'TerraEnzymeIntl.missingId' });
};

const id = 'Foo.id';
const result = foo(id, mockIntl);
expect(result).toMatchSnapshot(); // OK, doesn't depend on real translations
```

## Node version support

This package was developed and tested using Node 10 up to Node 14. Consumers using Node 16 or greater are advised to use it at their own risk since those versions are not officially supported due to lack of thorough testing.

## LICENSE

Copyright 2018 - 2020 Cerner Innovation, Inc.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

    <http://www.apache.org/licenses/LICENSE-2.0>

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

repository: cerner/terra-toolkit

branch_name: refs/heads/main

extension: md

gha_language: JavaScript

license_type: permissive

repo_name: cerner/terra-toolkit


text:
# Design

## What?

This is a document to collect thoughts about architecture/languages/features. Primarily it's for
 figuring out what would actually be an improvement in the space.

## Improvements over Artisan
- **Personally** Means this is my suggestive personal opinion
- Artisan contains one giant main.py file. While it is being broken up currently, it is still over 55k lines,
pychram refuses to even syntax highlight it without manual config changes.
  - **Personally** I find this too impenetrable
- Artisan was built up over time leading to duplication. For example, adding a device requires changes in
at least 4 places in main.py and an additional adapter for actually interacting with the device
- Artisan has no tests
- Using a client/server architecture means the frontend can be accessed on any web connected device, and means
it has separation of the presentation and data processing layers
  - Of course, this comes with all of the downsides of client/server architecture including possible code duplication
  between languages, communication issues, and increased resource usage when run on one device
- **Personally** I find python hard to work with for large projects, type checking is important for not having type
issues at runtime. This is especially compounded when the amount of features and devices supported is high.
- **Personally** I want to stop direct contributions into master as fast as possible

## General architecture

The program will follow a multiple process architecture to take advantage of the advantages
of different languages and the limitations of hardware.

## Components needed

### MVP
- Device communication layer (serial, hottop only)
- Local database communication (to store data locally)
- Builds on Linux
- Presentation layer (that connects to the core)

### Extended Components
- Device communication layer (BLE, Serial multiple devices)
- External/Network database communication
- Builds on OSX/Windows
- PID roasting as a device capability

## Supported device types

### MVP

- Serial (over USB or serial since OS's thankfully abstract this away)

Notes:
- Due to the wide range in device types, there needs to be a generic device type interface that
can abstract the underlying implementation away.

### Extended device types
- USB
- BLE
- Modbus

## Supported data output

### MVP
- flat file (csv with metadata)
- The frontend

### Extended data output

- SQLite
- Postgres?
- JSON?
- Mongo (?????)

## Settings/non roast related data

- Yaml (?)

## Front end

- Node/typescript

Notes:
- Most cross platform frontends are terrible, especially for a chart centered application,
NW.js with typescript seems like the best option

## Architecture diagram
Device layer
```
  _____________  USB/BT/Serial  _______________ device interface
 |   Device    |<------------->|  Device layer |<--->
 |_____________|               |_______________|
```

Core
```
                    (golang)
 Device interface  _________
           <----->|         |   Data interface
                  |  Core   |<----------->
                  |         |   Control interface
                  |_________|<----------->
```

Data layer
```
  _____________  USB/BT/Serial  _______________   Device interface
 |   Device    |<------------->|  Device layer |<----------------->
 |_____________|               |_______________|
```

Communication layer
```                   (golang)
     Data interface   ________   Frontend (http2)
   <---------------->| Server |<------------>
   Control interface |        |
   <---------------->|________|
```

Frontend
```
                         Frontend (NW.js)
  communication layer   ___________________
      <--------------->| -chart!           |
                       | -buttons!         |
                       | -terrible ball of |
                       | typescript!       |
                       |___________________|
```

### Architecture notes
- All data output goes through the same interface, real time streaming and bulk export are options
- Control encompass control and meta information like what things are connected

## Misc features

- Core can scan for devices based on known device types
- Some devices have different capabilities, frontend adjusts based on them
- Core communicates with the frontend over http2, even locally
- The ability to run the core and frontend on different machines
- Rpi as tested platform, must perform well on a rpi3

repository: hunterwerlla/second-crack

branch_name: refs/heads/master

repo_name: hunterwerlla/second-crack


text:
# Manage data domains {#concept_zh4_lnf_2hb .concept}

A data domain is used to categorize business concepts in a business unit. For example, you can create the commodity domain, transaction domain, and membership domain to store different types of business concepts.

## Create a data domain {#section_bmc_31g_2hb .section}

1.  Log on to Dataphin.
2.  In the top navigation bar of the Dataphin homepage, choose **Planning**. Alternatively, you can go to the Planning page from the **Intelligent Data Warehouse Planning** quick access area.

    ![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/148397/156171376441387_en-US.png)

3.  In the left-side navigation pane, choose **Business Units**. Click a business unit and the lower part of the page displays all data domains contained in the business unit. Click **Create Data Domain** to create a data domain.

    ![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/148399/156171376441399_en-US.png)

4.  In the dialog box that appears, enter a data domain display name, name, alias, and description. Click **OK** to complete the creation.

    ![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/148399/156171376441400_en-US.png)

## Modify a data domain {#section_ir1_k1g_2hb .section}

1.  In the data domain list, click **Change** on the right of a data domain to modify the data domain.

    ![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/148399/156171376541407_en-US.png)

2.  In the **Change Data Domain** dialog box, modify the data domain display name, name, alias, or description. Click **OK** to save your changes.

    ![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/148399/156171376541408_en-US.png)

    **Note:** If a data domain is referenced, its name cannot be changed.

    ![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/148399/156171376541411_en-US.png)

## Delete a data domain {#section_j5q_k1g_2hb .section}

In the data domain list, click **Delete** on the right of a data domain. In the dialog box that appears, click **OK** to complete the deletion.

![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/148399/156171376541412_en-US.png)

**Note:** Only the data domains that are not referenced can be deleted.

license: MIT

url: https://raw.githubusercontent.com/mixergit/dataphin/0c0002535f2f8849a108aff4379c687032d32200/intl.en-US/User Guide/Data warehouse planning/Business units/Manage data domains.md

repository: mixergit/dataphin

filename: Manage data domains.md

repo_name: mixergit/dataphin


text:
# Corrosion Model 6

The purpose of this project is to provide a shortcut for basic corrosion insight for a variety of galvanic couples between different metals, alloys, and materials.

STRN: 19-1231-2025

## Background
The origin of project grew out of the desire to provide useful corrosion information contained in unclassified, unrestricted distribution, standards that still seemed to be difficult to find if you didn't know what you were looking for.  For example, the basis of this project is:

>MIL-STD-889C Dissimilar Metals

It was originally published in 1969 and subsequently updated in 1976 and in 2016 with a couple of minor changes and revisions in between. I have not been able to track down a copy of the original standard but the 1976 and 2016 versions are available [here](http://everyspec.com/).

## Project Goals
This project aims to achieve the following goals:
* Provide the user with a list of different materials that can be selected to be combined into a galvanic couple
* Provide an estimate of the respective, isolated, corrosion potentials for the two materials (currently only from seawater exposure)
* Provide an estimate of the corrosion potential difference between the materials.  This provides an estimate of the overpotential available to drive corrosion, though no kinetics information is provided.

* Provide an estimate, obtained from Table 1 (see image to the right) on pg. 6 of MIL-STD-889C, of the relative compatibility of the different materials in three different environments:
  1. Marine atmopshere
  2. Seawater
  3. Industrial atmosphere
* Summarize the corrosion prevention strategies for different classes of materials as contained in Appendix A.
* Provide Windows, Android, and iOS versions of the app

## Code
This project was written in C# and XAML using Microsoft Visual Studio.  The data file used for the electrochemical potentials and material-types is written in XML.  The data file used to pull the corrosion prevention recommendations is also written in XML.  The data file used to summarize the Table I recommendations is a CSV file.

## Universal Windows Platform (UWP) App
The current version of the app is available as a free download [here](https://www.microsoft.com/store/productId/9P1L9679CFR4).  Or it can be built in Visual Studio from the source files.

repository: WIEQLI/cma

repo_name: WIEQLI/cma


text:
#Using Gulp in Mimogear

Mimogear uses gulp, a popular task runner. All the work for compiling stylesheets, compiling markup, concatenating and minifying javascript, creating a sprite, optimizing images, and watching assets has already been setup for you.

##Running Gulp

Once you're all [setup](https://github.com/mimoduo/Mimogear/tree/master/docs), there's a default gulp task to get your started:

```sh
gulp
```

**This will automatically open your browser to your site, compile all of your development assets within /src/, and watch for any file changes in the source /src/ folder.**

##Advanced Gulp

There's an advanced gulp task that will minify assets to ready them for production. Simply pass in the `--production` flag to set an environment variable for gulp to use:

```sh
gulp --production
```

##Specific Gulp Commands

Sometimes you may want to build only a particular set of files or watch without building. In that case, there are several commands you can run. Tasks with `--production` towards the end indicate that the task will run minifying scripts.

```sh
gulp pug
gulp pug --production
gulp postcss
gulp postcss --production
gulp js
gulp js --production
gulp images
gulp sprite
gulp watch
```

##Plugin List

If you'd like to modify some of the pre-existing tasks in Mimogear, check out the complete plugin list below:

* [**autoprefixer**](https://github.com/postcss/autoprefixer)
* [**browser-sync**](https://github.com/BrowserSync/browser-sync) / [official site](https://www.browsersync.io/)
* [**gulp**](https://github.com/gulpjs/gulp) / [official site](http://gulpjs.com/)
* [**gulp-concat**](https://github.com/contra/gulp-concat)
* [**gulp-cssnano**](https://github.com/ben-eb/gulp-cssnano) / [official site](http://cssnano.co/)
* [**gulp-gh-pages**](https://github.com/shinnn/gulp-gh-pages)
* [**gulp-if**](https://github.com/robrich/gulp-if)
* [**gulp-imagemin**](https://github.com/sindresorhus/gulp-imagemin)
* [**gulp-postcss**](https://github.com/postcss/gulp-postcss) / [official site](http://postcss.org/)
* [**gulp-pug**](https://github.com/jamen/gulp-pug)
* [**gulp-rename**](https://github.com/hparra/gulp-rename)
* [**gulp-svg-sprite**](https://github.com/jkphl/gulp-svg-sprite)
* [**gulp-uglify**](https://github.com/terinjokes/gulp-uglify)
* [**gulp-util**](https://github.com/gulpjs/gulp-util)
* [**postcss-discard-empty**](https://github.com/ben-eb/postcss-discard-empty)
* [**postcss-easy-import**](https://github.com/TrySound/postcss-easy-import)
* [**postcss-functions**](https://github.com/andyjansson/postcss-functions)
* [**postcss-mixins**](https://github.com/postcss/postcss-mixins)
* [**postcss-nesting**](https://github.com/jonathantneal/postcss-nesting)
* [**postcss-simple-grid**](https://github.com/iamfrntdv/postcss-simple-grid)
* [**postcss-simple-vars**](https://github.com/postcss/postcss-simple-vars)

repository: BrotherPhil/Mimogear

repo_name: BrotherPhil/Mimogear


text:
# COVID19 bots

This repository contains supplementary code for the following paper:
>Bots as Active News Promoters: A Digital Analysis of COVID-19 Tweets <br>
>DOI: [10.3390/info11100461](https://doi.org/10.3390/info11100461)
>
>Ahmed Al-Rawi, Vishal Shukla

This code is being used to perform analyses on COVID19 Twitter dataset collected by Twitter Capture and Analysis Toolset (TCAT). It generates files for the identified active users, Botometer scores for the user handles, terms, hashtags, emojis and sentiment for the tweets.

### Requirements

This code has the following listed requirements to run successfully.
- Python 3.x
- Apache Spark

To install Python package dependencies, use `pip install -r requirements.txt` command.

### Structure

The collected Twitter data is expected to be in `data` directory. Same directory will be used by the script to write generated output files. The entire dataset will be made available upon request.

```{bash}
.
├── data
│   ├── tcat_COVID-20200403-20200405------------fullExport--a04e82a9e6.csv # Collected data files
│   ├── tcat_COVID-20200404-20200405------------fullExport--a04e82a9e6.csv
│   ├── tcat_COVID-20200412-20200414------------fullExport--ecc23817f6.csv
.   .
.   .
.   .
│   └── tcat_COVID-20200414-20200416------------fullExport--ecc23817f6.csv
├── LICENSE
├── README.md
├── requirements.txt
└── src
    ├── bots.py
    ├── main.py
    └── udfs.py
```

### Usage

```{bash}
python ./src/main.py
```


text:
---
title: View Cookie Information
slug: CookieScanning
publish: true
position: 10
---

View Cookie Information
=======================

1. Install the [Privacy Scanner Fiddler add-on][1].

 Fiddler will gain a new top-level menu named **Privacy**.

 ![Privacy menu][2]

2. Ensure **Privacy > Enabled** is checked.

 The add-on will add a **Privacy Info** column to the session list and will flag HTTP/HTTPS responses which set cookies.

Evaluation of any P3P statements that come along with those cookies will change the session's background color:

 ![Privacy Info Column][3]

+ **Green** sessions send a satisfactory P3P policy.
+ **Yellow** sessions set a cookie without a P3P policy.
+ **Orange** sessions send a P3P policy that [does not permit use of the cookie in a 3rd party context][4].
+ **Red** sessions send invalid P3P policies.

See Also
--------

+ [Rename Invalid P3P Headers][5]
[1]: http://fiddler2.com/add-ons
[2]: ../../images/CookieScanning/PrivacyMenu.png
[3]: ../../images/CookieScanning/PrivacyInfo.png
[4]: https://msdn.microsoft.com/en-us/library/ie/ms537343(v=vs.85).aspx#unsatisfactory_cookies
[5]: ../../Modify-Traffic/Tasks/RenameInvalidP3P

repository: edgarvig/fiddler-docs

repo_name: edgarvig/fiddler-docs


text:
# Change Log

All notable changes to this project will be documented in this file.
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

# [2.14.0](https://github.com/boltdesignsystem/bolt/compare/v2.13.3...v2.14.0) (2020-01-06)

### Bug Fixes

* IE 11-specific layout fix ([952386a](https://github.com/boltdesignsystem/bolt/commit/952386a))
* minor CSS fixes per PR feedback ([74ed583](https://github.com/boltdesignsystem/bolt/commit/74ed583))
* update Jest snapshot for Card ([0eca083](https://github.com/boltdesignsystem/bolt/commit/0eca083))

repository: bitdesignsystem/bolt

repo_name: bitdesignsystem/bolt


text:
@page guides/contributing/documentation Improving the Docs & Site
@parent guides/contribute 6

@description Learn how to improve CanJS’s site and documentation.

@body

## Overview

The CanJS site is generated with [bit-docs](https://github.com/bit-docs/bit-docs),
a modified version of [DocumentJS](https://documentjs.com).  Its
content is hosted using GitHub pages publishing the [canjs/canjs#gh-pages](https://github.com/canjs/canjs/tree/gh-pages) repo.

`bit-docs` reads JavaScript comments and markdown files within the `canjs` repo as well as
the individual repositories within `node_modules` to produce a static site.

The high level content (Ex: homepage) and the guides content for the site is within the
`canjs/docs` folder.  Individual repositories contain their own markdown and commented
JavaScript files used to produce their API pages.

## Generate the documentation locally

First, follow the steps listed under [guides/contributing/developing-locally] to
fork & clone the repository, install the dependencies, build the documentation,
and view the site locally.

## Improve the theme’s design and styles

The CanJS theme is in
[bit-docs-html-canjs](https://github.com/canjs/bit-docs-html-canjs). Its
[README](https://github.com/canjs/bit-docs-html-canjs/blob/master/readme.md)
has instructions on how to test out the theme.  Once the theme is updated and published,

1. Open `canjs/package.json`. Update `bit-docs-html-canjs`’s version to the new theme version.
2. Run `npm run document` to make sure the theme is correctly applied.

The [CanJS design folder](https://drive.google.com/open?id=0B9uYesPecByGZGkzc2YxRHA4ZEE)
has logos, stickers, and other design resources.

## Test out content from other repos

As noted above, the API docs from each package come from that package.  So if you’re
improving the docs for say `can-compute`, you want to see what `can-compute`’s docs look like,
install your local `can-compute` and re-run bit-docs like:

```shell
npm install ../can-compute && npm run document
```

## Publish the documentation

Once the docs look right locally, commit your changes, then run:

```shell
make
```

The make script will generate the documentation again and push out the `gh-pages` branch.

## Writing API documentation

Our documentation is modeled off of jQuery’s.  Please read
their [guidelines](https://github.com/jquery/api.jquery.com/blob/master/README.md). Also read our
[guides/api].

Generally speaking there are three parts to every documentation page:

 - Its description
 - Its signatures
 - The body (typically "Use" section)

### Description

The description section should be a one or two sentence explanation of what this
piece of documentation does from a _user_-centric view.  Descriptions are a quick summary
of the __why__ and the __what__. It should take on an
active voice.  For example, [can-component]’s description:

> Create a custom element that can be used to manage widgets or application logic.

Notice that it uses "Create" not "Creates".

### Signatures

Signatures are the __what__ and the __how__.  They should include all or most of the following:

 - __What the signature does__, if different from the description, especially if there are
   multiple signatures.
 - High level details on __how the code works__.
 - A simple example showing __how to use the code__.

[can-compute]’s first signature is a good example of this. First, it explains
__what that signature does__:

> Create a compute that derives its value from other observables.

Then it briefly explains __how the code works__:

> Uses can-observation to call the getterSetter and track observables.

Finally, it provides minimal sample code:

```js
let age = compute(32);

let nameAndAge = compute(function(){
    return "Matthew - " + age();
});

nameAndAge() // -> "Matthew - 32"

age(33);

nameAndAge() // -> "Matthew - 33"
```

Not all signatures need to hit all three points.  For example [can-event/batch/batch]’s
signature simply adds a bit more depth to the purpose of [can-event/batch/batch]
and then details __how the code works__.  __How to use the code__ is
left for the `body` section as importing the module is not necessary to show.

Signature titles should follow jQuery’s conventions:

 - Static methods like: `TypeAlias.method()`
 - Prototype methods like: `typeAlias.method()`
 - Spaces in between arguments: `typeAlias.method( arg1, arg2 )`
 - Brackets around optional args: `typeAlias.method( arg1 [, arg2 ], arg3 )` or
   `typeAlias.method( arg1 [, arg2 ][, arg3 ] )`

Make sure to fully document the a signature’s parameters and return
value.  There’s a lot of flexibility in documenting the [type expression](https://documentjs.com/docs/documentjs.typeExpression.html) of
a return value or parameters and the [name expression](https://documentjs.com/docs/documentjs.nameExpression.html) of
parameters.

 - Parameter and descriptions should start with a `Capital` and end with a period like:
   `@param {Type} name Indicates that something should happen.`

### Body

Most body sections start with a `## Use` subsection.  This is a mini guide on
how to use that piece of code.  Modules should have long bodies that span
multiple topics.  For example [can-component]’s body has examples and
information about nearly all of its sub-functions.  However
[can-component.prototype.tag can-component.prototype.tag] doesn’t have a
use section because it’s covered in [can-component].

### Structuring documentation

- Group names (like `prototype`) should be lower case.
- Types should be capitalized `{String}` except when they are describing a function [can-fixture.requestHandler].

repository: stackriot/canjs

gha_license_id: NOASSERTION

repo_name: stackriot/canjs


text:
# Installation
> `npm install --save @types/d3-transition`

# Summary
This package contains type definitions for D3JS d3-transition module (https://github.com/d3/d3-transition/).

# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-transition.

### Additional Details
 * Last updated: Wed, 29 Jan 2020 22:02:37 GMT
 * Dependencies: [@types/d3-selection](https://npmjs.com/package/@types/d3-selection)
 * Global values: none

# Credits
These definitions were written by Tom Wanzek (https://github.com/tomwanzek), Alex Ford (https://github.com/gustavderdrache), Boris Yankov (https://github.com/borisyankov), and Robert Moura (https://github.com/robertmoura).

gha_language: CSS


text:
---
title: Mark Zuckerberg's Masking Tape
date: 2016-06-28 10:55:05+00:00
redirect_from:  /zuckerbergs-masking-tape/
excerpt:  "Is American privacy more shadow than substance?  In this mishmash, we look at the state of privacy starting with Facebook Chairman and CEO Mark Zuckerberg's masking tape."
header:
  teaser: "/assets/images/category-spirit-of-the-age.png"
  image: /assets/images/zuckerberg-taped-camera.jpg
  caption: "Mark Zuckerberg with camera taped"
categories: spirit-of-the-age
tags:
  - technology
  - neo-feudalism
  - Mark-Zuckerberg
  - Amazon
  - Kindle
  - ebooks
  - social-conditioning
  - privacy
---
{% include toc title='Contents' icon='book' %}

Americans love their privacy.  But what if the privacy that still exists is more shadow than substance?  In this mishmash, we look at the state of privacy starting with Facebook Chairman and CEO Mark Zuckerberg's masking tape.

_Quis custodiet ipsos custodes? - Who will watch the watchers?_ -Juvenal, the Sixteen Satires

# Mark Zuckerberg's Masking Tape

In 2010, there was a brief flurry of media attention when Facebook head Mark Zuckerberg stated, "Privacy is no longer a social norm" and unilaterally changed the privacy settings on more than 350 million user accounts.[^799ed9a5]

[^799ed9a5]: https://www.theguardian.com/technology/2010/jan/11/facebook-privacy

Despite his public statements, Zuckerberg fears for his own privacy.  In this photo from his Facebook page, you can see Zuckerberg uses masking tape to block his computer's webcam and microphone.

![Zuckerberg taped camera mic]({{ site.url }}{{ site.baseurl }}/assets/images/zuckerberg-taped-camera-2.jpg)
{: .full}

...the posted photo highlighted to many that even the technically-savvy Facebook boss faces worries about being spied on.

Hacking into a laptop’s webcam is not particularly difficult business...Most times, the user may not even be aware that their cameras have been hacked and are being watched.

Often, hackers would tap into a target’s camera to secretly record a victim during compromising moments, and could then later threaten for a blackmail payment in order to refrain them from posting the footage publicly.

Some hackers are known to remotely hack baby monitors merely for the sake of tormenting children and babies in these rather chilling cases).
[^28913f3b]

[^28913f3b]: [Mark Zuckerberg Puts Tape Over His Webcam. Should You?](https://www.bolehvpn.net/blog/2016/06/26/mark-zuckerberg-puts-tape-over-his-webcam-should-you/)

# Amazon says - you don't own your books.  We do

![Amazon owns your books]({{ site.url }}{{ site.baseurl }}/assets/images/amazon-kindle-you-dont-own-your-books.jpg)
{: .full}

Private property ownership is one of the fundamental marks of a free people.  If you live in the US or Britain, you probably assume that those ebooks you've been purchasing belong to you.  Think again.  Amazon reserves the right to delete them from your devices and account with no warning and little recourse.

An Amazon Kindle user has had her account wiped and all her paid-for books deleted by Amazon without warning or explanation.

The Norwegian woman, identified only as Linn on media commentator Martin Bekkelund's blog, approached Amazon when she realised her Kindle had been wiped.

She was informed by a customer relations executive that her account had been closed, all open orders had been cancelled and all her content had been removed, but has been unable to find out why.

## What exactly was Linn's crime?

Linn stands accused of is using a friend's UK address to buy Amazon UK English Kindle books from Norway". Under Amazon's rules, this type of action is barred, as the publisher seeks to control what content is read in which territory of the world.

This is a perfect example of the reality of neo-feudal life across the globe.  Very often legal structures protect corporate practices which treat citizens as serfs.  Instead of _rights_, customers have _privileges_.  Without the knowledge, money and time to defend themselves, people are effectively disenfranchised.

"This shows the very worst of DRM.  And if you disagree, you're totally outlawed. With DRM, you don't buy and own books, you merely rent them for as long as the retailer finds it convenient."

Andy Boxall of Digital Trends said: "Amazon in turn uses the Digital Millennium Copyright Act to take your books and privileges away if it finds you've been naughty."

According to Amazon's Kindle Store terms of use, "Kindle content is licensed, not sold". Should you attempt to break the DRM security block or transfer your purchase to another device, Amazon may legally "revoke your access to the Kindle Store and the Kindle Content without refund of any fees."

If loud enough, public outcry can cause a temporary success, as happened against Amazon seven years ago:

In 2009, Amazon was forced to apologise for deleting books written by George Orwell from customers' Kindle devices without their knowledge following a rights issue (the books were added to its Kindle store by a third-party who did not have the rights to them). Company founder Jeff Bezos said the move was "stupid" and "thoughtless".

[Amazon wipes customer's Kindle and deletes account with no explanation](http://www.theguardian.com/money/2012/oct/22/amazon-wipes-customers-kindle-deletes-account)

# Whatever your 16 year old posts on twitter or Facebook will be used forever to screen her applications for housing, credit, and work

![Personality profile from social media]({{ site.url }}{{ site.baseurl }}/assets/images/personality-profile-screen-from-social-media.jpg)
{: .full}
*Personality profile from social media*

It is probably not news that many landlords, hiring managers or college admissions counselors scope out our social media accounts to perform background checks on an individual. However, one start-up company is now taking this one step further by making use of algorithmic models to carry out social media audits of our networking accounts, with aims to **“take a deep dive into private social media profiles”.**

The UK start-up, Score Assured, has recently launched its first product; Tenant Assured, a software capable of combing through your social media profiles on Facebook, Instagram, Twitter, and LinkedIn to produce a report to unearth details on a potential tenant’s credit-worthiness. The **‘personality reports’** aims to give insights into an applicant’s five main personality traits: **extraversion, neuroticism, openness, agreeableness and conscientiousness.**

And what happens when [Christianity may be considered a mental illness](http://www.huffingtonpost.com/2013/05/31/kathleen-taylor-religious-fundamentalism-mental-illness_n_3365896.html)?

[This Start-Up Will Help Your Landlord Check Your Facebook Posts for Private Data](https://www.bolehvpn.net/blog/2016/06/12/this-start-up-will-help-your-landlord-check-your-facebook-posts-for-private-data/)

# Use emojis?  They are now being used to monitor your emotional state

![Emojis target ads]({{ site.url }}{{ site.baseurl }}/assets/images/emojis-monetized.jpg)
{: .full}
*Emojis target ads*

Emoji-targeted advertising could turn out to be a great cash cow for the company, as Twitter believes that marketers will be able to use the emoji activity as a way to determine a person’s mood and then “connect” with them, in turn driving “deep engagement and better performance for brands”.

Basically **any time an emoji is tweeted out, it could be used by brands to target you with specific products**. While the company uses food emojis as a target example for now, it could well move on to other options such as adverts from a sports brand when a user tweets a soccer ball emoji during a Euro 2016 match. Or if a user tends to tweet the emoji of a particular flag frequently, it could be an indication to advertisers on a person’s nationality and country preferences.  However, it is a very real one as **US Congressman Ted Lieu** in California experienced first-hand.  **CBS News’ ‘60 Minutes’ segment demonstrated just how easy it is for hackers to access vulnerable phones once a hacker has learned a target’s phone number.**

The results of the investigations are unsettling. All it took was Lieu’s phone number and the researchers were able to successfully listen to and record all his phone calls, to read his text messages, view his contacts and to track his location. Unsurprisingly, the experience was unnerving for Lieu as he claimed that when he arrived to tape the segment in Washington, **the hackers had even told the producers which hotel he was staying at albeit his GPS was turned off and he regularly uses encrypted messaging systems**.

[Your Phone Number is All That Hackers Need to Track Your Calls, Location & Emails](https://www.bolehvpn.net/blog/2016/04/23/your-phone-number-is-all-that-hackers-need-to-track-your-calls-location-emails/)

# What to do?

Knowing these things can strengthen you.  If you are aware of the true circumstances you're living under, you can make better decisions than those people who pretend that things are different than they are.

The Bible tells us that in the last days of apostasy evil men shall wax worse and worse (2 Tim 3.13).  There's only one thing that such people long for:  **_power_**.  Psychology calls them psychopaths. They truly believe they are the gods of this world.

The Masters of the Universe were a set of lurid, rapacious plastic dolls that his otherwise perfect daughter liked to play with. They looked like Norse gods who lifted weights, and they had names such as Dracon, Ahor, Mangelred, and Blutong. They were unusually vulgar, even for plastic toys. Yet one fine day, in a fit of euphoria, after he had picked up the telephone and taken an order for zero-coupon bonds that had brought him a $50,000 commission, just like that, this very phrase had bubbled up into his brain. On Wall Street he and a few others — how many? — three hundred, four hundred, five hundred? — had become precisely that ... Masters of the Universe. There was ... no limit whatsoever! Naturally he had never so much as whispered this phrase to a living soul.  Yet he couldn't get it out of his head. -Tom Wolfe, _Bonfire of the vanities_

All of these technological innovations are being used to tighten the surveillance, tighten the control, and increase the gap between them, and you.

The erosion of basic privacy rights is but one more indication of the lateness of the hour.

>And take heed to yourselves, lest at any time your hearts be overcharged with surfeiting, and drunkenness, and cares of this life, and so that day come upon you unawares. For as a snare shall it come on all them that dwell on the face of the whole earth. (Luke 21:34-35)

The days of any illusion of privacy for the average person are now over.    Your best protection is to act as if everything you say or do is open to all.  For it is.

But never forget that God watches the watchers.  There is a day coming when the deeds of everyone will be revealed.

And if the righteous scarcely be saved, where shall the ungodly and the sinner appear? (1 Peter 4:18)

Fear them not therefore: for there is nothing covered, that shall not be revealed; and hid, that shall not be known.  (Matthew 10:26)

# Prayer

Dear Lord, save us from the schemes and snares of wicked men.  Guard your people with an outstretched arm.  Teach us to rest peacefully in you.  For we are your people, and the sheep of your pasture.  Through the one-time sacrifice of Jesus Christ, clothed in his righteousness, and in his name we pray. _Amen_

Originally published at: Comfort for Christians

gha_license_id: MIT


text:
# Books
## Table of Contents

* [Usage](#usage)
* [User Story](#userstory)
* [Technologies](#technologies)
* [Credits](#credits)
* [License](#license)

## Usage

![Screenshoot](build/static/media/books.png)
Example of front page

![Screenshoot](build/static/media/books.gif)
Example of dashboard page

Heroku Deployment (https://mighty-everglades-62236.herokuapp.com/)

# User Story
An application created using the MERN stack and allows users to search for books via the Google Books API. Search results are dynamically rendered in the UI and users have the option to save and/or delete books.

# Technologies
* React JS
* MongoDB
* Mongoose
* Express JS
* Node
* Axios

## Questions
If you have any questions about the repo, please [open an issue](https://github.com/Ofarrell23/Books/issues or contact me via email at<EMAIL_ADDRESS>You can find more of my work on my GitHub, [Ofarrell23](https://github.com/Ofarrell23/).

## Credits
Below is a list of third-party tutorials used to help facilitate this project. There were no collaborators for this project.

* [Credits] (https://www.w3schools.com/tags/att_img_alt.asp)
* [Credits] (https://www.vikingcodeschool.com/html5-and-css3/html5-semantic-tags)
* [Credits] (https://developer.mozilla.org/en-US/docs/Web/JavaScript)

# License
![MIT License](https://img.shields.io/badge/license-MIT-green)


text:
# Folder Cleanup
Helps you remove old files and folders

A convenient way to rid of files and folders that are older than specified amount of time.
Cleanup function takes two arguments:
1. folder path
2. maximum file age (in milliseconds)

## Usage
```javascript
const cleanup = require('folder-cleanup');

let max_age = '5d';
let temp_uploads = '/usr/www/domain.me/temp_uploads';

// Deleting files that were created later than 5 days ago
cleanup(temp_uploads, max_age);
```

People who are feeling nauseous just thinking of how they will converting 90 weeks into milliseconds, could use already [built-in time converter](https://www.npmjs.com/package/string-to-ms).

repository: tpkn/folder-cleanup

repo_name: tpkn/folder-cleanup


text:
CLIR Tips
===============

In this repository are some files from a study on how to support cross-language recommendations for an existing research paper recommender system.

We focused on German, English and Spanish.

Unpublished paper available as pdf file in home folder of repository.

This was a project carried out in the University of Magdeburg Oct 2014-Feb 2015

Apart from surveying some available alternatives for implementing cross-language information retrieval, the aim of this project was to allow the comparison of different approaches to the cross-language support:

- Latent Semantic Analysis (based on user provided cross-language training data + a controlled vocabulary approach during indexing)
- Traditional per-language indexing (with Lucene) and automated query translation (using one of several systems: Apertium, Google Translate API and Moses), further improved by:
	- User mediated query refinement
	- Translation post-processing: Query expansion, by adding synonyms found in ontologies (after tagging with Stanfords PoS tagger) was tested. In the end only support for using MultiWordNet over its English resources was included. For Spanish, MultiWordNet could be also used, and GermaNet (http://www.sfs.uni-tuebingen.de/GermaNet/) for the German language (this requires an agreement with the author's).
	- Additional improvements at the point when results from different indexes are merged (i.e. boosting scores of hits in under-represented languages).
	- Other pre-processing improvements.

Additional notes:
- At this stage our system represents a simple framework that could be used as a starting-point for comparing cross-language services happening at different processing stages, and their contribution to the end results.
- Sense disambiguation for the query expansion was not supported (most common sense is chosen so far), but it could be added. Some recognition for searching phrases as opposed to words could also be a useful improvement to our approach.
- Code for PoS tagging German and Spanish is included but not used.

Code structure:
===============

Overall the provided library consists of the following packages:

Control package:
Classes that encapsuate the Business logic:
- Main class, that starts the GUI or allows a console run.

Mgmt sub-package:
- LanguagesManager: Singleton in charge of the overall information on languages.
- SpecificLanguageManager: Singleton looks after index and repo of a given language.
- RecommendationsHandler: Singleton that generates the recommendations.

Querytermgen sub-package:
- Query term generator: Called by the RecommendationsHandler.

Index sub-package:
- LSA indexer: LSA indexing.
- Per-Language indexer: Lucene indexing.
- Indexer: dummy super-class from which the 2 former inherit.

Query sub-package:
- Query handler: dummy super-class
- Per-language query handler
- LSA query handler: Querying with LSA.
- CL query handler: Cross-language query handler. Implements optimizations.

Utils sub-package:
- TranslationHandler: Singleton allowing to use translation services of Apertium, Google Translate and/or Moses.

Model package:
Data classes:
- LanguageFolder: Matches a language to its repository and index.
- PaperHit: Resulting item from a query.
- ResultsList: List of resulting items from a query.
- QueryTerms: Encapsulates a query string over each language, or one string that combines all languages.
- IndexedDocLSA: Data for indexing a document in LSA.

View package:
GUI related classes.

More information in the included JavaDocs and UML class-layout.

List of some open-source resources used:
===============

For title and plain-text extraction from pdf files:
- PDF-Inspector: https://github.com/Docear/PDF-Inspector

For matrix operations during LSA:
- Apache Commons Math: https://commons.apache.org/proper/commons-math/

For automated translation:
- Apertium Java Api: https://github.com/rmtheis/apertium-translator-java-api
- Apertium Web Service: http://api.apertium.org/

- Google Translate Api: https://code.google.com/p/google-api-translate-java/
- Google Web Service: https://cloud.google.com/translate/docs

- MOSES statistical machine translation system: http://www.statmt.org/moses/
- Aditionally Giza++ statistical translation models toolkit was required for alignment: https://code.google.com/p/giza-pp/
- Corpora used (still to be defined).

For PoS tagging in all languages:
- Stanford's PoS tagger: http://nlp.stanford.edu/software/tagger.shtml
Note that this required Java 1.8+

And specific PoS models:
English model:
- wsj-0-18-bidirectional-distsim.tagger

Trained on WSJ sections 0-18 using a bidirectional architecture and
including word shape and distributional similarity features.
Penn Treebank tagset.
Performance:
97.28% correct on WSJ 19-21
(90.46% correct on unknown words)

German model (not used in current version):
- german-fast.tagger

Lacks distributional similarity features.
Performance:
96.61% overall / 86.72% unknown.
Based on:
german-hgc.tagger
Trained on the first 80% of the Negra corpus, which uses the STTS tagset.
The Stuttgart-Tübingen Tagset (STTS) is a set of 54 tags for annotating
German text corpora with part-of-speech labels, which was jointly
developed by the Institut für maschinelle Sprachverarbeitung of the
University of Stuttgart and the Seminar für Sprachwissenschaft of the
University of Tübingen. See:
http://www.ims.uni-stuttgart.de/projekte/CQPDemos/Bundestag/help-tagset.html
This model uses features from the distributional similarity clusters
built over the HGC.
Performance:
96.90% on the first half of the remaining 20% of the Negra corpus (dev set)
(90.33% on unknown words)

Spanish model (not used in current version):
- Spanish-distsim.tagger

For adding synonym sets as a form of post-processing query expansion:
- MultiWordNet: http://multiwordnet.fbk.eu/english/home.php (English ontology kindly provided by email).
- Additionally we used a MySQL server running a database with the ontologies provided in .sql format.

For indexing and parsing:
- Lucene: http://lucene.apache.org/

Information on specific versions, authors, etc., can be found in the repository itself.

Known issues:
===============
- Portability needs improvement: Facilitate the server configurations so as to make the system more portable.
- Field extraction with PDF Inspector must be improved. Buggy behaviour has been observed, such as breaking up words when extracting terms in German and Spanish. This must be corrected so we can consider indexing other fields (citations, keywords, authors, etc.) and their benefits/shortcomings. Perhaps other PDF parsers could be tested, as Lemur.
- Observed issues while using Apertium (one translation request EN->ES or ES->EN stalls from time to time).

Future work:
===============
- Extend LSI to accept new terms during indexing. Configure with realistic training data/parallel or comparable corpus available on the Web. Study benefits of alternative corpora. For this some pre-processing per language has to be added. So as to limit dictionary growth, feature selection could be done in the stage preceding semantic reduction, so as to speed the resulting matrix calculations for indexing and querying (this would be a variation from regular feature selection, for we have to keep the approximately paired relation between features in each language). Evaluate time for querying and improve if needed, by using better matrix algorithms.
- Check and upload Moses model support, add this to documentation. Evaluate possibilities for using extended features. Once more, study the potentials of alternative comparable corpora which could be mined from the web.
- Use WordNets from the other languages and extend with word-sense disambiguation and NER. This might lead to more accurate terms. Perhaps migrate to EuroWordNet. Study adequateness of current POS given that we have incomplete sentences.
- Consider alternatives for adding lexical/semantic support for users during query refinement.
- Test other boost-on-merge options.
- Consider pre-processing alternatives for each supported language.
- Study and consider solutions for dealing with out of vocabulary words.
- Comprehensive evaluation under a more realistic configuration + testing scheme.
- Additional improvements to the existing approaches with semantics and NLP, as well as extensions to the current LSA model, would be of interest too.

- Optionally other configurations could be studied.
	- The use of aditional information available to the recommender system, as a way of supporting translation-disambiguation, could be of interest for it represents a stronger embedding of the system with the translation services, and a benefit almost exclusive to cross-language recommender systems (since, by comparison, most cross-language information retrieval systems rely on much more limited information for disambiguation). Several approaches could be tested:
		- A less embedded approach would be to provide the translation services with a larger body of text and then extract only the parts that are required.
		- Also with Moses a bag-of-words approach could be used for it to return potential, instead of exact, translations. Each of these words can be assigned an associated weight, which serves to signal the most likely translation to the document retriever or the indexer. The weights can be further tuned with a knowledge or corpus-based approach.
		- Inter-lingual nets coupled with good word-sense predictors, could be considered as a form of dictionary tranlation.
- Embedding the cross-language aspects into the inner workings of recommender systems. For this our query definition has to be extended so it includes any additional data that the recommender system might use needing translation. The matching itself can be performed in any way the recommender system does, and finally the merging can be adapted to suit the existing system. Of particular interest would be supporting translation of citation-related information (such as citation context), for this might enable the research paper recommender system to produce better cross-language recommendations, by having a multi-language characterization of how a paper is cited. This could be a fruitful area of research. Also, supporting other characteristics of the recommender, for example, recommendations of sequences of papers.

-Considerations of relevance feedback could be added.

-Language recognizer functionality could be added, perhaps to deal with OoV words, or other issues.

-Other indexer systems might provide benefits instead of Lucene: Wumpus, Indri (packed with Lemur project, for parsing pdfs)...

-Extensions to other languages + devising a clean process for incorporating these sort of extensions.

-Future studies on potential benefits of using semantic net-based similarity measures for cross-lingual queries might be of interest, since it's not a much researched topic.

- Finally, with a basis on our work and the large amount of technologies available, aditional cross-language services could be further built for users, such as cross-languge query suggestions,  providing multi-lingual explanations for the cross-language recommendations, etc.


text:
### Find and remove outliers

This step uses `clean_wqdata` from the `wqbc` R package to calculate potential outliers. Outliers can also be manually removed by clicking on the plot. Color indicates outliers, Symbol indicates if observation is <MDL (i.e., True).

repository: bcgov/shinyrems

gha_language: R

repo_name: bcgov/shinyrems


text:
# Benchmarks

This directory contains the code to benchmark three different `ffv1` versions
written in the following programming languages:

- Rust
- Go
- C

## Environment

Benchmarks are thought to run on `Linux` systems.

You need to install `Go`, `Rust` and `C` toolchains in order to
build the executables.

In case of the `C` executable, you also have to install
`libavformat`, `libavcodec`, `libavutil` from `FFmpeg`.

The code is benchmarked using [hyperfine](https://github.com/sharkdp/hyperfine).
Take a look at the [Releases](https://github.com/sharkdp/hyperfine/releases)
page to install the version best suited for your architecture.

## Building

To build executables, please run the `./compile.sh` script.

## Run benchmark

To run benchmarks, please run the `/.benchmarks.sh` script and have a coffee :)


text:
# maltools
This is a library of Python tools for working with MyAnimeList.com.

## Usage

```
import maltools

df = maltools.read_xml('animelist.xml')
```

repository: ryanquinnnelson/maltools

gha_language: Python

repo_name: ryanquinnnelson/maltools


text:
# A talk on why GraphQL can be a good choice for Startups

This talk is about the pertinence of GraphQL in a startup.

When launching a startup, a lot of critical choices must be made. In this postmortem, we will discuss how GraphQL allowed https://teamstarter.co to thrive.

In this talk we expect you to already know the basics of GraphQL. If you do not know them, I added some good references bellow to consult before going through the slides.

The slides are available [online](https://vincentdesmares.github.io/talk-startups-and-graphql-benefits-and-drawbacks/).

## References

- [Meetup Graphql@Paris](https://www.meetup.com/parisgraphql/)
- [Teamstarter](https://teamstarter.co)
- [graphql-sequelize-generator](https://github.com/matterstech/graphql-sequelize-generator)
- [Matters](https://matters.tech)

This talk was insipired by a more general problem, how to pick the right technology for a startup?

- [The right language](https://medium.com/future-of-work/which-programming-language-is-right-for-my-startup-a-guide-for-non-technical-founders-a7d96b00dd8b)
- [Is python a right pick for my startup?](https://www.merixstudio.com/blog/is-python-best-programming-language-your-startup/)

More about GraphQL:

- [GraphQL official doc](https://graphql.org/learn/)
- [Graphql Europe 2018](https://medium.com/graphqlconf/watch-all-talks-from-graphql-europe-2018-4a47ee28570a)
- [Slides: introduction-to-graphql-or-how-i-learned-to-stop-worrying-about-rest-apis](https://www.slideshare.net/AhmadHafizIsmail/introduction-to-graphql-or-how-i-learned-to-stop-worrying-about-rest-apis)
- [Slides : graphql-is-the-better-rest](https://www.slideshare.net/DataWorksMD/graphql-is-the-better-rest?qid=c1e36de6-f4f2-4a9f-87c5-fe6ec9404ccc&v=&b=&from_search=1)
- [Top 5 GraphQL predictions for 2019](https://medium.com/graphqlconf/top-5-graphql-predictions-for-2019-6f281f16fac1?source=collection_home---6------0---------------------)

More about generating things related to Graphql:

- [Graphql Code Generator](https://github.com/dotansimha/graphql-code-generator)
- [GraphqlGen by Prisma](https://www.prisma.io/blog/graphqlgen-fj3s0ssc1jsx/)
- [Graph-tools by Apollo](https://github.com/apollographql/graphql-tools)
- [GraphQL Server Generator for Go](https://en.99designs.fr/blog/engineering/gqlgen-a-graphql-server-generator-for-go)

Other references that helped doing this talk:

_And that I might have made references to during the presentation_

- [Dan's article: The Elements of UI Engineering](https://overreacted.io/the-elements-of-ui-engineering)

This project was bootstrapped with [Create React App](https://github.com/facebookincubator/create-react-app).

## Controls

| Key Combination | Function                       |
| --------------- | ------------------------------ |
| Right Arrow     | Next Slide                     |
| Left Arrow      | Previous Slide                 |
| Space           | Next Slide                     |
| Shift+Space     | Previous Slide                 |
| Alt/Option + O  | Toggle Overview Mode           |
| Alt/Option + P  | Toggle Presenter Mode          |
| Alt/Option + T  | Toggle Timer in Presenter Mode |
| Alt/Option + A  | Toggle autoplay (if enabled)   |
| Alt/Option + F  | Toggle Fullscreen Mode         |

### Contact

<EMAIL_ADDRESS>
### Thanks

Illustrations from the amazing site [undraw.co](https://undraw.co/illustrations), by [@NinaLimpi](https://twitter.com/NinaLimpi).


text:
# cosmos_sql_bulk_loader

A simple Console Program to load a CosmosDB/SQL container
using the DotNet C# SDK, and the Bulk Executor functionality.

The input file should be a text file with a JSON-document-per-line.
Each line in the input file will become a CosmosDB document.

## Quick Start

```
$ git clone https://github.com/cjoakim/azure-cosmosdb.git

$ cd code/dotnet/cosmos_sql_bulk_loader

$ dotnet restore      # downloads the dotnet libraries from NuGet
$ dotnet build        # compiles the code
...
Build succeeded.
    0 Warning(s)
    0 Error(s)

# "dotnet run" executes the Main method of Program.cs

$ dotnet run bulk_load_container dev travel data/air_travel_departures_10k.json 1
dbname:   dev
cname:    travel
infile:   data/air_travel_departures_10k.json
mbc:      1
uri: https://cjoakimcosmossql.documents.azure.com:443/
LoadContainer - db: dev, container: travel, infile: data/air_travel_departures_10k.json, maxBatchCount: 1
{"id":"cfd95b0f-0b6e-4ed9-8210-6eb3abfde9fd","pk":"MIA:MAO","date":"2001/04/01","year":"2001","month":"4","from_iata":"MIA","to_iata":"MAO","airlineid":"20149","carrier":"PRQ","count":"4","route":"MIA:MAO","from_airport_name":"Miami Intl","from_airport_tz":"America/New_York","from_location":{"type":"Point","coordinates":[-80.290556,25.79325]},"to_airport_name":"Eduardo Gomes Intl","to_airport_country":"Brazil","to_airport_tz":"America/Boa_Vista","to_location":{"type":"Point","coordinates":[-60.049721,-3.038611]},"doc_epoch":1631284457116,"doc_time":"2021/09/10-14:34:17"}
writing batch 1 (500) at<PHONE_NUMBER>120

EOJ Totals:
  Database:             dev
  Container:            travel
  Input Filename:       data/air_travel_departures_10k.json
  Max Batch Count:      1
  BulkLoad startEpoch:<PHONE_NUMBER>906
  BulkLoad finishEpoch:<PHONE_NUMBER>750
  BulkLoad elapsedMs:   2844
  BulkLoad elapsedSec:  2.844
  BulkLoad elapsedMin:  0.0474
  Batch Size:           500
  Batch Count:          1
  Exceptions:           0
  Document/Task count:  500
  Document per Second:<PHONE_NUMBER>125176
```

## Data

### Input Files

This implementation requires that the input JSON documents have a **pk**
attribute (partition key), and that the target CosmosDB container has the
partition key value of **/pk**.

See data/air_travel_departures_10k.json

### Sample CosmosDB Document from the above file

```
{
    "id": "65629b25-f738-44c7-9406-985c50bbbcd4",
    "pk": "BOS:KEF",
    "date": "2007/03/01",
    "year": "2007",
    "month": "3",
    "from_iata": "BOS",
    "to_iata": "KEF",
    "airlineid": "20402",
    "carrier": "GL",
    "count": "1",
    "route": "BOS:KEF",
    "from_airport_name": "General Edward Lawrence Logan Intl",
    "from_airport_tz": "America/New_York",
    "from_location": {
        "type": "Point",
        "coordinates": [
            -71.005181,
            42.364347
        ]
    },
    "to_airport_name": "Keflavik International Airport",
    "to_airport_country": "Iceland",
    "to_airport_tz": "Atlantic/Reykjavik",
    "to_location": {
        "type": "Point",
        "coordinates": [
            -22.605556,
            63.985
        ]
    },
    "doc_epoch":<PHONE_NUMBER>866,
    "doc_time": "2021/09/10-14:24:19",
    "_rid": "pVIbAKevu-sDAAAAAAAAAA==",
    "_self": "dbs/pVIbAA==/colls/pVIbAKevu-s=/docs/pVIbAKevu-sDAAAAAAAAAA==/",
    "_etag": "\"1000e5bc-0000-0100-0000-613b6a970000\"",
    "_attachments": "attachments/",
    "_ts":<PHONE_NUMBER>
}
```

repository: daniloescolin/azure-cosmosdb

repo_name: daniloescolin/azure-cosmosdb


text:
# SAPUI5 External Library Usage Test

## Intro

This is a basic app example that shows how you can consume an external lib.

Particularly the used lib encapsulate:

- The babel polyfills nedded for async/await statements.
- MyControl.

The lib is consumed as node package and you can find its code in the following repository:

- [https://github.com/sebasgoldberg/external-libs.git](https://github.com/sebasgoldberg/external-libs.git)

## Code For Reuse The Library

You can found the specific code for reuse in the following files:

- `./webapp/index.html`:
This is only for test environment, you do not need this in SAP Gateway Server.
```html
    <!-- Here we told told to SAPUI5 where it can find our library resources using the attribute data-sap-ui-resourceroots -->
    <!-- Note that the library is loaded at bootstrap with attribute data-sap-ui-libs -->
    <script id="sap-ui-bootstrap"
        src="https://sapui5.hana.ondemand.com/1.52.13/resources/sap-ui-core.js"
        data-sap-ui-libs="sap.m,iamsoft.libs.external.polyfill"
        data-sap-ui-theme="sap_belize"
        data-sap-ui-compatVersion="edge"
        data-sap-ui-preload="async"
        data-sap-ui-resourceroots='{
            "sap.ui.demo.basicTemplate": "./",
            "iamsoft.libs.external.polyfill": "resources/external-libs/dist/"
            }'>
    </script>
```
Obiously `resources` was mapped with node_modules folder in `Grunfile.js` and external-libs was added as node package dependency.

- `./manifest.json`: This is the important part. We indicate our custom library as dependency.
```json
    "sap.ui5": {
        "dependencies": {
            "libs": {
                "<other library>": {},
                "iamsoft.libs.external.polyfill": {}
            }
        }
    }
```

- `./webapp/view.App.view.xml`: This is an example where is used one of the controls of the library.
```xml
    <mvc:View
        controllerName="sap.ui.demo.basicTemplate.controller.App"
        <!-- Here we define the namespace -->
        xmlns:pf="iamsoft.libs.external.polyfill.control"
        xmlns:mvc="sap.ui.core.mvc"
        displayBlock="true"
        xmlns="sap.m">
        <App>
            <pages>
                <Page
                    id="page"
                    title="{i18n>title}">
                    <content>
                        <!-- Here we use the control -->
                        <pf:MyControl/>
                    </content>
                </Page>
            </pages>
        </App>
    </mvc:View>
```

## Getting started

1.Install node.js (get it from [nodejs.org](http://nodejs.org/)).
  * If working behind a proxy, you need to configure it properly (HTTP_PROXY / HTTPS_PROXY / NO_PROXY environment variables)

2.Install grunt-cli globally

```sh
npm install grunt-cli -g
```

3.Clone the repository and navigate into it

```sh
git clone https://github.com/sebasgoldberg/test-external-libs.git
cd test-external-libs
```

4.Install all npm dependencies

```sh
npm install
```

5.Run grunt to lint, build and run a local server (have a look into `Gruntfile.js` to see all the tasks).

```sh
grunt
```

7.Open the app in your browser: [http://localhost:8083](http://localhost:8083)

## Some notes

1.You can code using ES8.

2.Is possible to use async/await (babel-polyfills already imported in Component).

3.Transpiled version and Dist version are served in different ports (see grunt file).

4.UI5 preload compatible version was set for the current LTS version: 1.52.

5.Remember to change to your own namespace.

repository: sebasgoldberg/test-external-libs

repo_name: sebasgoldberg/test-external-libs


text:
---
title: Week 5, robot arm!
layout: post
author: james.spicer
permalink: /finishing-off/
source-id: 1HCITpJG49RRQ-fY-dvmhydMJQdoDMa_chiVyJUym8zw
published: true
---

    Title:
     ROBOT ARM  .
    Date
    08/11/2016

    Starting point:
    Finish booklet and check

Target for this lesson?

To finish off the booklet

Did I reach my target?
(add details to "Lesson Review")

Yes

    Lesson Review

    ***How did I learn? What strategies were effective? ***

     I learnt that during the time that it took to finish the booklet, i was building up my knowledge to the last stage, the robot. I also learnt that by looking at your work and checking it, at sometimes, can be really useful, as i am almost guaranteed to make mistakes during the lesson. A good example for this is a couple of stages before the robot, when we had to alter the spacing between the line and the code. At first i didn't get it right and got really annoyed at myself, but when i went back and checked, i knew that checking my work was the problem.

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

    The thing that limited my learning was, like i said in what i learnt, was my ability to go back on my work and check what i was doing was right. I really need to work on my habit of going back and checking my work. This, i think is the most important habit i need to workon. This is because this will help me in other subjects and everyday life as well as I.T.

.

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

      Next time, i will make sure that i go back and check my work. I will improve my learning by paying more attention of what is going on and to CHECK MY WORK. Next time i will read the instructions clearly, because the reason of why we hadn’t got our robot up and running was because it started in the wrong position.


text:
---
publishdate: "2020-05-12"
date: "2020-05-13"
tags:
- jekyll
- liquid
- slug
- data file
title: Jekyll slug and data files
---

If you haven't seen it, the markdown file of this post is named "_2020-05-12-{{page.slug | replace: '_', '\_'}}.md_". Why so?

### What they are

A post in Jekyll is the result of parsing a file which is named with the structure

> \<year\> - \<month\> - \<day\> - \<slug\>.\<extension\>

I only added spaces to make it clearer. There should be no space.

The Jekyll doc might call that "slug" part ["title"](https://jekyllrb.com/docs/posts/#creating-posts) but when you write `{{page.slug}}`, what you get is that "title". Oh sorry I forgot to add the `raw` tag. "when you write `{{page.slug}}`".

I have only written 4 posts here (this is the fifth, but one has been moved to the newly created [Notes]({% link notes.html %}) section), and [one of them]({% post_url 2020-03-25-toggle-krunner-plasma-5.17 %}) contains a dot in its slug. Again, you don't see any dot in URLs around here, whether in this post's or that old post's, although I also use "slug"s to build URLs. The reason is that "slug"s to build URL and `page.slug`s are slugified differently.

Slugification (don't take my word for it!) is the act of converting strings to a form with no space and no "strange" characters. In Liquid, the `slugify` filter helps you do this. How "strange" characters are converted depends on which [option](https://jekyllrb.com/docs/liquid/filters/#options-for-the-slugify-filter) you pass to the filter:
- `{{page.slug | slugify}}` gives "_{{page.slug | slugify}}_" just like what you see in the address bar;
- `{{page.slug | slugify: "ascii"}}` gives "_{{page.slug | slugify: 'ascii'}}_", it's what I'm gonna use with this site now;
- `{{page.slug | slugify: "latin"}}` gives "_{{page.slug | slugify: 'latin'}}_", it's what I was about to use because I thought of writing something in Vietnamese in the future, but as I see my characters are not preserved (I expected only partly though), for now I will skip it.

And as you might already see, `page.slug` still contains a bunch of special characters, which means that it is not slugified at all. So yes, `page.slug` is less sluggy than the URL.

### Why I am doing this

Back to the old post with a dot in its slug. When I used only `page.slug` for identifying which post a [Staticman]({% link _notes/staticman.md %}) comment belongs to, comments on that old post would end up in a directory with a dot in its name

> toggle-krunner-plasma-5.17

However, the dot does not appear in the property name of the data object `site.data.comments` that Jekyll retrieves

> {"toggle-krunner-plasma-517"=>{"entry...

So when my code tried to get `site.data.comments[page.slug]`, nothing was returned.

How Jekyll converts the directory name is still unknown to me. For example, "_{{page.slug | replace: '_', '\_'}}_", this post's slug, when read by Jekyll, appears as "_jekyll\_\_slg_", which shows that:
- Underscores are kept;
- Asterisks, dots, and pluses are removed. At least ü's and ư's are also removed;
- Spaces are changed to underscores.

And that's all I know so far.

What I can do with my Staticman commenting function is to slugify `page.slug` both in the comment form to indicate which post this comment belongs to and in the comment list to tell which post's comments to get. And let's see if my comment (later) can be shown down there.

### Side effect related to data files

While playing around with the slug, I also got a problem with Jekyll being unable to sort some null object. By fixing this error, I found out that data files are read by Jekyll as properties of their folder as the object. To be clearer, consider a post "How to slugify" with the slug "how-to-slugify". Its comments are placed as in this directory tree:
```
.
├─ _data
│  └─ comments
│     ├─ how-to-slugify
│     │  ├─ entry1.yml
│     │  ├─ entry2.yml
│     │  └─ entry3.yml
│     ├─ ...
```
and the data are read into this object `site.data.comments` as
```json
{
  "how-to-slugify": {
    "entry1": {...},
    "entry2": {...},
    "entry3": {...}
  },
  ...
}
```
So when I passed the object `site.data.comments[slug]` to a `sort` filter, it's not an array and the filter threw an error.

I went on and converted these properties into an array of comment objects. You can see more [here](https://github.com/PhuNH/phunh.github.io/blob/source/_includes/comments.html).
{{< highlight go >}}
{% assign props_array = '' | split: '' %}
{% for entry in site.data.comments[slug] %}
  {% assign props_array = props_array | concat: entry %}
{% endfor %}
{% assign comments_array = props_array | where_exp: "entry", "entry['_id'] != nil" %}
{% assign first_level = comments_array | where_exp: "item", "item.reply_to == ''" | sort: 'date' %}
{{< / highlight >}}

Basically, using Liquid, you cannot create an array directly, but only split a string to create a string array. So I did the trick of splitting an empty string and then concatenated each property to the resulting array. The concatenated properties, however, also contains property names ("entry1", "entry2", "entry3" in the example) as separate array elements, so I filtered them out using a `where_exp` filter to check for the "_id" property in each element.

There is however still one thing I don't understand about this problem with Liquid: `site.data.comments[slug]` after a filter (e.g. `where_exp: "item", "item.reply_to == ''"`) is shown to be an array, just like our `first_level` array variable above, but I still cannot sort it. It would be nice to know why. Anyway, off to the comment section.

path: /content/posts/jekyll*+_ slưü.g.md

filename: jekyll*+_ slưü.g.md

gha_language: SCSS


text:
# jsxphys
Markup language simple parser using JavaScript for x with the use of Physics

## Motivation
After reading some questions and answers [1-4], it triggers again a desire from the past in making a language for Physics that can accomodate equations, tables, figures, sounds, videos, and animations. We will not reinvent the wheel but use what has been already optimized or too complicated, e.g. equations will be handled by MathJax [5] (or later KaTeX? [6]), charts by Chart.js [7]. Tables will imitate markup from Markdown, but since it is in the development stage, the code is still complex and inefficient.

Right now the social distancing and limitation policy in Bandung due to coronavirus pandemic [8] and other cities,  work from home (WFH) and study from home (SFH) require a lot of data transaction through internet which also be an additional cost to the students [9], since the use of online meeting application with sound and video. It would be better when only plain text is transmitted and then the rich content is created in user browser, this will save user bandwidth.

## Version
0.0.1 Table with TAB markup and reference without style [20200418]

0.0.2 Chart from Chart.js with JS but not yet with markup [20200423]

## Limitation
The jsxPhys will remain a client-side application to support users without complexity in installation as in a server-side application.

## Dependencies
1. MathJax | https://www.mathjax.org/
2. Chart.js | https://www.chartjs.org/

## References
1. Markdown vs markup - are they related?

   url https://stackoverflow.com/a/24044/9475509

   23 Aug 2008
2. What is the difference between markup and Markdown?

   url https://meta.stackexchange.com/a/167679/538710

   14 Jul 2013
3. Creating a markup language like markdown [closed]

   url https://stackoverflow.com/a/39156767/9475509
   26 Aug 2016
4. If Markdown is a superset of HTML, then why can't it do everything HTML can?

   url https://stackoverflow.com/a/55558811/9475509

   7 Apr 2019
5. MathJax | Beautiful math in all browsers

   url https://www.mathjax.org/

   [20200423]
6. KaTeX | The fastest math typesetting library for the web

   url https://katex.org/

   [20200423]
7. Chart.js | Simple yet flexible JavaScript charting for designers & developers

   url https://www.chartjs.org/

   [20200423]
8. tim/fra, "Tangkal Corona, PSBB Bandung Raya Mulai Berlaku Hari Ini", CNN Indonesia

   url https://www.cnnindonesia.com/nasional/20200422071248-20-495899/tangkal-corona-psbb-bandung-raya-mulai-berlaku-hari-ini

   Rabu, 22/04/2020 07:22 WIB
9. Alfian Putra Abdi, "Nasib Mahasiswa UI saat Corona: Kuliah Online Tanpa Subsidi Pulsa", tirto.id - Pendidikan

   url https://tirto.id/nasib-mahasiswa-ui-saat-corona-kuliah-online-tanpa-subsidi-pulsa-eNGi

   17 April 2020

repository: dudung/jsxphys

repo_name: dudung/jsxphys


text:
# Texter

A full-fledged text editor for linux platform with all basic features.

## Usage

Clone this repository and go to the path of data from your terminal and just run
python texter.py

## Screenshot

![Hello World](screenshots/hello_world.png)

repository: abaugus/Texter

repo_name: abaugus/Texter


text:
# Ash

A very lightweight wrapper around Vulkan

[![Crates.io Version](https://img.shields.io/crates/v/ash.svg)](https://crates.io/crates/ash)
[![Documentation](https://docs.rs/ash/badge.svg)](https://docs.rs/ash)
[![Build Status](https://github.com/MaikKlein/ash/workflows/CI/badge.svg)](https://github.com/MaikKlein/ash/actions?workflow=CI)
[![LICENSE](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE-MIT)
[![LICENSE](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE-APACHE)
[![Join the chat at https://gitter.im/MaikKlein/ash](https://badges.gitter.im/MaikKlein/ash.svg)](https://gitter.im/MaikKlein/ash?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[![MSRV](https://img.shields.io/badge/rustc-1.60.0+-ab6000.svg)](https://blog.rust-lang.org/2022/04/07/Rust-1.60.0.html)

## Overview

- [x] A true Vulkan API without compromises
- [x] Convenience features without limiting functionality
- [x] Additional type safety
- [x] Device local function pointer loading
- [x] No validation, everything is **unsafe**
- [x] Generated from `vk.xml`
- [x] Support for Vulkan `1.1`, `1.2`, `1.3`

## ⚠ Semver compatibility warning

The Vulkan Video bindings are experimental and still seeing breaking changes in their upstream specification, and are only provided by Ash for early adopters. All related functions and types are semver-exempt [^1] (we allow breaking API changes while releasing Ash with non-breaking semver bumps).

[^1]: `generator` complexity makes it so that we cannot easily hide these bindings behind a non-`default` feature flag, and they are widespread across the generated codebase.

## Features

### Explicit returns with `Result`

```rust
// function signature
pub fn create_instance(&self,
                       create_info: &vk::InstanceCreateInfo,
                       allocation_callbacks: Option<&vk::AllocationCallbacks>)
                       -> Result<Instance, InstanceError> { .. }
let instance = entry.create_instance(&create_info, None)
    .expect("Instance creation error");
```

### `Vec<T>` instead of mutable slices

```rust
pub fn get_swapchain_images(&self,
                            swapchain: vk::SwapchainKHR)
                            -> VkResult<Vec<vk::Image>>;
let present_images = swapchain_loader.get_swapchain_images_khr(swapchain).unwrap();
```

_Note_: Functions don't return `Vec<T>` if this would limit the functionality. See `p_next`.

### Slices

```rust
pub fn cmd_pipeline_barrier(&self,
                            command_buffer: vk::CommandBuffer,
                            src_stage_mask: vk::PipelineStageFlags,
                            dst_stage_mask: vk::PipelineStageFlags,
                            dependency_flags: vk::DependencyFlags,
                            memory_barriers: &[vk::MemoryBarrier],
                            buffer_memory_barriers: &[vk::BufferMemoryBarrier],
                            image_memory_barriers: &[vk::ImageMemoryBarrier]);
```

### Strongly typed handles

Each Vulkan handle type is exposed as a newtyped struct for improved type safety. Null handles can be constructed with
`T::null()`, and handles may be freely converted to and from `u64` with `Handle::from_raw` and `Handle::as_raw` for
interop with non-Ash Vulkan code.

### Builder pattern

```rust
let queue_info = [vk::DeviceQueueCreateInfo::default()
    .queue_family_index(queue_family_index)
    .queue_priorities(&priorities)];

let device_create_info = vk::DeviceCreateInfo::default()
    .queue_create_infos(&queue_info)
    .enabled_extension_names(&device_extension_names_raw)
    .enabled_features(&features);

let device: Device = instance
    .create_device(pdevice, &device_create_info, None)
    .unwrap();
```

### Pointer chains

Use `base.push_next(ext)` to insert `ext` at the front of the pointer chain attached to `base`.

```rust
let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::default();
let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::default();

let mut device_create_info = vk::DeviceCreateInfo::default()
    .push_next(&mut corner)
    .push_next(&mut variable_pointers);
```

The generic argument of `.push_next()` only allows valid structs to extend a given struct (known as [`structextends` in the Vulkan registry](https://registry.khronos.org/vulkan/specs/1.3/styleguide.html#extensions-interactions), mapped to `Extends*` traits).
Only structs that are listed one or more times in any `structextends` will implement a `.push_next()`.

### Flags and constants as associated constants

```rust
// Bitflag
vk::AccessFlags::COLOR_ATTACHMENT_READ | vk::AccessFlags::COLOR_ATTACHMENT_WRITE
```

```rust
// Constant
vk::PipelineBindPoint::GRAPHICS,
```

### Debug/Display for Flags

```rust
let flag = vk::AccessFlags::COLOR_ATTACHMENT_READ
        | vk::AccessFlags::COLOR_ATTACHMENT_WRITE;
println!("Debug: {:?}", flag);
println!("Display: {}", flag);
// Prints:
// Debug: AccessFlags(110000000)
// Display: COLOR_ATTACHMENT_READ | COLOR_ATTACHMENT_WRITE
```

### Function pointer loading

Ash also takes care of loading the function pointers. Function pointers are split into 3 categories.

- Entry: Loads the Vulkan library. Needs to outlive `Instance` and `Device`.
- Instance: Loads instance level functions. Needs to outlive the `Device`s it has created.
- Device: Loads device **local** functions.

The loader is just one possible implementation:

- Device level functions are retrieved on a per device basis.
- Everything is loaded by default, functions that failed to load are initialized to a function that always panics.
- Do not call Vulkan 1.1 functions if you have created a 1.0 instance. Doing so will result in a panic.

Custom loaders can be implemented.

### Extension loading

Additionally, every Vulkan extension has to be loaded explicitly. You can find all extensions under [ash::extensions](https://github.com/MaikKlein/ash/tree/master/ash/src/extensions).

```rust
use ash::extensions::khr::Swapchain;
let swapchain_loader = Swapchain::new(&instance, &device);
let swapchain = swapchain_loader.create_swapchain(&swapchain_create_info).unwrap();
```

### Raw function pointers

Raw function pointers are available, if something hasn't been exposed yet in the higher level API. Please open an issue if anything is missing.

```rust
device.fp_v1_0().destroy_device(...);
```

### Support for extension names

```rust
use ash::extensions::{Swapchain, XlibSurface, Surface, DebugReport};
#[cfg(all(unix, not(target_os = "android")))]
fn extension_names() -> Vec<*const i8> {
    vec![
        Surface::NAME.as_ptr(),
        XlibSurface::NAME.as_ptr(),
        DebugReport::NAME.as_ptr()
    ]
}
```

### Implicit handles

Handles from Instance or Device are passed implicitly.

```rust
pub fn create_command_pool(&self,
                           create_info: &vk::CommandPoolCreateInfo)
                           -> VkResult<vk::CommandPool>;

let pool = device.create_command_pool(&pool_create_info).unwrap();
```

### Optional linking

The default `loaded` cargo feature will dynamically load the default Vulkan library for the current platform with `Entry::load`, meaning that the build environment does not have to have Vulkan development packages installed.

If, on the other hand, your application cannot handle Vulkan being missing at runtime, you can instead enable the `linked` feature, which will link your binary with the Vulkan loader directly and expose the infallible `Entry::linked`.

## Example

You can find the examples [here](https://github.com/MaikKlein/ash/tree/master/examples).
All examples currently require: the LunarG Validation layers and a Vulkan library that is visible in your `PATH`. An easy way to get started is to use the [LunarG Vulkan SDK](https://lunarg.com/vulkan-sdk/)

#### Windows

Make sure that you have a Vulkan ready driver and install the [LunarG Vulkan SDK](https://lunarg.com/vulkan-sdk/).

#### Linux

Make sure that you have a Vulkan ready driver and install the [LunarG Vulkan SDK](https://lunarg.com/vulkan-sdk/). You also have to add the library and layers to your path. Have a look at my [post](http://askubuntu.com/a/803110/77183) if you are unsure how to do that.

#### macOS

Install the [LunarG Vulkan SDK](https://lunarg.com/vulkan-sdk/). The installer puts the SDK in `$HOME/VulkanSDK/<version>` by default. You will need to set the following environment variables when running cargo:

```sh
VULKAN_SDK=$HOME/VulkanSDK/<version>/macOS \
DYLD_FALLBACK_LIBRARY_PATH=$VULKAN_SDK/lib \
VK_ICD_FILENAMES=$VULKAN_SDK/share/vulkan/icd.d/MoltenVK_icd.json \
VK_LAYER_PATH=$VULKAN_SDK/share/vulkan/explicit_layer.d \
cargo run ...
```

### [Triangle](https://github.com/MaikKlein/ash/blob/master/examples/src/bin/triangle.rs)

Displays a triangle with vertex colors.

```
cd examples
cargo run --bin triangle
```

![screenshot](http://i.imgur.com/PQZcL6w.jpg)

### [Texture](https://github.com/MaikKlein/ash/blob/master/examples/src/bin/texture.rs)

Displays a texture on a quad.

```
cd examples
cargo run --bin texture
```

![texture](http://i.imgur.com/trow00H.png)

## Useful resources

### Examples

- [vulkan-tutorial-rust](https://github.com/Usami-Renko/vulkan-tutorial-rust) - A port of [vulkan-tutorial.com](https://vulkan-tutorial.com).
- [ash-sample-progression](https://github.com/bzm3r/ash-sample-progression) - A port of the LunarG examples.
- [ash-nv-rt](https://github.com/gwihlidal/ash-nv-rt) A raytracing example for ash.

### Utility libraries

- [vk-sync](https://github.com/gwihlidal/vk-sync-rs) - Simplified Vulkan synchronization logic, written in rust.
- [vk-mem-rs](https://github.com/gwihlidal/vk-mem-rs) - This crate provides an FFI layer and idiomatic rust wrappers for the excellent AMD Vulkan Memory Allocator (VMA) C/C++ library.
- [gpu-allocator](https://github.com/Traverse-Research/gpu-allocator) - Memory allocator written in pure Rust for GPU memory in Vulkan and in the future DirectX 12
- [lahar](https://github.com/Ralith/lahar) - Tools for asynchronously uploading data to a Vulkan device.

### Libraries that use ash

- [gfx-rs](https://github.com/gfx-rs/gfx) - gfx-rs is a low-level, cross-platform graphics abstraction library in Rust.

## A thanks to

- [Api with no secrets](https://software.intel.com/en-us/articles/api-without-secrets-introduction-to-vulkan-part-1)
- [Vulkan tutorial](http://jhenriques.net/development.html)
- [Vulkan examples](https://github.com/SaschaWillems/Vulkan)
- [Vulkan tutorial](https://vulkan-tutorial.com/)
- [Vulkano](https://github.com/vulkano-rs/vulkano)
- [vk-rs](https://github.com/Osspial/vk-rs)

repository: Traverse-Research/ash

repo_name: Traverse-Research/ash


text:
# Linear Axesservice

Version: **V1**
Authors: [@CoLa5](https://github.com/CoLa5)
Date: 10.09.2021

## Table to copy into implementation folder

When implementing the service, put this table into a `README.md` next to it, to mark the implemented plugins by `X`.

| Service                          |   |
|----------------------------------|---|
| **HardwareController**           | X |
| MoveWithScalarVelocityPlugin     | X |
| MoveWithVectorVelocityPlugin     |   |
| MoveWithScalarAccelerationPlugin |   |
| MoveWithVectorAccelerationPlugin |   |
| MoveWithTriggerPlugin            |   |


text:
---
hrs_structure:
  division: '2'
  volume: '9'
  title: '24'
  chapter: '431'
  section: '431:4-401'
type: hrs_section
tags:
  - Business
menu:
  hrs:
    identifier: HRS_0431-0004-0401
    parent: HRS0431
    name: '431:4-401 Application of other sections'
weight: 11325
title: Application of other sections
full_title: '431:4-401 Application of other sections'
---
**PART IV. RECIPROCAL INSURERS**

**§431:4-401 Application of other sections.** The provisions of article 3, Insurers General Requirements, shall apply except where inconsistent with the express provisions of this article. [L 1987, c 347, pt of §2]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# datasetWeb - A simple static web page for my master thesis dataset

The aim is to offer a static web page, that later can be used to publish the data set and findings of my master thesis.

To run the page, clone this repo and open the index.html file. You can also publish it to a simple web server.

repository: pmanlukas/datasetWeb

repo_name: pmanlukas/datasetWeb


text:
# Learn to scrape

Materials for MIT Methods Lab workshop on learning to scrape web pages

## Preperation

We'll be using Python 3 for this workshop because it has much better support
than 2 for different character encodings in text, which is something that comes
up quite often in web scraping.
Please install the Anaconda distribution of Python 3 and Jupyter notebook from
the [Anaconda](https://www.anaconda.com/download/?lang=en-us#macos) site. For
more details, see [@soubhikbarari](https://github.com/soubhikbarari/)'s instructions
[here](https://github.com/soubhikbarari/MITPolMeth-PythonDataSci-02-2018/blob/master/setup.pdf),
but making sure to install Python 3.

Anaconda should automatically have all of the needed packages pre-installed.
Please verify that they are by:

1. downloading this repository (the button is on the upper right of the page)
2. launching Jupyter using [@soubhikbarari](https://github.com/soubhikbarari/)'s instructions
3. opening the `.ipynb` notebook
4. running each of the cells with `import` in them to verify the packages load

## Contents

`Scraper_Skeleton.ipynb` contains a skeleton of a web scraper and is what we'll
be working through during the workshop.

`Scraper_Completed.ipynb` is the "solutions" for `Scraper_Skeleton`.


text:
# barnes-ops-www

**Final state:** This repository looks like it had been a prior repository for the collection or main site frontend. It's no longer in use and has very minimal code published to it.

This repository will now be archived.

**Superseded By:** The [barnes-collection-www](https://github.com/BarnesFoundation/barnes-collection-www) repository.

repository: BarnesFoundation/barnes-ops-www

repo_name: BarnesFoundation/barnes-ops-www


text:
---
layout: layout.pug
navigationTitle: Permissions Management
title: Permissions Management
menuWeight: 30
excerpt: Managing permissions
enterprise: true
render: mustache
model: /mesosphere/dcos/2.0/data.yml
---
<!-- The source repository for this topic is https://github.com/dcos/dcos-docs-site -->

The DC/OS Identity and Access Management (IAM) system is designed to protect resources via fine-grained authorization.
Each protected resource has one associated Access Control List (ACL) that declares which principals may perform which actions on a named resource. This is performed according to the whitelisting (deny-by-default) model.

Permissions can be applied to users and groups using either the DC/OS web interface, the [IAM HTTP API](/mesosphere/dcos/2.0/security/ent/iam-api/) or the [DC/OS Enterprise CLI](/mesosphere/dcos/2.0/cli/enterprise-cli/). Each interface provides a way to manage Access Control Entries (ACEs). Each ACE includes the following pieces of information:

* A principal identifier
* A resource identifier
* An action identifier

These three pieces of information are strings.

Action identifiers must be chosen from a fixed set of actions. The available action identifiers are `create`, `read`, `update`, `delete`, and `full`. By convention, `full` indicates that the permission supports all other action identifiers. The identifier `full` may include actions not supported by any other action identifier.

### Managing permissions from the CLI

There are [four commands](/mesosphere/dcos/2.0/cli/command-reference/dcos-security/dcos-security-org/) used for managing permissions from the DC/OS Enterprise CLI.

To manage permissions for **groups** from the DC/OS Enterprise CLI, use the following commands:

* [`dcos security org groups grant [OPTIONS] GID RID ACTION`](/mesosphere/dcos/2.0/cli/command-reference/dcos-security/dcos-security-org/dcos-security-org-groups/dcos-security-org-groups-grant/)
* [`dcos security org groups revoke [OPTIONS] GID RID ACTION`](/mesosphere/dcos/2.0/cli/command-reference/dcos-security/dcos-security-org/dcos-security-org-groups/dcos-security-org-groups-revoke/)

To manage permissions for **users** from the DC/OS Enterprise CLI, use the following commands:

* [`dcos security org users grant [OPTIONS] UID RID ACTION`](/mesosphere/dcos/2.0/cli/command-reference/dcos-security/dcos-security-org/dcos-security-org-users/dcos-security-org-users-grant/)
* [`dcos security org users revoke [OPTIONS] UID RID ACTION`](/mesosphere/dcos/2.0/cli/command-reference/dcos-security/dcos-security-org/dcos-security-org-users/dcos-security-org-users-revoke/)

### Managing permissions using the API

The [IAM HTTP API](/mesosphere/dcos/2.0/security/ent/iam-api/) provides operations to manage permissions for users and groups.

Note that all entities must exist when creating a permission.

A typical pattern to create a permission is:

1. Call `PUT /acls/{rid}` to create the access control list for the protected resource `{rid}`, ignoring any returned `409` status code (which indicates that it already exists); then
1. Call `PUT /acls/{rid}/users/{uid}/{action}`  or `PUT /acls/{rid}/groups/{gid}/{action}` to create the specific user or group access control entry.

repository: mesosphere/dcos-docs-site

repo_name: mesosphere/dcos-docs-site


text:
---
author: dealingwith
date: '2010-02-15 14:35:00'
layout: post
slug: bad-buzz
status: publish
title: Bad Buzz
wordpress_id: '3255'
categories:
 - nonlinear
---

Based on my casual observation of the situation, it seems to me [the bad
things about Google Buzz][1] [[2][2]] [*] were the result of just a couple
basic product design decisions that probably felt natural and ingenious to the
product designers, based on their usage of Google products as a whole. Of
course being Google employees, their usage likely differs significantly from
other Gmail users, say nothing of their trust in the company as a whole.

While [building software for yourself][3] is a good idea, especially for small
businesses or startups, it is dependent on you being a lot like your
customers. Once you are building products for yourself inside a giant
organization that internally looks a lot different than the outside world,
that is when having [empathy][4] [[2][5]] for your actual customers becomes
increasingly important. Especially when you have the resources to actually go
and find out, scientifically, what your users are like.

Google is still just a search company, and that piece of their business and
experience they get right every time. But they are also increasingly a
product** company, and getting a lot of exposure through their products. I
suspect that these products are primarily developed by (relatively) small
teams of very smart people, whose intelligence has led to a certain self-
assurance but whose myopic experience has led to a certain naiveté about how a
product will be received in the "outside" world. Buzz feels a lot like
Google's version of [Clippy][6]. Let's just hope Google is able to turn the
user experience ship early and go back to creating products born out of novel
innovations and not just internal versions of other company's products.

* There were a ton of intelligent critiques of Buzz and I hoped to link to a
few more of my favorites, but I failed to preserve the links or re-find them
in a cursory search. Although just now I found [this well-written (if wordy)
analysis that I think says the same things I just did but in a more business-
like, thought out way][7].

** Their search engine and results presentation is also a product, but for the
purposes of this discussion I've categorized it separately.

Postscript: FWIW, I disabled Buzz after about 15 minutes of testing. Had there
been a setting to keep it out of my inbox without having to create a filter I
might have tried it for a day or two, but the email inbox is sacred, and their
intrusion into it was enough of an offense for me to make a quick and final
judgement in terms of my own usage of the product.

   [1]: http://www.nytimes.com/2010/02/15/technology/internet/15google.html

   [2]: http://ilovebenbrown.com/post/382112393/waiting-for-the-google-buzz-privacy-outcry

   [3]: http://gettingreal.37signals.com/ch02_Whats_Your_Problem.php

   [4]: http://www.poetpainter.com/thoughts/article/what-a-designer-does-part-i

   [5]: http://www.peterme.com/archives/000085.html

   [6]: http://en.wikipedia.org/wiki/Office_Assistant

   [7]: http://counternotions.com/2010/02/15/buzzback/ ('What Google is missing, in other words, is strategic design.')

repository: dealingwith/poole

extension: markdown

repo_name: dealingwith/poole


text:
# [Linter](https://janke-learning.github.io/linter)

Paste in your code to get tips on code style, syntax errors, and potential problems.

> Powered by [jshint](https://github.com/jshint/jshint)

___
___
###  Janke Learning

repository: oldd/linter

repo_name: oldd/linter