text:
---
# Documentation: https://sourcethemes.com/academic/docs/managing-content/

title: "Tougher rating system evaluates nine supercomputer capabilities"
subtitle: "Results released at Supercomputing Conference 2010"
summary: ""
authors: []
tags: []
categories: []
date: 2010-11-18T21:53:10-04:00
lastmod: 2010-11-18T21:53:10-04:00
featured: false
draft: false

# Featured image
# To use, add an image named `featured.jpg/png` to your page's folder.
# Focal points: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight.
image:
  caption: ""
  focal_point: ""
  preview_only: false

# Projects (optional).
#   Associate this post with one or more of your projects.
#   Simply enter your project's folder or file name without extension.
#   E.g. `projects = ["internal-project"]` references `content/project/deep-learning/index.md`.
#   Otherwise, set `projects = []`.
projects: []
---

 Nine supercomputers have been tested, validated and ranked by the new "Graph500" challenge, first introduced this week by an international team led by Sandia National Laboratories. The list of submitters and the order of their finish was released Nov. 17 at the supercomputing conference SC10 meeting in New Orleans.

The machines were tested for their ability to solve complex problems involving random-appearing graphs, rather than for their speed in solving a basic numerical problem, today's popular method for ranking top systems.

"Some, whose supercomputers placed very highly on simpler tests like the Linpack, also tested them on the Graph500, but decided not to submit results because their machines would shine much less brightly," said Sandia computer scientist Richard Murphy, a lead researcher in creating and maintaining the test.

Murphy developed the Graph500 Challenge with researchers at the **Georgia Institute of Technology**, University of Illinois at Urbana-Champaign, and Indiana University, among others.

Complex problems involving huge numbers of related data points are found in the medical world where large numbers of medical entries must be correlated, in the analysis of social networks with their huge numbers of electronically related participants, or in international security where huge numbers of containers on ships roaming the world and their ports of call must be tracked.

Such problems are solved by creating large, complex graphs with vertices that represent the data points -- say, people on Facebook -- and edges that represent relations between the data points -- say, friends on Facebook. These problems stress the ability of computing systems to store and communicate large amounts of data in irregular, fast-changing communication patterns, rather than the ability to perform many arithmetic operations. The Graph500 benchmarks are indicative of the ability of supercomputers to handle such complex problems.

The Graph500 benchmarks present problems in different input sizes. These are described as huge, large, medium, small, mini and toy. No machine proved capable of handling problems in the huge or large categories.

"I consider that a success," Murphy said. "We posed a really hard challenge and I think people are going to have to work to do 'large' or 'huge' problems in the available time." More memory, he said, might help.

The abbreviations "GE/s" and "ME/s" represented in the table below describe each machine's capabilities in giga-edges per second and mega-edges per second -- a billion and million edges traversed in a second, respectively.

Competitors were ranked first by the size of the problem attempted and then by edges per second.

The rankings were:

* Rank #1 - Intrepid, Argonne National Laboratory - 6.6 GE/s on scale 36 (Medium)
* Rank #2 - Franklin, National Energy Research Scientific Computing Center - 5.22 GE/s on Scale 32 (Small)
* Rank #3 - cougarxmt, Pacific Northwest National Laboratory - 1.22 GE/s on Scale 29 (Mini)
* Rank #4 - graphstorm, Sandia National Laboratories' - 1.17 GE/s on Scale 29 (Mini)
* Rank #5 - Endeavor, Intel Corporation, 533 ME/s on Scale 29 (Mini)
* Rank #6 - Erdos, Oak Ridge National Laboratory - 50.5 ME/s on Scale 29 (Mini)
* Rank #7 - Red Sky, Sandia National Laboratories - 477.5 ME/s on Scale 28 (Toy++)
* Rank #8 - Jaguar, Oak Ridge National Laboratory - 800 ME/s on Scale 27 (Toy+)
* Rank #9 - Endeavor, Intel Corporation - 615.8 ME/s on Scale 26 (Toy)

A more detailed description of the Graph500 benchmark and additional results are available at graph500.org. Any organization may participate in the ratings. The next Graph500 Challenge list is expected to be released at the International Supercomputing Conference 2011 next summer, and then at SC 2011 again in the fall.

*Sandia National Laboratories is a multiprogram laboratory operated and managed by Sandia Corporation, a wholly owned subsidiary of Lockheed Martin Corporation, for the U.S. Department of Energy's National Nuclear Security Administration. With main facilities in Albuquerque, N.M., and Livermore, Calif., Sandia has major R&D responsibilities in national security, energy and environmental technologies, and economic competitiveness.*

https://eurekalert.org/pub_releases/2010-11/dnl-trs111810.php

gha_language: Shell


text:
# worlds

a demo for iphone by dekadence.

