text:
---
layout: default
---

# 1998-11-14 - RE: DBS, Privacy, Money Laundering nonsense.

## Header Data

From: "Todd Boyle"<EMAIL_ADDRESS>To: "dbs"<EMAIL_ADDRESS>Message Hash: a1c7878b1263ef7d8f746cec419a09e3448e25ca8be2cc6d513ba34ca8d2b6f3

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1998-11-14 19:49:00 UTC

Raw Date: Sun, 15 Nov 1998 03:49:00 +0800

## Raw message

```
{% raw  %}From: "Todd Boyle"<EMAIL_ADDRESS>Date: Sun, 15 Nov 1998 03:49:00 +0800
To: "dbs"<EMAIL_ADDRESS>Subject: RE: DBS, Privacy, Money Laundering nonsense.
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

>Oops. Looks like you weren't watching your >'s :-). You're actually
>responding to Unicorn, not me. *He* was responding to something Todd Boyle
>said (well, probably trolled, given his past behavior :-)) on the DBS list.

I don't altogether enjoy living in the world I've created.  My
intent in posting my ideas is so that they'll either be verified,
or be neutralized or corrected by enzymes on your excellent list!  <G>

But I'm still stuck on these points:

 * Thieves exist in large numbers, throughout the world including my
     own immediate area.  Many more potential thieves in line, behind them.

 * If thieves could hide the money they stole, there would be substantial
    increase in frequency and severity of theft; mostly fraud, employee
    embezzlement, and white collar theft but also blatant scams and
    grift that is impractical today.  We're already seeing annual increases
    in embezzlement in the Seattle area from 10-50% over the last 10 years,
    getting similar to the rates around Los Angeles, for example.

 * Reducing trackability of money increases the severity and frequency
    of collusive crimes.  Large-scale political corruption, kickbacks
    and monopolies in the commercial sector, and a whole range of
    outright criminal blackmail become harder to prosecute.  With
    DBS you wouldn't be able to prove a damned thing.

 * The biggest single financial problem I have is mandatory levies
     (tax, utilities, monopolies) by the corrupt government. Your
     DBS will make this much worse by making it even easier to
     channel cash to politicians.

 * Fraud, embezzlement and corruption are in riotous equilibrium.  DBS
     reduces pressure on laundering, requiring other measures that hit
     my civil liberties somewhere else (physical IDs, cops, etc.)

 * Untraceable money *obviously* reduces tax collections.  What the IRS
     fails to collect from tax dodgers, eventually, I must pay more.

You seem to have a subconscious belief that DBS will shrink the government
sector.  This is a false assumption.  The government long ago achieved the
power to tax *as much as it wants*.  There is no natural immunity in our
culture or legal system.

The public sector has stabilized at 25% or 35% of the GNP, which is
apparently the maximum the animal can tolerate without falling over dead
(people striking, quitting work, and business moving overseas.)

Gimmicks like DBS will certainly not reduce the public sector in our
lifetimes. It will require an evolution in individual awareness and
behavior.

In mean time, managing the out-of-control government sector is your civic
duty, to your less intelligent wives, pensioners, and children and
neighbors. The preferred way to manage the governmt is the democratic
process, and public discourse and debate such as this list.

Breaking ranks and disobeying the law breeds further breakdown in
obedience of the whole legal framework.  There are lots of dumber and more
dangerous elements in the population.  The system is already *quite*
unfair to them.
Frankly, we need laws, a lot more than we need DBS.

Now, what is your solution to prevent the use of DBS in large-scale
financial fraud, political payoffs, etc.?   Or is that outside your
scope, and such problems should be solved by wiretaps, surveillance or
what?

Don't tell me these problems are minor or will just disappear! Do you
know how much money is already wasted on audits and law enforcement in
this country?  Auditing is already hideously expensive, and the only
solid facts in the entire audit process are the goddamn bank statements.

You need a coherent argument on this problem.  You need measures within
the DBS technology itself, to address the need.  Opponents of DBS will
raise all these demagogic arguments.  You'll be hooted off the podium.

I fear you'll end up damaging the reputation of legitimate forms of
peer-to-peer electronic payments, which are badly needed in the economy.

Todd Boyle CPA   Kirkland WA<EMAIL_ADDRESS>

{% endraw %}
```

## Thread

+ Return to [November 1998](/archive/1998/11)

+ Return to "["Black Unicorn" <unicorn@schloss.li>](/authors/black_unicorn_unicorn_at_schloss_li_)"
+ Return to "[Robert Hettinga <rah@shipwright.com>](/authors/robert_hettinga_rah_at_shipwright_com_)"
+ Return to "[scoops <scoops@quiknet.com>](/authors/scoops_scoops_at_quiknet_com_)"
+ Return to "["Todd Boyle" <tboyle@rosehill.net>](/authors/todd_boyle_tboyle_at_rosehill_net_)"

+ 1998-11-14 (Sat, 14 Nov 1998 14:34:24 +0800) - [DBS, Privacy, Money Laundering nonsense.](/archive/1998/11/ba54c3795459f7e7d35e523ff43f99ed103df18dc7be54817e74da895dce5ec0) - _Robert Hettinga<EMAIL_ADDRESS>  + 1998-11-14 (Sat, 14 Nov 1998 15:54:56 +0800) - [Re: DBS, Privacy, Money Laundering nonsense.](/archive/1998/11/8b9548277eab65802df02311f454818d80c5c7a8ecd10e8715ec0b191ab9fefa) - _scoops<EMAIL_ADDRESS>  + 1998-11-14 (Sat, 14 Nov 1998 22:41:07 +0800) - [Re: DBS, Privacy, Money Laundering nonsense.](/archive/1998/11/adf804a594bc0f0f5e339f8dfadb97297d38410bd226238d3288f865bc2e2989) - _Robert Hettinga<EMAIL_ADDRESS>    + 1998-11-14 (Sun, 15 Nov 1998 03:49:00 +0800) - RE: DBS, Privacy, Money Laundering nonsense. - _"Todd Boyle"<EMAIL_ADDRESS>      + 1998-11-14 (Sun, 15 Nov 1998 05:11:46 +0800) - [RE: DBS, Privacy, Money Laundering nonsense.](/archive/1998/11/baf5ac18581f6395c6f6e3bdca6f5a95d6052104be7ba50b978058f18d679c72) - _"Black Unicorn"<EMAIL_ADDRESS>


text:
# Analytics Dashboard

