text:
# Yalc

> Better workflow than **npm | yarn link** for package authors.

## Why

When developing and authoring multiple packages (private or public), you often find yourself in need of using the latest/WIP versions in other projects that you are working on in your local environment **without publishing those packages to the remote registry.** NPM and Yarn address this issue with a similar approach of [symlinked packages](https://docs.npmjs.com/cli/link) (`npm/yarn link`). Though this may work in many cases, it often brings nasty [constraints and problems](https://github.com/yarnpkg/yarn/issues/1761#issuecomment-259706202) with dependency resolution, symlink interoperability between file systems, etc.

## What

- `yalc` acts as very simple local repository for your locally developed packages that you want to share across your local environment.
- When you run `yalc publish` in the package directory, it grabs only files that should be published to NPM and _puts_ them in a special global store (located, for example, in `~/.yalc`).
- When you run `yalc add my-package` in your `project` it _pulls_ package content into `.yalc` in the current folder and injects a `file:`/`link:` dependency into `package.json`. Alternatively, you may use `yalc link my-package` which will create a symlink to the package content in `node_modules` and will not touch `package.json` (like `npm/yarn link` does), or you even may use it with **Pnmp/Yarn/Npm workspaces**.
- `yalc` creates a special `yalc.lock` file in your project (similar to `yarn.lock` and `package-lock.json`) that is used to ensure consistency while performing `yalc`'s routines.
- `yalc` can be used with projects where `yarn` or `npm` package managers are used
  for managing `package.json` dependencies.

## Installation

![npm (scoped)](https://img.shields.io/npm/v/yalc.svg?maxAge=86400) [![Build Status](https://travis-ci.org/whitecolor/yalc.svg?branch=master)](https://travis-ci.org/whitecolor/yalc)

Using NPM:

```
npm i yalc -g
```

Using Yarn:

```
yarn global add yalc
```

Some documented features might not have been published yet, see the [change log](./CHANGELOG.md).

## Usage

### Publish

- Run `yalc publish` in your dependency package `my-package`.
- It will copy [all the files that should be published in remote NPM registry](https://docs.npmjs.com/files/package.json#files).
- If your package has any of these lifecycle scripts: `prepublish`, `prepare`, `prepublishOnly`, `prepack`, `preyalcpublish`, they will run before in this order. If your package has any of these: `postyalcpublish`, `postpack`, `publish`, `postpublish`, they will run after in this order. Use `--no-scripts` to publish without running scripts.
- When publishing, `yalc` can optionally calculate a hash signature from the file contents and use the signature in the resulting package `version` (like `"1.2.3+ffffffff"`). To enable this, pass the `--sig` option to the `yalc publish` command.
- You may also use `.yalcignore` to exclude files from publishing to yalc repo, for example, files like README.md, etc.
- `--content` flag will show included files in the published package
- **NB!** In terms of which files will be included in the package `yalc` fully supposed to emulate behavior of `npm` client (`npm pack`). [If you have nested `.yalc` folder in your package](https://github.com/whitecolor/yalc/issues/95) that you are going to publish with `yalc` and you use `package.json` `files` list, it should be included there explicitly.
- **NB!** Windows users should make sure the `LF` new line symbol is used in published sources; it may be needed for some packages to work correctly (for example, `bin` scripts). `yalc` won't convert line endings for you (because `npm` and `yarn` won't either).
- **NB!** Note that, if you want to include `.yalc` folder in published package content, you should add `!.yalc` line to `.npmignore`.
- [Easily propagate package updates everywhere.](#pushing-updates-automatically-to-all-installations)
- Yalc by default resolve `workspace:` protocol in dependencies, to omit this use `-no-workspace-resolve` flag

### Add

- Run `yalc add my-package` in your dependent project, which
  will copy the current version from the store to your project's `.yalc` folder and inject a `file:.yalc/my-package` dependency into `package.json`.
- You may specify a particular version with `yalc add my-package@version`. This version will be fixed in `yalc.lock` and will not affect newly published versions during updates.
- Use the `--link` option to add a `link:` dependency instead of `file:`.
- Use the `--dev` option to add yalc package to dev dependencies.
- With `--pure` flag it will not touch `package.json` file, nor it will touch modules folder, this is useful for example when working with [**Yarn workspaces**](https://yarnpkg.com/lang/en/docs/workspaces/) (read below in _Advanced usage_ section)
- With `--workspace` (or `-W`) it will add dependency with "workspace:" protocol.

### Link

- As an alternative to `add`, you can use the `link` command which is similar to `npm/yarn link`, except that the symlink source will be not the global link directory but the local `.yalc` folder of your project.
- After `yalc` copies package content to `.yalc` folder it will create a symlink:
  `project/.yalc/my-package ==> project/node_modules/my-package`. It will not touch `package.json` in this case.

### Update

- Run `yalc update my-package` to update the latest version from store.
- Run `yalc update` to update all the packages found in `yalc.lock`.
- `preyalc` and `postyalc` scripts will be executed in target package on add/update operations which are performed while `push`
- if need to perform pre/post `scripts` on update of particular package use `(pre|post)yalc.package-name` name for script in your `package.json`.
- update `--update` (`--upgrade`, `--up`) to run package managers's update command for packages.

### Remove

- Run `yalc remove my-package`, it will remove package info from `package.json` and `yalc.lock`
- Run `yalc remove --all` to remove all packages from project.

### Installations

- Run `yalc installations clean my-package` to unpublish a package published with `yalc publish`
- Run `yalc installations show my-package` to show all packages to which `my-package` has been installed.

## Advanced usage

### Pushing updates automatically to all installations

- When you run `yalc add|link|update`, the project's package locations are tracked and saved, so `yalc` knows where each package in the store is being used in your local environment.
- `yalc publish --push` will publish your package to the store and propagate all changes to existing `yalc` package installations (this will actually do `update` operation on the location).
- `yalc push` - is a use shortcut command for push operation (which will likely become your primarily used command for publication):
- `scripts` options is `false` by default, so it won't run `pre/post` scripts (may change this with passing `--scripts` flag).
- With `--changed` flag yalc will first check if package content has changed before publishing and pushing, it is a quick operation and may be useful for _file watching scenarios_ with pushing on changes.
- Use `--replace` option to force replacement of package content.
- Use `preyalc` and `postyalc` (read in `update` docs) to execute needed script on every push.
- Use `--update` to run `yarn/npm/pnpm update` command for pushed packages.

### Keep it out of git

- If you are using `yalc'ed` modules temporarily during development, first add `.yalc` and `yalc.lock` to `.gitignore`.
- Use `yalc link`, that won't touch `package.json`
- If you use `yalc add` it will change `package.json`, and ads `file:`/`link:` dependencies, if you may want to use `yalc check` in the [precommit hook](https://github.com/typicode/husky) which will check package.json for `yalc'ed` dependencies and exits with an error if you forgot to remove them.

### Keep it in git

- You may want to keep shared `yalc'ed` stuff within the projects you are working on and treat it as a part of the project's codebase. This may really simplify management and usage of shared _work in progress_ packages within your projects and help to make things consistent. So, then just do it, keep `.yalc` folder and `yalc.lock` in git.
- Replace it with published versions from remote repository when ready.
- **NB!** - standard non-code files like `README`, `LICENCE` etc. will be included also, so you may want to exclude them in `.gitignore` with a line like `**/.yalc/**/*.md` or you may use `.yalcignore` not to include those files in package content.

### Publish/push sub-projects

- Useful for monorepos (projects with multiple sub-projects/packages): `yalc publish some-project` will perform publish operation in the `./some-project` directory relative to `process.cwd()`

### Retreat and Restore

- Instead of completely removing package you may temporary set it back with `yalc retreat [--all]` for example before package publication to remote registry.
- After or later restore it with `yalc restore`.

### Use with **Yarn/Pnpm workspaces**

Use if you will try to `add` repo in `workspaces` enabled package, `--pure` option will be used by default, so `package.json` and modules folder will not be touched.

Then you add yalc'ed package folder to `workspaces` in `package.json` (you may just add `.yalc/*` and `.yalc/@*/*` patterns). While `update` (or `push`) operation, packages content will be updated automatically and `yarn` will care about everything else.

If you want to override default pure behavior use `--no-pure` flag.

### Clean up installations file

- While working with yalc for some time on the dev machine you may face the situation when you have locations where you added yalc'ed packages being removed from file system, and this will cause some warning messages when yalc will try to push package to removed location. To get rid of such messages, there is an explicit command for this: `yalc installations clean [package]`.

### Override default package store folder

- You may use `--store-folder` flag option to override default location for storing published packages.

### Control output

- Use `--quiet` to fully disable output (except of errors). Use `--no-colors` to disable colors.

### Set default options via .yalcrc

- For example add `workspace-resolve=false` line to the `.yalcrc` file to turn off `workspace:` protocol resolution or `sig=false` to disable package version hash signature.

## Related links

- [yarn probably shouldn't cache packages resolved with a file path](https://github.com/yarnpkg/yarn/issues/2165)
- ["yarn knit": a better "yarn link"](https://github.com/yarnpkg/yarn/issues/1213)
- [npm-link-shared](https://github.com/OrKoN/npm-link-shared)
- [yarn link does not install package dependencies](https://github.com/yarnpkg/yarn/issues/2914)
- [[npm] RFC: file: specifier changes](https://github.com/npm/npm/pull/15900)

## Licence

WTF.

repository: wclr/yalc

repo_name: wclr/yalc


text:
MathJax Addon
=============

* Author: Tobias Diekershoff
* License: [3-clause BSD](http://opensource.org/licenses/BSD-3-Clause) license
  (see the LICENSE file in the addon directory)

About
-----

This addon for friendica includes the [MathJax][1] CDN to enable rendering of
[LaTeX][2] formulae in your friendica postings.

Configuration
-------------
All you need to do is provide Friendica with the base URL of MathJax. This can
be either the URL of the CDN of MathJax or your own installation.

In case you want to use the CDN you can try the following URL as a quick start

	http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS_HTML

In case you don't want or can use the admin panel of Friendica you can activate
the addon by adding _mathjax_ to the list in your `config/node.config.php` file

	'addons' => [
		...
		'mathjax' => [
			admin => true,
		],
	]

and then providing the base URL after that in the `config/mathjax.config.php` file

	return [
		'mathjax' => [
			'baseurl' => '[the URL to your MathJax installation]',
		],
	];

Usage
=====

Once the addon is configured you can use LaTeX syntax in your postings to share
formulae with your contacts. But remember that the formulae are rendered in the
browser of the user thus your contacts need to activate this addon as well. If
they don't they will only see the LaTeX syntax in your texts.

Just enclose your equations in $$...$$ pairs like e.g. $$f_c(x)=ax+b$$.

[1]: http://www.mathjax.org/
[2]: https://en.wikipedia.org/wiki/LaTeX

repository: friendica/friendica-addons

branch_name: refs/heads/develop

extension: md

gha_language: PHP

license_type: permissive

repo_name: friendica/friendica-addons


text:
# ShenRuby Release History

## Not Yet Released
### Features
- Upgrade to Shen 19.1
- STDERR is now available via *sterror*
- Added `(exit N)` to exit the process with a given return code

## 0.15.1 - March 31, 2014
### Bug Fix
- Fixed Shen version in Gem description

## 0.15.0 - March 31, 2015
### Features
- Added `shen-ruby` executable for running ShenRuby programs outside of REPL
  - Including support for shebang scripts
- Upgrade to Shen 18.1
- Upgrade to Klam 0.0.9 for performance improvements

### Bug Fixes
- Evaluating "c#13;" no longer triggers the message "warning: encountered \r in middle of line, treated as a mere space."

## 0.13.0 - February 3, 2015
### Features
- Upgrade to Shen 17
  - Shen is now BSD-licenesed, making ShenRuby BSD/MIT licenesed

## 0.12.1 - February 1, 2015
### Breaking Changes
- The arity of block arguments to Ruby methods no longer needs to be specified. Now all block arguments are denoted by a `&` followed by the function to pass as the block. Any usages of the old syntax, e.g. `&2`, must be updated to `&`.

## 0.12.0 - January 31, 2015
### Features
- Shen -> Ruby interop
  - See README.md for details

## 0.11.0 - January 15, 2015
### Features
- KLambda implementation switched to [Klam](https://github.com/gregspurrier/klam). This has many implications, including:
  - Significant performance increase. E.g., the Shen Test Suite now runs 2.5 times faster than with ShenRuby 0.10.0.
  - Tail call optimization applies only to self tail calls
  - The environment extends BasicObject rather than Object
  - Shen functions are directly installed as methods on the ShenRuby::Shen instance.
  - Many primitives are inlined.
  - Primitives are less strict with respect to type errors, relying on the Shen type checker to do this work when type checking is enabled.
    - E.g., `(+ "a" "b") no longer throws a type error

### Breaking Changes
- Ruby->Shen interop has changed as a result of the switch to Klam and in preparation for more substantial Ruby<->Shen interop to come. Notably:
  - Underscores in method names are no longer coerced to hyphens before invoking Shen functions. Use `__send__` to invoke Shen functions having names that are not valid Ruby method names.
  - Ruby arrays are no longer automatically coerced to Shen lists and vice versa.

## 0.10.0 - September 19, 2014
### Features
- Upgrade to Shen 16

## 0.9.0 - February 11, 2014
### Features
- Upgrade to Shen 15

## 0.8.1 - January 27, 2014
### Features
- Upgrade to Shen 14.2

## 0.8.0 - November 29, 2013
### Features
- Upgrade to Shen 14

### Misc
- Removed JRuby from "known limitations". ShenRuby runs and passes the test suite under JRuby 1.7.8.

## 0.7.0 - July 3, 2013
### Features
- Upgrade to Shen 13
  - `pr` is no longer a K Lambda primitive
  - `write-byte` added as K Lambda primitive
  - `open` no longer takes stream type as its first argument

### Misc
- Clarify license

## 0.6.0 - June 11, 2013
### Features
- Upgrade to Shen 12

### Bug Fixes
- [KLaSC](https://github.com/gregspurrier/klasc) compliance fixes:
  - if now supports partial application

## 0.5.0 - May 12, 2013
### Features
- Upgrade to Shen 11

### Bug Fixes
- [KLaSC](https://github.com/gregspurrier/klasc) compliance fixes:
  - absvector now raises an error when applied to a negative number

## 0.4.1 - March 21, 2013
### Features
- Upgrade to Shen 9.1

## 0.4.0 - March 15, 2013
### Features
- Upgrade to Shen 9.0

### Bug Fixes
- [Issue 8](https://github.com/gregspurrier/shen-ruby/issues/8) -- `quit` no longer raises a type error when invoked with type checking enabled.
- Fixed many instances of ShenRuby's behavior not matching the Shen CLisp reference implementation:
  - `absvector`, `address->`, `<-address`, `intern`, `n->string`, `pos`, `string->n`, and `tlstr` now throw errors catchable by `trap-error` when type violations occur with their arguments.
  - `tlstr` now raises an error when applied to an empty string
  - `set` and `value` now require their first arugment to be a symbol
  - `hd` and `tl` now raise an error when applied to non-lists
  - `freeze` now supports partial application with zero arguments

## 0.3.1 - January 24, 2013
- No code changes. Updates Gemspec to refer to Shen 8.0.

## 0.3.0 - January 24, 2013
### Features
- Upgrade to Shen 8.0

## 0.2.0 - January 16, 2013
### Features
- Graceful handling of Control-C in ShenRuby REPL [Bruno Deferrari]
- Handle `do` in the K Lambda compiler so that it is eligible for tail call elimination [Bruno Deferrari]
- Ruby->Shen interop
  - Shen functions can now be called from Ruby by invoking the corresponding method on the `ShenRuby::Shen` instance
  - Ruby arrays are coerced back and forth to K Lambda lists
  - Underscores in Ruby symbols are coerced back and forth to hyphens in Shen symbols

### Optimizations
Compared to ShenRuby 0.1.0, 50% faster Shen REPL launch and 38% faster execution of the Shen Test Suite achieved by:
- Faster application of K Lambda primitives when not partially applied
- Inlining of list primitives when not partially applied

### Bug Fixes
- [Issue 4](https://github.com/gregspurrier/shen-ruby/issues/4) -- `and` and `or` may now be partially applied
- [Issue 5](https://github.com/gregspurrier/shen-ruby/issues/4) -- the error raised by applying too many arguments to a function is now caught by `trap-error`.

## 0.1.0 - December 30, 2012
- First public release
- Shen 7.1
- Shen REPL available via `srrepl` executable

repository: gregspurrier/shen-ruby

branch_name: refs/heads/master

gha_language: Ruby

repo_name: gregspurrier/shen-ruby


text:
---
date: 2019-01-30
title: "Run Job - Producing artifacts"
categories:
   - Kubernetes
description: Run Job - Producing artifacts
type: Document
---

If you're using the `Run Job (Manifest)` stage in Spinnaker, it is sometimes helpful to be able to produce arbitrary artifacts.  For example, if you have a run job that produces a Kubernetes manifest, you can have the run job output the manifest in base64 as an `embedded/base64` artifact.

Here's how to achieve this:

* Have your Run Job output the artifacts into STDOUT so they get added to the stage JSON: `SPINNAKER_CONFIG_JSON={"artifacts": [{YOUR_ARTIFACT_JSON}]}`
* Configure the Run Job to Capture Output from "Logs" (not "Artifact")
* Configure the stage "Produces Artifacts" section to match your artifact

Here's an example:

* We have a run job that's going to produce a Kubernetes manifest that looks like this:

```yml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-today
spec:
  replicas: 1
  selector:
    matchLabels:
      app: hello-monday
  template:
    metadata:
      labels:
        app: hello-monday
    spec:
      containers:
      - image: 'justinrlee/nginx:monday'
        name: 'hello-today'
```

* The base64-formatted version of this is roughly like this (depending on spacing of the above):

```base64
YXBpVmVyc2lvbjogYXBwcy92MQpraW5kOiBEZXBsb3ltZW50Cm1ldGFkYXRhOgogIG5hbWU6IGhlbGxvLXRvZGF5CnNwZWM6CiAgcmVwbGljYXM6IDEKICBzZWxlY3RvcjoKICAgIG1hdGNoTGFiZWxzOgogICAgICBhcHA6IGhlbGxvLW1vbmRheQogIHRlbXBsYXRlOgogICAgbWV0YWRhdGE6CiAgICAgIGxhYmVsczoKICAgICAgICBhcHA6IGhlbGxvLW1vbmRheQogICAgc3BlYzoKICAgICAgY29udGFpbmVyczoKICAgICAgLSBpbWFnZTogJ2p1c3RpbnJsZWUvbmdpbng6bW9uZGF5JwogICAgICAgIG5hbWU6ICdoZWxsby10b2RheScK
```

* Create a Spinnaker stage of type "Run Job (Manifest)"

* For the purposes of the example, we're just echo-ing the output, but you could generate the base64 in a number of ways, such as piping helm to base64: `helm template | base64`.  Put this in the Manifest Configuration:

```yml
apiVersion: batch/v1
kind: Job
metadata:
  name: echo
  namespace: spinnaker
spec:
  template:
    spec:
      containers:
      -
        command:
          - echo
          - "SPINNAKER_CONFIG_JSON={\"artifacts\": [{\"type\":\"embedded/base64\",\"name\": \"hello-manifest\", \"reference\": \"YXBpVmVyc2lvbjogYXBwcy92MQpraW5kOiBEZXBsb3ltZW50Cm1ldGFkYXRhOgogIG5hbWU6IGhlbGxvLXRvZGF5CnNwZWM6CiAgcmVwbGljYXM6IDEKICBzZWxlY3RvcjoKICAgIG1hdGNoTGFiZWxzOgogICAgICBhcHA6IGhlbGxvLW1vbmRheQogIHRlbXBsYXRlOgogICAgbWV0YWRhdGE6CiAgICAgIGxhYmVsczoKICAgICAgICBhcHA6IGhlbGxvLW1vbmRheQogICAgc3BlYzoKICAgICAgY29udGFpbmVyczoKICAgICAgLSBpbWFnZTogJ2p1c3RpbnJsZWUvbmdpbng6bW9uZGF5JwogICAgICAgIG5hbWU6ICdoZWxsby10b2RheScK\"}]}"
        image: alpine
        name: manifest-generator
      restartPolicy: Never
```

* Configure the "Output" section as follows:

   * Capture Output From: `Logs`
   * Container Name: `manifest-generator`

* Scroll to the "Produces Artifacts" section, and click "Define Artifact".  Specify these options:

   * Account: "embedded-artifact"
   * Name: "hello-manifest"

   This will generate an artifact "Display name" which can be used in later stages to reference the generated artifact.  For example, this might be "alpine-fox-34"

* To use the artifact, create a "Deploy (Manifest)" Stage that depends on the Run Job stage.  Specify the following:

   * Account: Choose your Kubernetes cluster or account
   * Manifest Source: "Artifact"
   * Manifest Artifact: Select the display name from the previous stage (such as "alpine-fox-34")

* Save and run your pipeline

license: MIT

repository: armory/knowledge-base

gha_language: HTML

gha_license_id: MIT

repo_name: armory/knowledge-base


text:
---
layout: post
title: The Breakup
excerpt: Competition is making it easy to do...
tag:
  - adobe
  - software
  - tech

---

![image]({{ site.url }}/images/2017-12-21-goodbyeadobe.png)

**Dear Adobe,**

By the time you read this, I'll be long gone.

I'm taking my files, fonts, and brush presets with me.

I'd love to say that it's not you, its me.... _but I can't. It's you. It's definitely you._

There were good times, to be sure. I still remember fondly the first time I learned how to use the pen tool in Illustrator 7. The power and possibility of artboards and layers. Transparency, Gradient and Pattern fills. And then I was introduced to the Wacom tablet. And it was beautiful. I didn't have to sketch and scan something onto my computer to start my illustration anymore. I'd have an idea, and you'd be right there waiting. Photoshop 6 was good. And InDesign was just what we needed when Quark Xpress decided it didn't like money anymore.

And there was no one else. I mean, not really. Macromedia was always sniffing around, but it was like the kid wearing black dress socks in gym class.

Things were great for a long time. Then, it got cloudy.

....creative cloudy.

We knew where we stood once. I bought your software. I owned your software. I used your software to create art. Then you'd come up with something new and release a new version, and if it was good enough I'd buy the upgrade. And we'd repeat the cycle.

Now though, it's different. You've become controlling.... nagging. You want me to put all my work on your cloud. Try out this app. Load me on your phone and iPad. Update update update. Your hardware isn't supported anymore, but I let you update the app anyway and now your file won't open. Sync issue. You're logged out. Did you want Stock photos? No? Here's some goddamn stock photos anyway. Why aren't you connected to the internet right now, I can't see what you're doing.

I turned off the notifications, so you started emailing me. Then, when I ran the updates you wanted, notifications were turned back on.

I don't need the notifications. I just need to work. You know, like we used to.

There's enough people yelling at me already.

So, I wish you well. I'm sure our bezier paths will cross again someday. I hope you're in a better place than you are now.

Sincerely,

Doran

*Note: In the interest of full disclosure, the image at the top of this post was created in [Affinity Designer][b7e619b5] by Serif, which I have found to be an excellent replacement for Adobe Illustrator.*

**UPDATE 01/10/2018:** Since this article, I discovered a few unsavory details about cancelling my subscription. I had amassed a large about of illustrations in Adobe Draw, which is an excellent app, but exporting all of them at once is not an option. You can export a project folder, but it only saves the image thats on top and only as a JPEG or PNG. Thats not ideal.

Second, I was expecting them to react to my cancellation request with a counter offer to stay. 90 days free. I get that. What I wasn't expecting was that if I still proceeded with the cancellation, I would be dinged for approximately $80, roughly half of what I'd be paying to reach the end of my subscription. Should have seen that coming...

So. Even though I'll most likely not need to fire up any of the Adobe Products, guess I'll be keeping the subscription alive for a while yet.

I'll update then.

Sincerely,

Doran

  [b7e619b5]: https://affinity.serif.com/en-us/ "Affinity by Serif"


text:
MEXPRESS data processing
========================

Run the wrapper script to download the TCGA data for the cancer types in the file `clinicalParameters.txt`. This file must be located in the working directory!
```
nohup ./mexpressTCGAwrapper > nohup_wrapper.out 2>nohup_wrapper.err &
```
The wrapper script calls the script `downloadTGCAdata`. This script downloads all the necessary data and processes this data using the appropriate R scripts. Once the data has been downloaded and processed, the wrapper script calls the upload script `uploadTCGAdata`, which will then upload all the data to the MySQL database.

Don't forget to update the `uploadTCGAdata` script with your database parameters!

repository: SiYangming/mexpress-legacy

repo_name: SiYangming/mexpress-legacy


text:
# Creating a Collective

Open Collective allows you to create a transparent funding page for your project in just a few clicks. No need to incorporate, hire a lawyer and accountant, or define organizational roles!

Once you've registered on Open Collective, reveal the dropdown menu by clicking on your username, then click on the **+ New** button under the **My Collectives** section.

![Adding a collective](../.gitbook/assets/collectives_creating_a_collective_2021-05-31.png)

Then, select the category that best describes your Collective.

!['Create a Collective' page showing three categories for Collectives: open source projects, community, and climate initiatives.](../.gitbook/assets/collectives_creatingacollective_createacollective_2021-07-5.png)

If you are not creating an [open-source Collective,](https://www.oscollective.org/) you will be immediately directed to a Collective creation form, where you will be asked for your **Collective name**, **URL slug** of choice, and a **brief description** of your Collective's activities.

![](../.gitbook/assets/collectives_creating-a-collective_form_2020-03-23.png)

If you are creating a Collective for an **open-source project**, you will be directed to a verification process to join the [Open Source Collective](https://www.oscollective.org/) fiscal host. [More info about that here](osc-verification/).


text:
# Setting up Raspberry Pi units for use with ODM360

We provide pre-configured images for the various components (Parent, Child, and Timeserver) of the ODM360 kit __(TODO: THAT)__, but for developers or people wishing to customize their setup, this is the full install procedure.

  - For a TimeServer or a Child, this is a Raspberry Pi Zero W (or the WH, which is the same device but has pre-soldered headers, which will save you some work).
    - Note that the non-W version does not have a WiFi chip, and will be more complicated to set up (it can be done, specifically by sharing network over USB from your computer, but you don't want to).
  - For a Parent, you probably want a heavier Raspberry Pi. __TODO: MENTION WHICH ONE__
- Get a decent quality micro SD card. Absolute minimum 8GB, but wouldn't recommend bigger than 64GB (compatibility issues can come up). Read [this](https://www.raspberrypi.org/documentation/installation/sd-cards.md) or do some research if you want to fiddle with it, otherwise buy a bog-standard brand-name SD card and get on with it. I'm using SanDisk Extreme 64GB cards. They seem fine.
- Work somewhere where there's a WiFi router without any complicated settings. You'll need the SSID and password of the router.
  - If there's a captive portal/login page or other complexities (as in a lot of hotels and some co-working spaces) be warned: your life will suck.
  - If need be (for example if the only WiFi you can find has a captive portal) you can do it all tethered to a WiFi Hotspot from your phone.
- You'll need a computer with an SD card reader.

## Set up base infrastructure on the Pi
- Download the Raspberry Pi OS (32-bit) Lite image from [here](https://www.raspberrypi.org/downloads/raspberry-pi-os/). The Lite image doesn't have a graphical interface (it's "headless") and is therefore smaller to download and will run more efficiently on the limited Pi hardware.
- Unzip the archive and flash the image to your SD card using [Balena Etcher](https://www.balena.io/etcher/). You can mess around with other ways to burn images if you are feeling masochistic; Etcher just works, and it's open source.
- After flashing the image, it's a good idea to eject the card. You'll need to put it back in momentarily, but it seems that sometimes things go wrong if you don't eject and re-insert the card.
- Now you need to get the Pi on the WiFi, enable SSH, and connect to it. The SD card you just flashed should appear in your file explorer, open it up.
  - The SD card should now have two partitions, a small one called ```boot``` and a larger one called ```rootfs``` (if you're on Windows you might not see the ```rootfs``` partition; too bad for you—you should be using Linux anyway—but it doesn't matter for now). Put a ```wpa_supplicant.conf``` file in the ```boot``` partition of the SD card. Explanation of that file [here](https://www.raspberrypi.org/documentation/configuration/wireless/headless.md).

```
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
country=TZ

network={
 ssid="OMDTZ-Guest"
 psk="apassword"
}

```

I copy the contents of that example, navigate to the root of the ```boot``` partition on the SD card and type ```nano wpa_supplicant.conf``` and paste in the contents, replacing the SSID, password, and country code with the appropriate ones.
  - Also in the ```boot``` partition, you need to place a file called ```ssh```. It doesn't matter what's in it (an empty file is fine) and there's no extension on the filename. This enables [SSH](https://en.wikipedia.org/wiki/Secure_Shell) on the Pi (disabled by default). You can do this on Linux or Mac by navigating to the root of the ```boot``` partition and typing ```touch ssh```.
- Eject the SD card and remove it from your computer, put it in the Pi, and power it up. Wait about 90 seconds to make sure it has time to boot up before you try to connect to it.
- Make sure your computer is connected to the same WiFi network as the Pi, open a terminal, and type ```ssh<EMAIL_ADDRESS>  - Didn't work? ```Could not resolve hostname...``` or something like it? Sigh. Ok, try to figure out if the Pi is on the WiFi. You can try [nmap](https://nmap.org/) to attempt to identify every device on your local subnet with ```nmap -sP 192.168.X.0/24```, but I recently found a lovely FOSS application called [Angry IP Scanner](https://angryip.org/); it's great. Try it. If you're lucky, you'll see the Pi on the network along with its IP address, and maybe you can ssh into it using the IP address instead of the ```raspberrypi.local``` alias. If not, you'll have to dive into the world of Google, StackExchange, and the Raspberry Pi forums until you get it sorted.
- Log into the Pi using the default password, which is ```raspberry```. Once you're in, immediately type ```passwd``` (_without_ ```sudo```) and—at the prompts—enter first the old and then the new password (twice). Try not to forget the new password.
- Get everything up to date with ```sudo apt update && sudo apt upgrade -y```. This will take a few minutes, more if your Internet connection is slow.
- You might as well install a few more basic infrastructure bits while you're at it:

```
sudo apt install -y git python3-pip libgphoto2-dev libatlas-base-dev gfortran
```
- Fetch and install the ODM360 code

```
git clone https://github.com/OpenDroneMap/odm360
cd odm360
pip3 install -e .

```

From here you have a basic Raspberry Pi configuration; you can make it into a Parent, a Child, or a TimeServer with the next steps.

## Postgresql and accessing it from Python

Install posgresql:

```
sudo apt install postgresql postgresql-contrib
```

Set up a user and database.

- Create a postgres user by
```
sudo su postgres
createuser --interactive
```
Give the user a sensible name like ```odm360``` and make it a superuser

- Run psql and set up that user and a database
```
psql
# GIVE USER A PASSWORD, CREATE A DATABASE, SET DATABASE OWNER TO THE USER, ETC
```

Install psycopg2, an adapter (sort of like a driver) for Python to connect to Postgres

```
sudo apt install libpq-dev
pip3 install psycopg2
```

Try connecting to the database in Python with a connection and a cursor. Proper documentation [here[(https://www.psycopg.org/docs/usage.html). Sample code:

```
import psycopg2

con = psycopg2.connect('dbname=odm360 user=odm360 host=localhost password=mypassword')
cur = con.cursor()
```

Try making a table with the cursor:

```
cur.execute("CREATE TABLE photos(uuid serial PRIMARY KEY, project VARCHAR (50) NOT NULL, survey_run VARCHAR (50) NOT NULL, device VARCHAR (50) NOT NULL, photo_filename VARCHAR (100) NOT NULL, photo_id VARCHAR (50) NOT NULL)")
con.commit()
```

Try sticking some data into that table:

```
cur.execute("INSERT INTO photos VALUES (1,'stonetown', '2020-09-11', 'cam3', 'in/that/folder', 'DCIM123456.jpg');")
con.commit()
```

Try reading it:

```
cur.execute("SELECT * FROM photos")
data = cur.fetchall()
data
```

Clean up after yerself:
```
cur.close()
con.close()
```

## Physical wiring

You will need to connect the serial communication and power pins on the GNSS receiver to the Raspberry Pi Zero (or other Raspberry Pi). Here's an example with an Ardusimple connected to a Zero (note: this cable harness was made with a kit of DuPont connecters and a crimper, which is the way to go if you are doing more than a little of this).

![Pi_wiring](Photos/Pi_wiring.jpg)
![ublox_wiring](Photos/ublox_wiring.jpg)
![Pi_and_ublox_wiring](Photos/Pi_and_ublox_wiring.jpg)

*TODO: photo of Ardusimple with header soldered onto PPS pin and connected to an appropriate Pi GPIO pin*

## Setting up NTP for a server and client device on the local network

### On all devices

Raspberry Pi OS comes with a lightweight version of NTP client called systemc-timesyncd. We want the full NTP service. Set it up with ```sudo apt install ntp```.

Then become root ```sudo su -``` (you should now be root, and have a hashmark rather than a dollar sign as your terminal prompt).

Stop the default lightweight NTP service (systemd-timesyncd) and start the full NTP:

```
systemctl stop systemd-timesyncd
systemctl disable systemd-timesyncd
/etc/init.d/ntp stop
/etc/init.d/ntp start
```

Test it with ```ntpq -pn```. You should see an infodump that lists what timeservers are being contacted and which of them is the reference being used, marked with an asterisk (*). It may take a few minutes after starting NTP for the asterisk to appear (it takes a while for NTP to be sure of the timing over a network; there's actually a lot of sophisticated stuff going on under the hood to account for network latency)

The configuration to choose other timeservers (which we'll use on the client Pi's to select the timeserver Pi), you edit ```/etc/ntp.conf```.

Stop being root with ```exit``` (you should now be the pi user again).

### Server-specific setup (to share time with others)

Again you have to log in as the root user with ```sudo su -``` (and ```exit``` when you're done).

Edit the ```/etc/ntp.conf``` file again, adding the lines:
```
restrict <IP_ADDRESS> mask <IP_ADDRESS>

broadcast <IP_ADDRESS>
broadcast <IP_ADDRESS>
```

### Client-specific setup (assuming you already have a server on the network)

Again you have to log in as the root user with ```sudo su -``` (and ```exit``` when you're done).

You should already have the IP address of the timeserver on your network (if not, you can use the hostname).

Edit the ```/etc/ntp.conf``` file, commenting out the existing servers (which will probably be listed as a pool rather than specific servers). Comment them out, and add a line directing NTP to the server on the network. The relevant section of the ```/etc/ntp.conf``` file should look like this when you're done (of course with the correct IP address at the end):

```
#pool 0.debian.pool.ntp.org iburst
#pool 1.debian.pool.ntp.org iburst
#pool 2.debian.pool.ntp.org iburst
#pool 3.debian.pool.ntp.org iburst
server <IP_ADDRESS>
```

Test with ```ntpq -p```. It may take a few minutes for the client to sync with the server, but when it does, the results of this command should show an asterisk (*) in front of the line for the timeserver.

## TimeServer (now implemented on the Parent)

The TimeServer is a dedicated Raspberry Pi that listens to the GNSS unit and syncs to the ([extremely precise](https://gssc.esa.int/navipedia/index.php/Precise_Time_Reference)) timing pulse from it and provides timing information via [Network Time Protocol (NTP)](https://en.wikipedia.org/wiki/Network_Time_Protocol) to the rest of the kit.

All devices in the ODM360 kit need to have very precise time, _milliseconds count_. Even moving at a walking speed (around 1.5 m/s), more than a few tens of milliseconds of timing offset will already introduce errors larger than the accuracy of a well-functioning GNSS setup. On a vehicle (car, motorcycle, Bajaj, or drone) which moves faster, this is much worse. We aim for synchronization of less than 5ms.

To work well, the TimeServer must listen to both the [NMEA stream](https://en.wikipedia.org/wiki/NMEA_0183) coming from the GNSS, which provides timestamps per reading (not particularly accurate, but close enough for setting time to the second) as well as the [Pulse Per Second (PPS)](https://en.wikipedia.org/wiki/Pulse-per-second_signal) signal that is sub-millisecond precise.

Once its own clock is set from the GNSS device (making it a [stratum 1 device](https://en.wikipedia.org/wiki/Network_Time_Protocol#Clock_strata)), it provides an NTP server to the other devices. This ideally requires a short-wire, very low-latency, symmetrical (same signal time both directions) network connection—we're still working on getting this right.

The PPS signal needs to be on a separate pin (__TODO: PICTURES OF THE PIN WIRING__) and for best precision should use an interrupt instead of a loop.

### Steps to configure the Pi Zero as a TimeServer

*Note: Much of this can be done while setting up the base Pi just after flashing. It's separated out here so that it can be scripted and eventually added to a [.deb package](https://en.wikipedia.org/wiki/Deb_(file_format)) specific to the TimeServer setup.*

- Change the name of the Pi to "timeserver" ```sudo hostnamectl set-hostname timeserver``` and inform the Pi of this in the hosts file ```sudo sed -i 's/<IP_ADDRESS>\tlocalhost/<IP_ADDRESS>\tlocalhost timeserver/g' /etc/hosts```

- Disable IPv6 ```sudo sed -i '$s/$/ ipv6.disable=1/' /boot/cmdline.txt```

- Disable the default serial console to free up UART serial line ```sudo sed -i 's/console=serial0,115200 //g' /boot/cmdline.txt```


text:
# Csharp
C# subsystem for Repeat

For simplicity, all subsystems are versioned using the same version number as the main system (in Java) for every release.

repository: repeats/Csharp

repo_name: repeats/Csharp


text:
# Meliola buteae Hafiz Khan, Azmatullah & Kafi SPECIES

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
Biologia, Lahore 1(1): 112 (1955)

#### Original name
Meliola buteae Hafiz Khan, Azmatullah & Kafi

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
---
layout: post
title: Swedish brass band championships - revisited
date: 2006-11-13T06:59:00.000Z
author: Marcus Hammarberg
tags:
  - BrassBand
modified_time: 2006-11-13T07:11:28.348Z
blogger_id: tag:blogger.com,1999:blog-36533086.post-419045354838279576
blogger_orig_url: http://www.marcusoft.net/2006/11/swedish-brass-band-championships.html
---

[<img
src="http://www.goteborgbrassband.org.se/images/GBB_SM_2006_BAND.jpg"
style="DISPLAY: block; MARGIN: 0px auto 10px; WIDTH: 320px; CURSOR: hand; TEXT-ALIGN: center"
data-border="0" />](http://www.goteborgbrassband.org.se/images/GBB_SM_2006_BAND.jpg)

The Swedish brass band championships took place this weekend and as i
hope it became the best brass band competition ever in Sweden.

Also to my prediction the Gothenburg Brass band went home with the first
price. I am quite proud of getting the first three band, in the right
order a month ahead of the competition. The only thing i missed was the
points. [See for
yourself](http://marcushammarberg.blogspot.com/2006/10/swedish-brass-band-championships.html)

To my opinion Gothenburg was best on the own choice program (the part i
heard) - but not with as much as i expected. Windcorp really made a very
very good effort with Tristan Encounters - which is a very hard piece
indeed.

Full results from the competition [can be found
here](http://www.brassband.se/main.php?page=77)

branch_name: refs/heads/main


text:
#The conscientious cause of the sufferers, called Quakers pleaded and expostulated with their oppressors in this nation of England, and particularly in and about the city of London : and those in power that go about to transport, banish, or suppress them for their meetings, innocently informed, and impartially cautioned, from the innocent and oppressed seed of God, which herein calls for justice and equity, and utterly exclaims against severity and persecution for matters of conscience or religion : wherein first and principally is shewed, the use and end of the publick assemblies of the said sufferers, in answer to several objections against them, 1. with respect to their conscientiousness, as it being their duty to meet, 2. with respect to their innocency and peaceable deportment both to the nation and government therein / by G.W.#

##Whitehead, George, 1636?-1723.##
The conscientious cause of the sufferers, called Quakers pleaded and expostulated with their oppressors in this nation of England, and particularly in and about the city of London : and those in power that go about to transport, banish, or suppress them for their meetings, innocently informed, and impartially cautioned, from the innocent and oppressed seed of God, which herein calls for justice and equity, and utterly exclaims against severity and persecution for matters of conscience or religion : wherein first and principally is shewed, the use and end of the publick assemblies of the said sufferers, in answer to several objections against them, 1. with respect to their conscientiousness, as it being their duty to meet, 2. with respect to their innocency and peaceable deportment both to the nation and government therein / by G.W.
Whitehead, George, 1636?-1723.

##General Summary##

**Links**

[TCP catalogue](http://www.ota.ox.ac.uk/tcp/)  •
[HTML](http://tei.it.ox.ac.uk/tcp/Texts-HTML/free/A65/A65857.html)  •
[EPUB](http://tei.it.ox.ac.uk/tcp/Texts-EPUB/free/A65/A65857.epub) •
[Page images (Historical Texts)](https://data.historicaltexts.jisc.ac.uk/view?pubId=eebo-12291294e&pageId=eebo-12291294e-58896-1)

**Availability**

This keyboarded and encoded edition of the
	       work described above is co-owned by the institutions
	       providing financial support to the Early English Books
	       Online Text Creation Partnership. This Phase I text is
	       available for reuse, according to the terms of Creative
	       Commons 0 1.0 Universal. The text can be copied,
	       modified, distributed and performed, even for
	       commercial purposes, all without asking permission.

**Major revisions**

1. __2004-11__ __TCP__ *Assigned for keying and markup*
1. __2004-12__ __Apex CoVantage__ *Keyed and coded from ProQuest page images*
1. __2005-01__ __John Latta__ *Sampled and proofread*
1. __2005-01__ __John Latta__ *Text and markup reviewed and edited*
1. __2005-04__ __pfs__ *Batch review (QC) and XML conversion*

##Content Summary##

#####Front#####

#####Body#####

1. The Consciencious Cause of the Sufferers (called Quakers) pleaded, &c.

**Types of content**

  * Oh, Mr. Jourdain, there is **prose** in there!

There are 1 **ommitted** fragments!
 @__reason__ (1) : illegible: blotted (1)  •  @__extent__ (1) : 1 letter (1)

**Character listing**

|Text|string(s)|codepoint(s)|
|---|---|---|
|General Punctuation|•—|8226 8212|

##Tag Usage Summary##

###Header Tag Usage###

|No|element name|occ|attributes|
|---|---|---|---|
|1.|__author__|2||
|2.|__availability__|1||
|3.|__biblFull__|1||
|4.|__change__|5||
|5.|__date__|8| @__when__ (1) : 2005-10 (1)|
|6.|__edition__|1||
|7.|__editionStmt__|1||
|8.|__editorialDecl__|1||
|9.|__extent__|2||
|10.|__idno__|6| @__type__ (6) : DLPS (1), STC (2), EEBO-CITATION (1), OCLC (1), VID (1)|
|11.|__keywords__|1| @__scheme__ (1) : http://authorities.loc.gov/ (1)|
|12.|__label__|5||
|13.|__langUsage__|1||
|14.|__language__|1| @__ident__ (1) : eng (1)|
|15.|__listPrefixDef__|1||
|16.|__note__|5||
|17.|__notesStmt__|2||
|18.|__p__|11||
|19.|__prefixDef__|2| @__ident__ (2) : tcp (1), char (1)  •  @__matchPattern__ (2) : ([0-9\-]+):([0-9IVX]+) (1), (.+) (1)  •  @__replacementPattern__ (2) : http://eebo.chadwyck.com/downloadtiff?vid=$1&page=$2 (1), https://raw.githubusercontent.com/textcreationpartnership/Texts/master/tcpchars.xml#$1 (1)|
|20.|__projectDesc__|1||
|21.|__pubPlace__|2||
|22.|__publicationStmt__|2||
|23.|__publisher__|2||
|24.|__ref__|2| @__target__ (2) : https://creativecommons.org/publicdomain/zero/1.0/ (1), http://www.textcreationpartnership.org/docs/. (1)|
|25.|__seriesStmt__|1||
|26.|__sourceDesc__|1||
|27.|__term__|1||
|28.|__textClass__|1||
|29.|__title__|3||
|30.|__titleStmt__|2||

###Text Tag Usage###

|No|element name|occ|attributes|
|---|---|---|---|
|1.|__closer__|1||
|2.|__date__|1||
|3.|__dateline__|1||
|4.|__desc__|1||
|5.|__div__|2| @__type__ (2) : title_page (1), treatise (1)|
|6.|__g__|94| @__ref__ (94) : char:EOLhyphen (93), char:EOLunhyphen (1)|
|7.|__gap__|1| @__reason__ (1) : illegible: blotted (1)  •  @__extent__ (1) : 1 letter (1)|
|8.|__head__|1||
|9.|__hi__|147||
|10.|__p__|29| @__n__ (2) : 1 (1), 2 (1)|
|11.|__pb__|16| @__facs__ (16) : tcp:58896:1 (2), tcp:58896:2 (2), tcp:58896:3 (2), tcp:58896:4 (2), tcp:58896:5 (2), tcp:58896:6 (2), tcp:58896:7 (2), tcp:58896:8 (2)  •  @__rendition__ (7) : simple:additions (7)  •  @__n__ (13) : 3 (1), 4 (1), 5 (1), 6 (1), 7 (1), 8 (1), 9 (1), 10 (1), 11 (1), 12 (1), 13 (1), 14 (1), 15 (1)|
|12.|__q__|4||
|13.|__trailer__|1||


text:
django-redcap
=============

Utilities for porting REDCap projects to and from Django models.

What it does
------------

[Djredcap] (https://github.com/dmegahan/django-redcap) and [djfixture] (https://github.com/cbmi/djFixture) are 2 scripts that automate the process of transferring patient or survey data from Redcap to Harvest. The programs work alongside one another to create a models.py file, a fixtures.json file and a filename.json file.

When djredcap is run on a data dictionary from redcap, it will iterate through each line in the file, grouping each field (a line in a data dictionary describes a field) by their form names and printing each form as a json object. The json file outputted by djredcap now contains each form, with every field grouped into a form. Djredcap then iterates through the forms in the json file and builds the model.py file by reading each fields information and constructing the models.py file form by form.

Install and Setup
-----------------

**Dependencies**

`inflect`

```bash
easy_install inflect
```
--------------------
To install:

1. Download django-redcap from github
2. Enter /django-redcap/ and do

```bash
python setup.py sdist
cd dist
tar xvfz django-redcap-0.1.12b2.tar.gz
cd django-redcap-0.1.12b2
python setup.py install --user
```

Once installed, simply add `djredcap` to your `INSTALLED_APPS` project settings:

```python
INSTALLED_APPS = (
    'djredcap',
    ...
)
```

Commands
--------

Djconvert and djfixture function alongside one another. For both of them to work correctly, they must be run in the correct order. djconvert should be run first. Djredcap creates an intermediary json file that describes each form, including each field and its information, from the redcap data dictionary submitted in djconvert. This json file is used in djfixture to describe the models.py file.

Commands are executed using the `redcap` command with a sub-command, e.g.:

```bash
./manage.py redcap [options] subcommand [args]
```

**inspect**

The basic command. The inspect command takes in a redcap data dictionary and outputs a
models.py file based on the dictionary, along with an intermediate JSON file describing
the data dictionary. For better control over the output of the subcommands, it is recommended to use json and models together to replace inspect. Inspect writes two files, making it messy to control where both are written.
```bash
./manage.py redcap inspect path/to/exported/data_dictionary.csv
```
**convert**

The convert command takes the data dictionary and directly writes to models.py.
The json file that would normally be output (inspect) is not created.

Use -o or -output-file to provide a path for models.py.

```bash
./manage.py redcap convert path/to/exported/data_dictionary.csv
```
**models**

The models command takes the intermediate JSON file and writes a models.py file based on it.

Use -o or -output-file to provide a path for models.py.

```bash
./manage.py redcap models path/to/generated/json_file.json
```
**json**

The json command takes the data dictionary from redcap as input and outputs an intermediate JSON file.

Use -o or -output-file to provide a path for the json file.

```bash
./manage.py redcap json path/to/exported/data_dictionary.csv
```
**fixture**

The fixture command creates a django data fixture from a redcap data file, a JSON intermediate file(generated
from inspect or json commands) and a django project name. The name of the outputted file is fixtures.json.

Use -o or -output-file to provide a path for fixtures.json.

```bash
./manage.py redcap fixture path/to/exported/data_file.csv path/to/generated/json_file.json django_project_name
```

How to use it
-------------
You will need a REDCap data dictionary (.csv). A data dictionary would be a file that
describes the fields in the database you are looking to create a model of. Each line in a data dictionary would
be a description of a field, from its name, form, branching logic, type, etc.

Use the inspect command to create a models.py file from the REDCap data dictionary.
For example:
```bash
./manage.py redcap inspect data_dictionary.csv
```
Outputted will be a json file named after the data dictionary and the models.py file. The json intermediate is
currently used to create a fixtures.json file, since it is schema based on the model.

To create a fixtures.json file to go along with your models.py file, you will need a REDCap data file (.csv) that
contains data from the matching database, the matching intermediate file created from running the inspect or json
commands, and the name of your django project.

```bash
./manage.py redcap fixture data.csv intermediate.json projectname
```

How it works
-------------

djconvert
========

There are 2 main parts to djconvert. The function(csv_2_json) that generates the json file from the
data dictionary, and the function(json_2_dj) that generates the models.py file from the intermediate json
file.

**csv_2_json**

[csv_2_json](https://github.com/cbmi/django-redcap/blob/master/djredcap/management/subcommands/djconvert.py#L51), in the simplest terms, parses through the data dictionary, line by line, and groups the fields in the dictionary by their form name, while retaining the rest of the field information.

*Non-repeating fields*
Non-repeating fields are simple. When a new form is found by reading the fields information, a json syntactic form,
which the form's information and empty list of fields, is generated([generate_json_form](https://github.com/cbmi/django-redcap/blob/master/djredcap/management/subcommands/djconvert.py#L405)). Each field in that form is added to that list([generate_json_field](https://github.com/cbmi/django-redcap/blob/master/djredcap/management/subcommands/djconvert.py#L415)). Once a different form is started, [the previous form is printed](https://github.com/cbmi/django-redcap/blob/master/djredcap/management/subcommands/djconvert.py#L93).

*Repeating fields*
This is done by constructing lists of lists of lists of fields, called repeating_rows, based on their form names
and if they are a part of repeating groups. A repeating group is a group of fields, where the first field in the group has startrepeat "num" "new form name" and the last field in the group has endrepeat. A repeating group can be
nested inside another repeating group, and so on. repeating_rows mirrors the nesting, by creating the same relationship inside lists of lists([last_inner_append](https://github.com/cbmi/django-redcap/blob/master/djredcap/management/subcommands/djconvert.py#L301)).

Once all the endrepeats have been matched up with startrepeats(there is no more repeating fields), repeating_rows is cleaned of any junk fields(clean_list,blank fields created by last_inner_append or fields that only contain "endrepeat") and each form is related to the form it is nested inside by create_form_relations. Each list in repeating_rows is then ordered by appearance in the list([order_list](https://github.com/cbmi/django-redcap/blob/master/djredcap/management/subcommands/djconvert.py#L232)).

Repeating_rows is then appended to all_repeats, which holds all the repeating rows in the current form. Once a new field form is encountered, all_repeats is printed([95](https://github.com/cbmi/django-redcap/blob/master/djredcap/management/subcommands/djconvert.py#L94)).

**json_2_dj**

[json_2_dj](https://github.com/cbmi/django-redcap/blob/master/djredcap/management/subcommands/djconvert.py#L440) works by loading in each json form, read from the intermediary created before, and reading each field in it.
The first thing printed is the form information(class form_name). If the form name contains a ‘~’, then it was a
repeating form and a foreign key field is created. A string, to be printed, is created based on the fields
“attributes”, like field type, field note, field label, field name, etc. The field is then printed to the models.py.

djfixture
=========

[djfixture](https://github.com/cbmi/django-redcap/blob/master/djredcap/management/subcommands/djfixture.py) uses the json intermediary to retrieve the relevant data from the REDCap data csv.
Each form in the json file is parsed, one by one. Once a form has been read in, the program reads through each line
in the data csv, which corresponds to an individual record. If a form is a repeating form, the number of repeats is
stored and the name of the forms it relates to is stored in list([93](https://github.com/cbmi/django-redcap/blob/master/djredcap/management/subcommands/djfixture.py#L93)).

The [generate_repeating_fixtures](https://github.com/cbmi/django-redcap/blob/master/djredcap/management/subcommands/djfixture.py#L158) function is then called. This function creates a number of fixtures, based on the
number of repeats, and populates them with data. This is done by looping through each field in the form, determining
the matching field in the data file by using the field’s name and type ([get_field_name](https://github.com/cbmi/django-redcap/blob/master/djredcap/management/subcommands/djfixture.py#L344), [get_field_names](https://github.com/cbmi/django-redcap/blob/master/djredcap/management/subcommands/djfixture.py#L391)). Once the
right field has been found, the data and field name are stored in a fixture and added to a list of fixtures ([289](https://github.com/cbmi/django-redcap/blob/master/djredcap/management/subcommands/djfixture.py#L289), [335](https://github.com/cbmi/django-redcap/blob/master/djredcap/management/subcommands/djfixture.py#L335)).
Once all forms have been parsed and the fixture list has been populated, it is printed ([print_fixtures](https://github.com/cbmi/django-redcap/blob/master/djredcap/management/subcommands/djfixture.py#L455)).

More in-depth comments can be found in djconvert and djfixture.

repository: chop-dbhi/django-redcap

gha_language: Python

repo_name: chop-dbhi/django-redcap


text:
# RubyGems

Compatible with probably with any type of guest distro, will hook into the `cache`
folder under the result of running `gem env gemdir` as the default SSH user (usualy
`vagrant`) on your guest. If you use rbenv / rvm on the guest machine, make sure
it is already installed before enabling the bucket, otherwise you won't benefit
from this plugin.

To manually enable it:

```ruby
Vagrant.configure("2") do |config|
  config.vm.box = 'some-box-with-ruby-installed'
  config.cache.enable :gem
end
```

## Heads up about `bundle install --deployment`

Please note that when the `--deployment` flag is passed on to `bundle install`
your gems **will not be cached** since bundler ends up skipping the default gem
cache dir. For more information about this, please check [GH-62](https://github.com/fgrehm/vagrant-cachier/issues/62).

repository: fgrehm/vagrant-cachier

repo_name: fgrehm/vagrant-cachier


text:
# react-navigator

This is a react version of the [react-native navigator](https://facebook.github.io/react-native/docs/navigator.html) used in apps.
We use this to implement the same navigating behavior in iOS and Web.

** This is a work in progress. No way to use this in production. Contributions welcome.**

*Documentation stolen from react-native by Facebook:*

## Navigator Methods
If you have a ref to the Navigator element, you can invoke several methods on it to trigger navigation:

### Implemented
* getCurrentRoutes() - returns the current list of routes
* jumpBack() - Jump backward without unmounting the current scene
* push(route) - Navigate forward to a new scene, squashing any scenes that you could jumpForward to
* pop() - Transition back and unmount the current scene
* popToTop() - Pop to the first scene in the stack, unmounting every other scene

### TBD
* popToRoute(route) - Pop to a particular scene, as specified by it's route. All scenes after it will be unmounted
* replace(route) - Replace the current scene with a new route
* replaceAtIndex(route, index) - Replace a scene as specified by an index
* replacePrevious(route) - Replace the previous scene
* immediatelyResetRouteStack(routeStack) - Reset every scene with an array of routes
* jumpForward() - Jump forward to the next scene in the route stack
* jumpTo(route) - Transition to an existing scene without unmounting

repository: mosch/react-navigator

repo_name: mosch/react-navigator


text:
# WhisperHub

[日本語](README-ja.md) ・ English

### A **masked** micro-blogging social media service 🎭

WhisperHub is a open-source micro-blogging service written in typescript. However, it's not just one.

## Anonymous User

In WhisperHub, you don't have to set your user's name. All posts are published without user's name. It's like 2ch, a Japanese BBS.

See [Wiki (In Japanese)](https://wiki.citringo.net/doku.php?id=whisperhub) to get more information.

## Requirement

- node
- npm or yarn
- mongodb

## To Build

``` shell
git clone https://github.com/xeltica/whisperhub
cd whisperhub

# install all deps
npm i
# and run it
npm run dev

# if you want to use yarn
yarn
yarn dev
```

## Contributing

If you want to report bugs, improvements, or new features to me: [Issues](/xeltica/whisperhub/issues)

If you want me to merge your code: [Pull Requests](/xeltica/whisperhub/pulls)

## LICENSE

Under [MIT LICENSE](LICENSE). You can create your own instance at your own risk, but you **must not** delete my copyright notation.

repository: EbiseLutica/whisperhub

repo_name: EbiseLutica/whisperhub


text:
# RTP formatted ID

[![Build Status](https://travis-ci.org/UKHomeOffice/rtp-formatted-id.svg?branch=master)](https://travis-ci.org/UKHomeOffice/rtp-formatted-id)
[![npm version](https://badge.fury.io/js/rtp-formatted-id.svg)](https://www.npmjs.com/package/rtp-formatted-id)

This module creates non-sequential ids to use in your applications. The aim is to avoid duplicates: the longest the id
you creates, the most unlikely the creation of duplicates is.

## Usage

To use straight off with the default format, you can simply do.

``` JavaScript
var FormattedId = require('rtp-formatted-id');
var formattedId = new FormattedId();
formattedId.generate();  // outputs something like EF-435670-LU
```

##### Advanced

If you set the format to something that uses the `mapYear` and / or `mapProduct` initialisers (Y or P respectively) then
you must supply the options to the `generate` function. An example is below: -

``` javascript
var FormattedId = require('rtp-formatted-id');
var formattedId = new FormattedId({
  format: 'Y-P-NN-LL',
  products: {
      productName: {
          applicationTypeName: 'A',
          otherApplicationTypeName: 'B'
      },
      otherProductName: {
          applicationTypeName: 'C'
      }
  }
});
formattedId.generate({
    // pass 2016 as argument to the method identified by the letter Y, in this case mapYear
    Y : 2016,
    // pass object as argument to the method identified by the letter P, in this case mapProduct
    P : {
        product: 'productName', // matches a product set in the FormattedId config
        applicationType: 'applicationTypeName' // matches an applicationType set in the FormattedId config
    }
});  // outputs something like A-A-72-DH
```

Note, config can be passed to the constructor on initialisation or you can call the `setConfig` method.

Some more examples of possible formats are as follows: -

```
format: 'LLLNNNLLL  // outputs something like PLW682LMV
```

This will create an id composed by 3 letters, 3 numbers, 3 letters.
You can use separators in the format, that will be conserved.

```
format: 'LLL-NNN-LLL  // outputs something like PLW-682-LMV
```

## How it works

In the folder `initialisers` you'll find pre-made modules that can be added to your config. Each module needs to exports
two things: `method` and `identifier`.

``` javascript
module.exports = {
    method: mapYear,
    identifier: 'Y'
};
```

The method is what outputs your result; the identifier is the letter that gets used in the config to identify strings made
out of that component. So, in the example above, `mapYear` maps the years to alphabet letters, and therefore adding Y's to
the config will create sequences of the mapped letter. For example: -

```
format: 'LLLNNNLLL-Y  // outputs something like PLW682LMV-A
```

Conversely, you can pass arguments indexed by letters to the `generate` method -- they will be distributed to the correct
component.

``` javascript
var FormattedId = require('rtp-formatted-id');
var formattedId = new FormattedId();
//  pass 2016 as argument to the method identified by the letter Y, in this case mapYear
formattedId.generate({
   Y : 2016
});
```

All the components in the `initialisers` folder are loaded automatically. You can add your own as long as they have the
same interface and map to a letter unambiguosly.

## Using the demo

To provide you with a quick evaluation tool, you can use the script `demo.js`. Run it as a bash script after doing a
`chmod +x` to make it executable, or do `npm install -g` and run `demo` in your terminal.

You must specify how many codes you want to generate and the format to use. For example: -

```
./demo.js 100 LL-NNN-YY  // 100 codes in format letter-letter-number-number-number-mapYear-mapYear
```

You can also use the options -a (pass a json string as arguments to `generate`, see above) and -o (show the output).

```
./demo.js 100 LL-NNN-YY -a '{ "Y": 2016 }' -o true   // pass 2016 to mapYear, show the codes
```

Please note that the generation may take a long time if you specify a very high number of codes, especially with `-o true` enabled.

## Caveats

This software doesn't guarantee the ids will be unique. A short config like `LL-NN` is likely to generate conflicts after
a few hundred runs. Conversely, a longer config like `LLLLL-NNNNN` is unlikely to have one conflict after one million runs.
You can use the various initialisers to protect yourself even further, by adding deterministic parts to the generated id,
until you reach a degree of risk that is either negligible or acceptable.

repository: UKHomeOffice/rtp-formatted-id

gha_language: JavaScript

repo_name: UKHomeOffice/rtp-formatted-id


text:
# TITAN tracking of storms in WRF output
Code and documentation for tracking simulated thunderstorms in WRF output.

Tim Raupach<EMAIL_ADDRESS>

This code was written by me (Tim Raupach) while I was a postdoc in the Institute of Geography and Oeschger Centre for Climate Change Research, University of Bern, Bern, Switzerland.

Affiliation:
- Until 31.12.2019: Institute of Geography and Oeschger Centre for Climate Change Research, University of Bern, Bern, Switzerland.
- Current affiliation: Centre for Climate Change Research, UNSW Sydney, Sydney, Australia.

Documentation - setup:

- [How to compile TITAN](doc/compiling_TITAN.md).
- [How to compile script dependencies](doc/compiling_dependencies.md).
- [Required R packages for R code](doc/required_R_packages.md).

Documentation - running:

- [How to run TITAN on permutations of threshold values](doc/test_params.md).
- [How to track storms in WRF output using TITAN](doc/running_TITAN_on_WRF.md).
- [How to collect hail properties from WRF/TITAN output](doc/collecting_hail_properties.md).

Structure:

- [WRF_config](WRF_config) -- WRF namelist.input file and information.
- [code](code) -- scripts, split into ncl, R, and sh.
- [data](data) -- support data for storm tracking (subdomain definitions).
- [doc](doc) -- documentation.
- [threshold_optimisation](threshold_optimisation) -- reports showing TITAN threshold optimisation.

LROSE utilites:

- Modified versions of LROSE utilities that are used in this project are available under a [separate repository](https://github.com/traupach/modified_LROSE_utils). Parameter files for the LROSE utilities, including optimisted parameter files per microphysics scheme, are available under that repository.

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4667884.svg)](https://doi.org/10.5281/zenodo.4667884)

repository: traupach/stormtrack

repo_name: traupach/stormtrack


text:
---
layout: default
---

# 1994-09-21 - Re: Laws Outside the U.S.

## Header Data

From: Cyber City<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 566dd48615faeb8f80876c8deefd2df5ae7cfca919d1c0395074b907fb8c8c20

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-09-21 17:46:18 UTC

Raw Date: Wed, 21 Sep 94 10:46:18 PDT

## Raw message

```
{% raw  %}From: Cyber City<EMAIL_ADDRESS>Date: Wed, 21 Sep 94 10:46:18 PDT
To<EMAIL_ADDRESS>Subject: Re: Laws Outside the U.S.
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Tim May writes:

> Indeed. One of the mysteries is why so few French are on our list...I
> can't recall any, actually. Their country has some of the most
> draconian laws, it is alleged, and, as Phil notes, an active SDECE
> industrial espionage unit.

I noticed the following in sci.crypt recently.  There are some useful crypt-
analysis papers in the archive, among other things:

> From<EMAIL_ADDRESS>Wed Sep 14 11:52:18 EDT 1994
> Subject: New WWW-Crypto-server
> Organization: Ecole Normale Superieure, Paris, France
>
> We are happy to annonce the birth of the html pages of our team :
>
> http://www.ens.fr/equipes_dmi/grecc
>
> Most of our papers are available.
>
>  --Serge for the GRECC team.

The French company BULL makes a nice encrypting laptop computer, called
"Sub Rosa", which is used by Canada's Department of national revenue auditors.

--
Alex Brock

{% endraw %}
```

## Thread

+ Return to [September 1994](/archive/1994/09)

+ Return to "[Adam Shostack <adam@bwh.harvard.edu>](/authors/adam_shostack_adam_at_bwh_harvard_edu_)"
+ Return to "[Cyber City <cyber1@io.org>](/authors/cyber_city_cyber1_at_io_org_)"
+ Return to "["Perry E. Metzger" <perry@imsi.com>](/authors/perry_e_metzger_perry_at_imsi_com_)"

+ 1994-09-21 (Wed, 21 Sep 94 10:46:18 PDT) - Re: Laws Outside the U.S. - _Cyber City<EMAIL_ADDRESS>  + 1994-09-21 (Wed, 21 Sep 94 12:06:18 PDT) - [Re: Laws Outside the U.S.](/archive/1994/09/7803a552903e0c2caf46ba4390226a10afec9e9aff91a43b373ed6faed97ab81) - _Adam Shostack<EMAIL_ADDRESS>    + 1994-09-21 (Wed, 21 Sep 94 14:36:11 PDT) - [Re: Laws Outside the U.S.](/archive/1994/09/467659f99fd695e7412047e1df29be011b6ed9f31b65436fa15c777e2076d23a) - _"Perry E. Metzger"<EMAIL_ADDRESS>


text:
---
title: "Detection of Acute Respiratory Distress Syndrome by Incorporation of Label Uncertainty and Partially Available Privileged Information"
date: 2019-07-01
publishDate: 2020-07-13T03:35:36.551899Z
authors: ["Elyas Sabeti", "Joshua Drews", "Narathip Reamaroon", "Jonathan Gryak", "Michael W. Sjoding", "Kayvan Najarian"]
publication_types: ["1"]
abstract: "Acute respiratory distress syndrome (ARDS) is a fulminant inﬂammatory lung injury that develops in patients with critical illnesses including sepsis, pneumonia, and trauma. However, many patients with ARDS are not recognized when they develop this syndrome nor given outcome-improving treatments. Because ARDS is a clinical syndrome, physicians may not be certain about a patient’s diagnosis (label uncertainty). In addition, the diagnosis requires a chest x-ray, which may not be always be available in a clinical setting (privileged information). For this paper, we implemented the Learning Using Label Uncertainty and Partially Available Privileged Information (LULUPAPI) paradigm, built on classical SVM, to detect ARDS using Electronic Health Record (EHR) data and chest radiography. In comparison to SVM, this resulted in a 3.55 percent improvement of test AUC."
featured: false
summary: "*IEEE Engineering in Medicine and Biology Conference*"
publication: "*2019 41st Annual International Conference of the IEEE Engineering in Medicine and Biology Society (EMBC)*"
url_pdf: "https://ieeexplore.ieee.org/document/8857434/"
doi: "10.1109/EMBC.2019.8857434"
url_code: "https://github.com/kayvanlabs/ARDS/tree/master/SVMp%2B"
url_project: 'https://nickreamaroon.com/project/lupi/'
tags: ["Publication"]

---

repository: nreamaroon/academic-kickstart

repo_name: nreamaroon/academic-kickstart


text:
---
layout: post
title:  "Weekly Update #24 - Blades, bugs and crushers 15.8 - 21.8"
date: 2016-08-21 14:29:00
---
I've had a quite productive week, both in terms of game content and bug fixes. Let's got to all of it!
The winter environment uses blades a lot as environment hazards, and I spent some time tweaking the blades. Mainly, now the blades turn red if the player hits them. The effect isn't perfect, but I think it looks quite nice, and makes the blades look cooler and more dangerous.

![There was blood everywhere!](/assets/WeeklyUpdates/24/BladeEdge.gif)
While working on the big blades, I got an idea to add smaller blades that are shot by cannons introduced to the game a while ago. So, a few sprites and few lines of code later I had cannons launching spinning blades to the levels!

![There was blood everywhere!](/assets/WeeklyUpdates/24/CannonBlades.gif)
I also added an arrow that points to hostages in levels. I realized that it's frustrating if the player hops on to the truck at the end of a level, and then noticed that the level was failed, because he failed to pick up the hostage. Now it should be more obvious when there is a hostage in a level.

![The arrow is rotated and all that jazz!](/assets/WeeklyUpdates/24/Arrow.png)
Finally, I added crusher entities, that look like giant hammers. The crushers drop from the ceiling, and as their name says, they crush anything that gets in their way. I reused the crushing code from the elevators. I am also quite proud of the crusher sprite, it turned out really well.

![There was blood everywhere!](/assets/WeeklyUpdates/24/Crusher.gif)
All in all, I have a pretty nice set of obstacles and hazards to use in level creation for the winter environment. I've already made a few levels, but there is still some missing. The winter environment is coming along nicely though.
While tweaking the blades, I noticed that I had run out of entity type flags. I use a bitflag approach for types, which makes collision masking very easy and nice. However, a 32-bit integer couldn't hold my entity types anymore, and I decided that the most sustainable approach would be to switch to using std::bitset, which works like an array of booleans. Now, my entity types simply refer to an index in the array, and the class offers utilities for and-ing and or-ing values together. The change only ended up taking about 20 minutes, which was a pleasant surprise to someone who was prepared to spend the whole day refactoring the type system!
Next week I want to keep on working on the winter environment and probably fix more bugs too. I also should start thinking about ideas for the winter boss. That's it for this week, thanks for dropping by!

*   Fixed controller vibration
*   Fixed decal clearing
*   Fixed player jump and animation states
*   Fixed character force friction on ice
*   Fixed NPC movements on ice
*   Fixed a few SDL warnings
*   Fixed particle clearing in level editor
*   Fixed brush list boxes getting focus while hidden
*   Fixed terrain brushes on top rows of levels
*   Fixed entity property dialog showing even if there isn't a property
*   Fixed entities getting placed at the end of an area selection
*   Fixed entity property dialog popping to weird places at weird times
*   Fixed area selection not working of the property text entry was selected
*   Fixed list boxes reporting false positive hover values
*   Fixed player walking out of bounds if hoving on a brush listbox
*   Fixed bullets not colliding with crumble blocks
*   Fixed bullets colliding with dead pilots
*   Fixed editor crashing when the selected entity is deleted
*   Fixed scrolling in listboxes
*   Fixed dead players being able to pick up health and ammo kits
*   Fixed crushing spawning multiple entities
*   ...and a bunch of other smaller tweaks and fixes

extension: markdown


text:
---
title: "ejunkie"
created_at: Sun Aug  7 06:23:40 MDT 2016
kind: article
tags:
  - ejunkie
  - ecommerce
---

e-junkie features page

Add ecommerce to your website in minutes with easy drop-in code snippets

E-junkie is designed for people who want a feature-rich shopping cart for
their own website or blog, without having to be expert coders or deal
with the headaches of a bloated off-the-shelf software suite. We’ve
gone for that perfect balance between simplicity and customizability.

### Subscription Pricing

monthy # storage remote-caching
$5 	10 	200 MB 	no
$10 	20 	1 GB 	no
$15 	40 	2 GB 	no
$20 	60 	3 GB 	YES

### Supported Payment Processors

PayPal Payments Standard

PayPal Payments Advanced

PayPal Payments Pro

PayPal Payflow Pro

2CheckOut

Authorize.Net

TrialPay

ClickBank


text:
---
label: new-features-in-goland-2021-1
date: 2021-05-24
title: New Features in GoLand 2021.1
technologies: [go, web, containers, kubernetes]
topics: []
author: dlsniper
subtitle: A selection of useful features from GoLand 2021.1
thumbnail: ./thumbnail.png
cardThumbnail: './card.png'
playlistItems:
    - /tips/run-targets-wsl/
    - /tips/go-embed-support/
    - /tips/test-bench-fatal-calls/
    - /tips/add-keys-to-struct-field-tags/
    - /tips/change-struct-tag-style/
    - /tips/json-to-go-struct-type/
    - /tips/add-json-fields-to-struct-types/
    - /tips/quickly-handle-go-error/
    - /tips/create-missing-struct-type-with-all-fields/
    - /tips/create-getters-and-setters/
    - /tips/extract-type-refactoring/
    - /tips/rename-go-module-name/
    - /tips/handle-go-errors-with-postfix-completion/
    - /tips/get-container-and-tag-completion-for-docker-files/
    - /tips/check-apis-from-the-ide/
    - /tips/builtin-html-preview/
    - /tips/kubernetes-convert-resources-format/
    - /tips/kubernetes-delete-resource-from-run-button/

---

GoLand 2021.1 was released on April 7th, 2021! It allows you to build
and run your program remotely via Docker, SSH, and WSL 2, use newly
supported features from Go 1.16, including //go:embed, quickly generate
code from JSON, and handle errors with ease using new quick fixes,
among other new features and enhancements!

Check out
DataGrip 2021.1 What's New
and
WebStorm 2021.1 What's New to read all about the new features
related to database and modern web development included in GoLand.


text:
---
layout: default
---

# 1997-06-08 - IRA (was Re: [CONTROVERSIAL]: A Defense of Terrorism)

## Header Data

From: Adam Back<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 8b1ddbf6e2b7cb91570d3fb4b65820126625184acfeec5505dd11c3e7171ec84

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1997-06-08 17:10:21 UTC

Raw Date: Mon, 9 Jun 1997 01:10:21 +0800

## Raw message

```
{% raw  %}From: Adam Back<EMAIL_ADDRESS>Date: Mon, 9 Jun 1997 01:10:21 +0800
To<EMAIL_ADDRESS>Subject: IRA (was Re: [CONTROVERSIAL]: A Defense of Terrorism)
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

William Geiger<EMAIL_ADDRESS>writes
> Paul Bradley<EMAIL_ADDRESS>writes:
> >I live in mainland England. NI, although still violent, is now not the
> >only place bombed by the IRA, until a few years ago they mainly attacked
> >targets in NI, they now bomb all over the country.
>
> Well I can only see this as a good thing. :)
>
> It is the people of England that support that illegal occupation of Irish
> soil by Brittish troops. It is only right that they should have to suffer
> the consequences.

Personally I would be happy for all UK police and military forces to
pull out of Northern Ireland.  Give it back to them, see if I care.
What difference can it make to me?  Foreign intervention is a waste of
time in my book.

However, here are a few things you might be interested to know.  I
understand the majority of people in Northern Ireland do not want to
be part of Southern Ireland.  The people in NI have been there for
multiple generations, and probably also don't want to be relocated to
England.  Many of these people are English descent and their ancestors
where given land by the British government which was stolen from
native Irish about 300 years ago.  They have also intermarried.
British government was brutal at that time, before they turned soft
and lost their empire.  (You might see parallels with the US, where
you guys are also living on stolen property).

Perhaps most NI people would not actually be that badly off if they
were part of SI.

You should also realise that IRA and supporters are minority in NI
today, for a sense of perspective.

In the mean time the IRA and the opposing paramilitary organisation
blow up, assasinate, knee-cap each other, protestants, catholics, joy
riders, and a few innocent bystanders, and I think both deal in drugs,
and are involved in organised crime to fund their activities.  IRA
makes attempts to blow up UK politicians.  Managed to smuggle rocket
launcher in van with hole cut in roof to within a few hundred yards of
10 Downing St.  But they missed.  (Dimitri says: shame, shame, and
increases Sinn Fein campaign contributions in the hope they are better
funded next time.)

(I forget name, but there is a non-governmental paramilitary group on
other side to IRA in NI, occasionally there is rumor that British Army
is feeding this paramilitary organisation names of IRA suspects to
hit, to save them the trouble).

You guys remember the Faulkland Islands thing under Thatcher?  Some
miniscule lump of rock with a few hundred sheep farmers on it?  UK
government sent warships etc at multiple billion cost.  Would've been
cheaper to desert rock, and give each and every inhabitant a cool $1
million relocation expenses.  But no, had to waste money because some
alterior motive, suitable missile outpost or something.

Wonder what the interest is in Northern Ireland?

Should give the Irish (go Paddy) back Northern Ireland, Scottish
autonomy also (haggis home rule:-).  Wales (leeks) too, yeah.
Fragmented government is a good thing, divide and conquer.  I
understand the Muslims want their own government over here also!

Some Scottish people want home rule (Scottish Independence Party?),
they had a vote on it and lost a while back.  Wales is a poor part of
the country, some richer people have bought second home holiday
cottages in picturesque welsh country side.  Result: drives up prices
for poorer locals.  A few welsh started burning down such cottages.
Some Welsh also want independence.  They have road signs in English
and in a language which most of the locals can't even read.  Similar
thing in Southern Ireland.  (Desparately hanging on to heritage).

Adam

ps Paddy is generic name for an Irishman, a haggis is a stuffed part
of sheeps anatomy, a peculiar highland delicacy, nick name for
Scotsman, leek is a vegetable, some kind of Welsh emblem, and used as
name for Welshman.  Scots call English Sasenachs (I lived in Scotland
for a couple of years, you get so you can understand what it is
they're saying after a while :-).  Not sure of Welsh and Irish names
for English.  US name is `Limey'.  OK `Yankees' :-) Vote Indian home
rule: Running Deer for president.

{% endraw %}
```

## Thread

+ Return to [June 1997](/archive/1997/06)

+ Return to "[Adam Back <aba@dcs.ex.ac.uk>](/authors/adam_back_aba_at_dcs_ex_ac_uk_)"
+ Return to "[David Lucas <davidlu@sco.COM>](/authors/david_lucas_davidlu_at_sco_com_)"
+ Return to<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)](/authors/dlv_at_bwalk_dm_com_dr_dimitri_vulis_kotm_)"
+ Return to "[Paul Bradley <paul@fatmans.demon.co.uk>](/authors/paul_bradley_paul_at_fatmans_demon_co_uk_)"
+ Return to "["William H. Geiger III" <whgiii@amaranth.com>](/authors/william_h_geiger_iii_whgiii_at_amaranth_com_)"

+ 1997-06-08 (Sun, 8 Jun 1997 20:24:54 +0800) - [Re: [CONTROVERSIAL]: A Defense of Terrorism](/archive/1997/06/48ec67d158d927a8768f81bdb359effd8e2cd69ddc322c97ed1744aa740e95b7) - _"William H. Geiger III"<EMAIL_ADDRESS>  + 1997-06-08 (Sun, 8 Jun 1997 21:53:30 +0800) - [Re: [CONTROVERSIAL]: A Defense of Terrorism](/archive/1997/06/0cb6d390b9205b404aca5b7e510398a910c4447233594eb03cf82edf3850d25f) -<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)_
    + 1997-06-08 (Mon, 9 Jun 1997 00:13:33 +0800) - [Re: [CONTROVERSIAL]: A Defense of Terrorism](/archive/1997/06/b179364765fd9d05a59acd152f226e68a3f5de71bc9eed7a2ff275332cc72cc6) - _Paul Bradley<EMAIL_ADDRESS>      + 1997-06-08 (Mon, 9 Jun 1997 00:31:56 +0800) - [Re: [CONTROVERSIAL]: A Defense of Terrorism](/archive/1997/06/e9a5441ae6acd9590dc727f4715d33f15378a5d9f8c75cff45935b74a8808127) -<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)_
  + 1997-06-08 (Mon, 9 Jun 1997 01:10:21 +0800) - IRA (was Re: [CONTROVERSIAL]: A Defense of Terrorism) - _Adam Back<EMAIL_ADDRESS>    + 1997-06-09 (Mon, 9 Jun 1997 21:29:35 +0800) - [Re: IRA (was Re: [CONTROVERSIAL]: A Defense of Terrorism)](/archive/1997/06/9493ea6f102642ef13828580dd6502876a3249d837262bc2021c4f84c2f3cc7b) -<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)_
      + 1997-06-10 (Wed, 11 Jun 1997 02:55:30 +0800) - [Re: IRA (was Re: [CONTROVERSIAL]: A Defense of Terrorism)](/archive/1997/06/87e10af7235d45e6051efb76e3197ba0e90114089afecdfa281327fbb5421df3) - _Adam Back<EMAIL_ADDRESS>    + 1997-06-09 (Mon, 9 Jun 1997 23:34:11 +0800) - [Re: IRA (was Re: [CONTROVERSIAL]: A Defense of Terrorism)](/archive/1997/06/9d4645097035ccd28d61518e36f31aba1f4b888551e9e218a5bdf25e8bd732d3) - _Paul Bradley<EMAIL_ADDRESS>  + 1997-06-09 (Mon, 9 Jun 1997 22:42:32 +0800) - [Re: IRA (was Re: [CONTROVERSIAL]: A Defense of Terrorism)](/archive/1997/06/47a9a007e211cfa8a15d3344c501344dfec337e65622e436a47d3afc63a57707) - _David Lucas<EMAIL_ADDRESS>


text:
## Project overview
The goal of this project is to build and test mass voting systems in Javascript. In the running instance, a test is run which will build a random number of voters who vote for a number of parties. The application can run assessments on the data and return a candidate with the most votes, or alternatively all tied candidates.

### Running the project ###
The application can be run at https://izzykupferstein.github.io/js-election-simulator/. There will be a 2+ second delay as data is being generated. See console for logged output.

There is an exposed variable `election` you can use to access the Election Object.

The `election` Object's structure is as follows:

`{ candidates: [{ name: 'Abe Lincoln', votes: [{ name: 'James Green', age: 42, gender: 'male' }, ... ], ... ] }`

repository: izzykupferstein/js-election-simulator

repo_name: izzykupferstein/js-election-simulator


text:
Storing Gold traces in BigTable
===============================

This implementation is based on the original btts.go made for Perf.
See perf/BIGTABLE.md for an overview of that schema.

Note that we assume our BigTable instance is strongly consistent, which is
only valid if there is no replication (which we shouldn't need for now).

Data we want to store
---------------------

We need to store traces, which are arranged in a table.
Traces have commits as their columns, a tiling.traceID as their rows, and
a digest as their cells. These traceIDs are derived from the key:value pairs
associated with the digest, e.g. {"os":"Android", "gpu": "NVidia1080"}

Gold has an idea of a tile, which is a collection of N of these trace columns (i.e. commits).

Mapping the data to BigTable
----------------------------

BigTable (BT) stores its data as one big table. Concretely, we have

```
     | col_1  | col_2  | col_3  | ...
==================================
row_1| [data] | [data] | [data] | ...
row_2| [data] | [data] | [data] | ...
...
```

For performance, BT provides [Column Families](https://cloud.google.com/bigtable/docs/schema-design#column_families_and_column_qualifiers)
which group columns together so you can query some cells from a row belonging
to that family w/o getting everything. As an analogy, if the whole table is a Sheets
workbook, a column family can be thought of as a single spreadsheet in that workbook (at least,
for our purposes).

BT uses the term "Column Qualifier", which essentially just means "column name", because they
can be arbitrary strings.

It's tempting to just put the commit hashes as columns, the trace ids as the row names and store the
digests in the cells, but this isn't ideal for these reasons:

  1. traceIDs get really long with lots of params - BT has a limit of 4kb per
     row name (aka a row key).
  2. BT has a soft limit of 100Mb of data per row.
  3. BT will perform better if each row contains only the columns we are interested in
    reading. Since we only really want to fetch the last few hundred commits, we would
    like to limit each row to contain enough data for a single tile.
    See also https://cloud.google.com/bigtable/docs/performance#slower-perf
  4. We want to split our rows up further into shards, so we can execute multiple queries at once
     (one query per shard).

To address these performance issues, we need to store our traces and some auxiliary data:
  - an OrderedParamSet (OPS for short) that can convert tiling.TraceId (long string)
    to/from EncodedTraceId (short string).
  - The Options key/values that are a part of the trace, but don't affect the traceID
    or filtering/searching.

These data, along with the traces, will be stored using 3 Column Families and can
logically thought of being stored as independent "tables" or "spreadsheets" even
though they are all stored in the "one big table".

Row naming scheme
-----------------
There is a row naming scheme (for all 4 tables) as follows:

    [shard]:[namespace]:[type]:[tile]:[subkey]

Where shard and subkey are optional (can be ""). Some tables have tile with a constant value.
"namespace" is constant for all tracestore data: "ts". Reminder that there's one table per Gold
instance, so if we store other data to BT (e.g. expectations, tryjobs, etc) we need to have
several unique namespaces.

tile is a 0 padded 32 bit number (2^32-1) - [tile number].
For example, tile 0 (the oldest commits) is number `2147483646`.
Note that this reverses the order of the tiles, i.e. new tiles have
smaller numbers, so that we can do a simple query to find the newest tile.

BigTable can easily fetch rows starting with a given prefix, so this naming schema
is set up to request things of a type for one or more tiles, with optional sharding.

Note that sharding is a thing we have enabled by our choice of row names, not something
given out for free by BigTable.

Gold (and Perf) shards its data based on the subkey (conceptually subkey % 32)
This makes the workload be spread more evenly, even when fetching only one tile.
The shards come first in the naming convention to try to spread the rows across multiple
tablets for better performance (rows on BT are stored on tablets sorted by the entire row name).

Storing the OrderedParamSet for traceIDs
----------------------------------------
As mentioned above, traceIDs are derived from the paramtools.Params map of key-value pairs.
We compress these maps using a paramstool.OrderedParamSet which concretely look like:

    ,0=1,4=2,3=1,

To do this compression/decompression, we need to store the OrderedParamSet (OPS).
There is one OPS per tile. Conceptually, an OPS is stored like:
```
          |   OPS   |    H   |
==============================
ops_tile0 | [bytes] | [hash] |
ops_tile1 | [bytes] | [hash] |
...
```

The bytes stored in under the "OPS" column are just a gob encoded OrderedParamSet and
the hash stored under the "H" column is the hash of the OPS, used to query the row when updating.

As mentioned before, ops_tile0 is a conceptual simplification of the actual
row name. Given the row naming schema, we define "type" for OPS to be "o" and
let "shard" and "subkey" both be "".
Thus, the actual row for tile 0 would be

    :ts:o:2147483646:

Storing the traces
------------------

With all the auxiliary data set, we can look at how the traces themselves are stored.
Going with the default tile size of 256, the data would be like:

```
             | offset000 | offset001 | ... | offset255
====================================================
tile0_trace0 |  [dig_1]  |  [dig_1]  | ... | [dig_2]
tile0_trace1 |  [dig_1]  |  [dig_2]  | ... | [dig_2]
...
tile0_traceN |  [dig_8]  |  [blank]  | ... | [dig_6]
tile1_trace0 |  [blank]  |  [dig_2]  | ... | [blank]
...
```

The columns are the offset into a tile of a commit. For example, the third commit in a repo would
end up in tile 0, offset 3. The 1000th commit with a tile size of 256 would be in
tile 3 (1000 / 256), offset 232 (1000 % 256). This has the effect of wrapping a given
trace across many tiles. The column values are zero padded so they sort lexicographically.

The rows follow the standard naming scheme, using "t" as "type", and making use of the shards
(32 by default). The value for "subkey" is the encoded ParamSet (and from this subkey a shard
is derived). An example row for encoded ParamSet ",0=1,1=3,3=0," on tile 0 (assume shard
calculates to be 7) would be:

    07:ts:t:2147483646:,0=1,1=3,3=0,

The cells are the 16 bytes of the digest that were drawn according to that ParamSet.
Blank cells will be decoded to MISSING_DIGEST ("") [We will sometimes represent blank cells with
a single null byte].

Storing the trace Options
----------------------------------------
Options are small map[string]string. Since Options are submitted per entry
(i.e. alongside a digest), we store them, but only care about the latest one (most recent commit).

```
             |     B
==========================
tile0_trace0 |  [bytes]
tile0_trace1 |  [blank]
...
tile0_traceN |  [bytes]
tile1_trace0 |  [blank]
...
```

We store the maps as strings, encoded like trace keys (`,key1=value1,key2=value2,`) which can use
less disk (since GOB needs to specify the type of the encoded object) and allows us to intern the
option maps, using less RAM on decoding.

Of note, the timestamp applied to each cell will be the commit time. Options aren't expected to be
flaky (digests can be flaky from run to run), so once they are set for a given trace+commit, they
won't be overwritten except by a later commit.

The rows have the same names as their trace counterparts, with the exception of the type
(and column family). We only read the most recent cell value, which corresponds to the latest
commit. There is a garbage collection policy that will clean up older cell values over time.

An example row for encoded ParamSet ",0=1,1=3,3=0," on tile 0 (assume shard
calculates to be 7) would be:

    07:ts:p:2147483646:,0=1,1=3,3=0,

repository: msftenhanceprovenance/skia-buildbot

repo_name: msftenhanceprovenance/skia-buildbot


text:
---
id: 585
title: Random reads 1
date: 2016-09-04T13:21:18+00:00
author: Nick Ang
layout: post
guid: http://www.nickang.com/?p=585
permalink: /rr1/
categories:
  - thought of the day
---
I've broken the promise of writing every day for a few days in a row now, and I'm starting to feel a bit sick of blaming myself for it. So I'm pasting a few passages I'd read today that brightened my day and injected inspiration where it is lacking.

## How to become a great programmer

I googled that, and was presented with 2.44 million results. I picked the first three. Two of them were Quora answers to the exact question I asked, which came with tens of different answers each. I read them all - here are sensible answers among the lot:

- Answers from [Quora](https://www.quora.com/What-is-the-best-way-to-become-a-great-programmer), word-for-word:
    - Get outside of the “engineering cave” and learn how business works. (checked)
    - 80–20 everything! (I consider myself lazy, so checked)
    - Leverage your technical skills to solve problems that provide huge value. (not yet)
    - You need to put in at least few years into core programming, and work on at least 4-5 good product based projects. (started seriously [learning](https://www.freecodecamp.com/nickangtc) to code in June, so that's 3 months. Far from checking this one)
- From [gamedev.net](http://www.gamedev.net/blog/355/entry-2250592-become-a-good-programmer-in-six-really-hard-steps/):
    - Get into the mentality that a day/week/month in which you have not learned something interesting is a failure. There's enough stuff out there that you surely can learn something cool every day. (checked)
    - Write lots of code. At some point when you've made a few projects, read other people's code. (not writing quite as much code as I sometimes feel I am)
    - Specifically, learn a variant of the Lisp programming language, just because it's worth the time to explore the philosophy of good programming. (heard this one before on a Reddit post on coding virtual-reality games - starting to explore this with [The Little Schemer](https://medium.com/getting-technical/day-18-i-know-nothing-1d068aae5c18#.2894oylwd))

As an aside, I just received Steven Pressfield's The War of Art in the mail and have started reading it. Even the prologue got me nodding. Definitely a book worth writing notes on - will do a post on it once I'm done with it, which should be very soon. Its subtitle reads: "Break through the blocks and win your inner creative battles."

repository: nickangtc/old-jekyll-blog

repo_name: nickangtc/old-jekyll-blog


text:
# Drechslera tuberosa (G.F. Atk.) Shoemaker, 1959 SPECIES

#### Status
SYNONYM

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

#### Published in
Can. J. Bot. 37: 881 (1959)

#### Original name
Helminthosporium tuberosum G.F. Atk., 1897

### Remarks
null

path: /life/Fungi/Ascomycota/Dothideomycetes/Pleosporales/Pleosporaceae/Pyrenophora/Pyrenophora japonica/ Syn. Drechslera tuberosa/README.md


text:
# Max Hauri Max Smart 2.0

Support package to send packets to [Max Smart 2.0](https://maxsmart.ch) smart plugs using the local UDP protocol.
The protocol is probably compatible with any other [Revogi](https://revogi.com) devices that also support v3 of their protocol.

Currently doesn't support pairing or other devices.

## Features

Supports changing the power state of a plug and getting the current usage as well as basic pairing.

## Example

```js
const mh = require("mh-maxsmart2");

(async () => {
    // Tell plug how to connect to wifi. Sets spoofed max smart cloud credentials, if these are used.
    // Warning: this sends the wifi credentials in a way that is discoverable for devices that aren't in the wifi.
    const deviceInfo = mh.pair({
        wifiSSID: "WiFi SSID",
        wifiPassword: "WiFi password",
        uid: "MHM000000000", // this is the ID of the registered user in the maxsmart cloud service.
        server: "localhost", // defaults to "www.maxsmart.ch"
        port: 5000 // defaults to 5000
    });
    // Get power usage on plug
    console.log(await mh.send(deviceInfo.sn, deviceInfo.ip, mh.CMD.GET_WATT));
})();
```

## License

[MIT](LICENSE)


text:
### [CVE-2022-40235](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-40235)
![](https://img.shields.io/static/v1?label=Product&message=IBM%20InfoSphere%20Information%20Server&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=%3D%2011.7%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Vulnerability&message=Denial%20of%20Service&color=brighgreen)

### Description

"IBM InfoSphere Information Server 11.7 could allow a user to cause a denial of service by removing the ability to run jobs due to improper input validation. IBM X-Force ID: 235725."

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/karimhabush/cyberowl

repository: trickest/cve

repo_name: trickest/cve