[download the demo to your iphone!](https://itunes.apple.com/fi/app/the-jumalauta-collection/id1344164506?mt=8)

[watch the demo on youtube!](https://www.youtube.com/watch?v=cI9C751w01E)

programming and music by johan halin (aka ricky martin / dekadence).
words by karl marx and friedrich engels.

open the project in xcode, and install on your iphone. tested on iphone x and 7, on which the demo works fine.

i'll try to get the demo on the app store, but i doubt apple will ever allow this on the store. (they're not too keen on demos) [update 27.11.2017: got rejected for "minimal functionality"]

[update 13.12.2017: after a phone call with an apple representative and a complaint to the app review appeals board, it's by now clear that this demo will never be on the app store in its current form. i have some ideas on how to package the demo so that it'd be allowed, but for now this is the only way of distributing the demo to potential viewers. needless to say i don't agree with apple's reasoning at all and consider their policies anti-art.]

[update 5.2.2018: [the demo is now available on the app store as part of the jumalauta collection!](https://itunes.apple.com/fi/app/the-jumalauta-collection/id1344164506?mt=8)]

greets to jumalauta and all other cool folks.

repository: trolleycrash/worlds

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: trolleycrash/worlds


text:
---
id: api-binding-mock
title: 📦 binding-mock
---
| [npm](https://www.npmjs.com/package/@serialport/binding-mock) | [github](https://github.com/serialport/binding-mock) |

## Mock Binding

```ts
import { MockBinding } from '@serialport/binding-mock'
// or
const { MockBinding } = require('@serialport/binding-mock')
```

Testing is an important feature of any library. To aid in our own tests, we've developed a `MockBinding`, a fake hardware binding that doesn't actually need any hardware to run. This class passes all of the same tests as our hardware based bindings and provides a few additional test related interfaces.

This class is used in the [`SerialPortMock`](api-serialport.md) class if you wish to test the stream interface.

### createPort(options: CreatePortOptions)

```ts
interface CreatePortOptions {
  echo?: boolean;
  record?: boolean;
  readyData?: Buffer;
  maxReadSize?: number;
  manufacturer?: string;
  vendorId?: string;
  productId?: string;
}

// Create a port and enable the echo and recording.
MockBinding.createPort('/dev/ROBOT', { echo: true, record: true })
```

### reset

This removes all created ports.

```ts
MockBinding.reset()
```

### open(opt: OpenOptions): MockPortBinding

Open a port and return it.

## MockPortBinding

### emitData

Emits data from an open port.

```ts
port.emitData(data: Buffer | string): void
```

### serialNumber

A unique number for each port returned from `open()`

### recording

If the port was created with `record: true` this will contain all data written to the port. If recording is disabled it will be a 0 length buffer.

```ts
port.recording // Buffer
```

### lastWrite

Contains the contents of the last write to the port.

```ts
port.lastWrite // null | Buffer
```

## Example

```ts
const { MockBinding } = require('@serialport/binding-mock')
const { SerialPortStream } = require('@serialport/stream')
const {ReadlineParser} = require("@serialport/parser-readline");

// Create a port and enable the echo and recording.
MockBinding.createPort('/dev/ROBOT', { echo: true, record: true })
const port = new SerialPortStream({ binding: MockBinding, path: '/dev/ROBOT', baudRate: 14400 })

/* Add some action for incoming data. For example,
** print each incoming line in uppercase */
const parser = new ReadlineParser()
port.pipe(parser).on('data', line => {
  console.log(line.toUpperCase())
})

// wait for port to open...
port.on('open', () => {
  // ...then test by simulating incoming data
  port.port.emitData("Hello, world!\n")
})

/* Expected output:
HELLO, WORLD!
*/
```

license: MIT

repository: serialport/website

branch_name: refs/heads/main

gha_language: CSS

gha_license_id: MIT

repo_name: serialport/website


text:
laundry-check
=============

A command line tool that checks for French Laundry reservations in the next two months.  It's already found me a few at rather inconvenient times.

Uses the Twilio API, so be sure to set the necessary API keys in the environment before running (see SmsService).

## Usage

```
java -jar laundryCheck.jar [-party <Party Size>] [-phone <Number to Text>]
```

## Author

Justin Appler: [@justinappler][twitter]

## License

Licensed under [MIT][mit].

[twitter]: http://twitter.com/justinappler
[mit]: http://www.opensource.org/licenses/mit-license.php

repository: justinappler/laundry-check

repo_name: justinappler/laundry-check


text:
# Client Library For PHP

[![Build Status](https://travis-ci.org/AbdallaMohammed/alsaad-php.svg?branch=master)](https://travis-ci.org/AbdallaMohammed/alsaad-php)

*This library requires a minimum PHP version of 7.1*

This is the PHP client library for use Alsaad2's API. To use this, you'll need a Alsaad2 account.

* [Installation](#installation)
* [Usage](#usage)
* [Examples](#examples)

## Installation

To install the PHP client library to your project, we recommend using [Composer](https://getcomposer.org/).

```
composer install abdallahmohammed/alsaad-php
```

## Usage

If you're using Composer, make sure the autoloader is included in your project's bootstrap file:

```php
require_once "vendor/autoload.php";
```

Create a client with your Username and Password:

```php
$client = new Alsaad\Client([
    'username' => ALSAAD2_USERNAME,
    'password' => ALSAAD2_PASSWORD,
]);
```

## Examples

#### Sending a Message

To use Alsaad2's SMS API to send an SMS message, call the `$client->message()->send()` method.

```php
$message = $client->message()->send([
    'to' => ALSAAD2_TO, //can be array of numbers or string
    'from' => ALSAAD2_SENDER,
    'message' => 'Hello World'
]);
```
The API response data can be accessed as array properties of the message.

#### Accessing Response Data
When things go wrong, you'll receive an Exception. The exception class `Alsaad\Client\Exception\Request` support an additional `getEntity()` method which you can use in addition to `getCode()` and `getMessage()` to find out more about what went wrong. The entity returned will typically be an object related to the operation, or the response object from the API call.

repository: AbdallaMohammed/alsaad-php

repo_name: AbdallaMohammed/alsaad-php


text:
---
title: Running Native Code in Electron and the Case for WebAssembly
date: "2018-09-26T12:00:00.000Z"
external: https://pspdfkit.com/blog/2018/running-native-code-in-electron-and-the-case-for-webassembly/
---

Electron is a powerful open source framework that allows development of cross-platform desktop GUI applications with JavaScript, HTML, and CSS. In the past few years, it has been adapted by major companies in the tech industry including GitHub, Facebook, Microsoft, and Slack.

branch_name: refs/heads/blog

gha_language: JavaScript


text:
# Copilot

![copilot](./snapshots/copilot-01.png)
[With GitHub Copilot, get suggestions for whole lines or entire functions right inside your editor.](https://copilot.github.com/)

## Some feedbacks on copilot usage

---

## 100% match

![match01](./snapshots/screenshot-01.png)

---

## 90% match but 100% in the intent

Here I just started to write the function signature, and copilot inferred all the code that should be in that function.
Copilot did infer correctly that the code inside the function is about to change a markdown file, but he proposed to modify the `README.md` which is not the right one.

![Match02](./snapshots/screenshot-02.png)

Final version:

![match02](./snapshots/screenshot-02-final.png)

---

## 0% match at first  — then 100% match when coding line by line - then complete failure

Here I just started to write the function name and signature, and copilot could not infer something useful from the function signature.

The idea of that function is, given the start date of a project and given the percentage of the `done` as of today, estimate the end date of the project.

![Match03](./snapshots/screenshot-03.png)

Then after googling, I found the first step of the code should be to find the elapsed days from the start of the project (yes, I know I am a stupid developer), so I just started to type `const elap` :

![Match04](./snapshots/screenshot-03b.png)

Not so bad, after all!

Then I told me: now I have to get the number of remaining days from what has already been done, so I just started to type `const rema` :

![Match05](./snapshots/screenshot-03c.png)

Oh, great!

Could it be possible that if I define a variable named `endDate` at the next line that `copilot` gives me the solution?

So I just started to type `const endDate` :

![Match06](./snapshots/screenshot-03d.png)

And final result is:

![Match06](./snapshots/screenshot-03e.png)

But... wait, I have red squiggles in my code and could not get rid of it! How is it possible?

Go back to googling (Oh yes I am really stupid) and found it: `copilot` think I am a JavaScript coder, but I am writing my code in Typescript!

> Ok dear pair-programer `copilot`, let me pilot now to polish the final code:

![Match07](./snapshots/screenshot-03f.png)

Ok great ! Thanks to `copilot`, I have a great function ready to be used.

Now the following test should be green, isn't ?

```gherkin
Given I started my Github project on 2019-08-08
And I have achieved 50% of it as of now (2021-08-08)
Then the estimated end date should be 2023-08-08
```

Hold on! The test is RED !!! The computed estimated end date is `2020-11-19` : my project is about to finish in the past !

What's wrong ?

Ah, ah, I should add the remaining time not to the start date but to the `now` date instead.

> Now listen to me dear `copilot` and learn from a real developer :

![Match08](./snapshots/screenshot-03g.png)

Houra ! Now the above test is green !!!

> Let's try another test dear `copilot` just to show that you and I are the best pair:

```gherkin
Given I started my Github project on 2020-08-08
And I have achieved 10% of it as of now (2021-08-08)
Then the estimated end date should be 2030-08-08
```

Hey ! W... T..... F...., test is RED !!! The estimated date is `2022-07-03`.

Hum, after doing some math on a small piece of paper, I realized that the code should be :

![Match08](./snapshots/screenshot-03h.png)

Above test, still not green, but estimated date is now `2030-08-13` which is very near to what it should be.

### Conclusion for this use case

In some situation, `copilot` might drive you in the wrong direction without you noticing that at the end your code is buggy.

Always ensure you have a good testing strategy when using `copilot`.

TDD coding should be the recommended way to pair with `copilot`.

---

## 100% match

I just started to write this function name and signature :

`function isJson(content: string): boolean`

and immediate feedback from my fellow pair-programmer (you are my friend again):

![match](./snapshots/screenshot-04.png)

---

## 100% match

I was in the middle of writing a typescript code generator:

```ts
const dataFileName = `${targetFolderName}.json`;
const dataFilePath = path.join(targetSubDirectory, dataFileName);
writeFileSync(dataFilePath, JSON.stringify(missingMock.response, null, 2));
const mockSourceCode = generateMockCodeOf(missingMock, dataFileName);
```

The `mockSourceCode` is a string that represent typescript source code that is supposed to import as a first step the JSON file `dataFileName`:

```ts
import response from './${dataFileName}';
```

In my mind the next code line was to write the content of `mockSourceCode` to a typescript file.

When I was about to type my code, suddenly my fellow pair-programmer, told me :

> Hey man, it's too late for you, go to sleep and let me finish the job :

![match](./snapshots/screenshot-05.png)

> Hey my fellow `copilot`, are you reading in my mind ???

---

repository: hdorgeval/copilot

repo_name: hdorgeval/copilot


text:
# SysMonTask
[![forthebadge made-with-python](http://ForTheBadge.com/images/badges/made-with-python.svg)](https://www.python.org/)

Linux system monitor with the compactness and usefulness of Windows Task Manager to allow higher control and monitoring.

### Important
**Next major SysMonTask (v2) will be released with new architectural/backend changes to improve the code and performance with new features.**
**Until, v1.x.x will follow a rolling release model where no new major feature will be added but fixes of buges will be provided.**

*[Get A Glance Of The New Features](https://github.com/KrispyCamel4u/SysMonTask#whats-new--)*
- ***Filter Dialog [Must Read](https://github.com/KrispyCamel4u/SysMonTask/blob/master/DOCS.md#filter-dialog-view-filter)***
- ***Process Log Record and Log_Plot [Must Read](https://github.com/KrispyCamel4u/SysMonTask/blob/master/DOCS.md#process-log-recordplot)***

---

## Installation
***[need help in making a package for Suse, Redhat]***

### #Ubuntu and Its Family**(only for: 18.04, 20.04, 20.10, 21.04 and equivalent)**, run:
```
$ sudo add-apt-repository ppa:camel-neeraj/sysmontask
$ sudo apt install sysmontask
// Install psutil if Ubuntu<=20.04, other-wise skip this step(more info given below) :
$ sudo pip3 install -U psutil
$ sysmontask   // optional to run via terminal but recommended for the first time
```
Alternatively, if you don't want to add the PPA (Personal Package Archives) then download the binaries from releases, and install by double-clicking on it.

***Note: Some information such as Memory static details(slots, Frequency) and Disk IO(disk usage per process) for the other user's processes(including root) requires root access, hence to run with root access:***
```
$ sudo sysmontask
```
**For Ubuntu<=20.04(for others it will be installed automatically), psutil will not be installed automatically with sysmontask(python3-psutil doesn't meet the version requirements), hence install with:**

```
$ sudo apt install python3-pip  // skip if you already have pip3 installed
$ pip3 install psutil          // if you're not planning to use it with root access
  OR
$ sudo pip3 install -U psutil  // needed to run sysmontask with root access, hence recommended
```
---

### #Arch Based:
Using any AUR helper tools like Yay:
```
$ yay -S sysmontask
```
Or, Manually:
```
$ git clone https://aur.archlinux.org/sysmontask.git
$ cd sysmontask
$ makepkg -si
$ sysmontask
```
Or,
Install using pamac(gui for software add/remove), first enable the AUR(arch user repository) in preferences, then search sysmontask, install and enjoy.

### #Fedora:

Available in official [Fedora repos](https://src.fedoraproject.org/rpms/sysmontask).
```
$ sudo dnf install sysmontask
```
---
### #Installing From Source
Install the dependencies required, mentioned in the [requirments.md](https://github.com/KrispyCamel4u/SysMonTask/blob/master/requirements.md). In case of issue related to PyGoject or pycairo OR to get the command for the specific package manager, follow the link given in requirements.md .

While installing from source, pip automatically installs some of the packages(which can be installed using pip) required others need to be installed using package manager.

After installing dependencies:
```
$ git clone https://github.com/KrispyCamel4u/SysMonTask.git
$ cd SysMonTask
$ sudo python3 setup.py install
$ sysmontask
```
It will install it in "/usr/local/lib/python<version>/dist-packages/".
To uninstall it run the uninstall.sh script in the SysMonTask cloned directory, with:
```
$ ./uninstall.sh
  Done
```

---

**Note: For Nvidia GPUs, nvidia-smi needs to be installed. Check if nvidia-smi is installed by running:**
```
$ nvidia-smi
```
If not then install it for your system (generally it is automatically installed with Nvidia proprietary drivers).

Then start application from the menu or by the command "sysmontask" (recommended only in case of error/crashed) on terminal.

Hurray, you're good to go in understanding capabilities of your system:)

## What's New: [![Generic badge](https://img.shields.io/badge/What's_New-History-red.svg)](https://github.com/KrispyCamel4u/SysMonTask/blob/master/HISTORY.md) [![Generic badge](https://img.shields.io/badge/Read_More-Docs-blueviolet.svg)](https://github.com/KrispyCamel4u/SysMonTask/blob/master/DOCS.md)

### v1.x.x
#### [Enhancements]
- [[#50](https://github.com/KrispyCamel4u/SysMonTask/issues/50)] Color Customizations: Color of each devices can be changed now.
- [[#61](https://github.com/KrispyCamel4u/SysMonTask/issues/50)]Show/Hide Devices: Uninterested devices can be made hidden.

#### [Bug Fix]
- [[#56](https://github.com/KrispyCamel4u/SysMonTask/issues/56),[#57](https://github.com/KrispyCamel4u/SysMonTask/issues/57)] Unneeded Column name, Better space management.
- [[#58](https://github.com/KrispyCamel4u/SysMonTask/issues/58)] Running it with superuser permission doesn't use the right theme, theme API bug.
- [[#60](https://github.com/KrispyCamel4u/SysMonTask/issues/60)] For some people Nvidia GPU usage is not showing and GPU graphs don't work.
- [[#62](https://github.com/KrispyCamel4u/SysMonTask/issues/62)] CPU cache NA value and Wifi adapter NA.
- [[#63](https://github.com/KrispyCamel4u/SysMonTask/issues/63)] Error trying to open sysmontask: Handling of large number of cores.
- [[#64](https://github.com/KrispyCamel4u/SysMonTask/issues/64)] SSD usage sometimes goes to 103%
- [[#65](https://github.com/KrispyCamel4u/SysMonTask/issues/65),[#76](https://github.com/KrispyCamel4u/SysMonTask/issues/76)] Ubuntu hirsute release does not have a release file, Support 21.04.2
- [[#72](https://github.com/KrispyCamel4u/SysMonTask/issues/72)] Process Menu Need to Refresh Manually and Not Working: Python dictionary reverse error.

### Previous Highlights

 Filter Dialog (Customisable Process Filtering Utility)

 Highly Customisable fearure to preicisely pin-point the unwanted process to filter them out. Can be accesed from **View->Filter**
 **Strict Syntex and semantic** need to be followed to use it, ***Hence [Must Read](https://github.com/KrispyCamel4u/SysMonTask/blob/master/DOCS.md#filter-dialog-view-filter) the Docs to use it***
 ![Screenshot from 2021-04-14 22-42-58](https://user-images.githubusercontent.com/48773008/114751481-d298e480-9d72-11eb-8fc2-13b370b557f2.png)

 A simple TYPE:I use given below:

 To filter out process which contains a peculiar word in its Name, Owner and Command, add the word in Filter as given below:
 ```<word>:1```

 ***NOTE:** Using without Filter will show all the processes. Since python is not a Fast executing language, the CPU utilisation will be more than 1% in steady state. Using Filter to remove all root process reduces the burden a improved performance can be seen. Hence for **low end systems** use FILTER.*

    Process Log Record and Log Plot

Process performance metrics can be recorded as Logs in **$HOME/sysmontask_log** directory using Record button on selected process and can be visualised using Log_Plot. [Read More](https://github.com/KrispyCamel4u/SysMonTask/blob/master/DOCS.md#process-log-recordplot)

**Record**

![Screenshot from 2021-04-14 22-42-58](https://user-images.githubusercontent.com/48773008/114751481-d298e480-9d72-11eb-8fc2-13b370b557f2.png)

**Log_Plot** utility uses matplotlib(python3-matplotlib) and it is not installed automatically. To use it install matplotlib via pip3 or pacakge manager.

![Screenshot from 2021-04-16 11-42-51](https://user-images.githubusercontent.com/48773008/114979668-ea728480-9ea8-11eb-8655-e8730a32418e.png)

- Processes filtering for user for fast look-ups. ([Read More](https://github.com/KrispyCamel4u/SysMonTask/blob/master/DOCS.md)).
- **rCPU, rMemory** (recursive-CPU,recursive-Memery) columns. ([Read More](https://github.com/KrispyCamel4u/SysMonTask/blob/master/DOCS.md)).

## Theme Settings

By Default sysmontask will use the system-wide setting for themes. If you use any of dark theme(dark mode), that dark theme(dark mode) will be applied to sysmontask. If you use any of light theme(default/light mode), that light theme(default/light mode) will be used by sysmontask.

To Force apply a particular available theme(light or dark) regardless of system-wide theme, use the below commands:
```
$ sudo sysmontask.set_light
  0 : Raleigh
  1 : HighContrast
  2 : Pop
  3 : Default
  4 : Adwaita
  5 : Emacs
  Index for Corresponding Theme that you want to apply?:2
  Setting of Light Theme Done:)
$ sudo sysmontask.set_dark
  0 : Pop-dark
  1 : Adwaita-dark
  Index for Corresponding Theme that you want to apply?:0
  Setting of Dark Theme Done:)
  ```
This setting will be permanent. If you want to revert back to system-wide theme settings for sysmontask, run:
```
$ sudo sysmontask.set_default
  Setting done:)
```

## Highlights
![Screenshot from 2021-02-17 17-54-27](https://user-images.githubusercontent.com/48773008/108204170-79814b80-7149-11eb-8b1f-843a1efa8d42.png)

![Screenshot from 2021-02-21 22-06-32](https://user-images.githubusercontent.com/48773008/108631693-1bc66980-7491-11eb-8b1e-59df9622bd32.png)

![Screenshot from 2021-01-24 11-00-18](https://user-images.githubusercontent.com/48773008/105622210-7ab6a580-5e35-11eb-9a43-8f09c0efbdb2.png)

![Screenshot from 2021-02-17 18-09-43](https://user-images.githubusercontent.com/48773008/108212228-a33f7000-7153-11eb-9d3d-2c56d411efc7.png)

repository: kaderghal/SysMonTask

repo_name: kaderghal/SysMonTask


text:
---
layout : default
title : mySQL configuration
---

# mySQL configuration

You don't necessarily need to do this,unless you are having problems with the current mySql Program.

Why do we consider this configuration as not a must be done action ?

Because you are going to get same confirmations / prompts as you did the first time you were setting up this program. This will be a useful method of changing a root password.

If you have already got your database code on your script and you are using root as your database user then you've realized that your database password for the user:root configuration on your script.js is not the same as the one that you chose when you were setting up this program ,then this is a good place for your otherwise you should have a separate user for each specific database such that chances of you getting errors with your configuration on your script.js would be minimal.

In order to configure it, we would have to terminate mySql process by executing the following command:

<input type="checkbox" class="sidebar-checkbox" id="sidebar-checkbox">
`VirtualPrivateServer`$`sudo service mysql stop`

Then to start with the configuration you will then need to know the current version.
To get current version type the following command:

<input type="checkbox" class="sidebar-checkbox" id="sidebar-checkbox">
`VirtualPrivateServer`$`mysql --version` :white_check_mark:

 and it would not allow you to use the following method for version checking:
 `mysql -v`  :x:

Now that you know the current version, you can type next command to re-configure mySql:

<input type="checkbox" class="sidebar-checkbox" id="sidebar-checkbox">
`VirtualPrivateServer`$`sudo dpkg-reconfigure mysql-server-<yourCurrentVersion>`

Remember to type yourCurrentVersion without `< >` signs

Like this: `sudo dpkg-reconfigure mysql-server-5.5`

With that :sparkles: you're done. :stuck_out_tongue_winking_eye:

repository: codex-academy/DigitalOceanServerSetup

branch_name: refs/heads/gh-pages

gha_language: HTML

repo_name: codex-academy/DigitalOceanServerSetup


text:
---
layout: default
---

# 1996-08-17 - IE3.0 128-bit

## Header Data

From<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 1eec60ba79b93c8e38decfbec93ca790e13311c435d3e6c3916fae021f04d656

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-08-17 16:11:39 UTC

Raw Date: Sun, 18 Aug 1996 00:11:39 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>Date: Sun, 18 Aug 1996 00:11:39 +0800
To<EMAIL_ADDRESS>Subject: IE3.0 128-bit
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

-----BEGIN PGP SIGNED MESSAGE-----

To<EMAIL_ADDRESS>Date: Sat Aug 17 08:59:05 1996
Just got off of MS IE3 download page. To retrieve the 128-bit version,
they've got a perl script asking for a remote address and a host address
via a pair of cookies. Unfortunately, it chokes *every single time* it's
invoked on my system, and shows me a 1-800 number (terminally busy) to
call.

Has anyone either managed to download it, or gotten through to the 1-800
number? I'd _really_ like a copy of the 128-bit version. I'm a U.S.
citizen, live here in Amarillo, TX.

Anyone from MicroSloth reading this *might* want to let a Responsible
Person know about the perl script hiccups....

Dave Merriman, Densa's mole in Mensa

- -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
PGP Email welcome, encouraged, and PREFERRED. Visit my web
site at         http://www.shellback.com/p/merriman
for my PGP key and fingerprint
"What is the sound of one hand clapping in a forest
with no one there to hear it?"
I use Pronto Secure (tm) PGP-fluent Email software for Windows
-----BEGIN PGP SIGNATURE-----
Version: 2.6.2

iQCVAwUBMhUZZcVrTvyYOzAZAQHqygQAiEe7RmKjZcZ44Ok7Gz6GI1CCebBcdWsc
1lk2AvHJNOsI1ifq+oXbz1IuSbYJFwBOAUgJmwdXh4OMq8TIyX7mJKpR+imlysFC
kk1kMtVsdPNbtaLap5LLOMMnw13NxjC4ysae1rKZ/j/8SLXEvmscoDwzO+wtyOyn
kYgcgh6n8NQ=
=5P41
-----END PGP SIGNATURE-----

{% endraw %}
```

## Thread

+ Return to [August 1996](/archive/1996/08)

+ Return to<EMAIL_ADDRESS><EMAIL_ADDRESS><merriman@amaonline.com>](/authors/david_k_merriman_at_toad_com_webmaster_at_www_shellback_com_merriman_at_amaonline_com_)"

+ 1996-08-17 (Sun, 18 Aug 1996 00:11:39 +0800) - IE3.0 128-bit -<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>


text:
# JPMorgan-Chase-Virtual-Internship-2020

This repository contains the submitted patch files of the various tasks assigned by JPMorgan Chase & Co. Software Engineering Virtual Internship
## Website Link:

[https://careers.jpmorgan.com/us/en/students/campaign/virtual-internship](https://careers.jpmorgan.com/us/en/students/campaign/virtual-internship)

## Data Feed and help traders to take decisions
![](https://github.com/iamlovelesh/JPMorgan-Chase-Virtual-Internship/blob/master/Final_Result_Data_Feed.png)

## For any queries/doubts:

:envelope<EMAIL_ADDRESS>:thumbsup:


text:
# Demo Introduction

[中文版本](../../cn/user/demo.md)

## I. Introduction to iOS Demo

### How to run

1. Download the Demo model

   ```
   cd <path_to_tnn>/model
   sh download_model.sh
   ```
   PS: If the script cannot download the model due to network problems, please manually create the corresponding folder according to the information in the script and download it by yourself.

2. Open the TNNExamples project

   Enter the directory `<path_to_tnn>/examples/ios/` and double-click to open the TNNExamples project.

3. Set up a developer account

   Click the TNNExamples project as shown below, find the project setting `Signing & Capabilities`, click the Team tab and select `Add an Account...`

   Enter the Apple ID account and password in the following interface. Return to the `Signing & Capabilities` interface, and select the added account in the Team tab. If you don’t have an Apple ID, you can also use the “Create Apple ID” option to apply according to the relevant prompts.

   `PS: There is no fee to apply for Apple ID, it can be passed immediately, and the APP can be run on the real machine after debugging.`

4. Run on real machine

   4.1 Modify `Bundle Identitifier`

   As shown in the figure, after the existing `Bundle Identifier`, a suffix (limited to numbers and letters) is randomly added to avoid personal account conflicts.

  4.2 Verify authorization

   For the first time, use the shortcut key `Command + Shift + K` to clean up the project, and then execute the shortcut key` Command + R` to run. If it is the first time to log in with Apple ID, Xcode will pop up a box and report the following error. You need to verify the authorization on the iOS device according to the prompt. Generally speaking, the authorization path on the phone is: Settings-> General-> Profile and Device Management-> Apple Development Options-> Click Trust

  4.3 Result

   For the first run, use the shortcut key `Command + Shift + K` to clean up the project, and then execute the shortcut key` Command + R` to run. Click the Run button on the interface, the interface will display the CPU and GPU time consumption of all models in the model directory. The running result of the iPhone7 real machine is shown below.

  PS:

  a) Due to the different GPU and CPU acceleration principles, the GPU performance of a specific model is not necessarily higher than that of the CPU. It is related to the specific model, model structure, and engineering implementation. Everyone is welcome to participate in the development of TNN and make progress together.

  b) The macro TNN_SDK_USE_NCNN_MODEL in TNNSDKSample.h defaults to 0, and the TNN model can be set to 1 to run the ncnn model.

     c) If you encounter an error message of `Unable to install...`, please delete the existing TNNExamples on the real device and run the installation again.

     d) If the CodeSign error `Command CodeSign failed with a nonzero exit code` is encountered when the real device is running, please refer to issue20 `iOS Demo Operation Step Instructions`

### Demo effect

1. Face detection

   Model source: https://github.com/Linzaer/Ultra-Light-Fast-Generic-Face-Detector-1MB

   Effect example: iPhone 7, ARM single thread 6.3206ms

2. Image classification

   Model source: https://github.com/forresti/SqueezeNet

   Example: iPhone 7, ARM single thread 13.83ms

## II. Introduction to Android Demo
### Environment requirements

1. Android Studio 3.5 or above
2. NDK version >= 16

### Steps

1. Download the Demo model

   ```
   cd <path_to_tnn>/model
   sh download_model.sh
   ```

   PS: If the script cannot download the model due to network problems, please manually create the corresponding folder according to the information in the script and download it yourself.

   PS for Huawei NPU :
   You need to download the DDK before run the demo. Refer to： [FAQ](../faq_en.md): Huawei NPU Compilation Prerequisite.

2. Open the TNNExamples project

   Enter the directory `<path_to_tnn>/examples/android/` and double-click to open the TNN example project.

   PS for Huawei NPU ：

   1).  After opening the TNN example project，you need to set the TNN_HUAWEI_NPU_ENABLE switch to ON in <path_to_tnn>/examples/android/demo/CMakeList.txt below to use Huawei NPU ：

   ````
        set(TNN_HUAWEI_NPU_ENABLE ON CACHE BOOL "" FORCE)
   ````

   2). If encountering  `<path_to_tnn>/examples/android/src/main/jni/thirdparty/hiai_ddk/include/graph`Permission Denied，
   Clean Project and rerun.

   3). Only Huawei phones of rom version >= 100.320.xxx.xxxx supportS building the example TNN models.

   To run the demo, you need to first download the ddk. Refer to ： [FAQ](../faq_en.md) to check the current NPU support and how to update the ROM.

### Running result
1. Face Detection-Pictures

   Model source: https://github.com/Linzaer/Ultra-Light-Fast-Generic-Face-Detector-1MB

   Effect example: Huawei P30, ARM single thread 32.2359ms

   Example： Huawei P30, NPU rom 100.320.010.022 9.04ms

2. Face detection-video
   Model source: https://github.com/Linzaer/Ultra-Light-Fast-Generic-Face-Detector-1MB

   Effect example: Huawei P30, ARM single thread 122.296ms

    Example： Huawei P30, NPU rom 100.320.010.022 28ms

3. Image classification

   Model source: https://github.com/forresti/SqueezeNet

   Effect example: Huawei P30, ARM single thread 81.4047ms

   Example： Huawei P30, NPU rom 100.320.010.022 2.48ms

## III. Introduction to Linux/Mac/Windows/Armlinux/CudaLinux Demo

### Ability
* Demonstrate the calling method of TNN basic interface, quickly run the model in Linux/Mac/Windows/ArmLinux environment.

### Running Steps
#### 1. Downloand demo models
   ```
   cd <path_to_tnn>/model
   sh download_model.sh
   ```
   If the script cannot download the model due to network problems, please manually create the corresponding folder according to the information in the script and download it yourself.

#### 2. Compile Steps
##### Linux
* Environment Requirements
   - Cmake (>=3.11)
   - OpenCV3, Can be imported in CMake by find_package(OpenCV 3)
* Compile
   Move to `examples/x86` directory and execute `build_linux.sh`:
   ```
   cd <path_to_tnn>/examples/x86
   ./build_linux.sh
   ```
* Execute
   Move to `examples/x86/build_linux` directory and execute:
   ```
   cd build_linux

   image-classification demo
   ./demo_x86_imageclassify ../../../model/SqueezeNet/squeezenet_v1.1.tnnproto ../../../model/SqueezeNet/squeezenet_v1.1.tnnmodel

   face-detector demo
   ./demo_x86_facedetector ../../../model/face_detector/version-slim-320_simplified.tnnproto ../../../model/face_detector/version-slim-320_simplified.tnnmodel
   ```

##### MacOS
* Environment Requirements
   - Cmake (>=3.11)
   - OpenCV3, Can be imported in CMake by ```find_package(OpenCV 3)```. you can install opencv with brew (```brew install opencv@3 && brew link --force opencv@3```).
* Compile
   Move to `examples/x86` directory and execute `build_macos.sh`:
   ```
   cd <path_to_tnn>/examples/x86
   ./build_macos.sh
   ```
* Execute
   Move to `examples/x86/build_macos` directory and execute:
   ```
   cd build_macos

   image-classification demo
   ./demo_x86_imageclassify ../../../model/SqueezeNet/squeezenet_v1.1.tnnproto ../../../model/SqueezeNet/squeezenet_v1.1.tnnmodel

   face-detector demo
   ./demo_x86_facedetector ../../../model/face_detector/version-slim-320_simplified.tnnproto ../../../model/face_detector/version-slim-320_simplified.tnnmodel

   webcam base face alignment demo
   ./demo_x86_webcam
   ```

##### Windows
* Environment Requirements
   - Visual Studio (>=2015)
   - Cmake (>=3.11; Or run scripts with Visual Studio Prompt)
   - OpenCV3, compiled by the same version of VC.
* Comiple
   Open `x64 Native Tools Command Prompt for VS 2017/2019`.
   Move to `examples\x86` directory and execute `build_msvc.bat`:
   ```
   set OpenCV_DIR=`OPENCV_INSTALL_DIR`
   cd <path_to_tnn>\examples\x86
   .\build_msvc.bat
   ```
* Execute
   Move to `examples\x86\release` directory and execute：
   ```
   cd release

   image-classification demo
   .\demo_x86_imageclassify ..\..\..\model\SqueezeNet\squeezenet_v1.1.tnnproto ..\..\..\model\SqueezeNet\squeezenet_v1.1.tnnmodel

   face-detector demo
   .\demo_x86_facedetector ..\..\..\model\face_detector\version-slim-320_simplified.tnnproto ..\..\..\model\face_detector\version-slim-320_simplified.tnnmodel

   webcam base face alignment demo
   .\demo_x86_webcam
   ```

##### ArmLinux
* Environment Requirements
   - Cmake (>=3.1)
   - Install arm toolchain
   - ubuntu:
      aarch64: sudo apt-get install g++-aarch64-linux-gnu  gcc-aarch64-linux-gnu
      arm32hf: sudo apt-get install g++-arm-linux-gnueabihf gcc-arm-linux-gnueabihf
  - other linux: download toolchains from https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-a/downloads
* Comiple
   Move to `examples/linux` directory:
   ```
   cd <path_to_tnn>/examples/linux
   ```
   Modify `build_aarch64.sh` or `build_armhf.sh`，take aarch64 as an example, modify building options:
   ```
   CC=aarch64-linux-gnu-gcc
   CXX=aarch64-linux-gnu-g++
   TNN_LIB_PATH=../../scripts/build_aarch64_linux/
   ```
   execute `build_aarch64.sh`
   ```
   sh build_aarch64.sh
   ```
* Execute
   Move to `examples/linux/build` directory and execute：
   ```
   cd build

   image-classification demo
   ./demo_arm_linux_imageclassify ../../../model/SqueezeNet/squeezenet_v1.1.tnnproto ../../../model/SqueezeNet/squeezenet_v1.1.tnnmodel

   face-detector demo
   ./demo_arm_linux_facedetector ../../../model/face_detector/version-slim-320_simplified.tnnproto ../../../model/face_detector/version-slim-320_simplified.tnnmodel
   ```

##### CudaLinux
* Environment Requirements
   - Cmake (>= 3.8)
   - CUDA (>= 10.2)
   - TensorRT (>= 7.1)

* Compile
   Configure the TensorRT path in env
   ```
   export TENSORRT_ROOT_DIR=<TensorRT_path>
   ```
   Configure the CuDNN path in env
   ```
   export CUDNN_ROOT_DIR=<CuDNN_path>
   ```
   Move to `example/cuda` directory and execute `build_cuda_linux.sh` :
   ```
   cd <path_to_tnn>/examples/cuda
   sh build_linux.sh
   ```
* Execute
    Move to `examples/cuda/build_cuda_linux` directory and execute:
    ```
    cd build_cuda_linux

    image-classification demo
    ./demo_cuda_imageclassify ../../../model/SqueezeNet/squeezenet_v1.1.tnnproto ../../../model/SqueezeNet/squeezenet_v1.1.tnnmodel

   face-detector demo
   ./demo_cuda_facedetector ~/tnn-models/face-detector/version-slim-320_simplified.tnnproto ~/tnn-models/face-detector/version-slim-320_simplified.tnnmodel
   ```

### Function process
#### Image classification function process
* Create predictor:
   ```cpp
   auto predictor = std::make_shared<ImageClassifier>();
   ```
* Init predictor:
   ```cpp
   CHECK_TNN_STATUS(predictor->Init(option));
   // for Linux/Windows
   option->compute_units = TNN_NS::TNNComputeUnitsOpenvino;
   // for ArmLinux
   option->compute_units = TNN_NS::TNNComputeUnitsCPU;
   ```
* Create image_mat:
   ```cpp
   // for Linux/Windows
   auto image_mat = std::make_shared<TNN_NS::Mat>(TNN_NS::DEVICE_X86, TNN_NS::N8UC3, nchw, data);
   // for ArmLinux
   auto image_mat = std::make_shared<TNN_NS::Mat>(TNN_NS::DEVICE_ARM, TNN_NS::N8UC3, nchw, data);
   ```
* Run predictor:
   ```cpp
   CHECK_TNN_STATUS(predictor->Predict(std::make_shared<TNNSDKInput>(image_mat), sdk_output));
   ```
#### Face detection function process
* Create predictor:
   ```cpp
   auto predictor = std::make_shared<UltraFaceDetector>();
   ```
* Init predictor:
   ```cpp
   CHECK_TNN_STATUS(predictor->Init(option));
   // for Linux/Windows
   option->compute_units = TNN_NS::TNNComputeUnitsOpenvino;
   // for ArmLinux
   option->compute_units = TNN_NS::TNNComputeUnitsCPU;
   ```
* Create image_mat:
   ```cpp
   // for Linux/Windows
   auto image_mat = std::make_shared<TNN_NS::Mat>(TNN_NS::DEVICE_X86, TNN_NS::N8UC3, nchw, data);
   // for ArmLinux
   auto image_mat = std::make_shared<TNN_NS::Mat>(TNN_NS::DEVICE_ARM, TNN_NS::N8UC3, nchw, data);
   ```
* Run predictor:
   ```cpp
   CHECK_TNN_STATUS(predictor->Predict(std::make_shared<UltraFaceDetectorInput>(image_mat), sdk_output));
   ```
* Mark face:
   ```cpp
   TNN_NS::Rectangle((void *)ifm_buf, image_orig_height, image_orig_width, face.x1, face.y1, face.x2, face.y2, scale_x, scale_y);
   ```

## IV. NCNN model usage and interface introduction

- [NCNN related](./ncnn_en.md)

repository: bluaxe/TNN

gha_license_id: NOASSERTION

repo_name: bluaxe/TNN


text:
@appnest/blob

[The blob is waiting for you here](https://appnest-demo.firebaseapp.com/blob/).

[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#usage)

## ➤ Usage

Add the `blob-element` to your html and you're ready to go.

```html
<blob-element></blob-element>
```

If you want to change the sharpness of the blob you can change the `sharpness` attribute to a number between `0` and `100`. A sharpness of `0` will turn the blob into a circle. The default `sharpness` is `25`.

```html
<blob-element sharpness="30"></blob-element>
```

Remember to give your blob a width, a height and a background of some sort. If you want transitions on your blob you can set the `--blob-transition` css variable. Have fun!

[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#inspiration)

## ➤ Inspiration

During the [February 2019 week 3 #CodePenChallenge](https://codepen.io/challenges/2019/february/3) the theme was blob shapes. I found [this](https://codepen.io/LekovicMilos/full/omVzYv) awesome blob generator and decided to turn it into a reusable web component.

[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#license)

## ➤ License

Licensed under [MIT](https://opensource.org/licenses/MIT).


text:
### Simple Local Example

![local queue](local.png)

Here's a barebones example of a local, in-memory Honeydew queue.

Let's create a basic worker module:

```elixir
defmodule Worker do
  @behaviour Honeydew.Worker

  def hello(thing) do
    IO.puts "Hello #{thing}!"
  end
end
```

Then we'll ask Honeydew to start both the queue and workers in its supervision tree.

```elixir
defmodule App do
  def start do
    :ok = Honeydew.start_queue(:my_queue)
    :ok = Honeydew.start_workers(:my_queue, Worker)
  end
end
```

A task is simply a tuple with the name of a function and arguments, or a `fn`. In our case, `{:hello, ["World"]}`.

We'll add tasks to the queue using `async/3`, a worker will then pick up the job and execute it.

```elixir
iex(1)> {:hello, ["World"]} |> Honeydew.async(:my_queue)
Hello World!
```

The `async/3` function returns a `Honeydew.Job` struct. You can call `cancel/1` with it, if you want to try to kill the job.

repository: basbz/honeydew

repo_name: basbz/honeydew


text:
---
layout: creature
name: "Grung"
tags: [pequena, humanoide, cr1/4, volos-guide]
cha: 10 (0)
wis: 11 (0)
int: 10 (0)
con: 15 (+2)
dex: 14 (+2)
str: 7 (-2)
size: Small humanoid (grung)
alignment: legal maligna
challenge: "1/4 (50 XP)"
languages: "Grung"
skills: "Athletics +2, Percepción +2, Sigilo +4, Survival +2"
damage_immunities: "poison"
saving_throws: "Des +4"
speed: "25 ft., climb 25 ft."
hit_points: "11 (2d6+4)"
armor_class: "12"
condition_immunities: "Envenenado"
---

***Anfibio.*** The grung puede respirar aire y agua.

***Poisonous Skin.*** Any creature that grapples the grung or otherwise comes into direct contact with the grung's skin must succeed on a DC 12 Constitution saving throw or become envenenado for 1 minute. A envenenado creature no longer in direct contact with the grung can repeat the saving throw at the end of each of its turns, ending the effect on itself on a success.

***Standing Leap.*** The grung's long jump is up to 25 feet and its high jump is up to 15 feet, with or without a running start.

***Variant: Grung Poison.*** Grung poison loses its potency 1 minute after being removed from a grung. A similar breakdown occurs if the grung dies.

>A creature envenenado by a grung can suffer an additional effect that varies depending on the grung's skin color. This effect lasts until the creature is no longer envenenado by the grung.

Green. The envenenado creature can't move except to climb or make standing jumps. If the creature is flying, it can't take any actions or reactions unless it lands.

Blue. The envenenado creature must shout loudly or otherwise make a loud noise at the start and end of its turn.

Purple. The envenenado creature feels a desperate need to soak itself in liquid or mud. It can't take actions or move except to do so or to reach a body of liquid or mud.

### Acciones

***Dagger.*** Melee or Ranged Weapon Attack: +4 al ataque, alcance 5 pies (1.5 mts)or range 20/60 pies, un objetivo. Impacto: 4 (1d4+2) puntos de daño perforante, and the target must succeed on a DC 12 Constitution saving throw or take 5 (2d4) poison damage.


text:
# Cook Crook

A web app for cooks and crooks alike. Users can post, steal and rate their favorite recipes.

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.

### Prerequisites

What things you need to install the software and how to install them

```
Give examples
```

### Installing

A step by step series of examples that tell you have to get a development env running

Say what the step will be

```
Give the example
```

And repeat

```
until finished
```

End with an example of getting some data out of the system or using it for a little demo

## Running the tests

Explain how to run the automated tests for this system

### Break down into end to end tests

Explain what these tests test and why

```
Give an example
```

### And coding style tests

Explain what these tests test and why

```
Give an example
```

## Deployment

Add additional notes about how to deploy this on a live system

## Built With

* [React](https://reactjs.org/) - The client framework used
* [Redux](https://redux.js.org/) - State Management
* [Firebase](https://firebase.google.com/) - Used for authentication, user data
* [GraphQL](https://www.graphql.com/) - Used for database querying
* [PostgresQL](https://www.postgresql.org/) - Used for items database

## Authors

* **Nicholas Johnston** - [Git Hub](https://github.com/nejohnston)

## License

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

## Acknowledgments

* Framework of this app is inspired and imitated from my [RED Academy Boomtown Project](http://boom.academy.red/).

repository: nejohnston/cook-crook

repo_name: nejohnston/cook-crook


text:
# TiKV Change Log
All notable changes to this project are documented in this file.
See also [TiDB Changelog](https://github.com/pingcap/tidb/blob/master/CHANGELOG.md) and [PD Changelog](https://github.com/pingcap/pd/blob/master/CHANGELOG.md).

## [3.0.0-beta]
- Support distributed GC [#3179](https://github.com/tikv/tikv/pull/3179)
- Check RocksDB Level 0 files before applying snapshots to avoid Write Stall [#3606](https://github.com/tikv/tikv/pull/3606)
- Support reverse `raw_scan` and `raw_batch_scan` [#3724](https://github.com/tikv/tikv/pull/3724)
- Support using HTTP to obtain monitoring information [#3855](https://github.com/tikv/tikv/pull/3855)
- Support DST better [#3786](https://github.com/tikv/tikv/pull/3786)
- Support receiving and sending Raft messages in batch [#3913](https://github.com/tikv/tikv/pull/3913)
- Introduce a new storage engine Titan [#3985](https://github.com/tikv/tikv/pull/3985)
- Upgrade gRPC to v1.17.2 [#4023](https://github.com/tikv/tikv/pull/4023)
- Support receiving the client requests and sending replies in batch [#4043](https://github.com/tikv/tikv/pull/4043)
- Support multi-thread Apply [#4044](https://github.com/tikv/tikv/pull/4044)
- Support multi-thread Raftstore [#4066](https://github.com/tikv/tikv/pull/4066)

## [2.1.2]
- Support the configuration format in the unit of `DAY` (`d`) and fix the configuration compatibility issue [#3931](https://github.com/tikv/tikv/pull/3931)
- Fix the possible panic issue caused by `Approximate Size Split` [#3942](https://github.com/tikv/tikv/pull/3942)
- Fix two issues about Region merge [#3822](https://github.com/tikv/tikv/pull/3822), [#3873](https://github.com/tikv/tikv/pull/3873)

## [2.1.1]
- Avoid transferring the leader to a newly created peer, to optimize the possible delay [#3878](https://github.com/tikv/tikv/pull/3878)

## [2.1.0]
+ Coprocessor
    - Add more built-in functions
    - [Add Coprocessor `ReadPool` to improve the concurrency in processing the requests](https://github.com/tikv/rfcs/blob/master/text/2017-12-22-read-pool.md)
    - Fix the time function parsing issue and the time zone related issues
    - Optimize the memory usage for pushdown aggregation computing

+ Transaction
    - Optimize the read logic and memory usage of MVCC to improve the performance of the scan operation and the performance of full table scan is 1 time better than that in TiDB 2.0
    - Fold the continuous Rollback records to ensure the read performance
    - [Add the `UnsafeDestroyRange` API to support to collecting space for the dropping table/index](https://github.com/tikv/rfcs/blob/master/text/2018-08-29-unsafe-destroy-range.md)
    - Separate the GC module to reduce the impact on write
    - Add the`upper bound` support in the `kv_scan` command

+ Raftstore
    - Improve the snapshot writing process to avoid RocksDB stall
    - [Add the `LocalReader` thread to process read requests and reduce the delay for read requests](https://github.com/tikv/rfcs/pull/17)
    - [Support `BatchSplit` to avoid large Region brought by large amounts of write](https://github.com/tikv/rfcs/pull/6)
    - Support `Region Split` according to statistics to reduce the I/O overhead
    - Support `Region Split` according to the number of keys to improve the concurrency of index scan
    - Improve the Raft message process to avoid unnecessary delay brought by `Region Split`
    - Enable the `PreVote` feature by default to reduce the impact of network isolation on services

+ Storage Engine
    - Fix the `CompactFiles` bug in RocksDB and reduce the impact on importing data using Lightning
    - Upgrade RocksDB to v5.15 to fix the possible issue of snapshot file corruption
    - Improve `IngestExternalFile` to avoid the issue that flush could block write

+ tikv-ctl
    - [Add the `ldb` command to diagnose RocksDB related issues](https://github.com/tikv/tikv/blob/master/docs/tools/tikv-control.md#ldb-command)
    - The `compact` command supports specifying whether to compact data in the bottommost level

+ Tools
    - Fast full import of large amounts of data: [TiDB-Lightning](https://pingcap.com/docs/tools/lightning/overview-architecture/)
    - Support new [TiDB-Binlog](https://pingcap.com/docs/tools/tidb-binlog-cluster/)

## [2.1.0-rc.5]
- Improve the error message of `WriteConflict` [#3750](https://github.com/tikv/tikv/pull/3750)
- Add the panic mark file [#3746](https://github.com/tikv/tikv/pull/3746)
- Downgrade grpcio to avoid the segment fault issue caused by the new version of gRPC [#3650](https://github.com/tikv/tikv/pull/3650)
- Add the upper limit to the `kv_scan` interface [#3749](https://github.com/tikv/tikv/pull/3749)

## [2.1.0-rc.4]
- Optimize the RocksDB Write stall issue caused by applying snapshots [#3606](https://github.com/tikv/tikv/pull/3606)
- Add raftstore `tick` metrics [#3657](https://github.com/tikv/tikv/pull/3657)
- Upgrade RocksDB and fix the Write block issue and that the source file might be damaged by the Write operation when performing `IngestExternalFile` [#3661](https://github.com/tikv/tikv/pull/3661)
- Upgrade grpcio and fix the issue that “too many pings” is wrongly reported [#3650](https://github.com/tikv/tikv/pull/3650)

## [2.1.0-rc.3]
### Performance
- Optimize the concurrency for coprocessor requests [#3515](https://github.com/tikv/tikv/pull/3515)
### New features
- Add the support for Log functions [#3603](https://github.com/tikv/tikv/pull/3603)
- Add the support for the `sha1` function [#3612](https://github.com/tikv/tikv/pull/3612)
- Add the support for the `truncate_int` function [#3532](https://github.com/tikv/tikv/pull/3532)
- Add the support for the `year` function [#3622](https://github.com/tikv/tikv/pull/3622)
- Add the support for the `truncate_real` function [#3633](https://github.com/tikv/tikv/pull/3633)
### Bug fixes
- Fix the reporting error behavior related to time functions [#3487](https://github.com/tikv/tikv/pull/3487), [#3615](https://github.com/tikv/tikv/pull/3615)
- Fix the issue that the time parsed from string is inconsistent with that in TiDB [#3589](https://github.com/tikv/tikv/pull/3589)

## [2.1.0-rc.2]
### Performance
* Support splitting Regions based on statistics estimation to reduce the I/O cost [#3511](https://github.com/tikv/tikv/pull/3511)
* Reduce clone in the transaction scheduler [#3530](https://github.com/tikv/tikv/pull/3530)
### Improvements
* Add the pushdown support for a large number of built-in functions
* Add the `leader-transfer-max-log-lag` configuration to fix the failure issue of leader scheduling in specific scenarios [#3507](https://github.com/tikv/tikv/pull/3507)
* Add the `max-open-engines` configuration to limit the number of engines opened by `tikv-importer` simultaneously [#3496](https://github.com/tikv/tikv/pull/3496)
* Limit the cleanup speed of garbage data to reduce the impact on `snapshot apply` [#3547](https://github.com/tikv/tikv/pull/3547)
* Broadcast the commit message for crucial Raft messages to avoid unnecessary delay [#3592](https://github.com/tikv/tikv/pull/3592)
### Bug fixes
* Fix the leader election issue caused by discarding the `PreVote` message of the newly split Region [#3557](https://github.com/tikv/tikv/pull/3557)
* Fix follower related statistics after merging Regions [#3573](https://github.com/tikv/tikv/pull/3573)
* Fix the issue that the local reader uses obsolete Region information [#3565](https://github.com/tikv/tikv/pull/3565)
* Support UnsafeDestroyRange API to speedup garbage data cleaning after table/index has been truncated/dropped [#3560](https://github.com/tikv/tikv/pull/3560)

## [2.1.0-rc.1]
### Features
* Support `batch split` to avoid too large Regions caused by the Write operation on hot Regions
* Support splitting Regions based on the number of rows to improve the index scan efficiency
### Performance
* Use `LocalReader` to separate the Read operation from the raftstore thread to lower the Read latency
* Refactor the MVCC framework, optimize the memory usage and improve the scan Read performance
* Support splitting Regions based on statistics estimation to reduce the I/O usage
* Optimize the issue that the Read performance is affected by continuous Write operations on the rollback record
* Reduce the memory usage of pushdown aggregation computing
### Improvements
* Add the pushdown support for a large number of built-in functions and better charset support
* Optimize the GC workflow, improve the GC speed and decrease the impact of GC on the system
* Enable `prevote` to speed up service recovery when the network is abnormal
* Add the related configuration items of RocksDB log files
* Adjust the default configuration of `scheduler_latch`
* Support setting whether to compact the data in the bottom layer of RocksDB when using tikv-ctl to compact data manually
* Add the check for environment variables when starting TiKV
* Support dynamically configuring the `dynamic_level_bytes` parameter based on the existing data
* Support customizing the log format
* Integrate tikv-fail in tikv-ctl
* Add I/O metrics of threads
### Bug fixes
* Fix decimal related issues
* Fix the issue that `gRPC max_send_message_len` is set mistakenly
* Fix the issue caused by misconfiguration of `region_size`

## [2.1.0-beta]
### Features
* Upgrade Rust to the `nightly-2018-06-14` version
* Provide a `Raft PreVote` configuration to avoid leader reelection generated when network recovers after network isolation
* Add a metric to display the number of files and `ingest` related information in each layer of RocksDB
* Print `key` with too many versions when GC works
### Performance
* Use `static metric` to optimize multi-label metric performance (YCSB `raw get` is improved by 3%)
* Remove `box` in multiple modules and use patterns to improve the operating performance (YCSB `raw get` is improved by 3%)
* Use `asynchronous log` to improve the performance of writing logs
* Add a metric to collect the thread status
* Decease memory copy times by decreasing `box` used in the application to improve the performance

## [2.0.4]
### Features
* Add the RocksDB `PerfContext` interface for debugging
* Add the `region-properties` command for `tikv-ctl`
### Improvements
* Make GC record the log when GC encounters many versions of data
* Remove the `import-mode` parameter
### Bug Fixes
* Fix the issue that `reverse-seek` is slow when many RocksDB tombstones exist
* Fix the crash issue caused by `do_sub`

## [2.0.3]
### Bug Fixes
* Correct wrong peer meta for learners
* Report an error instead of getting a result if divisor/dividend is 0 in do_div_mod

## [2.0.2]
### Improvements
* Support configuring more gRPC related parameters
* Support configuring the timeout range of leader election
### Bug Fixes
* Fix the issue that the Raft log is not printed
* Fix the issue that obsolete learner is not deleted
* Fix the issue that the snapshot intermediate file is mistakenly deleted

## [2.0.1]
### Performance
* Reduced number of `thread_yield` calls
* Fix the issue that `SELECT FOR UPDATE` prevents others from reading
### Improvements
* More verbose logs for slow query
* Speed up delete range
### Bug Fixes
* Fix the bug that raftstore is accidentally blocked when generating the snapshot
* Fix the issue that Learner cannot be successfully elected in special conditions
* Fix the issue that split might cause dirty read in extreme conditions
* Correct the default value of the read thread pool configuration

## [2.0.0] - 2018-04-27
### Features
* Protect critical configuration from incorrect modification
* Support `Region Merge` [experimental]
* Add the `Raw DeleteRange` API
* Add the `GetMetric` API
* Add `Raw Batch Put`, `Raw Batch Get`, `Raw Batch Delete` and `Raw Batch Scan`
* Add Column Family options for the RawKV API and support executing operation on a specific Column Family
* Support Streaming and Streaming Aggregation in Coprocessor
* Support configuring the request timeout of Coprocessor
* Carry timestamps with Region heartbeats
* Support modifying some RocksDB parameters online, such as `block-cache-size`
* Support configuring the behavior of Coprocessor when it encounters some warnings or errors
* Support starting in the importing data mode to reduce write amplification during the data importing process
* Support manually splitting Region in halves
* Improve the data recovery tool `tikv-ctl`
* Return more statistics in Coprocessor to guide the behavior of TiDB
* Support the `ImportSST` API to import SST files [experimental]
* Add the TiKV Importer binary to integrate with TiDB Lightning to import data quickly [experimental]
### Performance
* Optimize read performance using `ReadPool` and increase the `raw_get/get/batch_get` by 30%
* Improve metrics performance
* Inform PD immediately once the Raft snapshot process is completed to speed up balancing
* Solve performance jitter caused by RocksDB flushing
* Optimize the space reclaiming mechanism after deleting data
* Speed up garbage cleaning while starting the server
* Reduce the I/O overhead during replica migration using `DeleteFilesInRanges`
### Stability
* Fix the issue that gRPC call does not returned when the PD leader switches
* Fix the issue that it is slow to offline nodes caused by snapshots
* Limit the temporary space usage consumed by migrating replicas
* Report the Regions that cannot elect a leader for a long time
* Update the Region size information in time according to compaction events
* Limit the size of scan lock to avoid request timeout
* Limit the memory usage when receiving snapshots to avoid OOM
* Increase the speed of CI test
* Fix the OOM issue caused by too many snapshots
* Configure `keepalive` of gRPC
* Fix the OOM issue caused by an increase of the Region number

## [2.0.0-rc6] - 2018-04-19
### Improvements
* Reduce lock contention in Worker
* Add metrics to the FuturePool
### Bug Fixes
* Fix misused metrics in Coprocessor

## [2.0.0-rc.5] - 2018-04-17
### New Features
* Support compacting Regions in `tikv-ctl`
* Add raw batch put/get/delete/scan API for TiKV service
* Add ImportKV service
* Support eval error in Coprocessor
* Support dynamic adjustment of RocksDB cache size by `tikv-ctl`
* Collect number of rows scanned for each range in Coprocessor
* Support treating overflow as warning in Coprocessor
* Support learner in raftstore
### Improvements
* Increase snap GC timeout

## [2.0.0-rc.4] - 2018-04-01
### New Features
* Limit the memory usage during receiving snapshots, to avoid OOM in extreme conditions
* Support configuring the behavior of Coprocessor when it encounters warnings
* Support importing the data pattern in TiKV
* Support splitting Region in the middle
### Improvements
* Fix the issue that too many logs are output caused by leader missing when TiKV is isolated
* Use crossbeam channel in worker

## [2.0.0-rc.3] - 2018-03-23
### New Features
* Support Region Merge
* Add the Raw DeleteRange API
* Add the GetMetric API
* Support streaming in Coprocessor
* Support modifying RocksDB parameters online
### Improvements
* Inform PD immediately once the Raft snapshot process is completed, to speed up balancing
* Reduce the I/O fluctuation caused by RocksDB sync files
* Optimize the space reclaiming mechanism after deleting data
* Improve the data recovery tool `tikv-ctl`
* Fix the issue that it is slow to make nodes down caused by snapshot
* Increase the raw_get/get/batch_get by 30% with ReadPool
* Support configuring the request timeout of Coprocessor
* Carry time information in Region heartbeats
* Limit the space usage of snapshot files to avoid consuming too much disk space
* Record and report the Regions that cannot elect a leader for a long time
* Speed up garbage cleaning when starting the server
* Update the size information about the corresponding Region according to compaction events
* Limit the size of scan lock to avoid request timeout
* Use DeleteRange to speed up Region deletion

## [2.0.0-rc.2] - 2018-03-15
### New Features
* Implement IngestSST API
* `tikv-ctl` now can send consistency-check requests to TiKV
* Support dumping stats of RocksDB and malloc in `tikv-ctl`
### Improvements
* Reclaim disk space after data have been deleted

## [2.0.0-rc.1] - 2018-03-09
### New Features
* Protect important configuration which cannot be changed after initial configuration
* Check whether SSD is used when you start the cluster
### Improvements
* Fix the issue that gRPC call is not cancelled when PD leaders switch
* Optimize the read performance using ReadPool, and improve the performance by 30% for raw get
* Improve metrics and optimize the usage of metrics

## [1.1.0-beta] - 2018-02-24
### Improvements
* Traverse locks using offset + limit to avoid potential GC problems
* Support resolving locks in batches to improve GC speed
* Support GC concurrency to improve GC speed
* Update the Region size using the RocksDB compaction listener for more accurate PD scheduling
* Delete the outdated data in batches using DeleteFilesInRanges, to make TiKV start faster
* Configure the Raft snapshot max size to avoid the retained files taking up too much space
* Support more recovery operations in tikv-ctl
* Optimize the ordered flow aggregation operation

## [1.0.8] - 2018-02-11
### Improvements
* Use DeleteFilesInRanges to clear stale data and improve the TiKV starting speed
* Sync the metadata of the received Snapshot compulsorily to ensure its safety
### Bug Fixes
* Use Decimal in Coprocessor sum

## [1.0.7] - 2018-01-22
### Improvements
* Support key-only option in Table Scan executor
* Support the remote mode in tikv-ctl
* Fix the loss of scheduling command from PD
### Bug Fixes
* Fix the format compatibility issue of tikv-ctl proto
* Add timeout in Push metric

## [1.1.0-alpha] - 2018-01-19
### New Features
* Support Raft learner
* Support TLS
### Improvements
* Optimize Raft Snapshot and reduce the I/O overhead
* Optimize the RocksDB configuration to improve performance
* Optimize count (*) and query performance of unique index in Coprocessor
* Solve the reconnection issue between PD and TiKV
* Enhance the features of the data recovery tool `tikv-ctl`
* Support the Delete Range feature
* Support splitting according to table in Regions
* Support setting the I/O limit caused by snapshot
* Improve the flow control mechanism

repository: wujunze/tikv

repo_name: wujunze/tikv


text:
matplotconf
=============

A repository of custom matplotlib settings. Make sure matsettings.py is at the same level as your code and simply import in to your script and you're good to go! Edit the file to customise your matplotlib any way you like. This is a simpler way to customise matplotlib without having to edit the .matplotlibrc file.

```python
import matsettings
```

repository: sgjholt/matplotconf

repo_name: sgjholt/matplotconf


text:
## 27.1-1

> Suppose that we spawn $\text{P-FIB}(n - 2)$ in line 4 of $\text{P-FIB}$, rather than calling it as is done in the code. What is the impact on the asymptotic work, span, and parallelism?

There will be no change in the asymptotic work, span, or parallelism of $\text{P-FIB}$ even if we were to spawn the recursive call to $\text{P-FIB}(n - 2)$. The serialization of $\text{P-FIB}$ under consideration would yield the same recurrence as that for $\text{FIB}$; we can, therefore, calculate the work as $T_1(n) = \Theta(\phi^n)$. Similarly, because the spawned calls to $\text{P-FIB}(n - 1)$ and $\text{P-FIB}(n - 2)$ can run in parallel, we can calculate the span in exactly the same way as in the text, $T_\infty(n) = \Theta(n)$, resulting in $\Theta(\phi^n / n)$ parallelism.

## 27.1-2

> Draw the computation dag that results from executing $\text{P-FIB}(5)$. Assuming that each strand in the computation takes unit time, what are the work, span, and parallelism of the computation? Show how to schedule the dag on 3 processors using greedy scheduling by labeling each strand with the time step in which it is executed.

- Work: $T_1 = 29$.
- Span: $T_\infty = 10$.
- Parallelism: $T_1 / T_\infty \approx 2.9$.

## 27.1-3

> Prove that a greedy scheduler achieves the following time bound, which is slightly stronger than the bound proven in Theorem 27.1:
>
> $$T_P \le \frac{T_1 - T_\infty}{P} + T_\infty. \tag{27.5}$$

Suppose that there are x incomplete steps in a run of the program. Since each of these steps causes at least one unit of work to be done, we have that there is at most $(T_1 - x)$ units of work done in the complete steps. Then, we suppose by contradiction that the number of complete steps is strictly greater than $\lfloor (T_1 - x) / P \rfloor$. Then, we have that the total amount of work done during the complete steps is

$$P \cdot (\lfloor (T_1 - x) / P \rfloor + 1) = P \lfloor (T_1 - x) / P = (T_1 - x) - ((T_1 - x) \mod P) + P > T_1 - x.$$

This is a contradiction because there are only $(T_1 - x)$ units of work done during complete steps, which is less than the amount we would be doing. Notice that since $T_\infty$ is abound on the total number of both kinds of steps, it is a bound on the number of incomplete steps, $x$, so,

$$T_P \le \lfloor (T_1 - x) / P \rfloor + x \le \lfloor (T_1 - T_\infty) / P \rfloor + T_\infty.$$

Where the second inequality comes by noting that the middle expression, as a function of $x$ is monotonically increasing, and so is bounded by the largest value of $x$ that is possible, namely $T_\infty$.

## 27.1-4

> Construct a computation dag for which one execution of a greedy scheduler can take nearly twice the time of another execution of a greedy scheduler on the same number of processors. Describe how the two executions would proceed.

The computation is given in the image below. Let vertex $u$ have degree $k$, and assume that there are $m$ vertices in each vertical chain. Assume that this is executed on $k$ processors. In one execution, each strand from among the $k$ on the left is executed concurrently, and then the $m$ strands on the right are executed one at a time. If each strand takes unit time to execute, then the total computation takes $2m$ time. On the other hand, suppose that on each time step of the computation, $k - 1$ strands from the left (descendants of $u$) are executed, and one from the right (a descendant of $v$), is executed. If each strand take unit time to executed, the total computation takes $m + m / k$. Thus, the ratio of times is $2m / (m + m / k) = 2 / (1 + 1 / k)$. As $k$ gets large, this approaches $2$ as desired.

## 27.1-5

> Professor Karan measures her deterministic multithreaded algorithm on $4$, $10$, and $64$ processors of an ideal parallel computer using a greedy scheduler. She claims that the three runs yielded $T_4 = 80$ seconds, $T_{10} = 42$ seconds, and $T_{64} = 10$ seconds. Argue that the professor is either lying or incompetent. ($\textit{Hint:}$ Use the work law $\text{(27.2)}$, the span law $\text{(27.3)}$, and inequality $\text{(27.5)}$ from Exercise 27.1-3.)

By the work law for $P = 4$, we have $80 = T_4 \ge T_1 / 4$, or $T_1 \le 320$. By the span law for $P = 64$, we have $T_\infty \le T_{64} = 10$. Now we will use inequality $\text{(27.5)}$ from Exercise 27.1-3 to derive a contradiction. For $P = 10$, we have

$$
\begin{aligned}
42 & =   T_{10} \\\\
   & \le \frac{320 - T_\infty}{10} + T_\infty \\\\
   & =   32 + \frac{9}{10} T_\infty
\end{aligned}
$$

or, equivalently,

$$
\begin{aligned}
T_\infty & \ge \frac{10}{9} \cdot 10 \\\\
         & >   10,
\end{aligned}
$$

which contradicts $T_\infty \le 10$.

Therefore, the running times reported by the professor are suspicious.

## 27.1-6

> Give a multithreaded algorithm to multiply an $n \times n$ matrix by an $n$-vector that achieves $\Theta(n^2 / \lg n)$ parallelism while maintaining $\Theta(n^2)$ work.

```cpp
FAST-MAT-VEC(A, x)
    n = A.rows
    let y be a new vector of length n
    parallel for i = 1 to n
        y[i] = 0
    parallel for i = 1 to n
        y[i] = MAT-SUB-LOOP(A, x, i, 1, n)
    return y
```

```cpp
MAT-SUB-LOOP(A, x, i, j, j')
    if j == j'
        return a[i, j] * x[j]
    else mid = floor((j + j') / 2)
        lhalf = spawn MAT-SUB-LOOP(A, x, i, j, mid)
        uhalf = MAT-SUB-LOOP(A, x, i, mid + 1, j')
        sync
        return lhalf + uhalf
```

We calculate the work $T_1(n)$ of $\text{FAST-MAT-VEC}$ by computing the running time of its serialization, i.e., by replacing the **parallel for** loop by an ordinary **for** loop. Therefore, we have $T_1(n) = n T_1'(n)$, where $T_1'(n)$ denotes the work of $\text{MAT-SUB-LOOP}$ to compute a given output entry $y_i$. The work of $\text{MAT-SUB-LOOP}$ is given by the recurrence

$$T_1'(n) = 2T_1'(n / 2) + \Theta(1).$$

By applying case 1 of the master theorem, we have $T_1'(n) = \Theta(n)$. Therefore, $T_1(n) = \Theta(n^2)$.

To calculate the span, we use

$$T_\infty(n) = \Theta(\lg n) + \max_{1 \le i \le n} iter_\infty (i).$$

Note that each iteration of the second **parallel for** loop calls procedure $\text{MAT-SUB-LOOP}$ with the same parameters, except for the index $i$. Because $\text{MAT-SUB-LOOP}$ recursively halves the space between its last two parameters ($1$ and $n$), does constant-time work in the base case, and spawns one of the recursive calls in parallel with the other, it has span $\Theta(\lg n)$. The procedure $\text{FAST-MAT-VEC}$, therefore, has a span of $\Theta(\lg n)$ and $\Theta(n^2 / \lg n)$ parallelism.

## 27.1-7

> Consider the following multithreaded pseudocode for transposing an $n \times n$ matrix $A$ in place:
>
> ```cpp
> P-TRANSPOSE(A)
>     n = A.rows
>     parallel for j = 2 to n
>         parallel for i = 1 to j - 1
>             exchange a[i, j] with a[j, i]
> ```
>
> Analyze the work, span, and parallelism of this algorithm.

We analyze the work of $\text{P-TRANSPOSE}$, as usual, by computing the running time of its serialization, where we replace both the **parallel for** loops with simple **for** loops. We can compute the work of $\text{P-TRANSPOSE}$ using the summation

$$
\begin{aligned}
T_1(n) & = \Theta \Bigg( \sum_{j = 2}^n (j - 1) \Bigg) \\\\
       & = \Theta \Bigg( \sum_{j = 1}^{n - 1} j \Bigg) \\\\
       & = \Theta(n^2).
\end{aligned}
$$

The span of $\text{P-TRANSPOSE}$ is determined by the span of the doubly nested **parallel for** loops. Although the number of iterations of the inner loop depends on the value of the variable $j$ of the outer loop, each iteration of the inner loop does constant work. Let $iter_\infty(j)$ denote the span of the $j$th iteration of the outer loop and $iter'\_\infty(i)$ denote the span of the ith iteration of the inner loop. We characterize the span $T_\infty(n)$ of $\text{P-TRANSPOSE}$ as

$$T_\infty(n) = \Theta(\lg n) + \max_{2 \le j \le n} iter_\infty(j).$$

The maximum occurs when $j = n$, and in this case,

$$iter_\infty(n) = \Theta(\lg n) + \max_{1 \le i \le n - 1} iter'_\infty(i).$$

As we noted, each iteration of the inner loop does constant work, and therefore $iter'_\infty(i) = \Theta(1)$ for all $i$. Thus, we have

$$
\begin{aligned}
\Theta(\lg n)
    & = \Theta(\lg n) + \Theta(\lg n) + \Theta(1) \\\\
    & = \Theta(\lg n).
\end{aligned}
$$

Since the work $\text{P-TRANSPOSE}$ is $\Theta(n^2)$ and its span is $\Theta(\lg n)$, the parallelism of $\text{P-TRANSPOSE}$ is $\Theta(n^2 / \lg n)$.

## 27.1-8

> Suppose that we replace the **parallel for** loop in line 3 of $\text{P-TRANSPOSE}$ (see Exercise 27.1-7) with an ordinary **for** loop. Analyze the work, span, and parallelism of the resulting algorithm.

If we were to replace the inner **parallel for** loop of $\text{P-TRANSPOSE}$ with an ordinary **for** loop, the work would still remain $\Theta(n^2)$. The span, however, would increase to $\Theta(n)$ because the last iteration of the **parallel for** loop, which dominates the span of the computation, would lead to $(n - 1)$ iterations of the inner, serial **for** loop. The parallelism, therefore, would reduce to $\Theta(n^2) / \Theta(n) = \Theta(n)$.

## 27.1-9

> For how many processors do the two versions of the chess programs run equally fast, assuming that $T_P = T_1 / P + T_\infty$?

Based on the values of work and span given for the two versions of the chess program, we solve for $P$ using

$$\frac{2048}{P} + 1 = \frac{1024}{P} + 8.$$

The solution gives $P$ between $146$ and $147$.


text:
# Yildiz-Engine module-physics.

This is the official repository of the Physics Module, part of the Yildiz-Engine project.
The physics module is an abstract component to handle the physics, it is meant to be materialized.

## Features

* Mesh and primitive shapes.
* Different worlds support.
* Static, and dynamic objects.
* Masking.
* Forces(gravity,...).
* ...

## Requirements

To build this module, you will need a java 9 JDK and Maven 3.

## Coding Style and other information

Project website:
https://engine.yildiz-games.be

Issue tracker:
https://yildiz.atlassian.net

Wiki:
https://yildiz.atlassian.net/wiki

Quality report:
https://sonarqube.com/overview?id=be.yildiz-games:module-physics

## License

All source code files are licensed under the permissive MIT license
(http://opensource.org/licenses/MIT) unless marked differently in a particular folder/file.

## Build instructions

Go to your root directory, where you POM file is located.

Then invoke maven

	mvn clean install

This will compile the source code, then run the unit tests, and finally build a jar file.

## Usage

In your maven project, add the dependency

```xml
<dependency>
    <groupId>be.yildiz-games</groupId>
    <artifactId>module-physics</artifactId>
    <version>1.0.7</version>
</dependency>
```

## Contact
Owner of this repository: Grégory Van den Borre

repository: yildiz-online/module-physics

branch_name: refs/heads/develop

gha_language: Java

repo_name: yildiz-online/module-physics


text:
---
title: Reanalysis of PXD022085
---

# Proteomic re-analysis of bronchoalveolar lavage fluid in COVID-19 patients

## Live Resources

| usegalaxy.eu |
|:--------:|:------------:|:------------:|:------------:|:------------:|
| <FlatShield label="Input data" message="view" href="https://usegalaxy.eu/u/subina/h/pxd022085inputfiles" alt="Raw data" /> |
| <FlatShield label="PXD022085 history" message="view" href="https://usegalaxy.eu/u/arajczewski/h/imported-pxd022085-balf-samples-2" alt="Galaxy history" /> |
| <FlatShield label="workflow" message="run" href="https://usegalaxy.eu/u/arajczewski/w/imported-workflow-for-covid-19-peptide-validation-pxd018094-and-pxd022085" /> |

## Description

**[Zeng lab](https://www.iprox.org/page/subproject.html?id=IPX0002429001)** collected bottom-up mass spectrometry (MS) data on bronchoalveolar lavage fluid in COVID-19 positive patient samples with respiratory failure.
Data-dependent acquisition MS spectra were acquired using Q Exactive HF-X mass spectrometer coupled with an EASY-nLC 1200 system and a nano-electrospray ion source.

## Workflow

![](./../img/wfVal.png)

The Galaxy workflow includes RAW data conversion to MGF and mzML format. The MGF files are searched against the combined database of
Human Uniprot proteome, contaminant proteins and SARS-Cov-2 proteins database using PepQuery Validation workflow. This resulted in detection of 88 peptides from SARS-CoV-2 proteins. The detected peptides were searched against NCBInr to ascertain that these peptides were specific to SARS-CoV-2 proteins.
The detected peptides were later subjected to analysis by Lorikeet visualization to ascertain the quality of peptide identification.

Our Database search workflow did not detect any SARS-CoV2 peptides from both positive and negative samples.

![](./../img/wfDB.png)

## Results

We detected 36 COVID-19 peptides from all pooled samples in the respiratory tract datasets, We detected 25 SARS-CoV2 peptides from positive patients , 11 SARS-CoV2 peptides from negative patient samples. The peptides were subjected to BLAST-P andLorikeet analysis to ascertain the validity of peptide spectral matches.

gha_language: Jupyter Notebook


text:
# About Project

The purpose of the project is to detect plant disease and diagnose the same. The procedure is to detect plant disease by digital video.  Dataset consist a collection of plant disease images. The system must be already trained with collected dataset. The converted image frame process with DL system using DCNN (Deep Convolutional Neural Network). To gain the crop yield on agriculture,  system classify particular disease and report diagnosis to the user. Result of our project is system classifies whether the plant is affected or not. On our own we will research about implementing the system in a drone, which flies in a specific pattern to cover the whole field. We hope that this will enable our system to produce more accuracy

## Getting Started

this project has 2 parts. they are image/video based detection (ROI by opencv) and
recognition of disease in affected plant (ie. paddy) classify by input and tell results with report to user.it runs under flask web framework. dataset were collected by own camera field images.it was challenging project for me. it helps farmer to moniter thier field.

## Instructions

run file 'app.py; in "image recognition" folder
run file 'object_detection_video.py' or 'object_detection_video.py' in "object detection" folder

### Screenshots

here are some of the project screenshots:

## License
Prakash A – [@iamprakash13](https://github.com/iamprakash13) - [ptan022<EMAIL_ADDRESS>
Distributed under the MIT License

Copyright (c) 2019 Prakash A

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

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

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

***
### Show some :heart: and star the repo to support the project

repository: gargarchit/UdacityOpenSource

path: /Prakash A/readme.md

repo_name: gargarchit/UdacityOpenSource


text:
# Working With Ember Data

In this section, we cover how to use TypeScript effectively with specific Ember Data APIs \(anything you'd find under the `@ember-data` package namespace\).

We do _not_ cover general usage of Ember Data; instead, we assume that as background knowledge. Please see the Ember Data [Guides](https://guides.emberjs.com/release/models) and [API docs](https://api.emberjs.com/ember-data/release)!

repository: typed-ember/ember-cli-typescript

gha_language: TypeScript

repo_name: typed-ember/ember-cli-typescript


text:
# FizzBuzz (Level II)

[It has been said](http://imranontech.com/2007/01/24/using-fizzbuzz-to-find-developers-who-grok-coding/)
that many recent Computer Science graduates walk into their first job interviews
completely unable to write a single line of code. Some hiring managers have
started to use very simple tests to screen out the obviously incompetent programmers.
One such test is known as FizzBuzz. The typical description of this test is as follows:

*Write a program that prints the numbers from 1 to 100. But for multiples of three
print “Fizz” instead of the number and for the multiples of five print “Buzz”. For
numbers which are multiples of both three and five print “FizzBuzz”.*

We will use a variation of this test in which the last number of the series isn't
necessarily 100, and the two numbers being tested for multiples aren't necessarily
three and five. For example, your program should behave just like this:

```
How many numbers shall we print? 25
For multiples of what number shall we print 'Fizz'? 3
For multiples of what number shall we print 'Buzz'? 5
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
17
Fizz
19
Buzz
Fizz
22
23
Fizz
Buzz
```

repository: Runpython-IntroProgramming/fizzbuzz

gha_language: Python

repo_name: Runpython-IntroProgramming/fizzbuzz


text:
# CreateUserResponse

## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**Data** | Pointer to [**User**](User.md) |  | [optional]

## Methods

### NewCreateUserResponse

`func NewCreateUserResponse() *CreateUserResponse`

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

### NewCreateUserResponseWithDefaults

`func NewCreateUserResponseWithDefaults() *CreateUserResponse`

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

### GetData

`func (o *CreateUserResponse) GetData() User`

GetData returns the Data field if non-nil, zero value otherwise.

### GetDataOk

`func (o *CreateUserResponse) GetDataOk() (*User, bool)`

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

### SetData

`func (o *CreateUserResponse) SetData(v User)`

SetData sets Data field to given value.

### HasData

`func (o *CreateUserResponse) HasData() bool`

HasData returns a boolean if a field has been set.

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

repository: rockset/rockset-go-client

gha_language: Go

repo_name: rockset/rockset-go-client


text:
---
type: work-example
title: Innovation Studio
position: Studio Director
tags: Design Thinking, Google Sprint, Agile Principles, Enterprise Engagement, User Testing, Empathy Research, Portfolio Management, Ideation, Innovation Lab, Regulated Environment, Rapid Prototyping, Community Engagement, Team Management
year: 2019
icon: RiLightbulbLine
context: A fortune 500 financial institution wanted to operationalize an innovation center to discover, test, and deploy product and operational ideas back into the business. They wanted a hands-on studio model built on design thinking and agile principles closely connected to users.
image: './innovation-01.svg'
imageDark: './innovation-02.svg'
---

### Challenges

The Studio needed to be a functional physical space where employees spent time away from their regular job for days, weeks, or months. Beyond space design, they needed an operating model that reflected their commitment to agile principles and customer engagement. All of this while operating within the bounds of strict legal risk and compliance of a regulated industry.

### Solution

I acted as the Studio Director and wrote an operating model that outline equipment and furniture, roles and responsibilities, agile ceremonies, ideation workshop, user testing, tools and techniques, corporate engagement, and more. I helped establish the teams in their new space and served as the Studio Director during the first year. We spent countless hours with users and validated ideas that changed business operations and improved products while empowering employees to drive innovation behaviors at all levels.

repository: joelbowen/joel-dot-software

repo_name: joelbowen/joel-dot-software


text:
# SetGridLines constructor

Initializes a new instance of the [`SetGridLines`](../SetGridLines.md) class.

```csharp
public SetGridLines()
```

## See Also

* class [SetGridLines](../SetGridLines.md)
* namespace [iTin.Utilities.Xlsx.Writer.ComponentModel](../../iTin.Utilities.Xlsx.Writer.md)

<!-- DO NOT EDIT: generated by xmldocmd for iTin.Utilities.Xlsx.Writer.dll -->

repository: bubdm/iXlsxWriter

repo_name: bubdm/iXlsxWriter


text:
# Set up Google scholar search

## Description

A utility program to retrieve data from google scholar into excel stylesheets using Selenium WebDriver, to discover Open Access status.
The program first searches google for the doi as an uri, and then falls back to using title if no results are found.

Google Scholar links directly to paid resources if a "campus" ip is recognized, so run on an off-campus network.

When CAPTCHAS are met, the user takes control over the Browser while the application waits for completion.

If the browser is closed, or an error is met, the excel file is closed, and can be found in the output folder.

Retrieved results are:

```
DOI, LOCAL_ID, LOCAL_TITLE, GS_TITLE, GS_AUTHOR, GS_NUM_OF_CITATIONS, GS_LINK_FORMAT (pdf, html), GS_LINK_DOMAIN, LOCAL_COMMENT (from application; not found),GS_OPEN_ACCESS, DATESTAMP
```

## Install and run

## Dependencies
* Java
* Chrome (release contains chromedriver and is configured for chrome only)
* ChromeDriver
* Maven to build

## Run

Make sure java is installed. Download OS specific binary from http://chromedriver.chromium.org/downloads (Download page lists supported version of Chrome as well). Unpack driver and release (https://github.com/ubbdst/frie-publikasjoner-gs/releases/download/v1.39/frie-publikasjoner-gs-v1.39.zip ) and place chromedriver binary in unzipped `lib` folder.
Releases are not OS specific (has been tested with IOS and Windows), but the chromedrivers are.

Create an input file, and place in data/input.txt. `input.txt` is a tab seperated format of DOI, LOCAL_ID (Cristin ID for us) and Title which is used to drive the query. The file is expected to be saved as UTF-8. An example file is found at
[input.txt](data/input.txt)

### To build:
```
git clone git@github.com:ubbdst/frie-publikasjoner-gs.git
mvn clean install
```

Or Open as maven-project in IDE of choice.

## Issues

The script runs as of 2018-10-02, but has been broken earlier by changes to google scholars web page structure. If that happens, look at updating the xpath in GoogleScholarSearch.java.

Sometimes if the web-page hangs on first page the google chromedriver and Chrome are out of sync. See http://chromedriver.chromium.org/downloads to check if versions are compatible.

repository: ubbdst/frie-publikasjoner-gs

repo_name: ubbdst/frie-publikasjoner-gs


text:
Hub Key Technical Specification V1
================================================

Table of Contents
=================

* [Introduction](#user-content-introduction)
* [Hub Key description](#user-content-hub-key-description)
  * [Examples](#user-content-examples)
* [Currently supported entity types](#user-content-currently-supported-entity-types)
* [Unicode](#user-content-unicode)

# Introduction

The Hub Key is a unique resource locator generated by the Open Permissions Platform to locate an entity.
The Hub Key is generated during the onboarding process.
A Hub Key is returned by the Onboarding API for each successfully onboarded entity such as Assets and Offers.
Thereafter it can be used as a key to retrieve entities from Hub repositories and can also be used directly in the browser to return entities in human readable form.

Typically the Hub Key is written into the Asset metadata after the Asset is onboarded, providing a direct link from the Asset to information held in Hub repositories.

The Hub Key takes the form of a valid URL conforming to [RFC3986 section 3.3](http://tools.ietf.org/html/rfc3986#section-3.3).

The remainder of this document is a specification of how the Hub Key is composed.

# Hub Key description

The Hub Key is composed from the following elements. Note that each segment **must** be valid as a URL path segment, as described below:

|Field|Description|Example|
|:---|:---|:---|
|**separator**|Use `/` as per specification below|`/`|
|**schema_version**|The version of the schema (this specification) that defines the key format|`s1`|
|**resolver_id**|The name of the host that can resolve the Hub Key. Must be a valid hostname and protocol |`https://copyrighthub.org`|
|**hub_id**|The id of the hub that is hosting the key|`hub1`|
|**entity_type**|The type of the entity to which the key refers. Hub Keys are used to uniquely identify different types of entities|See [Currently supported entity types](#user-content-currently-supported-entity-types)|
|**repository_id**|ID of the repository that contains the entity.|
|**entity_id**|The value of the entity as assigned by the Hub.|

A valid URL path segment consists of alpha numeric characters, the special characters `.-_~!$&'()*+,;=:@'`, or a percent encoded character. See [RFC3986 section 3.3](http://tools.ietf.org/html/rfc3986#section-3.3).

The Hub Key resolvable URL is composed from the Hub Key URI, with protocol and resolving host specified:

```
<resolver_id>/<schema_version>/<hub_id>/<repository_id>/<entity_type>/<entity_id>
```

## Examples

### Live Example
With these values:
* separator = `/`
* resolver_id = `https://copyrighthub.org`
* schema_version = `s1`
* hub_id = `hub1`
* entity_type = `asset`
* repository_id = `7421a6d45d39616d17313a4248008608`
* entity_id = `a5a177ba246f454bbc1ea315e07db873`

the following Hub Key resolvable URL is generated (shown non-URL encoded) identifying an Asset that was onboarded through `hub1` to `copyrighthub.org`:

* https://copyrighthub.org/s1/hub1/7421a6d45d39616d17313a4248008608/asset/a5a177ba246f454bbc1ea315e07db873

Note that the example above is a valid URL which resolves to Asset data held by ExampleCo, a sample company created by the Open Permissions Platform.
For example, the URL can be pasted directly into a browser and navigated to.

### Other Examples
The below examples are not currently resolvable, but show example Hub Keys that could be generated using different values.

* https://copyrighthub.org/s1/chf/1451451435345/asset/4514353134616
* https://copyrighthub.org/s1/chf/1451451435345/offer/2523452354315
* https://copyrighthub.org/s1/chf/1451451435345/agreement/1523267354315

The above Hub Keys show different entity types that exist in the same repository in the `chf` hub.
The same resolver is used for each entity, and in the Open Permissions Platform there will only be a single resolver available under their governance rules (at the time of writing).

* https://3dprinthub.com/s1/3d/4355451435346/asset/6678353134699
* https://3dprinthub.com/s1/3d/7657451439854/offer/5553452354987
* https://licensing.io/s1/3d/8261451435123/agreement/1523267354315

The above Hub Keys show different entity types that exist in different repositories available in the `3d` hub.
This hub allows multiple resolvers to operate and thus the owner of the creation can choose which site provides their entity resolution.

* https://abcd.com/s1/3d/4355451435346/asset/6678353134699
* https://abcd.com/s1/eu/8758587585858/asset/8765765786598

The above example shows Hub Keys from different hubs (`3d` and `eu`) being resolved by the same resolver.

# Currently supported entity types

The Hub Keys can be generated for a fix set of publicly exposed entities.

* **asset**
* **offer**
* **agreement**

# Unicode

The Hub Key **must not** contain Unicode characters, to ensure that it can be used as a valid URI.

Instead, when a Hub Key is generated the `resolver_id` is encoded using the Internationalized Domain Names in Applications (IDNA) ptotocol, see [RFC5891](https://www.ietf.org/rfc/rfc5891.txt).
The remaining components are percent encoded, see [RFC3987](https://www.ietf.org/rfc/rfc3987.txt) and [RFC3490](https://www.ietf.org/rfc/rfc3490.txt).

This work is licensed under a Creative Commons Attribution 4.0 International License.

repository: openpermissions/support-docs

gha_language: Makefile

repo_name: openpermissions/support-docs