Custom dashboard using [Google Analytics Embed API](https://developers.google.com/analytics/devguides/reporting/embed/v1/) and javascript. Goal was to create a monthly report to compare current month metrics with previous month, for marketing and sales teams to view. Content is only viewable by email addresses specified in Google Analytics account.

API is called with provided GA script and index.html file, client ID is imported via client_id.js for authorization.

Step-by-step dashboard creation in index file comments.

### To-do:
1. Change time from seconds to minutes
2. Add headers before charts
3. Add more months for comparison
4. Git push to server

MIT license

license: MIT

repository: loreguerra/analytics-dashboard

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: loreguerra/analytics-dashboard


text:
---
layout: default
title: Prioritization
nav_order: 7
description: "Prioritized single-cell proteomics for high-throughput and multiplexed single-cell proteomics by mass-spectrometry using pSCoPE"
permalink: prioritization
nav_exclude: true
---

# Prioritized single-cell proteomics

Prioritized single-cell proteomics ([pSCoPE](https://scp.slavovlab.net/pSCoPE)) was developed by [Huffman et al, 2022][pSCoPE_Preprint]. pSCoPE allows ensures duty-cycle time for analyzing prioritized peptides across all single cells (thus increasing data consistency) while analyzing identifiable peptides at full duty-cycle, thus increasing proteome depth. These strategies increased the quantified data points for challenging peptides and the overall proteome coverage about 2-fold.

---

## Implementation
pSCoPE is implemented as a module of MaxQuant.Live, starting with [version 2.1](http://www.maxquant.live) and is compatible with all Orbitrap instruments. All additional code needed for pSCoPE and reproducing [Huffman et al., 2022][pSCoPE_Preprint] is available at [github.com/SlavovLab/pSCoPE](https://github.com/SlavovLab/pSCoPE).

<iframe width="560" height="315" src="https://www.youtube.com/embed/SP0x3gAALtg" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

[pSCoPE_Preprint]: https://www.biorxiv.org/content/10.1101/2<IP_ADDRESS>4655v1 "Prioritized Single Cell ProtEomics by Mass-Spectrometry"

gha_language: R


text:
# teams-go
[![CI status](https://github.com/NoteToScreen/teams-go/workflows/CI/badge.svg)](https://github.com/NoteToScreen/teams-go/actions)

A (very simple) Go library for posting messages to incoming webhooks in Microsoft Teams.

For details about card formatting, see the [MessageCard reference](https://docs.microsoft.com/en-us/outlook/actionable-messages/message-card-reference). (even though it's described as 'legacy', that is actually the only format that the webhooks support) Note that not everything on that page is currently supported.

## Example
```go
package main

import "github.com/NoteToScreen/teams-go/teams"

func main() {
	url := "<insert webhook URL here>"
	card := teams.Card{
		Summary:    "This is a test.",
		ThemeColor: "0000FF",
		Title:      "Test",
		Sections: []teams.Section{
			teams.Section{
				ActivityTitle: "Important section",
				Text:          "This is a description of the section.",
				Facts: []teams.Fact{
					teams.Fact{
						Name:  "Is this a section?",
						Value: "Yes",
					},
					teams.Fact{
						Name:  "Contains text",
						Value: "Also yes",
					},
				},
			},
		},
	}

	err := teams.PostToWebhook(url, card)
	if err != nil {
		panic(err)
	}
}
```

repository: NoteToScreen/teams-go

repo_name: NoteToScreen/teams-go


text:
# Zigbee 3.0: Poll Control Cluster

## Need of the Poll Control Cluster

### Problem

The primary issue is a combination of two mechanisms which cause problems for sleepy end devices receiving messages.

First is the duration of time that the parent device stores messages for their children. This is only 7.68 seconds before a message is lost. This means that a message going from a router to an end device through another router (for example A -> B -> C, where A and B are routers and C is a sleepy end device), the message is held in the parent of the end device (B in this case). And the end device must poll within 7.68 seconds of receiving the message or the message times out of the queue. Messages can be resent, but this small window means a SED must poll frequently to receive messages.

But as we know, many customers sleepy end devices are powered by batteries and want the longest life possible, years in many cases. In order to save battery life, SED manufacturers prefer to have their devices sleep as long as possible. This usually results in polling intervals much longer than 7.68 seconds. This means that unless a SED is very lucky in polling at the right time, it will many times miss messages.

As a result sleepy end devices may miss the messages sent from other devices due to lack of polling frequency and this means that any sort of management by the controller is extremely difficult.

### Solution

In order to overcome this problem, the Poll Control cluster is used to provide a mechanism for the management of a sleepy end device’s data poll rate. It can be used by a configuration device to make an end device more responsive for a short period of time, polling at a very high rate, also known as fast polling, so that the device can more reliably receive message and be managed by the controller.

## Poll Control Cluster

The Poll Control cluster is a cluster that is defined in the Zigbee Cluster Library Specification. It is similar as other ZCL clusters in that it operates as in a server-client model. There is a Poll Control client and Poll Control server.

Now the confusing parts are which roles are played by each device. We normally think of a server as the always on device and a client the one that checks in. However in the Poll Control cluster, usually the Gateway acts as client and the sleepy end device works as the server. This is the case because the generally the server checks in with the client, which then sends commands to operate the server.

In the Poll Control cluster, once the SED server checks in with the client (usually a router), the client manages the data polling rate of the sleepy end device using four different commands:

- 0x00 - Check-in Response (Mandatory): When a server checks in, the client uses this to respond if it wants to enter fast polling mode or not.

- 0x01 - Fast Poll Stop (Mandatory): This tells a server that the client is finished sending messages and it can return to it’s regular polling interval.

- 0x02 - Set Long Poll Interval (Optional): set the long interval by which the end device polls

- 0x03 - Set Short Poll Interval (Optional): set the short interval by which the end device polls

__The poll control cluster server__ defines one Check-in command and several polling interval attributes. Some of the attributes are mandatory, the others are optional.

- Command

    - 0x00 - Check-in (M)

- Attributes

    - 0x0000 - Check-inInterval (M)

    - 0x0001 – LongPollInterval (M)

    - 0x0002 – ShortPollInterval (M)

    - 0x0003 – FastPollTimeout (M)

    - 0x0004 - Check-inIntervalMin (O)

    - 0x0005 - LongPollIntervalMin (O)

    - 0x0006 - FastPollTimeOutMax (O)

You can refer to the ZCL specification for a more detailed explanation about these commands and attributes.

## Attribute Settings and Battery Life Considerations

The sleepy end device works as Poll Control server and can be managed by Poll Control client. In order to help conserve battery life sleepy end devices have two attributes which set bounds on the time they are allowed to be kept awake and more importantly, turn on their radios to check in.

- _Check-inIntervalMin_ - Provide minimum value for the Check-inInterval to protect against the Check-inInterval being set too low and draining the battery on the device

- _FastPollTimeOutMax_ - Provide maximum value for the FastPollTimeout to avoid it being set to too high a value resulting in an inadvertent power drain on the device

The default values chosen for this cluster are:

- _Check-in Interval_ = 1 hour = 0x3840 quarter seconds
- _Long Poll Interval_ = 5 seconds = 0x14 quarter seconds
- _Short Poll Interval_ = 0.5 second = 0x02 quarter seconds
- _Fast Poll Timeout_ = 10 seconds = 0x28 quarter seconds

It also requires that the _Check-in interval_ >= _Long Poll interval_ >= _Short Poll interval_

It should also be noted that Fast polling mode will operate so long as the client is sending data to the server/end device. So these values only come into play once fast polling data transfers are complete.

## How does the Poll Control cluster work

In some practical user cases we need to use the Poll Control cluster for sleepy end device. For example: the sleepy end device receives an OTA update from the OTA server or the billing information being downloaded from the meter.

So here we have a sleepy end device/Poll Control server and router on the network/Poll Control client. This client/router will want to send data to the SED at certain intervals.

![Figure 2](./resources/poll-control-02.png)

Normally when a SED wakes up, it polls its parent for data and then go back to sleep. But this is where the Poll Control cluster operations step in.

1. When the devices first come up, usually during device discovery, the Poll Control client __configure bindings__ on the device implementing the Poll Control server. This will initiate the server sending Check-in commands to client.

2. Server sends Check-in to client periodically and the Check-in interval is guaranteed
    __Note__: On a normal check in, the client will return FALSE and the SED returns to sleep.

3. Client responds Check-in Response with True if the client wants to configure server, responds with False if nothing need to configure

4. Server enters fast poll mode if the Check-in Response is True

5. Client can configure the server when the server is in the fast poll mode

6. Client can send Fast Poll Stop after the configuration

From all above we can see that the Poll Control cluster allows you to configure end devices in a way that maximizes their sleep time while allowing them to have intervals where they receive data from other nodes on the network easily and efficiently.

license: Zlib

gha_language: C

gha_license_id: NOASSERTION


text:
# Getting started

## Minimal configuration

Minimal running configuration would just to add following script with script reference tag to your web page:

```html
<script src="https://cdn.rawgit.com/vbilopav/vbjs/master/src/vbjs/dist/<version>/bundle/vbjs.js"></script>
```

Where source reference in this script tag is actually reference to CDN link of bundled and minified version of library hosted internally on GitHub. Altough this CDN works, and it has high availability it is still not real CDN since it is not as nearly as fast and it is good for examples only (until real CDN is available).

## Local installation

This library is hosted on [GitHub](https://github.com/vbilopav/vbjs) and distributed via [npm](https://www.npmjs.com/package/vbjs).

Therefor, for installation from GitHub simply download and clone source code from GitHub. Distribution directory ([dist](https://github.com/vbilopav/vbjs/tree/master/src/vbjs/dist)) is included.

You may use original source version in `dev` folder, minified in `min` folder or minified and bundled in `bundle` folder.

For installation from NPM system, assuming that NPM system has already been installed on system, simply run:
```
npm install -g vbjs
```

That will install library globally, which is fine, but we actually recommend local installation:
```
npm install --save-dev vbjs
```

Note that you have to have already NPM initialized in directory and `package.json` created.

And after that, all you'l just have to include appropriate `script` tag into your start page, usually `index.html` that has reference to the library as described:

```html
<script src="/libs/vbjs/dist/<version>/bundle/vbjs.js"></script>
```

## Additional configuration attributes

Script tag can have additional and optional data attributes that can further configure your application:

- `data-dev` - Simple boolean flag value that can be accessed from global application object, just to flag is system in development state or not, default value is `true`.

- `data-version` - Simple string determines current scripts version. This value is automatically adds query string `v=<version-value>` to every script within system (even css if `data-css-files` attribute is used). Default value is none, no version query string is added.

- `data-app-url` - Default application url. Every module path is relative to this url. Default is your web root at `/`.

- `data-app-module` - Module ID for application entry point. Default value is system module `sys/single-view-app` that initializes single view app (not single-page app) by using module view id from following attribute `data-view-module`. App module can only be JavaScript code file, it cannot be template since it is code entry point to application. Also, script that loads this module will except it to be function which will be called automatically with only one parameter - container element id. This is useful if you want to have custom application entry point, rather then default one. For example [this demo](https://github.com/vbilopav/vbjs/blob/master/demos/github-user1/app.js).

- `data-view-module` - Module View ID that will be rendered by deafault by `sys/single-view-app` on initialization.

- `data-app-container-id` - Application container element ID. Passed as only function parameter for every custom entry point module. Not needed when using document template (`document!id` type view module) and default `sys/single-view-app`. In that case parent element with id from `document!id` is used or parent element from last `template` tag if view module not present. Otherwise `app` is default value.

- `data-app-object-name` - Name of default application root object. Default is `_app`.

- `data-settings` - Custom application setting. Accepts only JavaScript object creation syntax. Default values is empty object `{}`

- `data-css-files` - List of css files that will be loaded on startup. This is optional behavior and it will be used by bundler build tool.

- `data-loader-url` - URL for default AMD module loader library. Default is CDN version of requirejs - `https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.5/require.min.js`

- `data-libs-url` - Default libraries URL. System will use this URL to try to load loader library on fallout if primary module loader library fails.

Additionally I recommend to using `type="module"` in your script tag. This will ensure that library won't be loaded by older browsers like Internet Explorer or not-updated modern browsers.

Typical example would be:

```html
<script type="module" data-view-module="template!my-view-template.html" src="../node_modules/vbjs/dist/1.3.5/bundle/vbjs.js"></script>
```

## About view types and view modules

There are few module type already mentioned so far:

- **document** - Document templates have module id in this format `document!id` where id is element from within document (usually template element but not necessary) id that contains your template (which is basically just html that can contain standard JavaScript template string syntax).

- **template** - Template view is html file that is your template and uses standard JavaScript template string syntax. It has following format `template!your-view-in-html-file.html`. Your view in html file would have path relative to application path configured in script tag as described above.

- **text** - Is plain text module, simple static file with templating capability.  `text!your-file.html`

- **module** - JavaScript code module. Module ID uses standard JavaScript module syntax. It is JavaScript file without extension with path relative to application path configured in script tag as described above. View module in JS file would be usually something that is instantiable (like class or function) and that, at least have one render method that returns either a string with html, promise for a string with html, html element, promise for html element, function that returns one of two things (string or html element) or two element array. It all depends on application needs and complexity. Check out demos or rest of documentation for more info.

repository: vbilopav/vbjs

repo_name: vbilopav/vbjs


text:
# Spring Demo Application

Simple experiment keeping Spring at the perimeter of an Java app.

## Common Commands

Run the application tests.

``` bash
mvn clean test
```

Run OWASP dependency check.

``` bash
mvn org.owasp:dependency-check-maven:check
```

Package the application for distribution.

``` bash
mvn clean package
```

Run the packaged application.

``` bash
java -jar src/api/target/spring-demo-api-0.0.1-SNAPSHOT.jar
```

Start database and application.

``` bash
foreman start -f Procfile.development
```

## Setup

### Environment

``` bash
gem install foreman
```

### Postgresql

``` bash
brew install postgresql
```

``` bash
pg_ctl init -D vendor/postgresql
```

``` bash
psql -p 5432 -h localhost -d postgres
```

Create project user and database.

``` sql
CREATE USER springdemo;
CREATE DATABASE spring_demo OWNER springdemo;
```

Connect to the project database.

``` bash
psql --dbname=spring_demo
```

## Built With

* [Java SE 9.0.1](http://www.oracle.com/technetwork/java/javase/overview/index.html)
* [Spring Boot 1.5.2](https://projects.spring.io/spring-boot/)
* [PostgreSQL](https://www.postgresql.org)
* [Foreman](https://github.com/ddollar/foreman)
* [OWASP Dependency-Check](https://www.owasp.org/index.php/OWASP_Dependency_Check)

## License

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

repository: deangerber/java-spring-demo

repo_name: deangerber/java-spring-demo


text:
# Test Automation

## Theory

In class discussion driven by a deck

### Unit Tests
  - Why are they important
    - Open Source APIs
    - Refactoring
  - Do we really need them?
  - How are they structured
    - Setup
    - Run
    - Validate
  - Jest
  - .Net
    - Introduce my .Net Stack
  - Java

### End to End Tests

  - Why they are important
  - What do you need to run them

### Tech Options
  - Cypress.io
  - Selenium
  - Web Driver
  - Appium
  - Cucumber

### A11y Testing Tools
  - aXe-Core
  - Lighthouse
  - WebAim

## Hands-on

  1. Write a unit test for our code
  0. Write an end to end test for our code
  0. Insert Unit test into Dockerfile build
  0. Insert integration tests into build pipeline

repository: CalvinRodo/danotes

repo_name: CalvinRodo/danotes


text:
[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)

# React Redux Sagas Boilerplate

## Installation

```
npm install
```

## Build

Run the following command which will compile all the necessary files in a `/dist` folder.

```
npm run build
```

## Development

Start dev server:

```
npm run dev-server
```

Open a browser and visit `http://localhost:3000`

## Run end-to-end tests

Build the application first:

```
npm run build
```

Start selenium server:

```
npm run selenium-server
```

Start application server:

```
npm run pro-server
```

Execute tests:
```
npm run test-acceptance
```

## Code style

This project is using the [standard](http://standardjs.com/) rules:

```
npm run lint
```

[![js-standard-style](https://cdn.rawgit.com/feross/standard/master/badge.svg)](https://github.com/feross/standard)

repository: ToniChaz/react-redux-sagas-boilerplate

repo_name: ToniChaz/react-redux-sagas-boilerplate


text:
# ABRF 2020 Meeting

# Github: a powerful resource for scientific communications

## talk presented by Phillip Wilmarth, OHSU

---

### ABRF 2020: Empowering Team Science
February 29 - March 3

Palm Springs, California

#### Proteomics Data Science: Online Data resources
Monday, March 2, 3:30pm - 5:00 pm

[ABRF website](https://abrf.org/)

---

_slide 1_

![slide 1](images/Slide1.png)

I would like to thank the organizers for this opportunity to tell you about using Github for scientific communication. Github is not a proteomics resource like UniProt. Github is something that you can use to create **your own online resources**.

---

_slide 2_

![slide 2](images/Slide2.png)

The center piece of scientific communication is the publication. They used to be printed on paper.

---

_slide 3_

![slide 3](images/Slide3.png)

Now everything is electronic. Here is a 2017 MCP paper where the IRS normalization method for multi-plex TMT experiments was first described. We have the article in there somewhere, but there is a lot screen real estate devoted to other things.

Link to MCP article: [Plubell, et al.](https://www.mcponline.org/content/16/5/873.short)

---

_slide 4_

![slide 4](images/Slide4.png)

A scientific publication now consists of many parts. We have the main article. We can skip to the figures or tables. There are links to supplemental files. We have extra methods, figures, and data tables for this paper. There are metrics like social media activity, views, and downloads. We also have associated data in archives and repositories. Is there a better way to integrate all this information?

---

_slide 5_

![slide 5](images/Slide5.png)

This Atlantic article from a couple of years ago claims that the scientific paper is obsolete. The article was about how notebooks could replace scientific papers.

Link to [Atlantic article](https://www.theatlantic.com/science/archive/2018/04/the-scientific-paper-is-obsolete/556676/)

---

_slide 6_

![slide 6](images/Slide6.png)

The Atlantic article talked about Mathematica notebooks and open source Jupyter notebooks. These notebooks are web server applications with some connection to a local programming environment. You create and interact with notebooks through web browsers. You can think of notebooks as data analysis stories told through a linear series of cells. These cells can be rich text formatting (like a web page), executable code cells (typically Python or R), and the output (graphics and text) from the code cells. I mostly use Jupyter notebooks, but R Markdown is similar. Notebooks are ideal for telling data analysis stories.

[Jupyter notebooks](https://jupyter.org/)

[R Markdown](https://rmarkdown.rstudio.com/)

A talk I gave about notebooks at [Cascadia in 2018](https://github.com/pwilmart/Cascadia_2018)

---

_slide 7_

![slide 7](images/Slide7.png)

I think that life science research is too complex to replace with notebooks. However, the computational steps in research projects are hard to describe with just text.  Computational steps are only part of the story for most life science research, so notebooks should augment papers instead of replace them (add notebooks to the supplemental files).  Github has grown rapidly and is enormous. Github has strong support for Jupyter notebooks and hosts about 6.4 million notebooks currently. Github has a lot of additional functionality: it facilitates collaborative work on software (and other) projects, it acts like a syncing service to protect your files, and it supports web content creation and hosting.

[Wikipedia entry for Github](https://en.wikipedia.org/wiki/GitHub)

---

_slide 9_

![slide 9](images/Slide9.png)

When you are trying to learn about Git and Github, it helps to have a mental picture of how the pieces connect. Github itself is a collection of repositories that reside in the cloud. Copies of those repositories are mirrored on your local computers. That is the distributed part. For example, I go to OHSU and work on some code. I work on a local copy of the files in a Git repository. I save my work by committing the changes. I can push those changes to the corresponding Github repo, cycle home, pull the updated code to my home PC, and continue my work. Lather, rinse, and repeat (or maybe pull, commit, and push). Other users may just be fetching code from the repo to run on their PCs.

An outstanding book: [Happy Git with R](https://happygitwithr.com/)

[Git downloads](https://git-scm.com/downloads)

[Free Git book](https://git-scm.com/book/en/v2)

[main Github site](https://github.com/)

[Github help](https://help.github.com/en/github)

---

_slide 10_

![slide 10](images/Slide10.png)

Git and Github are complicated topics that take some serious time and effort to learn. There are good reasons to make the time investment. Journal articles and data archives are not under your control and will get out of date. The content may also be behind paywalls and limit access. What if you had a protocol described in a previously published paper that has changed? How does the community find the updated protocol? The scientific paper is only part of the professional communication we need to do daily. The version control and sharing features of Github are great for lab protocols, tutorials, and meeting presentations. If you write scripts to do routine tasks, you can share them with the proteomics community. Data analysis skills are valuable, and the content you have at Github showcases your skills.

> A way to get around the locked down content at journals and data archives would be to create a Github repository that corresponds to the publication and its associated data archive. You can put the repo URL in the paper text (Methods or Acknowledgements) as a "for updated information about methods and protocols used in this paper see: _Github URL_". That URL could be added to the archive metadata. Maybe use first author and year as the repo name (something unique to the paper but not using the journal name). If you have to resubmit to a different journal, you may not be able to alter the data archive meta data. It might make sense for the first author (or last author) to have a Github account for this. Then you have a mechanism for corrections, addition of overlooked content (like sample keys for TMT experiments), and updated/improved protocols.

This repo shows you how to [turn meeting content into Github content](https://github.com/pwilmart/talk_to_repo_example)

---

_slide 11_

![slide 11](images/Slide11.png)

This is my Github site. There is profile information on the left. You can pin up to 6 repositories to the landing page. I have a couple of repos about IRS data normalization, one for tandem mass tag (TMT) data analysis examples, my proteomics pipeline software, some utilities for managing FASTA protein databases, and even this talk. Each Github account can also have a dedicated website.

https://github.com/pwilmart

---

_slide 12_

![slide 12](images/Slide12.png)

Flexible web hosting and content creation is one of the best features of Github. I mostly use my main Github website for some blogging on proteomics topics. Each individual repository can also have an associated web page. The repo web pages are often used for documentation and tutorials. Each repository can also have a README file, written in Github markdown, that gets automatically rendered as web content.

https://pwilmart.github.io/

More about [Github pages](https://pages.github.com/)

A new tool for easy blogging: [fast pages](https://fastpages.fast.ai/fastpages/jupyter/2020/02/21/introducing-fastpages.html)

---

_slide 13_

![slide 13](images/Slide13.png)

One of the things you can do at Github is demonstrate data analysis topics using publicly available data. Real world examples are a powerful way to reach your audience. I have an interest in how to analyze data from less common organisms. I saw a presentation from Ben Neely about proteomics on marine mammals at last year’s ASMS meeting. Their group published a paper about California sea lion urine samples to probe kidney disease. When that paper was published, a sea lion genome was not available. They used a combined seal and walrus protein database. The sea lion genome has since been sequenced and I was curious how the results would change if a sea lion protein database was used. I repeated the analysis with the sea lion database and my open source pipeline that uses MSConvert for RAW file access and Comet for database searching.

JPR article: [Neely, et al.](https://pubs.acs.org/doi/abs/10.1021/acs.jproteome.8b00416)
The [ASMS presentation](https://zenodo.org/record/3687161)

---

_slide 14_

![slide 14](images/Slide14.png)

This is the repository for the re-analysis. The URL is at the top. On the left, we have the start of the repository with a description, some tags, and the list of files. Github is designed to be a code repository, so we see the files first with some versioning information. If we scroll to the bottom of the files (on the right), we see the README markdown file displayed as rich web content. We have headers, text, a hyperlink to the data archive, and a list.

https://github.com/pwilmart/Sea_lion_urine_SpC

---

_slide 15_

![slide 15](images/Slide15.png)

This is what the contents of the README.md file looks like. Markdown is more concise and readable than HTML source code. It is a little faster and easier to create web content with markdown. Markdown supports many basic web site features: headers, formatted text, hyperlinks, images, list, tables, etc.

The [Atom editor](https://atom.io/) is my favorite for working on README.md files. \<Shift>\<Control>\<M> will show you a markdown preview pane. Super helpful.

Help page for [Github markdown](https://guides.github.com/features/mastering-markdown/)

See Adam Prichard's [cheatsheet](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet)

---

_slide 16_

![slide 16](images/Slide16.png)

The README file covers the sea lion analysis steps with my pipeline. It uses the target/decoy method in an interactive and visual way to control PSM FDR. High resolution, accurate mass data is not searched by specifying a narrow parent ion tolerance. Instead, a wider tolerance search is done, and delta masses of the matches are displayed (on the left for 2+ peptides). We set windows on the delta mass peaks and then generate the corresponding conditional score distributions. On the right, we have the score distributions for the 2+ peptides in the zero-Da window. The decoy scores are in red and the target scores are in blue. The left histograms are semi-tryptic peptides and the right are fully tryptic peptides. The dotted lines are 1% FDR cutoffs.

[PAW pipeline](https://github.com/pwilmart/PAW_pipeline)

[FASTA utilities](https://github.com/pwilmart/fasta_utilities)

---

_slide 17_

![slide 17](images/Slide17.png)

The README has many more histograms, lots of descriptions, and summary statistics. There were 19 samples with a total of 1.26 million MS2 spectra. About 250 thousand PSMs passed the 1% FDR thresholds. There were 81% fully tryptic versus 19% semi-tryptic peptides. All biofluids (serum, saliva, CSF, and urine) will have a lot of semi-tryptic peptides. The semi-tryptic peptides were a little more abundant than oxidation. I made a similar walrus and seal database like what was used in the publication and did an analysis using that database. The number of identified PSMs dropped to 142 thousand. Using a sea lion database increased the identifications by 75%.

---

_slide 18_

![slide 18](images/Slide18.png)

The study had 8 sea lions without any kidney disease and 11 sea lions with kidney disease from leptospirosis infection. The paper used label free spectral counting to compare the two groups, so I repeated the differential expression testing. Any quantitative study should check the data before doing the statistical analysis. How did the data from each sample turn out? Do they all look okay or are some of them possible outliers to be excluded? We can always identify more things than we can quantify. The bar is higher for quantification. How do we determine a cutoff for quantification? After checking the data, we can do the statistical testing and visualize the results. We can do all of this with notebooks.

---

_slide 19_

![slide 19](images/Slide19.png)

The repo has a separate Jupyter R notebook to do some basic quality control processing. The control samples are in blue. The infected samples are in red. The boxplots of the spectral count distributions have 3 infected samples with low count distributions. If we drop those, we still have an 8 by 8 comparison. We can also do some clustering analysis. The plot on the right is a multi-dimensional scaling (MDS) plot. The two groups are well separated. There are many other R clustering package options that could also be used.

[QC notebook](https://pwilmart.github.io/TMT_analysis_examples/PXD009019_QC_check.html)

---

_slide 20_

![slide 20](images/Slide20.png)

Each biological sample was analyzed in a single LC run. We had close to 2,300 identified proteins. How many of those can we quantify? If we compute the average spectral count per protein for the samples, we can sort our count table by decreasing average counts. We can count the cells with missing data in the table as a fraction all the cells as a function of the average SpC. We can plot the average SpC on the x-axis and the fraction of missing data on the y-axis using another notebook. When we get to small average SpC, we see a sharp rise in missing data. The dotted line is an average SpC of 2.5. That has 669 quantifiable proteins. While this is only 30% of the identified proteins, those 669 proteins account for almost 90% of the total spectral counts observed in the experiment. Using a cutoff like this eliminates most of the missing data and its complications.

[Quantifiable cutoff notebook](https://pwilmart.github.io/TMT_analysis_examples/PXD009019_average_missing.html)

---

_slide 21_

![slide 21](images/Slide21.png)

We used the Bioconductor package edgeR to do the statistical testing in an R notebook. Here are just a couple of the many visualizations. We have a scatter plot on the left with differential candidates colored by some significance cuts. We are using Benjamini-Hochberg corrected p-values for significance. We can also make MA plots (commonly used in genomics) where we have separate MA plots for each DE candidate category. The unchanged proteins in purple have mostly less than 2-fold changes (the dotted lines). The highly significant orange proteins with FDR less than 0.01 have much larger than 2-fold changes.

[Differential expression notebook](https://pwilmart.github.io/TMT_analysis_examples/PXD009019_SpC_DE.html)

[edgeR users guide](https://www.bioconductor.org/packages/release/bioc/vignettes/edgeR/inst/doc/edgeRUsersGuide.pdf)

---

_slide 22_

![slide 22](images/Slide22.png)

The sea lion database made a big improvement. We identified close to 2,300 urine proteins. We had 410 differential expression candidates. What do we do with the results? We need some information about the proteins (functions and pathways). We only really have usable annotations for human and mouse among higher eukaryotes. We need to map the sea lion proteins to human orthologs and annotate the sea lion proteins with the corresponding human ortholog annotations.

---

_slide 23_

![slide 23](images/Slide23.png)

Mapping protein lists from less common species to human or mouse is something I end up doing all the time. It is a little complicated and is a perfect topic for a blog post. We are basically going to use a locally installed BLAST program to align all sea lion sequences against the human Swiss-Prot database and find the best matches. We will map the human annotation information (genes, keywords, GO terms, and pathways) to the sea lion proteins. There are a lot of steps we have to do a couple of thousand times, so it is safer to let the computer do the busywork.

[Orthologs blog post](https://pwilmart.github.io/blog/2019/10/14/orthologs-annotations)

---

_slide 24_

![slide 24](images/Slide24.png)

I have two repositories with scripts for doing this. One does the BLAST run and makes a summary table. The other gets the human annotation information and maps it to the sea lion orthologs. We start with a proteomics results table from my pipeline and add statistical testing results to the table. Then we add ortholog and annotation columns to the table. At the end, we have a more complete report to send to clients and publish.

[PAW Blast](https://github.com/pwilmart/PAW_BLAST)

[Annotations](https://github.com/pwilmart/annotations)

---

_slide 25_

![slide 25](images/Slide25.png)

Github is a powerful communication resource we can use. We saw how to use a repository to illustrate data analysis concepts on public data. We used Jupyter notebooks to help tell our story. We needed some custom scripts in the analysis that we have available at Github. The site webpage and blog were used in the story telling, as well as Github markdown in the README files. All of this is easy to share with the proteomics community thanks to Github URLs.

---

_slide 26_

![slide 26](images/Slide26.png)

Thank you for your time and I will take any questions.

---


text:
## Description

Seventeen Track Card is customizable card for the Home Assistant Lovelace front-end. It allows you to show what packages are currently in transit.

## Options

| Name | Type | Requirement | Description
| ---- | ---- | ------- | -----------
| type | string | **Required** | `custom:seventeen-track-card`
| entity | string | **Required** | The entity_id of the entity you want to show (for example, `sensor.seventeentrack_packages_in_transit`).
| title | string | **Optional** | Add a custom title to the card.

## Example

![](https://github.com/ping-localhost/seventeen-track-card/blob/master/example.png?raw=true)

repository: ping-localhost/seventeen-track-card

gha_language: JavaScript

repo_name: ping-localhost/seventeen-track-card


text:
# [Personal Portfolio](http://bhavish.me/)

Based off of [Grayscale](http://startbootstrap.com/template-overviews/grayscale/), a multipurpose, one page HTML theme for [Bootstrap](http://getbootstrap.com/) created by [Start Bootstrap](http://startbootstrap.com/).

## Changes from Grayscale

* Deleted map section
* Changed all text
* Added another js and css file

## Original Copyright/License
Copyright 2013-2015 Iron Summit Media Strategies, LLC. Code released under the [Apache 2.0](https://github.com/IronSummitMedia/startbootstrap-grayscale/blob/gh-pages/LICENSE) license.


text:
# Dynamic objects detection in LiDAR

[![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://github.com/Dtananaev/lidar_dynamic_objects_detection/blob/master/LICENSE.md)

The result of network (click on the image below)
[![result](https://github.com/Dtananaev/lidar_dynamic_objects_detection/blob/master/pictures/result.png)](https://youtu.be/f_HZg9Cq-h4)
The network weights could be loaded [weight](https://drive.google.com/file/d/1m8N5m2WXATgFNw88BRqEbUieiyV7p3S0/view?usp=sharing).


text:
# Tactical Board

Tactical boards on your devices. Make tactical communication convenient.

## Badminton tactical board

[Open the board Now!](https://tacticalboard.github.io/shuttle)

![](src/assets/screenshot/shuttle.jpg)

## Football tactical board

[Open the board Now!](https://tacticalboard.github.io/football)

![](src/assets/screenshot/football.jpg)

## Basketball tactical board

[Open the board Now!](https://tacticalboard.github.io/basketball)

![](src/assets/screenshot/basketball.jpg)

## Packages used

- [Vue.js](https://v3.vuejs.org/)
- [TailwindCSS](https://tailwindcss.com/)
- [interact.js](https://interactjs.io/)
- [screenfull.js](https://github.com/sindresorhus/screenfull.js/)

## License

MIT License


text:
# DbConnectorCommand.Connector property

The connector of the command.

```csharp
public DbConnector Connector { get; }
```

## See Also

* class [DbConnector](../DbConnector.md)
* struct [DbConnectorCommand](../DbConnectorCommand.md)
* namespace [Faithlife.Data](../../Faithlife.Data.md)

<!-- DO NOT EDIT: generated by xmldocmd for Faithlife.Data.dll -->

repository: ejball/FaithlifeData

gha_language: C#

gha_license_id: MIT

repo_name: ejball/FaithlifeData


text:
# diffbuff

Differenciable protocol buffers, the first attempt at implementation.

## Status

This project has turned out to be far much more difficult than I estimated. There
is a partial implementation of the X-Diff -algorithm in the diffbuff/treediff.py
module. Other than that, this goes into the abandoned bin.

## Implementation schedule

The implementation falls across the ladder:

 * Not implemented
 * Testing required
 * Alpha

When all subsystems reach this point, the milestone Alpha is reached. After
this point an incubation period is started, which will take 2-6 months. This is
the time reserved for writing and revising the specification. It is required so
that we hopefully avoid the "diffbuff2" or "diffbuff3".

### Testing required

 * Wire format

### Yet to be implemented

 * Diff on buffers
 * Pretty printing without a schema
 * Schema on schemas
 * Schema on edit scripts
 * Schema language and a compiler
 * Pretty printing with a schema
 * Python API on working with diffbuffs
 * Diffbuff-to-C compiler

### Rationale on the implementation order

The priority is on the defining qualities of the format. Without its defining
qualities there would be nothing that differenciates diffbuff from protobuf.

## Type support list

 1. Bit vectors
 1. Enumeration values, Messages, Union types, false, null, true
 1. IEEE 754-2008 floating point values, (base 2, base 10), extendable precision
 1. Lists, Maps, Sets
 1. Packed flat records
 1. Packed messages of uniform type
 1. Unicode strings
 1. Variable size signed and unsigned numbers
 1. Vectors, Matrices, Tensors
 1. Sparse matrices

The support is defined in tiers, and modules, so that people implementing the
features can report the tier and the modules they support. The exact grouping
is to be decided.

repository: cheery/diffbuff

repo_name: cheery/diffbuff


text:
---
templateKey: blog-post-video
slug: /install-unity-device-simulator
author: Peter Witham
tags: ["Videos", "Tutorials", "Unity", "Game Development"]
title: How to install and use the Device Simulator in Unity.
date: 2020-08-10T01:49:37
blurb: Unity is great for mobile game development, but setting up the game window can be annoying. Now we have the device simulator!
---

<iframe width="560" height="315" src="https://www.youtube.com/embed/Cwp2C5A8L8M" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

Setting up the game window in Unity for mobile device development can be annoying at times. Finding the right size or ratio for each device you want to check. Well, no more!

Say hello to the Device Simulator. You can just pick a tablet or phone from the menu and see exactly how it looks, removing the guesswork.

repository: GrfxGuru/gatsby-starter-netlify-cms

repo_name: GrfxGuru/gatsby-starter-netlify-cms


text:
# _Programming Language Suggester_

#### _A website to narrow down which programming language might be a good choice for you to learn_

#### _By Erika Debelis_

## Description

_a demostration site utilizing HTML, CSS, Javascript, and Markdown. specific focus on branching and radio buttons in JQuery_

## Technologies Used:

* _HTML_
* _CSS_
* _JS_
* _Markdown_
* _GitBash_

## Setup/Installation Instructions:

_https://erikadebelis.github.io/programming-language-suggester/_

* _Clone this repository to your desktop_
* _Navigate to the top of the directory_
* _Open portfolio/index.html in your web browser_
* _Click through questions and submit to find your language suggestion_

## Bugs

_only a few combinations of answers for each question currently offer a language suggestion result after submitting but project instructions stated we are not required to take every possible combination of answers into account_

## License

_MIT_

_Copyright (c) 2021 Erika Debelis_

_if any issues are discovered while navigating my site please let me know! It will help me learn and grow!_

## Contact Information

_Erika Debelis erika.debelis@gmail.com_

branch_name: refs/heads/main


text:
# Mathsteps Demo

This is the source for mathsteps demo, powered by React.

Feel free to suggest changes or add new content.

## Setup

```
$ git clone https://github.com/socraticorg/mathsteps-demo
$ cd mathsteps-demo
$ npm install
```

## Start development server

```
$ npm run start
```

> Note - The demo is bootstrapped using [`create-react-app`](https://github.com/facebookincubator/create-react-app).

## Build

```
$ npm run build
```

## Deploying

For publishing the changes and deploying, you will need [surge](https://surge.sh/).

```
$ npm install -g surge
```

After running `npm run build`, we will need to deploy the demo.

```
$ surge
```

This will show a prompt asking for the build directory path.

![demo](https://i.gyazo.com/b24ae9a9070d7c9eb635d6aa62317879.gif)

For domain name, use `mathsteps.surge.sh` only 😅

Traversing the codebase should be quite easy. All the components live under [`components`](./src/components) directory.

repository: kanikakalia/mathsets

repo_name: kanikakalia/mathsets


text:
# useful-meeting-reminder

Ics based meeting reminder allowing storing notes & ideas by replying to the email reminder.

## concept

The idea is to store a meeting plan associated with an event.
To be able to update this meeting plan by replying by mail to event reminders
The remind rule is called "halfway rule" : remind if event is new OR if time since last update is higher than time to event.

## overall command

### update meetings

* parse local ICS file
* keep event not older than 90 days and not farther in the furture than 90 days
* update local storage
* remove old events in storage, and notify by mail of the removal

### send reminders

* read local storage
* use the halfway rule to remind meeting

### process mails

* read dedicated inbox
* parse message
* if appending to the meeting plan is possible, do it
* if no appending and updating the meeting plan is possible, do it
* send back the results

repository: pzia/useful-meeting-reminder

repo_name: pzia/useful-meeting-reminder


text:
## todo

* Better game camera (mix of map/game camera)
* Remove shader graph
* Polygons
* Strip line with custom width
* Per segment line width
* line joins
* Hit test
* Text.
* Tree-shake friendly
* Unit tests.
* Render to canvas
* Export to SVG (done for wires. left line strip and points)
* ~~Thick lines~~
* ~~Game camera~~
* ~~Point cloud refactor (optimize colors)~~

## Ideas
* Game camera should be a mix of map camera and game camera. E.g. panzoom should work in that mode too.
* Use inertia/friction for the camera - makes it feel more natural?

repository: qiyuefun/w-gl

repo_name: qiyuefun/w-gl


text:
# Service Bus Firewall Virtual Network Rule

Adds a Virtual Network rule to an existing Service Bus Namespace.  Optionally can add IP rules.

## Parameters

servicebusName (required) string

The name of the Service Bus Namespace to ad the VNet rule to.

subnetNames (required) array

An array of Subnet names to add to the VNet rule.  All the subnets must be part of the same VNet.

vnetName (required) string

Name of the VNet that contains the subnets.

vnetResourceGroup (required) string

Name of the Vnet's resource group.

ipRules (optional) array

An array of IP Addresses, these can be added seperately using the servicebus-ipfilters-resources template (which needs to be relocated from the dss-infrastructure repo)

repository: SkillsFundingAgency/dfc-devops

gha_language: PowerShell

repo_name: SkillsFundingAgency/dfc-devops


text:
# Changelog

All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [0.7.0] - 2020-01-08

### Fixed
- Docuum now wakes up when an image is imported or loaded, not just when an image is built or pulled.

## [0.6.0] - 2020-01-08

### Fixed
- Docuum now wakes up when an image is pulled, not just when an image is built.

## [0.5.0] - 2020-01-07

### Fixed
- Fixed some incorrect error messages and log lines.
- Optimized the number of disk writes.

## [0.4.0] - 2020-01-07

### Added
- Added timestamps to the log format.

### Changed
- Renamed the `-c` ("capacity") option to `-t` ("threshold") as a follow-up from the change introduced in v0.3.0.
- Docuum now automatically restarts itself when an error occurs.

### Fixed
- Docuum now cleans up the `docker events` child process when an error occurs.

## [0.3.0] - 2020-01-06

### Changed
- Renamed the `--capacity` option to `--threshold`.

## [0.2.0] - 2020-01-06

### Added
- Initial release.

repository: mdheller/docuum

repo_name: mdheller/docuum


text:
# `@ResponseStatus` Decorator
By using the `@ResponseStatus` decorator, it is possible to specify a response status at a controller level, this means, it will be applied to all your endpoints inside your controller.

----

## Syntax
```typescript
@ResponseStatus(httpCode: Mandarine.MandarineMVC.HttpStatusCode)
```
> The `@ResponseStatus` decorator must always be located at a class level, otherwise it will have no effect

## API

```typescript
import { Mandarine, Controller, ResponseStatus } from<EMAIL_ADDRESS>
@Controller()
@ResponseStatus(Mandarine.MandarineMVC.HttpStatusCode.OK)
export class MyController {
}
```


text:
# VMC
This repository contains all the codes used to generate the plots used in the porject report on the topic Variational Monte Carlo. I have also included the simulation results as a `.csv` file in the folder `data`.

# Run the code online on Binder.

In order to run the codes online, paste these links in https://pluto-on-binder.glitch.me/ and click on the link that the website generates.

Harmonic Oscillator: https://github.com/Ved-Mahajan/VMC/blob/master/harmonic_oscillator.jl

Hydrogen Atom: https://github.com/Ved-Mahajan/VMC/blob/master/hydrogen_atom.jl

Particle in a box: https://github.com/Ved-Mahajan/VMC/blob/master/particle_in_a_box.jl

Heilium Atom: https://github.com/Ved-Mahajan/VMC/blob/master/helium_atom.jl

It will take some time to start and run for the fist time as it has to download the package `Plots.jl`, so please be patient 😄

PS: There is a file included for particle in a box which is not included in the report as it needs some more working.

repository: Ved-Mahajan/VMC

repo_name: Ved-Mahajan/VMC


text:
regions-topojson
================

Example with french regions : https://github.com/laem/regions-topojson/blob/master/france/lala.json

Follow these steps to get them for other countries :

create a file named my-country.xml.

Just change FR for DE to get german regions for example, and check http://wiki.openstreetmap.org/wiki/Tag:boundary%3Dadministrative to get the 'admin_level' that you need.

```
<osm-script timeout="1000">
  <!-- gather results -->

  <id-query into="searchArea" ref="3600365331" type="area"/>
  <union>
    <query type="relation">
      <has-kv k="admin_level" modv="" v="8"/>
      <area-query from="searchArea" ref=""/>
    </query>
  </union>

  <!-- print results -->
  <print mode="body"/>
  <recurse type="down"/>
  <print mode="skeleton" order="quadtile"/>
</osm-script>
```

then run this command...
```
wget http://www.overpass-api.de/api/interpreter --post-file=my-country.xml -O country.osm
```

after waiting few minutes (depending on size), you will get one file from the API, proceed by installing:

```
npm install osmtogeojson
osmtogeojson my.osm > MYREGIONS.geojson
```
You can stop here and use geojson, but files will be huge. Simplify them with topojson :

```
npm install -g topojson
topojson -o lala.json MYREGIONS.geojson -q 10000 --simplify-proportion 0.02 -p
```

Developed for [qunb.com](https://www.qunb.com)

repository: osmItalia/regions-topojson

repo_name: osmItalia/regions-topojson


text:
# Merge Sort

A divide and conquer sorting alogorithm. It recursively divides the data into halves until the count is one and then merges the halves until the data is back in one sorted piece.

## Pseudocode

```
ALGORITHM Mergesort(arr)
    DECLARE n <-- arr.length

    if n > 1
      DECLARE mid <-- n/2
      DECLARE left <-- arr[0...mid]
      DECLARE right <-- arr[mid...n]
      // sort the left side
      Mergesort(left)
      // sort the right side
      Mergesort(right)
      // merge the sorted left and right sides together
      Merge(left, right, arr)

ALGORITHM Merge(left, right, arr)
    DECLARE i <-- 0
    DECLARE j <-- 0
    DECLARE k <-- 0

    while i < left.length && j < right.length
        if left[i] <= right[j]
            arr[k] <-- left[i]
            i <-- i + 1
        else
            arr[k] <-- right[j]
            j <-- j + 1

        k <-- k + 1

    if i = left.length
       set remaining entries in arr to remaining values in right
    else
       set remaining entries in arr to remaining values in left
```

## Trace

[8,4,23,42,16,15]

![](./assets/merge.jpg)

## Efficency

O( n log n ) in both time and space, I believe


text:
### [CVE-2019-3999](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-3999)
![](https://img.shields.io/static/v1?label=Product&message=Druva%20inSync%20Windows%20Client&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=Unauthenticated%20OS%20Command%20Injection&color=brighgreen)

### Description

Improper neutralization of special elements used in an OS command in Druva inSync Windows Client 6.5.0 allows a local, unauthenticated attacker to execute arbitrary operating system commands with SYSTEM privileges.

### POC

#### Reference
- http://packetstormsecurity.com/files/157493/Druva-inSync-Windows-Client-6.5.2-Privilege-Escalation.html
- http://packetstormsecurity.com/files/157680/Druva-inSync-inSyncCPHwnet64.exe-RPC-Type-5-Privilege-Escalation.html
- https://www.tenable.com/security/research/tra-2020-12

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
#

### plot_factors
[source](https://github.com/allfed/Seaweed-Growth-Model/blob/master/src/plotting/plotter_methods.py/#L24)
```python
.plot_factors()
```

---
Plots the factors used in the model, with a range that fits to the factor

**Arguments**

None

**Returns**

None

repository: allfed/Seaweed-Growth-Model

gha_language: Jupyter Notebook

repo_name: allfed/Seaweed-Growth-Model


text:
# aShell

A component to aid in writing shell-like applications in Ada.

Under an ISC license.

## Example

A trivial shell script:

    #! /bin/sh
    tr '\000' '\n' | ds_harmonize

Might be written like this in Ada:

    with Shell;
    procedure SDS_to_DS is
       DS_Pipe         : Shell.Pipe;
       Zero_To_Newline : Shell.Process := Start (Program   => "tr",
                                                 Arguments => (+"\000", +"\n"),
                                                 Output    => DS_Pipe);
       DS_Harmonize    : Shell.Process := Start (Program   => "ds_harmonize",
                                                 Input     => DS_Pipe);
    begin
       null;
    end SDS_to_DS;

This does not give us any gain, but once you can mix and match Ada entities with
external filter commands, it may be easier to save time, as you don't have to
reimplement the algorithm of any external filter in Ada, to finish your program.

license: ISC

repository: sparre/aShell

repo_name: sparre/aShell


text:
# Latex_Documents_with_R_and_Python
This project aims to combine in a LaTeX document standard text with chunks of code, particulary chunks of R code and Python code.

Any feedback is welcome, 😄 so please feel free to ask or comment anything you want. If you are shy 😳 and do not want to
write in the repo, I will be happy to answer you by email at<EMAIL_ADDRESS>👩🏻💻 .

<img<EMAIL_ADDRESS>height="120" width="210"/>

## Goals

The goal of this repo is to give the steps to write LaTeX documents which include chunks of R and Python code. These chunks of code can be executed or not according to the requirements.

## How it works?

To develop this project, the LaTeX package [pythontex](https://ctan.org/pkg/pythontex) will be used. This package has been developed by [Geoffrey Poore](https://github.com/gpoore). The link to its Github repository can be found [here](https://github.com/gpoore/pythontex).

## Previous requirements

To write documents using LaTeX and execute chunks of R and Python code, it is obviously necessary to have the tools to do it. Although the installation of LaTeX, R and Python exceeds the goals of this repo, I suggest you some references to download and install them. Particularly, [here](https://www.latex-tutorial.com/installation/) you can find how to install Latex. Regarding R, [this page](https://www.r-project.org/) is recommended for the programme and [this one](https://www.rstudio.com/) to get the well known IDE, RStudio. Finally, downloading the IDE Pycharm [here](https://www.jetbrains.com/pycharm/), you will get also a version of Python.

For more information about the programme versions, I recommend you to read [this link](https://github.com/gpoore/pythontex/blob/master/pythontex/pythontex.pdf).

### Install non-default Python packages

Some Python packages are required for using pythontex, namely `pygments`, `numpy`, `scipy`, `matplotlib` and `sympy`. In the next lines, I will explain how to do it in a MAC computer. The steps for the installation in Linux or Windows platforms will be given soon.

This section is especially devoted for beginners, so if you already know how to install packages in Python, go to the next section.

The first thing we need to know is: Which Python packages do I have? To ask this question you have to open a terminal and follow these steps:

1) Call `python`.
2) Type `help('modules)`
3) Check the list of modules.

A screencast which shows the process can be seen below:

![check_packages_python](./videos_and_images_for_the_readme_file/check_packages_python.gif)

Once we know which packages are installed and which ones are missed, we need to proceed to the installation of some non-default packages. To this aim, you have to be sure that `pip` (a tool for installing Python packages is installed). Otherwise, you will get errors like this:

![error_no_pip_installed](./videos_and_images_for_the_readme_file/error_pip_not_installed.png)

To install `pip` you just have to open a terminal and follow these steps:

1) Write `sudo easy_install pip`.
2) Type the password of your Mac.
3) Now, `pip` is installed.

If you have doubts, then have a look at this video:

![check_packages_python](./videos_and_images_for_the_readme_file/install_pip.gif)

The next step is to install the python packages. Therefore, just write these instructions in a new terminal tab. Note that the given example shows how to install the `pygments` package. Hence, if a different library is to be installed, just change the name:

 `sudo python -m pip install pygments`

Check the video below for more details:

![install_packages_python](./videos_and_images_for_the_readme_file/install_packages_python.gif)

To test that the new packages have been downloaded, just execute `help('modules)` as explained above.

## Installation

Developed By
------------

* Asunción Jiménez-Cordero -<EMAIL_ADDRESS>

License
-------

    Copyright 2019 Asunción Jiménez-Cordero

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

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

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


text:
# Porting how-to

This document describes the requirements and necessary steps required to port
`MCUboot` to a new target `OS`.

# Requirements

* `MCUboot` requires a configuration file, which can be included as
   mcuboot_config/mcuboot_config.h, which configures various options
   (that begin with MCUBOOT_).

* `MCUboot` requires that the target provides a `flash` API with ability to
  get the flash's minimum write size, and read/write/erase individual sectors.

* `MCUboot` doesn't bundle a cryptographic library, which means the target
  OS must already have it bundled. The supported libraries at the moment are
  either `Mbed TLS` or the set `tinycrypt` + `Mbed TLS` (where `Mbed TLS` is
  used to provide functionality not existing in `tinycrypt`).

# Steps to port

## Main app and calling the bootloader

From the perspective of the target OS, the bootloader can be seen as a library,
so an entry point must be provided. This is likely a typical `app` for the
target OS, and it must call the following function to run the bootloader:

```c
int boot_go(struct boot_rsp *rsp);
```

This function is located at `boot/bootutil/loader.c` and receives a `struct
boot_rsp` pointer. The `struct boot_rsp` is defined as:

```c
struct boot_rsp {
    /** A pointer to the header of the image to be executed. */
    const struct image_header *br_hdr;

    /**
     * The flash offset of the image to execute.  Indicates the position of
     * the image header.
     */
    uint8_t br_flash_id;
    uint32_t br_image_addr;
};
```

After running the management functions of the bootloader, `boot_go` returns
an initialized `boot_rsp` which has pointers to the location of the image
where the target firmware is located which can be used to jump to.

## Configuration file

You must provide a file, mcuboot_config/mcuboot_config.h. This is
included by several files in the "library" portion of MCUboot; it
provides preprocessor definitions that configure the library's
build.

See the file samples/mcuboot_config/mcuboot_config.template.h for a
starting point and more information. This is a good place to convert
settings in your environment's configuration system to those required
by MCUboot. For example, Mynewt uses MYNEWT_VAL() and Zephyr uses
Kconfig; these configuration systems are converted to MCUBOOT_ options
in the following files:

- boot/zephyr/include/mcuboot_config/mcuboot_config.h
- boot/mynewt/mcuboot_config/include/mcuboot_config/mcuboot_config.h

## Flash Map

The bootloader requires to be able to address flash regions where the code
for MCUboot and images of applications are stored, in system-agnostic way.
For that purpose the MCUboot uses ID, which is integer (uint8_t) number
that should uniquely identify each flash region.
Such flash regions are served by object of `const struct flash_area` type while
layout of these objects is gathered under `flash_map`.
The common code of MCUboot, that is non-system specific, does not directly
access contents of that object and never modifies it, instead it calls
`flash_area_` API to perform any actions on that object.
This way systems are free to implement internal logic of flash map or define
`struct flash_area` as they wish; the only restriction is that ID should be
uniquely tied to region characterized by device, offset and size.

Changes to common MCUboot code should not affect system specific internals
of flash map, on the other side system specific code, within MCUboot, is
is not restricted from directly accessing `struct flash_area` elements.

An implementation of `struct flash_area` may take form of:
```c
struct flash_area {
    uint8_t  fa_id;         /** The slot/scratch identification */
    uint8_t  fa_device_id;  /** The device id (usually there's only one) */
    uint16_t pad16;
    uint32_t fa_off;        /** The flash offset from the beginning */
    uint32_t fa_size;       /** The size of this sector */
};
```
The above example of structure hold all information that is currently required
by MCUboot, although the MCUboot will not be trying to access them directly,
instead a system is required to provide following mandatory getter functions:

```c
/*< Obtains ID of the flash area characterized by `fa` */
int     flash_area_get_id(const struct flash_area *fa);
/*< Obtains ID of a device the flash area `fa` described region resides on */
int     flash_area_get_device_id(const struct flash_area *fa)
/*< Obtains offset, from the beginning of a device, the flash area described
 * region starts at */
uint32_t flash_area_get_off(const struct flash_area *fa)
/*< Obtains size, from the offset, of the flash area `fa` characterized region */
uint32_t flash_area_get_size(const struct flash_area *fa)

```

The MCUboot common code uses following defines that should be defined by system
specific header files and are used to identify destination of flash area by ID:

```c
/* Independent from multiple image boot */
#define FLASH_AREA_BOOTLOADER         0
#define FLASH_AREA_IMAGE_SCRATCH      3
```
```c
/* Flash area IDs of the first image in case of multiple images */
#define FLASH_AREA_IMAGE_PRIMARY      1
#define FLASH_AREA_IMAGE_SECONDARY    2
```
```c
/* Flash area IDs of the second image in case of multiple images */
#define FLASH_AREA_IMAGE_PRIMARY      5
#define FLASH_AREA_IMAGE_SECONDARY    6
```

The numbers, given above, are provided as an example and depend on system
implementation.

The main, also required, set of API functions that perform operations on
flash characterized by `struct flash_area` objects is as follows:

```c
/*< Opens the area for use. id is one of the `fa_id`s */
int      flash_area_open(uint8_t id, const struct flash_area **);
void     flash_area_close(const struct flash_area *);
/*< Reads `len` bytes of flash memory at `off` to the buffer at `dst` */
int      flash_area_read(const struct flash_area *, uint32_t off, void *dst,
                         uint32_t len);
/*< Writes `len` bytes of flash memory at `off` from the buffer at `src` */
int      flash_area_write(const struct flash_area *, uint32_t off,
                          const void *src, uint32_t len);
/*< Erases `len` bytes of flash memory at `off` */
int      flash_area_erase(const struct flash_area *, uint32_t off, uint32_t len);
/*< Returns this `flash_area`s alignment */
uint32_t flash_area_align(const struct flash_area *);
/*< What is value is read from erased flash bytes. */
uint8_t  flash_area_erased_val(const struct flash_area *);
/*< Given flash area ID, return info about sectors within the area. */
int      flash_area_get_sectors(int fa_id, uint32_t *count,
                                struct flash_sector *sectors);
/*< Returns the `fa_id` for slot, where slot is 0 (primary) or 1 (secondary).
    `image_index` (0 or 1) is the index of the image. Image index is
    relevant only when multi-image support support is enabled */
int      flash_area_id_from_multi_image_slot(int image_index, int slot);
/*< Returns the slot (0 for primary or 1 for secondary), for the supplied
    `image_index` and `area_id`. `area_id` is unique and is represented by
    `fa_id` in the `flash_area` struct. */
int      flash_area_id_to_multi_image_slot(int image_index, int area_id);
```

---
***Note***

*As of writing, it is possible that MCUboot will open a flash area multiple times simultaneously (through nested calls to `flash_area_open`). As a result, MCUboot may call `flash_area_close` on a flash area that is still opened by another part of MCUboot. As a workaround when porting, it may be necessary to implement a counter of the number of times a given flash area has been opened by MCUboot. The `flash_area_close` implementation should only fully deinitialize the underlying flash area when the open counter is decremented to 0. See [this GitHub PR](https://github.com/mcu-tools/mcuboot/pull/894/) for a more detailed discussion.*

---

## Memory management for Mbed TLS

`Mbed TLS` employs dynamic allocation of memory, making use of the pair
`calloc/free`. If `Mbed TLS` is to be used for crypto, your target RTOS
needs to provide this pair of function.

To configure the what functions are called when allocating/deallocating
memory `Mbed TLS` uses the following call:

```
int mbedtls_platform_set_calloc_free (void *(*calloc_func)(size_t, size_t),
                                      void (*free_func)(void *));
```

For reference see [Mbed TLS platform.h](https://tls.mbed.org/api/platform_8h.html).
If your system already provides functions with compatible signatures, those can
be used directly here, otherwise create new functions that glue to your
`calloc/free` implementations.

repository: mcu-tools/mcuboot

repo_name: mcu-tools/mcuboot


text:
localface
=========

100+ human faces to provide, especially for test

## Copyright Notice

All photos are picked from <http://randomuser.me/>

> All randomly generated photos are copyrighted under a Creative Commons BY-NC-SA 2.0 license. These photos were hand picked from Greg Peverill-Conti's 1,000 faces project.

## Usage

1. Install with Node

	```shell
	npm install localface
	```

2. Get a count

	```js
	var localface = require('localface');
	var womenCount = localface.count['f'];
	```

3. Get a file path

	```js
	var file = localface.get('f', _.random(0, womenCount - 1));
	file;		// "/home/fritz/Dev/npm/localface/portraits/women/59.jpg"
	fs.existsSync(file);		// true
	localface.get('m');		// random one
	```

repository: node-fun/localface

repo_name: node-fun/localface


text:
# pack

[**Repository moved to codeberg.org**](https://codeberg.org/fractalqb/pack)

`import "git.fractalqb.de/fractalqb/pack"`

---
# Intro

For Go packages it is common and good style to have packages
installabel with a simple `go get...` command. This is supported in a
great way by having so many good tools being part of the Go
distribution. However sometimes applications might require to be
distributed as a binary package with a crafted distribution file-tree
– especially when users are not expected to compile the application
themselves.

To have a portable way to pack such a distribution one would need a
portable runtime for the program that does the packing. So why not
write the packing program in Go? Most of the batteries are already
included in Go but IMHO they could use a little polishing,
i.e. lifting the API abstraction, to make the packing code even more
simple. And exactly that's what this package is provided for!

## By the way…

There is just a little tool included to create a source file with
constants defining the current version of the package. The idea is
extraordinary simple: Write down the version parameters in a separate
text file, e.g. `VERSION`, from which not only the Go code can be
generated but that also can likely be processed by a lot of other
programs too, e.g. shell, makefiles, Python and many others:

```shell
major=0
minor=2
bugfix=0
quality="a"
```

With such a simple file and one `go generate` directive, e.g. in an
application's `main.go`

```go
package main
…
//go:generate versioner ./VERSION ./version.go
…
```

a simple `go generate` will create the file `version.go` from the file
`VERSION`:

```go
package main

const (
	Major = 0
	Minor = 2
	Bugfix = 0
	Quality = "a"
)
```

and with this its trivial to let `myfancyprogram` show you its version
like this

```go
myfancyprogram v0.2.0a
Usage: [flags] input output
…
```

There are also some flags to define a common prefix for the constants,
to have automatically increasing build numbers and to generate a
timestamp from `time.Now()`.

# Install
To get the library for writing your packing program:

`go get -u git.fractalqb.de/fractalqb/pack`

To get the `versioner` binary:

`go install -u git.fractalqb.de/fractalqb/pack/versioner`

repository: fractalqb/pack

repo_name: fractalqb/pack


text:
# BuildSys
Build System For Common C++ Data Science / Math Libs

It's not complete, and really only serves my own purpose at this time.

it uses cmake in ways that serve my purpose... and might not be best practices.

# Requirements
* cmake3 ( 3.17 or newer)
* bash

# Basic Usage

Edit make_clean.sh to edit the path of your project, and any settings for verbosity, etc

Edit BuildSys_config.cmake and turn on any libraries you want to build.
run make_clean.sh to configure and build the libraries, and any apps you use that depend on it.

# Notes
this is really been an exercise in an effort to learn CMake, and super builds so that I can create a personalized development environment that can custom create / build any libraries I want, with whatever custom flags / settings / version that is needed to suit my testing needs.

Use this as a guide, and pick it apart for your own usage as you see fit.

I will likely continue building this up as I try to learn new libraries, and try to re-teach myself C++ ( especailly all these C++11, C++14, C++17 and C++20 additions), especially as it pertains to HPC, and data analytics.

repository: kettlewell/BuildSys

repo_name: kettlewell/BuildSys


text:
# ChangeLog

The following are lists of the notable changes included with each release.
This is intended to help keep people informed about notable changes between
versions, as well as provide a rough history. Each item is prefixed with
one of the following labels: `Added`, `Changed`, `Deprecated`,
`Removed`, `Fixed`, `Security`. We also use [Semantic
Versioning](http://semver.org) to manage the versions of this gem so
that you can set version constraints properly.

#### Next Release

#### [v2.0.0] - 2016-10-24

* Changed logger management to work at class or instance level

#### [v1.1.0] - 2016-10-18

* Added logger management module

#### [v1.0.0] - 2016-10-11

* Added documentation around all the classes, modules, constants and methods
* Added OptionalLogger::Logger level introspection methods (#debug?, #info?,
  #warn?, #error?, #fatal?)
* Added OptionalLogger::Logger level convenience methods (#debug, #info, #warn,
  #error, #fatal, #unknown)
* Added OptionalLogger::Logger#add and #log methods
* Added OptionalLogger::Logger class and constructor
* Added OptionalLogger module skeleton

[Unreleased]: https://github.com/Acornsgrow/optional_logger/compare/v2.0.0...HEAD
[v2.0.0]: https://github.com/Acornsgrow/optional_logger/compare/v1.1.0...v2.0.0
[v1.1.0]: https://github.com/Acornsgrow/optional_logger/compare/v1.0.0...v1.1.0
[v1.0.0]: https://github.com/Acornsgrow/optional_logger/compare/d377eb0...v1.0.0


text:
---
title: "Shop Ideas"
created_at: Thu Feb 26 21:15:36 MST 2015
kind: article
tags:
  - wood_shop
---

## Paulk Portable Workbench(s)

Workbench II and rolling stand for Craftsman saw first.  Then Miter stand.

#### [Paulk Store](http://stores.modularmarket.com/paulk_homes/new-package-1-total-station-workbench-ii-and-the-crosscut-jig-p6.php) plans #2 $22 Workbench II, Miter Stand, Crosscut Jig

## Shop Storage

#### [LumberJocks Forum](http://lumberjocks.com/projects/49116) KMT project - Parts storage with food containers

## Router Table

Use Jay's Quick Release Lever Router Lift

### [jayscustomcreations.com](http://jayscustomcreations.com/downloads/quick-release-lever-router-lift/) Lever Router Plans

### [youtube](https://www.youtube.com/watch?v=pFcWWbJKnyc) Router Lift build video

use PORTER-CABLE 892 2-1/4-Horsepower Router
$182.30 at Amazon

#### [woodpeckers store](http://www.woodpeck.com/prlv2.html#1356) Precision Router Lift V2

Paulk workbench II has router insert at far end.

## Matthias Wandel - tilt and non-tilt router lift

#### [woodgears page](http://woodgears.ca/router_lift/index.html) Matthias Wandel - Tilting router lift

### Steve Ramsey router table build

Steve uses the Kreg router insert.

#### [youtube](https://www.youtube.com/watch?v=Gf5tRp35EEU) Steve Ramsey router table

### Router Lift by John Heisz

#### [Order page](http://www.ibuildit.ca/Sales/sales-4.html) Router Lift Plans - $12

## Band Saw

#### [craftsy.com](http://www.craftsy.com/blog/2014/08/how-to-use-a-bandsaw/) Rob Porcaro - Creative Uses for Bandsaw

## Lathe

## Movable Moxon Vise

## Misc.

#### [LumberJocks Forum](http://lumberjocks.com/topics/82257) Best Upgrade you've made

## Storage

### [Matthias Wandel](https://www.youtube.com/watch?v=8En-OTfePys) Making wall tool holders

#### [Matthias site](http://woodgears.ca/tool_holders/making.html)

## Super Sled

### [eaglelakewoodworking.com](http://www.eaglelakewoodworking.com/post/Super-Sled-Crosscut-and-Miter-Sled.aspx) John W. Nixon super sled build

## Dust Collection

Plan to use shop vac with shop build Thien cyclone separator

Shop vac accessories from evenfallstudios.com

### Ridgid WD1450 14-gal. Professional Wet/Dry Vacuum

$99 Home Depot. Ridgid WD1450 14-gal. Professional Wet/Dry Vacuum

* Replacement Filters	VF4000, VF5000, VF6000,
* Filter Bag	VF3502
* Accessory Size	2-1/2 in.

### 32 gal. trash can.

$30 BRUTE 32 Gal. Gray Vented Waste Container with Lid

### [centralvacuumfactory.com](http://www.centralvacuumfactory.com/vacvalve-relief-valve-central-vacuum-systems-p-954.html) Pressure Relief

$13.00 Vac-Valve Air Relief Valve for Central Vacuum Systems
Model #: IS110

### [evenfallstudios.com](http://www.evenfallstudios.com/shopvacuum/hoses-cuffs/sv-orng-cp-hse-50.html) 1.25"x 50 ft Shop Hose

$5.00 1.25" to 2.25" Vacuum Tank to Hose Union Adapter

$55 1.25"x 50 ft Crushproof Shop Hose, Orange

$6.00 Low Profile Male Cuff For 1.25" Hose & Tools

$8.00 1.25" x 9" Deluxe Crevice Tool w/Air Release

$14.00 1.25" Deluxe Dust Brush w/horsehair fill

$8.00 1.25" x 17.75" Plastic Straight Wand

### [pennstateind.com](http://www.pennstateind.com/store/DC3XX.html) Dust Collection Parts

$310.00 1.5HP DC3 Portable Dust Collector Motor Blower (no bag or hose)
$395.00 2HP - Single Phase Motor Blower: 1350CFM  Item #: DC250SEMB

http://www.toro.com/en-us/homeowner/snow-blowers/electric/Pages/Model.aspx?pid=Power-Shovel-38361

### [cleanstream.com](http://www.cleanstream.com/products/detail_craftsman_ridgid_wetdry.html) HEPA Filter

* $33 including shipping
* Part Number: 09093
* Replaces RIDGID® Filters - VF4000,VF5000, VF6000 and VF7000.

### [jpthien.com](http://www.jpthien.com/cy.htm) Thien Cyclone Separator Lid

The Thien Cyclone Separator Lid
w/ the Thien Cyclone Separator Baffle

### [video](https://www.youtube.com/watch?v=m9Sn7g-vsf8) TabLeft Thien top hat build video

### [Matthias Wandel](https://www.youtube.com/watch?v=LBxFNUWD2GQ) Building a dust collector blower

Matthias Wandel -
Using a cheap table saw motor to build an efficient blower for a dust collector

### [Dave Gatton](https://www.youtube.com/watch?v=nzebi8lan0o) Thien top hat video

### [evenfallstudios.com](http://www.evenfallstudios.com/woodworks/2008/06/27/building-the-5_gallon-thien-separator/) 5-Gallon Thien Separator

Building the 5-Gallon Thien Separator for your Shop Vacuum.

### [evenfallstudios.com](http://www.evenfallstudios.com/woodworks/2014/09/03/now-available-new-shop-vacuum-tools-and-accessories/) Shop vacuum tools

### [evenfallstudios.com](www.evenfallstudios.com/woodworks/2008/05/17/improving-shop-vac-dust-collection/) Improving Shop Vac Dust Collection

### [evenfallstudios.com](http://www.evenfallstudios.com/woodworks_store/shopvacuum_acc_index.html) Shop Vacuum Accessories

### [usplastic.com](http://www.usplastic.com/catalog/item.aspx?itemid=104335&catid=752) 7 Gallon Bucket

### [lumberjocks forum](http://lumberjocks.com/topics/10921) Cyclone dust collector - make your own

evenfall responded on this thread.

### [Daves Workshop](http://home.earthlink.net/~dbhost/dustcollection.html) Dust Collection

### [harborfreight.com](http://www.harborfreight.com/2-hp-industrial-5-micron-dust-collector-97869.html) 70 gal. Industrial 5 Micron Dust Collector

### [billpentz.com](http://billpentz.com/woodworking/cyclone/) Dust Collection Research

### [cstrang at lumberjocks](http://lumberjocks.com/topics/41917) Dust Collector Canister Filter

uses Donaldson P181099 Air Filter

### [everythingtruckparts.com](http://www.everythingtruckparts.com/donaldson-p181099-air-filter/#.VQlEA_6vAcU) Donaldson P181099 Air Filter

### [harborfreight.com](http://www.harborfreight.com/24-in-x-36-in-folding-platform-truck-68894.html) 24 in. x 36 in. Folding Platform Truck

### [kehoe web page](http://users.eastlink.ca/~kehoe/cyclone/cyclone.html) My Thien Top Hat Cyclone


text:
Console++
========

![Console++](console++.jpg)

#about
Console++ is a Unity3D editor console which includes more features then the default unity console.

##features
- channels
- colors
- complete callstack jumpto
- use of params in logs *(using string.Format)*
- timestamp
- frame number
- more levels
  - Trace
  - Debug
  - Info
  - Warning
  - Error
- save to hmtl *(wip)*

#install
Just copy the ConsolePP folder in your project. After compilation you will be able to open the console++ under "Window/Console++".

#usage
##logging
You can still use
```C#
Debug.Log("");
Debug.LogWarning("");
Debug.LogError("");
```
these logs will be added to the default channel with the info, warning or error levels.

Next to that you can now use
```C#
Log.Trace(string id, string msg);
Log.Debug(string id, string msg);
Log.Info(string id, string msg);
Log.Warning(string id, string msg);
Log.Error(string id, string msg);
```
Here the id is the channel and the msg the normal message.

##commands (wip)
Inside the console there is a simple command line which supports a small number off command. These command can also be send using the command level (`Log.Command(string id, string msg);`). Commands which apply on a channel are executed on the given channel or the default if none is given. Other commands apply to the global level. A command channel can be defined by `channelId:command params`.

- channel commands
  - show
  - hide
  - toggle
  - color *r* *g* *b* *a*
  - log *lvl* *msg*
  - clear (not implemented yet)
- global commands
  - deselect
  - clearall
  - clearchannels
  - save
  - ulog *msg*

repository: depuits/ConsolePP

repo_name: depuits/ConsolePP


text:
# The Efficacy of League Formats in Ranking Teams

This repository contains the code used for the analysis of football data
in the paper *The efficacy of league formats in ranking teams*
that appeared in the [special issue on sports analytics in
Statistical Modelling Journal](https://journals.sagepub.com/doi/abs/10.1177/1471082X18798426)) by [Jan Lasek](http://lasek.rexamine.com)
and [Marek Gagolewski](http://gagolewski.com/).
The efficacy of a given league format is defined as the accuracy to
reproduce the true ranking of competing teams. The content of this repository,
steps to reproduce the main results and supplementary materials are outlined below.

## Contents

```
league-formats-efficacy
├── data
│    ├── download_data.sh # Script for downloading data from http://www.football-data.co.uk/
│    └── preprocessing_football_data_co_uk.R
├── scripts
│    ├── config.R # It should be defined locally
│    ├── setup_simulations.R
│    ├── run_simulations.R
│    ├── run_all.sh # Simulations for all settings
│    ├── schedule_functions.R
│    ├── simulation_functions.R
│    ├── evaluation_functions.R
│    ├── extra_functions.R
│    ├── evaluate_simulations.R
│    └── rating_systems
│         ├── rating_systems.R
│         ├── prediction_functions.R
│         └── optimise_models.R
└── appendix
     ├── League_Formats_in_UEFA(.md|.pdf)
     ├── Schedules_in_Two_Stage_Systems(.md|.pdf)
     └── Tournament_Metrics(.md|.pdf)
```

### Requirements

The project was developed in [R](https://www.r-project.org/) using
the following packages:

* doMC_1.3.5
* iterators_1.0.8
* foreach_1.4.3
* dplyr_0.5.0
* stringi_1.1.7
* skellam_0.2.0
* MASS_7.3-45

Compatibility of the scripts for other versions of the aforementioned packages
is not guaranteed.

## Reproducing the Main Results

### Step 1

First, create file **scripts/config.R** and set appropriate paths
for keeping data and saving the results. This depends on local platform
settings. File contents should look like:

```R
results_save_folder <- "where/you/want/to/store/simulation/results"
```

All the results will be saved in **results_save_folder**.

### Step 2

Second, to install necessary libraries and setup
the output data folders, run:

```
$ Rscript setup_simulations.R
```

Additionally, you can edit the script and define the following:

* the team rating model to use (`model` variable),
* the league formats to analyse (`league_formats`),
* directory for storing the results of a specific experiment
(`specific_result_folder`).

An error will be raised (`directory not empty`), if there are some old
results stored. Clean them first (or move to some other location).

### Step 3

Third, to produce the simulation results with given parameters,
edit the **run_all.sh** script and execute:

```
$ ./run_all.sh
```

Alternatively, to produce the results for a given parameter setup, run:
```
$ Rscript run_simulations.R --n=12 --model=poisson_correlated --n_sim=100 --shape=20 --sigma=0.3 --n_cores=3 --specific_result_folder=results_all --log2file=1
```

with appropriate parameters (please consult the script). These operations
are performed for a parameters grid in the **run_all.sh** script. The results
will be saved in the folder specified in the **config.R** script.

### Step 4

Finally, for measuring the agreement between the final league standings
and latent team strength parameters, execute:

```
$ Rscript evaluate_simulations.R
```

This produces a *csv* file with results in the respective folder.

## Reproducing Intermediate Results

### Rating Systems Performance

In order to generate and evaluate the predictions of different rating systems
first download data from http://www.football-data.co.uk/.
There is script **data/download_data.sh** to assist you with it.
The data need to be first preprocessed by running

```
$ Rscript preprocessing_football_data_co_uk.R
```

in the **data** folder.

The correlation parameter is set to ρ=0.45 (or as desired) for
the correlated Poisson model in the **scripts/rating_systems/prediction_functions.R** script.
To reproduce results, go to **scripts/rating_systems** and run

```
$ Rscript optimize_models.R
```
The script runs grid search for regularization parameter λ for different models
and a league season of choice (this can be specified directly in the script) and
saves some logs and results into **results** folder in the same directory.

## Appendices

### League Formats in UEFA

The first appendix consists of a listing of formats that are in
operation in the UEFA countries in the 2017/2018 (or 2018) season.

Click to download:
[PDF](appendix/League_Formats_in_UEFA.pdf) |
[MARKDOWN](appendix/League_Formats_in_UEFA.md)

### Tournament Metrics for Several Parameter Combinations

The second appendix gives the detailed estimates of different tournament
metrics considered in our study.

Click to download:
[PDF](appendix/Tournament_Metrics.pdf) |
[MARKDOWN](appendix/Tournament_Metrics.md)

### Schedules in Two Stage Systems

Two example schedules of the final round in the *2RR + (1RR/1RR)* league format
employed in the championship and the relegation group in the case of 12 and 16
teams are listed in the third appendix.

Click to download:
[PDF](appendix/Schedules_in_Two_Stage_Systems.pdf) |
[MARKDOWN](appendix/Schedules_in_Two_Stage_Systems.md)

repository: janekl/league-formats-efficacy

repo_name: janekl/league-formats-efficacy


text:
# Rendering Pipeline
For now, we can issue draw calls using textures and stuff. However, we need to
make a rendering pipeline to support both deferred and forward rendering,
post processing, shadows, etc.

To do that, we need to separate mesh phase and lighting phase. In order to do
forward rendering, the mesh shader and the lighting shader will be merged
and called. To do deferred rendering, these data will be separated to textures
and lighting pass will be done separately.

Basically, we need a way to dynamically recompile the shader to tailor to the
requirements.

The material, the lighting both should contain a shader. The material should
be able to specify instructions to render itself - whether if deferred rendering
is allowed, depth buffer is used or not, etc.

However, deferred shading requires the material to not use any blending mode
or stuff. So using any one of them will make the material to use forward
rendering.

We need a proper descriptor for describing the material! However, the material
itself is an adjustment instance for a shader, therefore the shader needs to
specify how the mesh should be rendered.

Basically, we'd end up something like this:

```js
{
  type: 'combined',
  shadow: false,
  passes: [{
    cull: 'back',
    depthTest: 'less',
    vert: '...',
    frag: `
      varying vec4 uNormal;

      void main(inout MaterialSpec spec) {
        spec.normal = uNormal;
      }
    `,
  }]
}

{
  type: 'forward',
  passes: [{
    type: 'base',
    blend: 'alpha',
    vert: '...',
    // Note that we can't pass lighting information to here! The lighting logic
    // is "fixed" - it must be specified by the shader.
    // This specifies what lights the shader is interested in.
    lighting: {
      point: 2,
    },
    frag: `
      uniform PointLightSpec uPointLights[2];
      // The function vec4 stdCalcPointLight(inout MaterialSpec spec);
      // is present; the forward shader may opt to use this
      void main() {
        gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
      }
    `,
  }],
}
```

However, this means that the actual "shader" object and pipeline shader is
separated - we need to manage internal shader instances, which is derived from
shader, created by the pipeline.

Therefore, we need to distinguish them; The Shader object is created by the
game and passed to the pipeline. The pipeline will create "GLShader" object
according to the spec of Shader and the pipeline.

This means that we have to propagate updates to the render object. Since
multiple render systems can exist on single engine, the Shader object shouldn't
contain any info about the renderer. Instead, the Shader object uses version or
UUID to identify itself.

The renderer object simply passes everything to the pipeline object - Since the
entire rendering pipeline must be handled by pipeline object, the renderer
simply helps the allocation of WebGL related buffers.

Therefore, this would kind of resemble cached propagation - Could this utilize
functional programming?