text:
# Atlas 200 DK x DJI Tello Ryze
Introducing the Ascend Eco-Platform for Intelligent UAVs - Enabled by the Atlas 200 DK and DJI Tello to achieve real-time deep learning solutions and fast prototyping for developers.
This project was created while keeping in mind of modularity and fast prototype development. We hope to build ready-to-use modularized capabilities for developers interested in taking deep learning to the realm of UAVs.

### Useful Links
[Official Atlas 200 DK Developer Kit](https://support.huaweicloud.com/intl/en-us/environment-deployment-Atlas200DK202/atlased_04_0029.html "Atlas 200 DK Upgrade")

[Ascend Samples](https://gitee.com/ascend/samples)

[Ascend ModelZoo](https://www.hiascend.com/en/software/modelzoo)

[DJITelloPy](https://github.com/damiafuentes/DJITelloPy) - third party open-source Python interface built on top of the official Tello SDK

[TP Link Wireless Router Setup](https://github.com/Ascend-Huawei/HiFly_Drone/wiki/TP-Link-Wireless-Router-Setup)

[HiFly Introduction YouTube Video 📹](https://youtu.be/zZQy9RBLlEo)

### Hardware Requirements
- [Atlas 200 DK](https://e.huawei.com/ph/products/cloud-computing-dc/atlas/atlas-200)
- [DJI Tello Ryze](https://www.ryzerobotics.com/tello)
- Wireless Router (TP-Link TL-WR902AC)

## Table of Content
[Installation](#installation)

[How to run the project](#how-to-run-the-project)

[Code Implementation and how to extend](#code-implementation)

[Available Modules](#available-modules)

## Installation
1. Git clone this repo

    `git clone  https://github.com/Ascend-Huawei/HiFly_Drone.git`

2. Navigate to the project directory:

    `cd HiFly_Drone`

3. Create and activate python virutal environment:

    `python3 -m hifly hifly && source hifly/bin/activate`

4. Install the required dependencies to run this project:

    `pip3 install -r requirements.txt`

## How to run the project
This section covers how to run inference on UAV's camera livefeed.

1. Refer to the [list of supported modules](#available-modules) below and download the one you wish to run. Once downloaded, store the `.om` file inside the `models` subdirectory.

2. Turn on DJI Tello and connect it to the 200 DK via a wireless router. For more details, please refer to the [TP Link Wireless Router Setup Guide](https://github.com/Ascend-Huawei/HiFly_Drone/wiki/TP-Link-Wireless-Router-Setup).
    >Note that you are not limited to only TPLink Wireless Routers

3. Once the offline model is in place and the UAV is connected to the 200 DK. Activate the virtual environment and navigate to the project's `src` subdirectory:

    1. To prepare the presenter server to view live video footage

        `bash lib/server/run_presenter_server.sh uav_presenter_server.conf`

    2. Run real-time inference

        `python3 main.py`

4. Running the above will prompt a manual on the terminal. Select the task and models you wish to use. The inference result can be found at http://<IP_ADDRESS>:7007.

    Click [here](#code-implementation) to learn more about what the program is doing in the back

## Code Implementation

The modularity feature of this project is enabled by the `ModuleSelector`. It takes the user's specification and dynamically load the corresponding  `Processor`  to handle real-time inference

|   File   |         Description           |
|:--------:|:-----------------------------:|
| `main.py`| Main script to invoke the interface and prompts user to select a model for inference      |
| `ModuleSelector.py`     | `ModuleSelector` Python class that takes the user's specifications and decides which task-specific `Processor` to load for inference |
| `BaseProcessor.py`      | Parent Processor class responsible for initialization of ACL resources and Model parameters. Each inference model have their respective `Processor` (child of `BaseProcessor`) for pre-and-post processing |
| `params.py`             | Hash table storing information for each task (which offline model to use and its corresponding Processor)

### Project Extension
To add your own inference module to this project, you need:

1. An offline model stored in the `model` subdirectory (you can view the projects in [Ascend Samples](https://gitee.com/ascend/samples) for more ideas or use the Ascend Tensor Compiler [ATC] to convert .caffe or .pb models into .om models).

2. Write a custom `Processor` class (inherited from `BaseProcessor`) to take care of the offline model's inputs and outputs by overriding the preprocess and postprocess methods.

3. Register the model's info to the dictionary in `src/utils/params.py` such that the `ModuleSelector` will know which Processor and model to load during selection

    For example, to add a YOLO face detector module for object detection, you would add another dictionary item inside object_detection. The dictionary is required to have the following keys to run the `ModuleSelector` and `Processor`: `model_width`, `model_height`, `model_path`, `model_processor`
    ```python
    "object_detection": {
        "face_detection": {
                "model_width": 416,
                "model_height": 416,
                "model_path": os.path.join(paths["MODEL_PATH"], "face_detection.om"),
                "model_processor": "FaceDetectionProcessor",
                "model_info": "<model description>",
                "camera_width": "<optional parameters>"960,
                "camera_height": 720,
            }
    }
    ```
    > Note that you may also pass in other parameters in the dictionary for later uses by deconstructing them in the `params` argument in your `Processor` class

## Available Modules
A list of currently available modules
### Objection Detection
- [YOLO Face Detector](https://gitee.com/ascend/samples/tree/master/python/contrib/head_pose_picture)

- [YOLOv3 Object Detection](https://gitee.com/ascend/samples/tree/master/python/level2_simple_inference/2_object_detection/YOLOV3_coco_detection_picture)

- [Hand Detection](https://gitee.com/ascend/samples/tree/master/python/contrib/hand_detection_Gitee)

branch_name: refs/heads/main


text:
---
layout:     post
title:      Fermionic criticality is shaped by Fermi surface topology &#58 a case study of the Tomonaga-Luttinger liquid
subtitle:   Anirban Mukherjee, Siddhartha Patra and Siddhartha Lal
date:       2020-05-06
author:     htscruc
header-img: img/pic.jpg
catalog: true
tags:
    - effective field theory
---

The authors studied the RG flow of the one-dimensional Hubbard model using a URG approach, emphasising the  role of Fermi surface topology. How much the idea invloved in such an 1D study can be generalized to understand the critical behavior in higher dimension remains to be seen.

arXiv link: [2005.02332](https://arxiv.org/abs/2005.02332v1)

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
---
hide: true
---

<!-- does not need translation -->

# Links

## Reference Links

Please try to use reference links where possible using the `[text][link_name]`
syntax, and move the actual links to the bottom of the page.

```md
# Title

Some linked [text][link_name]. And some more content.

And here is some more text.

[link_name]: https;//box.com
```

gha_language: JavaScript


text:
# saverelease

A perl script to convert an R package (well, mostly R/qtl) to be named
"[package]release", so I can have two versions installed (development
version "qtl" + released version "qtlrelease"). This way I can more
easily check how things are behaving in the released version.

It basically goes through and replaces "qtl" with "qtlrelease"
throughout.

This is a really old script with some minor updates.

### License

Licensed under the [MIT license](LICENSE.md). ([More information here](http://en.wikipedia.org/wiki/MIT_License).)

repository: kbroman/saverelease

repo_name: kbroman/saverelease


text:
[![Build status](https://ci.appveyor.com/api/projects/status/x9ergljy7cbs8ph3/branch/master?svg=true)](https://ci.appveyor.com/project/RamblingCookieMonster/appveyor-dsc-test)

This is a small POC. The idea is that we can test DSC configurations.

* Commit a change
* AppVeyor spins up a VM
* We trigger a DSC configuration of whichever config we want to test
* We use pester to verify the results

Caveats:

 * [No reboots](http://help.appveyor.com/discussions/kb/13-machine-restart-during-build).
 * You need to handle dependencies (e.g. download and extract the DSC Resource Kit).
 * This might not be a pristine VM. You get a new VM from AppVeyor, but AppVeyor makes their own changes.

More details in the associated blog post: [Testing DSC Configurations With Pester and AppVeyor](https://ramblingcookiemonster.wordpress.com/2015/03/01/testing-dsc-configurations-with-pester-and-appveyor/)

repository: RamblingCookieMonster/AppVeyor-DSC-Test

repo_name: RamblingCookieMonster/AppVeyor-DSC-Test


text:
# Claire's Cookbook
Search and save recipes from [CookBookAPI](https://github.com/KKetter/CookBookAPI) to your personal user account. After making a recipe, or when you save it, add notes to the recipes for next time, or to help you remember something special about the recipe.
[View Deployed Version Here](https://clairescookbook.azurewebsites.net/)

## Technologies, Tools, and Libraries
### Languages
- C#
- CSS
- HTML
- SQL
### Libraries and Frameworks
- ASP.Net Core
- EntityFrameworkCore
- Cookbook API
### Tools
- Visual Studios.
- Azure Dev Ops
- Git
- Github
- Draw IO

## Cookbook API
[View API documentation here](https://github.com/KKetter/CookBookAPI)
Summary: The cookbook API is a open, RESTful API that contains recipes, including their instructions and ingredients. We used this API to search for recipes a user could save to their personal list of recipes.

## Schema
![Schema Image](Assets/Schema.png)

### Schema Description
- The user contains a Primary Key of ID(int), UserName(varchar). User has the navigational property of Saved Recipes. It has a one to many relationship with SavedRecipes.
- SavedRecipes contains a Primary Key of ID(int) a Foreign Key of UserID(int) referencing the User table. It also contains a ApiRecipeID which is a reference to the Recipe inside the API. It has a one to many relationship with comments.
- Comments has a Primary Key of ID(int) a foreign key of SavedRecipesID, and a Comment(varchar). It has a navigational property of SavedRecipes and a many to one relationship with SavedRecipes.

## Set Up Instructions - Local Machine
- Fork the Cookbook repository.
- Open project in Visual Studios.
- Open user secrets. Establish a default connection of your local host.
```
    "DefaultConnection": "Server=(localdb)\\MSSQLLocalDB;Database=CookbookWebApp;Trusted_Connection=True;MultipleActiveResultSets=True",
```
- Double check for any build errors.
- Open up your Package Management Console.
- Type text "Add-Migration" and hit enter.
- You will be prompted to add a name. This is semantic and be anything.
- Once migration has been added, type text "Update Database" and hit enter.
- You now have a database set up for your program.
- Run program with IIS Express.
- Note: The database is pre-seeded with several users.

## User Instructions and Walkthrough
- Upon opening the web page for the first time, please select the link "My Profile" in the vertical nav bar.
- Enter in the username of your choice. If it is unique, it will redirect you to your user profile. If that name is already taken, you will be prompted to enter in another name.
- From the user page you may edit or delete your user, or log out. You will also be logged out if you close the window.
- To search for a recipe, enter a query into the search bar. If you leave the search bar blank, all available recipes will populate. You can search for new recipes from any page.
- After searching for a recipe, view details to see ingredients, instructions, and an image if available.
- On the details page, there is an option to save the recipe. If you chose to do so, it will be saved to your username.
- To view saved recipes, click the My Recipes link in the nav bar. This will show you a list of all your saved recipes. Select the details link to view the instructions and ingredients.
- When you view the details of a saved recipe, you will be given to option to add notes to your recipe, such as "great date night meal" or "cook an extra 15 minutes". These notes can be viewed from the recipe, or fromt he My Notes link on the nav bar.

## Images
#### Homepage
![homepage](Assets/sample_img/home.PNG)
#### Create and Login
![create](Assets/sample_img/create.PNG)
![login](Assets/sample_img/login.PNG)
![User view](Assets/sample_img/userpage.PNG)
#### Search Recipes
![search results](Assets/sample_img/search_results.PNG)
![search recipe details](Assets/sample_img/search_recipe_results.PNG)
![saved search recipe](Assets/sample_img/save_searched_recipe.PNG)
#### View Saved Recipes
![saved recipes list](Assets/sample_img/saved_recipes.PNG)
![saved recipes details](Assests/sample_img/saved_recipe_view.PNG)
#### Notes
![view notes](Assets/sample_img/notes_view.PNG)
![view all notes](Assets/sample_img/all_notes.PNG)

## Contributors
Ryna Truong, Nate Tibbals, Clarice Costello, Michael Goseco

repository: ntibbals/Cookbook-Web-App

gha_language: C#

gha_license_id: MIT

repo_name: ntibbals/Cookbook-Web-App


text:
# icy-proxy
Icy re-encoder proxy server

## Channels
Create a `channels.js` which exports a standard JS object with keys as channel names and values icy mp3 channels.

**NOTE** For each request to `/listen.mp3` a new stream is created, this server does not do multiplexing.

## Background
Recently I bought an [Amazon Alexa](https://www.amazon.com/s/?field-keywords=alexa) device and wanted to listen to [DI.fm](https://www.di.fm).

Alexa API requires any URL to use SSL, eg. `https://`, but DI.fm streams are plain HTTP. So this proxy is used also as an SSL-icy gateway.

It seems that Alexa only supports MP3 streams (and it has to be kinda like 128kbps or so) and because DI.fm Premium offers only 320kbps streams I needed a way to re-encode the stream.

It is totally possible to multiplex the stream (eg. have the proxy stream to multiple clients but maintain only one connection to underlying stream). *I'm pretty sure this scenario would have been illegal in case of paid service like DI.fm.* Anyway I was not going to implement multiplexing because I respect DI.fm and I pay for one account and I only have single client at a time listening to a single stream.

### TODO

1. Refactoring

repository: googoid/icy-proxy

repo_name: googoid/icy-proxy


text:
# BC Notice of Family Claim: Docassemble Automation

This Docassemble extension automates the BC Supreme Court Form F3, Notice of Family Claim, with Schedule 3 attached. The F3 with Schedule 3 is for claiming spousal support.

The resulting guided interview is hosted at [legalforms.wohanley.com](http://legalforms.wohanley.com).

## Author

William O'Hanley<EMAIL_ADDRESS>


text:
# Blueprint/Boilerplate For Golang Projects

[![Build Status](https://travis-ci.com/MartinHeinz/go-project-blueprint.svg?branch=master)](https://travis-ci.com/MartinHeinz/go-project-blueprint)
[![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=MartinHeinz_go-project-blueprint&metric=sqale_rating)](https://sonarcloud.io/dashboard?id=MartinHeinz_go-project-blueprint)
[![Test Coverage](https://api.codeclimate.com/v1/badges/ec7ebefe63609984cb5c/test_coverage)](https://codeclimate.com/github/MartinHeinz/go-project-blueprint/test_coverage)
[![Go Report Card](https://goreportcard.com/badge/github.com/trung85-go/go-project-blueprint)](https://goreportcard.com/report/github.com/trung85-go/go-project-blueprint)

## Blog Posts - More Information About This Repo

You can find more information about this project/repository and how to use it in following blog posts:

- [Ultimate Setup for Your Next Golang Project](https://towardsdatascience.com/ultimate-setup-for-your-next-golang-project-1cc989ad2a96)
- [Setting up GitHub Package Registry with Docker and Golang](https://towardsdatascience.com/setting-up-github-package-registry-with-docker-and-golang-7a75a2533139)
- [Building RESTful APIs in Golang](https://towardsdatascience.com/building-restful-apis-in-golang-e3fe6e3f8f95)
- [Setting Up Swagger Docs for Golang API](https://towardsdatascience.com/setting-up-swagger-docs-for-golang-api-8d0442263641)

### Setting Up
- Replace All Occurrences of `trung85-go/go-project-blueprint` with your username repository name
- Replace All Occurrences of `blueprint` with your desired image name

### Adding New Libraries/Dependencies
```bash
go mod vendor
```

### Using GitHub Registry

Create and Push:

```bash
docker login docker.pkg.github.com -u <USERNAME> -p <GITHUB_TOKEN>
docker build -t  docker.pkg.github.com/trung85-go/go-project-blueprint/blueprint:latest .
# make container
docker push docker.pkg.github.com/trung85-go/go-project-blueprint/blueprint:latest
# make push
```

List all docker packages on github: https://github.com/trung85-go/go-project-blueprint/packages

Pull and Run:

```bash
docker pull docker.pkg.github.com/trung85-go/go-project-blueprint/blueprint:latest
docker run -p 1234:1234 \
           -e BLUEPRINT_DSN="postgres://<USER>:<PASSWORD>@<DOCKER_SERVICE/URL>:<PORT>/<DB>?sslmode=disable" \
           -e BLUEPRINT_API_KEY="api_key" \
           docker.pkg.github.com/trung85-go/go-project-blueprint/blueprint:latest
```

### Setup new SonarCloud Project
- https://docs.travis-ci.com/user/sonarcloud/
- On _SonarCloud_:
    - Click _Plus_ Sign in Upper Right Corner
    - _Analyze New Project_
    - Click _GitHub app configuration_ link
    - Configure SonarCloud
    - Select Repository and Save
    - Go Back to Analyze Project
    - Tick Newly Added Repository
    - Click Set Up
    - Click Configure with Travis
    - Copy the Command to Encrypt the Travis Token
    - Run `travis encrypt --com <TOKEN_YOU_COPPIED>` (generate token in SonarCloud)
    - Populate the `secure` Field in `.travis.yml` with outputted string
    - Follow steps to populate your `sonar-project.properties`
    - Push
- On Travis CI:
    - Set `DOCKER_USERNAME`.  (organization github trung85-go)
    - Set `DOCKER_PASSWORD` to Your GitHub Registry Token (develop github token)

### Setup CodeClimate
- Go to <https://codeclimate.com/github/repos/new>
- Add Repository
- Go to Test Coverage Tab
- Copy Test Reporter ID
- Go to Travis and Open Settings for Your Repository
- Add Environment Variable: name: `CC_TEST_REPORTER_ID`, value: _Copied from CodeClimate_ (https://codeclimate.com/repos/5f114fcb20e8de018b00b776/settings/test_reporter)

## Swagger

- Application uses [gin-swagger](https://github.com/swaggo/gin-swagger).
- To generate/update docs use `swag init` (from `/go-project-blueprint/cmd/blueprint`)
- You can find generated docs in `docs` package

To view docs, navigate to <http://localhost:1234/swagger/index.html> or to <http://localhost:1234/swagger/doc.json> for raw _JSON_


text:
# SOCIÉTÉ GÉNÉRALE - OCTOBER 2015

SELECT A CHALLENGE TO DISPLAY ITS CONTENT AND SOLUTIONS

* [Closing balance](Closing balance/)
* [Card number validation](Card number validation/)
* [Peak Hour(s)](Peak Hour(s)/)
* [Handling cash requests](Handling cash requests/)
* [Cash usage](Cash usage/)
* [Flooding](Flooding/)
* [Fire alarms](Fire alarms/)

Source : http://www.isograd.com/EN/contestsolution.php?contest_id=11

repository: julien-amar/isograd-challenges

repo_name: julien-amar/isograd-challenges


text:
# github-commit-comment.vim

Post and show GitHub commit comment on vim

## Description

This plugin supports the following features;

- Post commit comment by vim
    - Line comment
    - Commit comment
    - File comment
- Show commit line comment on vim

These command work on last modified git revision of editing file and `origin` of remote.

## Commands

### GitHubLineComment [comment]

Posts commit line comment to last modified revision of editing file and current cursored line.

 Generate access token of GitHub at "Personal access tokens" ([https://github.com/settings/applications](https://github.com/settings/applications)). This plugin only requires `repo` permission.

2. Please put `.github_commit_comment.vim` file on your home directory. And fill github access token into this file. For example;

```vim
let g:github_commit_comment_vim = {'token': '__YOUR_ACCESS_TOKEN__'}
```

### Specify API Endpoint (optional)

Fill URL of API endpoint in `.github_commit_comment.vim`, like so;

```vim
let g:github_commit_comment_vim = {'api_endpoint': 'http://example.com/api/v3'}
```

Default API endpoint is "https://api.github.com". If you don't specify `api_endpoint`, this plugin use the default URL.

### Sample of configuration file

```vim
let g:github_commit_comment_vim = {
      \ 'token': '__YOUR_ACCESS_TOKEN__',
      \ 'api_endpoint': 'http://example.com/api/v3'
\ }
```

## Dependencies

### Requires

- [webapi-vim](https://github.com/mattn/webapi-vim])

### Recommends

- [vim-hier](https://github.com/jceb/vim-hier)
- [quickfixstatus](https://github.com/dannyob/quickfixstatus)

## License

MIT


text:
# AudioSession

we all have been there: you are listening to a podcast on a website and you accidentally close the tab. You can reopen the tab, but if you didn't pay close attention to the timer, finding the right place again can be tricky. __AudioSession__ is here to fix just that!

## What is it?
AudioSession is an extension of the [HTMLAudioElement][HAEdoc] prototype that keeps track of __<audio>__  `currentTime` and saves it to __localStorage__ to be able to retrieve it on the next play, regardless of page reload.
Works <del>great with autoplay</del> [`autoplay` doesn't work crossbrowser and is under investigation [#2](https://github.com/jcsrb/AudioSession/issues/2)]  and has no issues with `loop`

## Usage

you can use this automatically or manually depending  on your needs:

### Automatic activation
add `save-session` to your `<audio>` element like this:

```html
<audio controls save-session>
      <source src="source.mp3" type="audio/mpeg" />
      <source src="source.ogg" type="audio/ogg" />
</audio>
```

### JavaScript activation

```javascript
  var myAudioElement = document.getElementsByTagName("audio")[0]; // get your audio element
  myAudioElement.saveSession = true; // activate AudioSession
  myAudioElement.saveSession = false; // deactivate AudioSession
```
### Custom Events
for better integration in your project, AudioSession provides a set of custom events triggered at various points:

* `sessionStored` is fired when the current position has been stored (fires often)
* `sessionRestored` is fired when the stored position has been applied to the audio element
* `sessionCleared` is fired when the the session key has been removed from storage
* `sessionSaveActivated` is fired when AudioSession has been activated
* `sessionSaveDeActivated` is fired when AudioSession has been deactivated

## Browser Support
as AudioSession relies on [Audio][canIuseAudio] and [localStorage][canIuseStorage], only browsers that implement these specs are supported

in development AudioSession has been tested on:
* Chrome 25
* Firefox 19

## Limitations

### HTML 5 Validation
as described in the [Usage Section](#usage), AudioSession can be activated using the element property `save-session`.
If you are keen on spotless validation, rename all instances of `save-session` to `data-save-session`

### Session Key
The Session Key is build from the source URL of the file, this has the side effect that if you have the same audio file on multiple sub-pages it continues from where it left of.

It's either a bug or a feature depends on how you see it.
You can use this side effect to keep music continuing, when going to the next page.
If you don't want this to happen, use a unique ID for each <audio> element, and a include it in the _sessionKey_.

## Further Plans
* check compatibility with popular polyfills
* add tests
* annotate source
* apply functions to HTMLMediaElement therefore supporting both Audio and Video(?)

## Thanks to
* [Upfront Podcast][upfront] for the demo audio files
* [Ben][ben] and [Daryl][daryl] for input on JS Best Practices

## License
MIT, see the file for details

[HAEdoc]: https://developer.mozilla.org/en-US/docs/DOM/HTMLAudioElement
[canIuseAudio]: http://caniuse.com/audio
[canIuseStorage]: http://caniuse.com/namevalue-storage
[upfront]: http://upfrontpodcast.com
[ben]: https://github.com/benhowdle89
[daryl]: https://github.com/daryl

repository: jcsrb/MediaSession

repo_name: jcsrb/MediaSession


text:
> **Middleware-IO** - Modern middleware on Promise

| 📖 [Documentation](docs/) |
|---------------------------|

## Features

1. **Self-Sufficient.** The library has zero dependencies.
2. **Reliable.** The library is written in **TypeScript** and covered by tests.
3. **Modern.** The library comes with native ESM support
3. **Powerful.** Supports following additional features:
	- The library has enough built-in snippets;
	- The middleware chain builder;

## Installation
> **[Node.js](https://nodejs.org/) 12.0.0 or newer is required**

- **Using `npm`** (recommended)
	```shell
	npm i middleware-io
	```
- **Using `Yarn`**
  ```shell
  yarn add middleware-io
  ```
- **Using `pnpm`**
  ```shell
  pnpm add middleware-io
  ```

## Example usage

```js
import { compose } from 'middleware-io';

const composedMiddleware = compose([
	async (context, next) => {
		// Step 1

		await next();

		// Step 4

		// Print the current date from the next middleware
		console.log(context.now);
	},
	async (context, next) => {
		// Step 2

		context.now = Date.now();

		await next();

		// Step 3
	}
]);

composedMiddleware({}, () => { /* Last handler (next) */ })
	.then(() => {
		console.log('Middleware finished work');
	})
	.catch(console.error);
```

repository: negezor/middleware-io

gha_language: TypeScript

repo_name: negezor/middleware-io


text:
# Personal Website

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

## Description

A personal website dedicated to me. All the source code for creating it is located here (under the AbdulM95 repository) and deployed to the web.

Link to my personal website: [kingabdullah.codes](https://kingabdullah.codes).

## Features

Some things included in this site are the resume, skills, portfolio link, leisure, and soon to be added, **Github Statistics.** Github Statistics will be added using Github's API.

## Learn More

You can learn more in the [Create React App documentation](https://facebook.github.io/create-react-app/docs/getting-started).

To learn React, check out the [React documentation](https://reactjs.org/).


text:
---
title: An article on the history
tags:
  - Jul 1956
---

An article on the history of Miami. [Photos]

Newspapers: **Miami Morning News or The Miami Herald**

Page: **5**, Section: **F**


text:
RotatingCalipers
================

npm install rotating-calipers

API
>`convexHull`: return the convex hull of an array of arbitrary points.

>`rotateVector`: 旋转器

>`minAreaEnclosingRectangle`: the minimum area that bounds the convex hull.

A node/npm of RotatingCalipers by sntran: https://github.com/sntran/RotatingCalipers

Initially ported by sntran from https://github.com/brainbook/BbsRotatingCalipers


text:
Please note that **this software is deprecated and unsupported** (it's here for historical reasons).

It uses deprecated API from Dropbox and has been superseded by [Janus Notes 2](https://github.com/ilTofa/janusnotes2), also open source. Janus Notes 2 uses iCloud for data syncing and it still uses the same encryption mechanism as Janus Notes.

###Janus Notes

Janus Notes is a sync-capable notetaking app for iOS and OSX that
**seriously** respects your right to privacy.

 Janus Notes stores your data using strong encryption and synchronizes it
across different devices via Dropbox.  The name Janus is a reference to the ancient [Roman God Janus](https://en.wikipedia.org/wiki/Janus), depicted as having two faces since he looks to both future and past. Or perhaps, to cloud
storage and privacy. Or Macs and iPhone/iPad devices. Or sharing and control.

The app is available for free in the
[Mac App Store](http://itunes.apple.com/app/id651141191) and the iOS
[App Store](http://itunes.apple.com/app/id651150600). Usage notes,
[FAQ](http://www.janusnotes.com/faq.html) and
[screenshots](http://www.janusnotes.com/screenshots.html) are available at
[janusnotes.com](http://www.janusnotes.com).

###The code

There are two Xcode 5 projects, one for iOS and the other for OS X,
respectively in the IPhone and Mac subdirectories. Forks and pull requests are
always welcome.

Both apps leverage the CoreData framework to locally store all notes and
attachments.  Optionally they may also sync via Dropbox, using the Dropbox Sync API on iOS and the filesystem on OS X. The Dropbox files may be encrypted with an user-defined passphrase. Encryption is performed by the
[RNCryptor](https://github.com/rnapier/RNCryptor) third-party library
developed by Rob Napier.

Release versions matching the binaries distributed in the Apple app stores may
be built after checking out the correspondingly tagged commits in the
repository.

The only required file not already in the repository is the **DropboxKeys.h**
header, containing the app key and the secret that you'll need to access the
Dropbox Sync API.  This is only required for the iOS version.

Create your DropboxKeys.h so that it contains two macro defs as follows:

	#define DROPBOX_APP_KEY @"xxxxxxxxxxxxxxx"
	#define DROPBOX_SECRET  @"xxxxxxxxxxxxxxx"

Replace the "xxx.." with your own key and secret.

###Credits

Janus Notes uses the following third-party frameworks and libraries:

[iRate](https://github.com/nicklockwood/iRate) Copyright 2011 Charcoal Design

[RNCryptor](https://github.com/rnapier/RNCryptor) Copyright (c) 2012 Rob Napier

[sundown](https://github.com/vmg/sundown) Copyright (c) 2009, Natacha Porté and Copyright (c) 2011, Vicent Marti

[MBProgressHUD](https://github.com/jdg/MBProgressHUD) Copyright (c) 2013 Matej Bukovinski

[AHAlertView](https://github.com/warrenm/AHAlertView) Copyright (C) 2012 Auerhaus Development, LLC

####License

The code is available under the [MIT license](http://opensource.org/licenses/MIT).

Copyright (c) 2013 Giacomo Tufano

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

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

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

repository: ilTofa/janusnotes

gha_language: Objective-C

repo_name: ilTofa/janusnotes


text:
[![Build Status](https://travis-ci.org/noctune/disjoint-borrow.svg?branch=master)](https://travis-ci.org/noctune/disjoint-borrow)

# disjoint-borrow

Disjoint borrows of slices.

Provides the [`DisjointSlice`](struct.DisjointSlice.html) type, allowing disjoint borrows over
slices by adding runtime checks. Immutable borrows are allowed to intersect with other immutable
borrows, while mutable borrows may not intersect with any borrows.

Borrow tracking is implemented as type-level list. This has the advantage that no allocation is
necessary, but also limits the number of disjoint borrows to a compile-time constant.

No-std compatible.

## Example

```rust
use disjoint_borrow::DisjointSlice;

let mut array = [1, 2, 3, 4, 5];
let mut ds = DisjointSlice::new(&mut array);
let (mut ds, mut a) = ds.get_mut(0..2);
let (_, mut b) = ds.get_mut(3..5);

a[0] *= -1;
b[1] *= -1;

assert_eq!(a, &[-1, 2]);
assert_eq!(b, &[4, -5]);
```

License: MIT

repository: mpdn/disjoint-borrow

repo_name: mpdn/disjoint-borrow


text:
Tools
=====
This directory includes scripts and files to aide the development of this project. Below are some basic overviews of
the scripts included.

## MAKE_PACKAGE.PY
This script is designed to automatically generate our FreeBSD package Makefile and pkg-plist. This also attempts to
compile the package automatically if you run it on a FreeBSD system. Files are rendered using Jinja2 and templates are
found in the `templates` subdirectory

### Usage
`python3 tools/make_package.py`

### Dependencies
- `Jinja2` package must be installed before running (`python3 -m pip install jinja2`)

### Output
Command will output the FreeBSD make command output. Outputs the following files:

- `pfsense-saml2-auth/pfSense-pkg-saml2-auth/Makefile` : The rendered Makefile
- `pfsense-saml2-auth/pfSense-pkg-saml2-auth/pkg-plist`: The rendered pkg-plist
- `pfsense-saml2-auth/pfSense-pkg-saml2-auth/pfSense-pkg-saml2-auth-<VERSION>.txz` : The FreeBSD package distribution file. On FreeBSD 11,
this should be located in the `pfsense-saml2-auth/pfSense-pkg-saml2-auth` directory after completion. On FreeBSD 12 it should be
located in the `pfsense-saml2-auth/pfSense-pkg-saml2-auth/work/pkg` directory.

### Notes
- This script heavily depends on it's relative filepaths. You may execute the script from any directory, but do not move
the script to another directory.


text:
The Pylette has come to save your time!

## Usage
Let's take this bold picture as an example.

We can open this masterpiece in the Pylette.

After the picture is opened, the colors are shown in the Pylette where you can edit, add or delete colors. Afterwards, you can export your palette.

The resulting palette looks like this:

Now you can import the palette in your image processing program.

## Why use Pylette over built-in palette functionality?
Many image editing programs allow you to import palettes from images but since they don't focus on it they have a few weaknesses. A badly scaled pixel art image has way more colors than meets the eye. The original pixel art has only these 7 colors:

But when importing a badly resized picture gets imported into pixel editor, this happens:

This many colors are suboptimal and you would have to remove most of them and this just takes time. You can simply open the image in Pylette and directly get a good palette.

But this isn't exactly the original palette and you want to edit it. First thing you could try is editing the import settings and resetting the file.

You can also delete, add or edit existing colors.

Here you also have the ability to pick a screen color which can make adding a very specific color way easier.

## Installation

### Windows
Just double-click the pylette.exe.

### Linux
Find the Pylette file and double-click it.
If this doesn't work you have to give the pylette file executable permission.
You can do this with `chmod +x /path/to/pylette`.
I would also recommend you to create a .desktop file so you can open it with an application icon and the ability to start it outside the directory of the executable.
### MacOs
I don't have a Mac; if there is enough demand I may look into options to make an executable.

## Quirks
No program is perfect and the Pylette is a program so it would be better when you know about it quirks.

* Resetting a file not only resets the whole palette and the changed colors in the palette but does so according to the current settings as if you were deleting and adding the file.
* When you add a file, only the current settings are important. So if you want to add multiple pictures with different settings you can do that.
* When you import a picture with alpha channel... your palette won't have said alpha channel.
* When you import a gif only the first frame counts.
* If you have problems with a weird settings window; try to resize it.
* You can change a color in the palette by clicking on the color which opens a colordialog.
* Right-click on a color to delete it.
* If you want to add a color from your screen you must open a colordialog and there you will find an option to pick a color from your screen.
* That the "Custom Color" in the combobox never goes away is neither a bug nor a feature... it's less work.
* The Pylette can only work with rgb and rgb-compatible colorspaces.
* If your palette has a lot of colors and you can open the exported palette then try setting the scaling setting to 1 because otherwise you picture may be to big to open.

## FAQ
No Users...
No Questions!

## For Developers

### Requirements
* Used Python 3.7.2 but should be perfectly compatible down to 3.6. If you want to go lower, you need to replace f-strings with another syntax formatting.
* Built with PyQt5 5.12.1; PyQt5 5.13.0 and Pyinstaller don't work well with each other.
* Pillow 6.1.0 but newer version should work.
* Pyinstaller 3.5 but newer versions should work.

### Building executables
To create an executable you need to have pyinstaller installed.
1. cd to the directory
2. Run the command `pyinstaller -w -i Example/pylette_256.ico main.py`.
3. Rename the main(.exe) to pylette(.exe) (optional).
4. Copy the config.json and pylette_256.png into the folder with the executable.

## Credits
* Pillow https://github.com/python-pillow/Pillow
* PyQt5 https://www.riverbankcomputing.com/news
* Qt (Designer) https://www.qt.io/
* Python https://www.python.org/
* Pyinstaller https://www.pyinstaller.org/

## Shown in the pictures
* Manjaro KDE https://manjaro.org/
* Aseprite https://www.aseprite.org/
* Pylette https://github.com/MawOfTheVoid/Pylette

repository: MawOfTheVoid/Pylette

repo_name: MawOfTheVoid/Pylette


text:
Online Notifier
===============

This is a Chrome/Opera extension from the student organization Online at NTNU in Trondheim, Norway.

The software fetches data from sources like SiT, AtB and student organizations in order to provide you, as a student, with practical information in your daily life. It is made by the Application Committee (appKom) in Online.

*<EMAIL_ADDRESS>
Installation of Notifier
------------------------

* Install for Chrome: https://chrome.google.com/webstore/detail/hfgffimlnajpbenfpaofmmffcdmgkllf
* Install for Opera: https://addons.opera.com/en/extensions/details/online-notifier

Installation of Infoscreen
--------------------------

Use a spare computer, one you don't need for anything else.

1. Install the latest version of [Ubuntu](http://www.ubuntu.com/desktop)
  * Write down the username and password from the installation!
  * Turn on Autologin when asked about it
1. Open “System Settings”
  * Displays -> Set rotation to clockwise
  * Brightness & Lock -> Never turn screen off
  * Appearance -> Behavior -> Auto-hide the launcher
1. Open “Update Manager”
  * Settings -> Never automatically check updates (unless it's really important to you)
  * Settings -> Never notify me of a new Ubuntu version
1. Open “Software Updater”
  * Install updates this once
1. Open a terminal
  * `sudo apt-get install openssh-server unclutter chromium-browser`
1. Open Chrome
  * Settings -> Set Chrome as default browser
  * Settings -> Do not offer to save passwords
  * Settings -> On startup, open the new tab page (this is important for kiosk mode to work properly)
  * Install Notifier from the [Chrome Web Store](https://chrome.google.com/webstore/detail/online-notifier/hfgffimlnajpbenfpaofmmffcdmgkllf)
  * Online Notifier Options -> Enable Infoscreen
1. The launcher
  * Lock the Chrome icon to the launcher
  * Other apps you might want to lock to the launcher
    * System Settings, Startup Applications, Software Updater, Terminal
  * Remove unnecessary icons, yes, Firefox as well
1. Open “Startup Applications”
  * Add `chromium-browser --kiosk --disable-translate`
  * Add `unclutter`
1. `sudo reboot`
1. Enter the BIOS on startup (typically by clicking F2, F9, F10 or Del like a maniac)
  * Find the option for what happens on power-loss, set it to turn power back on
  * This feature is very important for the infoscreen to survive power outages, which are frequent at NTNU due to construction work

Technology stack
----------------

Some of the data is delivered by [Notipis](https://github.com/appKom/notipi) (raspberry pis), via the middle layer [Online Notiwire](https://github.com/appKom/notiwire). Notipi is a joint project between Omega Verksted and Onlines appKom. Notipis consist of hardware from Omega Verksted and software from Online appKom.

The hardware bundle which complements makes hardware features in Notifier accessible to any student union who purchases and installs the bundle. OmegaV currently sells this bundle at a reasonable price. The earnings goes to further development and to support OmegaV's operations.

*<EMAIL_ADDRESS>(hardware)
*<EMAIL_ADDRESS>(software)

Features overview
-----------------

For all the included affiliations

- Displays and notifies about news from the selected "linjeforening"
- Displays todays dinner menu and opening hours from SiT cantinas, cafés and kiosks
- Displays bus data from AtB in realtime and through the Oracle
- All pages in the extension are live, they stay updated while open
- Can be used as an infoscreen (full HD vertical screen) for continous use

Additional features for affiliations who have a [NotiPi](https://github.com/appKom/notipi)

- Displays office status: Open, closed, meeting, waffles
- Displays todays meetings and current servant at the office
- Displays the status of the coffee pot at the office

In-depth features
-----------------

General

- Only HTML5, CSS3 and JavaScript
- Libraries used: jQuery, LESS
- Opens options page on first run
- All pages keep themselves updated while running
- Separate scripts containing constants and defaults, for changeability
- Runs Google Analytics on all pages, tracking both pages and events anonymously
- Detects network status, halts all operations and resource usage when offline
- Dev mode: Faster updates, frequent clearing of localstorage
- Automatic production detection prevents accidentally using developer mode in production

Student organizations

- Affiliations
  - Tons of different organizations and institutions are supported
  - Each organization has it's own logos and symbols
  - Each organizations' news feed is fetched and parsed
  - Each organization has a recommended color palette
  - Support for organization specific color palettes
  - A highly customizable image fetcher that extracts images from each affiliation websites since the RSS-feeds usually doesn't contain image links
- News
  - Fetches and parses feeds from affiliations' websites, both for primary and secondary affiliation
  - Support for a separate news fetching function specific to an organization, even ones without RSS/Atom feeds
  - Counts unread news and presents unread number in icon badge
  - Separates between new, updated and read items (deprecated)
  - Serves HTML5 desktop notifications on news / updates
- Palettes
  - Stored as plain, short CSS stylesheets
  - Override common CSS selectors in options, popup and the infoscreen
  - Primarily changing style of the background image via CSS3 hue-rotation and such
  - Palettes may also change colors of titles, pageflip and other details

SiT

- Cantinas
  - Fetches and parses feed from SiTs website through http://sit.no/rss
  - User may select any two cantinas at any campus to be shown in the popup
  - Strips down dinner menu down to the bare necessities
  - Presents dinners with pricing in ascending order
  - Able to handle all known cases of strange formatting for SiT
- Hours
  - Also fetches opening hours for all cantinas through http://sit.no/ajax

AtB

- Realtime
  - Displays the user's two favorite stops
  - Fetches realtime bus data from a third-party API at bybussen.api.tmn.io
  - Frequently updated in order to always show correct information
  - Support for favorite bus lines, simplifying finding a particular bus at a busy stop
  - Smart selection of bus stops at the options page, quickly determining which stop the user wants
  - The complete list of bus stops is fetched and parsed every now and then
- Oracle
  - Allows the user access to SiTs bus oracle
  - The oracle has been improved with a feature that learns what you search for in order to allow intelligent auto-completion
  - The replies from the Oracle are simplified for better readability

Hardware Features (requires [NotiPi](https://github.com/appKom/notipi))

- Office
  - Office open/closed/meeting status is fetched from [Online Notiwire](https://github.com/appKom/notiwire) where it is based on light intensity data from [Notipis](https://github.com/appKom/notipi) and each affiliations Google Calendar
  - Icon changes based on light values and calendar events
  - Uses title text containing the name of the event, or other appropriate text
  - Separate icon showing when you are offline or when an error has occured
  - All states: Default, open, closed, meeting, waffles, error (error usually means disconnected)
- Meetings
  - Meeting list is fetched via [Online Notiwire](https://github.com/appKom/notiwire)
  - Showing the rest of the days meetings so users may easily spot when to grab a coffee
- Servant
  - Shows who is responsible for the affiliation office at any given time
  - Servant list fetched [Online Notiwire](https://github.com/appKom/notiwire)
- Coffee
  - Coffee pot status fetched via [Online Notiwire](https://github.com/appKom/notiwire)
  - Push the button on the [Notipi](https://github.com/appKom/notipi) in your organizations office to notify users when someone is cooking a new pot of coffee
  - Users get a HTML desktop notification with a random coffee meme when the coffee button is clicked
  - Overview shows how fresh the last pot of coffee is and how many pots of coffee has been made today

Options page

- All options react to changes immediately
- Github link to the open source repository
- Google +1 button for Onlines website when affiliation is Online

Injected script

- Automatically switches to the correct clicked cantina from the popup
- Detects when user is visiting the affiliation website, nullifying the counter badge
- Injects affiliation logo when opening the affiliation specific IRC channel via kiwiirc.com

Analytics

- All statistics are anonymously collected and helps develop the project further
- Runs page tracking on all pages which gives general traffic, OS, browsers, countries etc.
- Runs event tracking on key events throughout all main javascript files
- Event tracking is split into categories which have the same name as the page name it originates from, this is done because there are so few pages in the project
- Categories are split into actions which are either clickSomething, loadSomething or toggleSomething
- An action may have a label, which is usually the clicked link, the loaded file, and so on

Chronological Credz
-------------------

Key people are annotated with their email address

- Michael Johansen<EMAIL_ADDRESS>is the project leader and was the sole developer of the extension itself (not support services) for the first couple of years
- Espen Jacobsson wrote Onlines API-service in OnlineWeb3
- Roy Sindre Norangshol wrote the initial light service
- Dag Olav Prestegarden wrote the initial calendar service
- René Räisänen designed the background image
- Tri Minh Nguyen created the API for AtB's realtime bus API
- Jonas Svarvaa wrote several revisions of calendar services
- Roy Sindre Norangshol helped with several maintenance issues
- Magnus Dysthe has been working on hardware for the infoscreen
- Tor Håkon Bonsaksen helped with several hardware issues
- Kristoffer Dalby hacked up scripts that fixed ubuntu screen-to-black issues
- Jim Frode Hoff made Online's coffee button, attached to an Arduino
- Nils Herde fixed hardware issues, kept the infoscreen running and installed the coffee button
- Vegard Stenhjem Hagen installed all the hardware for Delta
- Eirik Larsen<EMAIL_ADDRESS>made the OmegaV NotiPi, which made Notifier's hardware features accessible to all the student unions in Trondheim
- Petter Rostrup made the Konami code video roll
- Also, the following made coffee memes:
	- Thomas Gautvedt
	- Aleksander Skraastad
	- John Hanssen Kolstad
	- Magnus Dysthe
	- Michael Johansen
	- Linn Vikre

Media coverage
--------------

* 2013.09.03 "Hemmelig program ble suksess": http://dusken.no/articles/details/23569/online-notifier/
* 2013.05.28 "Siste nytt - og om
litt er kaffen klar": http://universitetsavisa.no/campus/article17115.ece

Issues submitted to Chromium/Opera
----------------------------------

- Regex word boundary and ÆØÅ: https://code.google.com/p/chromium/issues/detail?id=223360
- Desktop Notification logging: https://code.google.com/p/chromium/issues/detail?id=225212
- Rich Notifications Don't Timeout at Midnight: https://code.google.com/p/chromium/issues/detail?id=284018&thanks=284018&ts=1378160265
- Transparent borders not playing well with inset box shadow: https://code.google.com/p/chromium/issues/detail?id=423881
- Opera 16.0 stable crashes instantly when selecting private key file (during extension packaging<EMAIL_ADDRESS>- Multi-screen fullscreen on OSX not playing well with desktop notifications: https://code.google.com/p/chromium/issues/detail?id=430728

repository: michaelmcmillan/notifier

repo_name: michaelmcmillan/notifier


text:
# Simple Connect 4 Game using pygame

![sample screen](/img/sample.png)

## To use this repo
You need to install pygame first, then do python connect4.py

## To play with AI
Do python connect4withAi.py

## AI algorithms used
Minimax, alpha-beta pruning and killer heuristic


text:
# Stagonospora koshkelovae Andrian., 1987 SPECIES

#### Status
SYNONYM

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

#### Published in
Ukr. bot. Zh. 44(1): 66 (1987)

#### Original name
Stagonospora calystegiae Koshk., 1961

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Dothideomycetes/Pleosporales/Phaeosphaeriaceae/Stagonospora/Stagonospora calystegiae/ Syn. Stagonospora koshkelovae/README.md

repo_name: mdoering/backbone


text:
---
layout:     post
title:      Unix Hard Links, Soft Links, and Files
date:       2017-08-04 10:00:00 +0200
tags:       [c, bsd, file, hardlink, howto, io, linux, open, posix, symlink, tutorial, unix]
og-image:   tux.png
---

This blog post describes the relation ship between file names and files on
Unix file systems. We'll also look at soft links and how all this interacts
with file descriptors.

<!-- excerpt -->

#### Creating a New File

Let's create a new file `my_file.txt` our application. We do this by
calling [`open()`][posix:open] with the file's name.

``` c
int fd0 = open("/home/joe_user/my_file.txt", O_RDWR|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP);
```

As we've seen in the previous [blog post][post:20170728] this creates a file
descriptor, an open file description, and a file buffer. You should read that
entry if you are interested in the relationship among file descriptors, open
file descriptions and file buffers.

![Data structures after opening `/home/joe_user/my_file.txt` once.]({{ site.baseurl }}/img/unix1.png)

In the file system, there's now a file name that refers to the file buffer
we just opened.

![File system after opening `/home/joe_user/my_file.txt`.]({{ site.baseurl }}/img/vfs1.png)

A file name that refers to a file buffer is also called *hard link.* There
can be multiple links to the same file buffer. Or in other words, the same
file buffer can be made available under different names.

#### Adding Hard Links

An additional name for a file is created with the command
[`link()`][posix:link]. The function takes an existing file name and a new
file name. If successful, the new name refers to the existing file name's
buffer.

Let's create an additional hard link of the name
`/home/joe_user/my_hard_link.txt`.

``` c
link("/home/joe_user/my_file.txt", "/home/joe_user/my_hard_link.txt");
```

Our file system now looks like this.

![File system after creating `/home/joe_user/my_hard_link.txt`.]({{ site.baseurl }}/img/vfs2.png)

What happens if we open the new file name from within our application?

``` c
int fd1 = open("/home/joe_user/my_hard_link.txt", O_RDWR|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP);
```

It's the same file buffer as before, so the result is the same as if
we'd opened the file by the original name.

![Data structures after opening `/home/joe_user/my_hard_link.txt` once.]({{ site.baseurl }}/img/unix2.png)

The application has opened two file descriptors, two open file descriptions,
and they both refer to the same file buffer.

This is also the reason why we cannot go through all files on a file
system to sum up how much space they consume on the disk. Since multiple
file names can refer to the same file buffer, we could calculate a cumulative
size that might be larger than the actually consumed size; maybe even
larger than the maximum size of the disk.

#### Unlinking, Closing, and the Removal of File Buffers

A call to [`unlink()`][posix:unlink] removes a file name from the file
system. Let's call `unlink()` on both file names and the file system will
be empty.

``` c
unlink("/home/joe_user/my_file.txt");
unlink("/home/joe_user/my_hard_link.txt");
```

Once the final link is gone, there's no way to create a new link to the
file buffer. But the application still has these files open! How does that
work?

For each file buffer, Unix maintains two counters: the link counter and
the open counter.

The *link counter* contains the number of links refering to a file buffer.
After being created, each file starts with a link count of *1.* When we
added a hard link with `link()` the counter went up by one. When we
removed a hard link with `unlink()` the counter went down by one.

The *open counter* countains the number of times the file buffer was opened,
or more specifically the number of open file descriptions refering to the
file buffer. When a file buffer is not opened, the open counter is *0.*
Each time we opened a file buffer with `open()` that counter went up by one.
Only when we later close the file descriptors and the open file
descriptions get removed, the counter goes down.

When both, link counter and open counter, reach zero at the same time
Unix removes the file buffer from the disk.

Let's close both file descriptors to remove the file buffer from the
disk.

``` c
close(fd0);
close(fd1);
```

#### Soft Links

Hard links have one major drawback, which is that they only work on the
file system that also maintains the buffer. So if you have one partition
for your computer's operating system, an another partition for your personal
data, it's not possible to create a hard link from one file system to the
other.

Unix file systems provide a solution called soft links, also called
symbolic links or symlinks. Although it has a file name, a soft link is
not a regular file, but a special file that stores a full file path.
When an application opens the soft links, it actually opens the file at
the path that is stored in the soft link. Because a file path is stored
(instead of a reference to a file buffer), it's independent from the
underlying file system.

Let's go back to the example of `/home/joe_user/my_file.txt`. We can create
a soft link with a call to [`symlink()`][posix:symlink]. Like `link()` before,
it takes the original file's path and the path of the symlink.

``` c
symlink("/home/joe_user/my_file.txt", "/home/joe_user/my_soft_link.txt");
```

With the soft link in place, the file system looks like this.

![File system after creating `/home/joe_user/my_soft_link.txt`.]({{ site.baseurl }}/img/vfs3.png)

We have a file name `my_file.txt`, which refers to a file buffer. And we
have a file name `my_soft_link.txt`, which refers to the soft-link file,
which in turn refers to the original file name.

The existance of a soft link does not have any impact on the actual file,
or that file buffers's link counter. So a file can be removed, even if it
is the target of a soft link. If this happens, the soft link goes stale
and trying to open it returns an error.

#### Summary

In this blog post, we went through a tour of how hard links and soft links
work on Unix, and how they affect the life time of file buffers.

 - Initially each file buffer is referenced by a file name.
 - The file name is called *hard link.*
 - There can be multiple hard links ot the same file buffer.
 - Opening any of a file buffer's hard links opens the file buffer.
 - A file buffer can not be opened any longer after all hard links have been
   removed.
 - A file buffer is removed from the disk after all hard links have been
   removed and the file buffer is not opened by any application.
 - Hard links don't work across file-system boundaries.
 - Soft links are a special type of file that reference other files by
   their path names.
 - Opening a soft link opens the referenced file.
 - Soft links can reference files on other file systems.

If you like this blog post about the basics of Unix File I/O, please
subscribe to the RSS feed, follow on Twitter or share on social networks.

#### Footnotes

[^1]:   There are a number of good books on Linux and Unix programming. If
        you're interested in Linux system programming I'd recommend Michael
        Kerrisk's [The Linux Programming Interface][man7:tlpi].

[posix:close]:              http://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html
[posix:open]:               http://pubs.opengroup.org/onlinepubs/9699919799/functions/open.html
[posix:link]:               http://pubs.opengroup.org/onlinepubs/9699919799/functions/link.html
[posix:symlink]:            http://pubs.opengroup.org/onlinepubs/9699919799/functions/symlink.html
[posix:unlink]:             http://pubs.opengroup.org/onlinepubs/9699919799/functions/unlink.html
[post:20170728]:            {% post_url 2017-07-28-data-structures-of-unix-file-io %}


text:
MacGyver
========
This folder contains a demo of the Angular version of the MacGyver component.

Installation
------------
1. Clone the repo
2. Change to the demo folder (`cd demo`)
3. Install all NPM deps (`npm install`)
4. Start the server (`node server`)
5. Browse to [localhost](http://localhost:8080)

repository: MomsFriendlyDevCo/macgyver

repo_name: MomsFriendlyDevCo/macgyver


text:
# Guide for submitting to RO2019
{:.no_toc}

This page describes how authors could submit to the [Workshop on Research Objects (RO2019)](http://www.researchobject.org/ro2019/).

> tl;dr: Preprint (and additional resources) should be uploaded to the [RO Zenodo community](https://zenodo.org/deposit/new?c=ro).
>
> The Zenodo research object is submitted for review in [EasyChair](https://easychair.org/conferences/?conf=ro2019) or [GitHub](https://github.com/ResearchObject/ro2019/issues/new/choose)
>
> Upon acceptance, the RO2019 proceedings will link to Green Open Access preprints/ROs in Zenodo, and DOI to papers accepted for the IEEE eScience proceedings.

* Table of Contents
{:toc}

## Submission types

RO2019 welcomed submissions for:

### Oral Communications

* **Short articles**: (about 4-8 pages) for more developed research, software or data contributions
* **Abstracts**: (1-2 pages) for oral communication
* **Poster and demo abstracts**: (1-2 pages)

The page limits are for guidance only, assuming reasonable font sizes and margins.

See the [Call for Papers](cfp) for details on topics covered at the workshop.

For any questions, email the RO2019 Workshop Organizers at [ro2019<EMAIL_ADDRESS>
### Unconference

Workshop participants are also encouraged to separately propose _lighting talks_, _breakout sessions_ and ideas for discussion points for the _unconference_ session of the workshop. To suggest an unconference activity, please [raise an issue](https://github.com/ResearchObject/ro2019/issues) in GitHub.

## Requirements

Unless indicated otherwise, the submitted preprint is assumed to be licensed [CC-BY 4.0](https://creativecommons.org/licenses/by/4.0/), and will, upon acceptance, be made available as **Green Open Access** on the [RO2019 website](http://www.researchobject.org/ro2019/) with DOI links to the Zenodo record and (where applicable) DOI for the published IEEE eScience Proceedings article.

RO2019 may reformat your preprint for web publishing.

It is a requirement that **at least one author** of each accepted submission attends the RO2019 workshop and **registers** using the [IEEE eScience 2019 system](https://escience2019.sdsc.edu/registration) (either for the workshop, or the whole conference). Registration [fees](https://escience2019.sdsc.edu/registration) applies.

## Formats

Submitted abstracts and articles can be in a range of **open formats** (e.g. [HTML5](https://www.w3.org/TR/html/), [ePub](https://www.w3.org/Submission/2017/SUBM-epub31-20170125/)) and are particularly encouraged to be submitted in a FAIR research data packing format. Guidance is provided below for those who do not have their own platform they wish to showcase.

Accepted articles will be included in the IEEE eScience 2019 proceedings; a secondary PDF, which may use the [IEEE templates](https://www.ieee.org/conferences/publishing/templates.html), **may** be included in the submission or provided later by the author to the IEEE submission system (camera-ready deadline for IEEE articles 29 July 2019).

## Submitting

Submissions should be uploaded to the [RO Zenodo community](https://zenodo.org/communities/ro/) and submitted for review in [EasyChair](https://easychair.org/conferences/?conf=ro2019).

You may also place your submission in another open repository and provide its permalink/DOI to EasyChair. Note that we will rely on the repository for later publishing of the preprints.

See guidance below for further details.

## Open Peer Review

RO2019 encourages _open peer review_, and recommend that reviewers are named and attributed; however reviewers may be anonymous if so desired. Reviewers are welcome to publish their reviews using the same guidelines as the research articles.

[Peer reviews](reviews) will be published on the RO2019 website following the workshop.

## Contact

For any questions, email the RO2019 Workshop Organizers at [ro2019<EMAIL_ADDRESS>

## Guidance

Below are detailed instructions on how we recommend submitting your work to RO2019:

* Author abstract/article
* Upload to Zenodo
* Submit for review in Easychair (or GitHub)
* Update in Zenodo

### Authoring

Use any authoring tool you prefer, as long as you can output in an open format with hyperlinks (e.g. HTML). Here is a list of some options of web-aware authoring tools:

  * [Authorea](https://www.authorea.com/) - web-based collaborative system for authoring in Markdown, LaTeX and WYSIWIG.
  * [dokieli](https://dokie.li/) - web-based WYSIWYG editor with a range of annotation and rendering option. Requires a [personal storage](https://dokie.li/#personal-storage) account or server.
  * [Fidus Writer](https://www.fiduswriter.org/) - web-based academic writing environment
  * [Markdown](https://guides.github.com/features/mastering-markdown/) - textual HTML template language, rendered using [pandoc](https://pandoc.org/), [GitHub Pages](https://pages.github.com/) or [Jekyll](https://jekyllrb.com/)
  * [Scholarly Markdown](http://scholarlymarkdown.com/) - MarkDown [extensions for academic writing](http://scholarlymarkdown.com/Scholarly-Markdown-Guide.html#summary-of-new-features-in-scholarlymarkdown)
  * [RASH Javascript Editor(RAJE)](https://rash-framework.github.io/raje-app/) - Javascript-based word processor for creating RASH documents
  * [Scholarly HTML](https://w3c.github.io/scholarly-html/) - conventions for academic writing in HTML
  * [Stencila](https://github.com/stencila/stencila) - platform for creating, collaborating on, and sharing data driven content.

Save your article as HTML, which may require you to use a ZIP or ePub archive to contain associated figures and CSS. You may optionally publish the preprint article on a website of your choice, and provide a URL to this during submission together with a static PDF rendering.

#### Word processors

Below are some legacy tools that are perhaps better at producing PDFs than web documents. If you prefer any of these you may want to use a [IEEE template](https://www.ieee.org/conferences/publishing/templates.html) as starting point, then use [RASH Online Conversion Service (ROCS)](https://rash-framework.github.io/rocs.html) to convert to HTML:

  * [Overleaf](https://www.overleaf.com/) - write LaTeX collaboratively on the web and GitHub
  * [Google Docs](https://www.google.com/docs/about/) - collaborative web-based word processor
  * [Apache OpenOffice](https://www.openoffice.org/) or [LibreOffice](https://www.libreoffice.org/) - traditional word processor
  * [Microsoft Office](https://products.office.com/en-gb/word) locally or online with [Office 365](https://www.office.com/)

If you use a legacy tool it is recommended you upload both a PDF and HTML version of your article.

#### Example: Google Docs

After using a word processor like Google Docs from a [IEEE template](https://www.ieee.org/conferences/publishing/templates.html), Save/Download as **Web page (HTML, zipped)** as well as **PDF**:
[![gdoc-html](assets/img/gdoc-html.png)](assets/img/gdoc-html.png)

### Zenodo

RO2019 promotes [Open Research](https://en.wikipedia.org/wiki/Open_research), and encourage authors to upload their Open Access preprint and resources to an open repository like [Zenodo](http://about.zenodo.org/), an Open Data repository provided by CERN and supported by [OpenAIRE](https://www.openaire.eu/).

Perhaps the simplest (lower-case) "research object" is a [Zenodo](https://zenodo.org/) record that contains:

* Abstract/article as HTML
* Abstract/article as PDF

If you are new to Zenodo you can play with the separate [sandbox instance](https://sandbox.zenodo.org/) first, where we have provided an equivalent [sandbox RO community](https://sandbox.zenodo.org/communities/ro/). Note that RO2019 submissions must use the [main Zenodo](http://zenodo.org/) instead of the sandbox.

Most of the information in the Zenodo form is optional, for RO2019 it is recommended you fill in these fields:

  * **Type:** Conference
  * **Author:** Your Full Name (_in your_ _[preferred order](https://www.w3.org/International/questions/qa-personal-names)_)
  * **ORCID:** (your [ORCID ](https://orcid.org/) identifier)
  * **Title:** (_same as in article_)
  * **Additional notes:** Preprint submitted to RO2019 workshop at IEEE eScience Conference 2019
  * **License:** Open Access  (_Note: This is the license of the preprint_)
  * **Abstract:** (_same as in article, unless the upload is an academic abstract_)

You may also want to fill in **Related Identifiers**, in particular if your submission already have a web-version, or has related datasets, software or websites. You do not need to fill in _References_.

### Example: Uploading to Zenodo

If you have not already done so, [sign up for Zenodo](https://zenodo.org/signup/). We recommended to use your [ORCID](https://orcid.org/) account to simplify registration and login.

Then, from the [Research Object Community](https://zenodo.org/communities/ro/) page in Zenodo, click [Upload](https://zenodo.org/deposit/new?c=ro) to add a new submission.
[![Upload to Zenodo](assets/img/zenodo-00-ro-upload.png)](assets/img/zenodo-00-ro-upload.png)

Now upload both the HTML and PDF version of your article:
[![zenodo-02-upload](assets/img/zenodo-02-upload.png)](assets/img/zenodo-02-upload.png)

It is recommended to also upload (or link) to related resources that support your work. Examples:

  * [Research Objects](http://www.researchobject.org/specifications/) (e.g. [RO Bundle](https://w3id.org/bundle/), [BagIt](https://w3id.org/ro/bagit), [BDBag](http://bd2k.ini.usc.edu/tools/bdbag/))
  * FAIR [Research Data Package](https://rd-alliance.org/approaches-research-data-packaging-rda-11th-plenary-bof-meeting) (e.g. [science.ai](https://nightly.science.ai/documentation/archive) package, [DataOne package](https://releases.dataone.org/online/api-documentation-v2.0.1/design/DataPackage.html), [DataCrate](https://github.com/UTS-eResearch/datacrate/blob/master/spec/1.0/data_crate_specification_v1.0.md), [FrictionLess Data package](http://frictionlessdata.io/data-packages/))
  * [Figures](https://figshare.com/)
  * [Datasets](https://www.datacite.org/)
  * [Software](https://research-software.org/citation/)
  * [Scripts](https://gist.github.com/)
  * [Workflows](https://www.myexperiment.org/)
  * [R](https://bookdown.org/yihui/rmarkdown/notebook.html) or [Jupyter](http://jupyter.org/) Notebooks
  * [Provenance](https://www.w3.org/TR/prov-overview/) and logs

However if these are already available in existing repositories (e.g. [Zenodo](https://zenodo.org/), [Figshare](https://figshare.com/)) you should instead refer to them by DOI or URL under **Related Identifiers** further down.

Remember to click the **Start Upload** button:

![Start Upload](assets/img/zenodo-09-start-upload.png)

At any point you can click the **Save** button to store the draft (upload and metadata) under your [Zenodo uploads](https://zenodo.org/deposit).

[![Save](assets/img/zenodo-10-save-then-publish.png)](assets/img/zenodo-10-save-then-publish.png)

Now fill in **Publication Type** (Conference), **Title** and **Authors**.
Leave _DOI_ blank. (After acceptance you may create a _New Version_ of this Zenodo record and provide the published DOI from the IEEE proceedings).

[![zenodo-03-info](assets/img/zenodo-03-info.png)](assets/img/zenodo-03-info.png)

If the submission is an article, provide the article's abstract as **Description**. (For academic abstracts you may leave this field blank or provide your own shorter abstract)

Under **Additional Notes** make it clear that this is a Preprint. Suggested text is:
> Preprint submitted to RO2019 workshop at IEEE eScience Conference 2019
[![zenodo-04-notes-and-license](assets/img/zenodo-04-notes-and-license.png)](assets/img/zenodo-04-notes-and-license.png)

If you prefer a different Open Access license for your preprint, select one here. Note that the IEEE eScience Conference proceedings are unfortunately not open access, which is why we rely on the Zenodo uploads to make your accepted work available.

If you have received funding for your research, e.g. from [H2020](https://ec.europa.eu/programmes/horizon2020/), then you may indicate this under **Funding**:
[![zenodo-06-funding](assets/img/zenodo-06-funding.png)](assets/img/zenodo-06-funding.png)

If you have a web version of your submission, a website or webapp, or any related resources in other repositories that you would like to link to by DOI or URL, then add them under **Related Identifiers**:
[![zenodo-07-related-identifiers](assets/img/zenodo-07-related-identifiers.png)](assets/img/zenodo-07-related-identifiers.png)

Finally, click Save followed by Publish:
[![Save](assets/img/zenodo-10-save-then-publish.png)](assets/img/zenodo-10-save-then-publish.png)

You will need to confirm that your upload is final:
[![zenodo-12-confirm](assets/img/zenodo-12-confirm.png)](assets/img/zenodo-12-confirm.png)

Now your preprint is uploaded to Zenodo:
[![zenodo-12-ready](assets/img/zenodo-12-ready.png)](assets/img/zenodo-12-ready.png)

Copy the **DOI** or URL of the Zenodo Record, e.g. [https://sandbox.zenodo.org/record/214634](https://sandbox.zenodo.org/record/214634), as you will need it in the EasyChair submission for RO2019 peer review next.

### Submit for review in EasyChair

After creating a Zenodo record (see above), you will need to submit it to RO2019 for review using [EasyChair](https://easychair.org/). You will need to [signup to EasyChair](https://easychair.org/account/signup.cgi) if you do not already have an account.

From the [RO2019 EasyChair submission page](https://easychair.org/conferences/?conf=2019), click **Enter as an Author**.

Add Corresponding **Author** to EasyChair. As you will be submitting your Zenodo record, you are **not** required to add co-authors again in EasyChair, unless _Corresponding Author_ is different from _Speaker_ or yourself.
[![easychair-01-author](assets/img/easychair-01-author.png)](assets/img/easychair-01-author.png)

In the EasyChair **Abstract** field, you do **not** need to duplicate the abstract from Zenodo. Simply paste the **URL to the Zenodo record** or the permalink to your submission in another open repository.
[![easychair-03-no-abstract](assets/img/easychair-03-no-abstract.png)](assets/img/easychair-03-no-abstract.png)
_Note: If you do not provide a Zenodo record URL in the abstract, you MUST upload a PDF to EasyChair._

Select the **Category** of your submission type:
[![easychair-04-category](assets/img/easychair-04-category.png)](assets/img/easychair-04-category.png)

If you created a PDF you may optionally also click **Browse** to upload it to EasyChair. The submitted preprint is assumed to be licensed [CC-BY 4.0](https://creativecommons.org/licenses/by/4.0/) unless stated otherwise.

Finally **submit** your contribution for consideration:
[![easychair-05-submit](assets/img/easychair-05-submit.png)](assets/img/easychair-05-submit.png)

EasyChair should send you a confirmation email, and will send you more emails during the review process.

### Alternative: Submit for review in GitHub

As an alternative to EasyChair, this year we also support submission of abstracts and article through GitHub. Submitting by GitHub means peer review will be done in public from day 1. If you prefer peer review to not open until acceptance, instead submit by EasyChair, as described above.

RO2019 GitHub submission procedure:

1. Sign up to or log in at <https://github.com/>
2. Create a new issue at <https://github.com/researchobject/ro2019/issues> - selecting the appropriate submission type
3. For articles and longer abstracts, provide DOI for preprint uploaded at <https://zenodo.org/deposit/new?c=ro>
4. For short abstracts and demo/poster submission you can instead provide the abstract in-line as text in the issue.
5. Follow your issue to respond to peer-review as it happens (feel free to update the submission!)
6. Browse <https://github.com/ResearchObject/ro2019/issues/> - feel free to contribute ad-hoc reviews to other submissions!

_Upon acceptance we will upload any inline abstracts to Zenodo to assign DOIs, assuming CC-BY-4.0 as license._

## Update Zenodo

In Zenodo you can augment most of the metadata by clicking "**Edit**" on your record. For instance, many authors prefer to update the "**Digital Object Identifier**" to the DOI from the the official proceedings.

Note that the uploaded files cannot be changed. However you may update your uploads in the Zenodo record by clicking **New Version**. Note that reviewers are not required to assess revisions added after the deadline, but this may be used for:

  * Providing updated article, links or resources requested by reviewers
  * On acceptance of an article, uploading the IEEE camera-ready author-version PDF with official DOI from IEEE
  * On eventual rejection, a revised white-paper or preprint submitted elsewhere


text:
---
layout: default
---

# 1994-12-06 - Re: Freeport information

## Header Data

From: "L. McCarthy"<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 121fd7a294a099f841e98570db8c83ec33ab1e7b118cc92de75e5f1d1ec3bfb2

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-12-06 08:26:07 UTC

Raw Date: Tue, 6 Dec 94 00:26:07 PST

## Raw message

```
{% raw  %}From: "L. McCarthy"<EMAIL_ADDRESS>Date: Tue, 6 Dec 94 00:26:07 PST
To<EMAIL_ADDRESS>Subject: Re: Freeport information
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

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

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

Michelle Montpetite writes (forwarded by Sam Kaplin):
> Anonymous users have read-only access (e.g. they cannot
> post to the bulletin boards nor send e-mail);
[...]
> Prerequisite software
>
> FreePort is distributed in source code.  You will need
> typical Unix program development tools including an C
> compiler, yacc, and linker.  The publicly available
> layered software mentioned above is available from
> various ftp sites on the internet,

(where ?)

> or is available from CWRU as a complete collection of the prerequisite
> source code.

(where ?)

[...]
> Installation and maintenance of the FreePort software
> requires an experienced Unix Systems Programmer.  The
> technical support person requires 'root' access to
> install and configure the various prerequisite
> communications software.
[...]
> Licensing
>
> A 5-year renewable FreePort 2.3 license for a nonprofit
> site is $850 ($2800 for-profit).  The software is
> shipped as a "tar" file on 8mm Exabyte cartridge, or
> for extra cost, on 1/2" magnetic tape or DC6150
> cartridge.

I'm still not clear about what's free and what costs eight hundred bucks.

>  The software is AS IS.

 Zen and the art of software maintenance.

- - -L. Futplex McCarthy; PGP key by finger or server  "We've got computers,
we're tapping phone lines; I know that that ain't allowed" --Talking Heads

- -----BEGIN PGP SIGNATURE-----
Version: 2.6.1

iQCVAwUBLuQf4Gf7YYibNzjpAQEBxwP/QuZ5dkFDpJvMJAWNyqvUd02XudTq+Fod
mrPmnY/2JxoxpHbXwbVs6BFvV1R3iEg+/0NpumQxSZYV9bcN5o7yBm5LSjCFurIW
2NkDbAaaEG6e9rV3efzhFO2FCe2jmrcXPkUVIGLORxMJ3oS7cZyYBpZNDidN+fOP
z9lBWln7MC4=
=h+xK
- -----END PGP SIGNATURE-----
- ---
[This message has been signed by an auto-signing service.  A valid signature
means only that it has been received at the address corresponding to the
signature and forwarded.]

-----BEGIN PGP SIGNATURE-----
Version: 2.6.2
Comment: Gratis auto-signing service

iQBFAwUBLuQhISoZzwIn1bdtAQFdeAF/SJVofZS/anhfZe8RkuxJajt1xQZV/aZR
n8B66+zP0aCMXZhfdMU2u/udI5LTCcLG
=RsyI
-----END PGP SIGNATURE-----

{% endraw %}
```

## Thread

+ Return to [December 1994](/archive/1994/12)

+ Return to "["L. McCarthy" <lmccarth@ducie.cs.umass.edu>](/authors/l_mccarthy_lmccarth_at_ducie_cs_umass_edu_)"

+ 1994-12-06 (Tue, 6 Dec 94 00:26:07 PST) - Re: Freeport information - _"L. McCarthy"<EMAIL_ADDRESS>


text:
# Gatsby And Digital Garden

A set of packages to create a digital garden with Gatsby.

- [fetch-roamresearch](./packages/fetch-roamresearch): Export and download a Roam Research database
- [gatsby-source-roamresearch](./packages/gatsby-source-roamresearch): Source plugin for pulling data into Gatsby from Roam Research.
- [gatsby-remark-double-brackets-link](./packages/gatsby-remark-double-brackets-link): Transform `[[page]]` into a proper link.
- [gatsby-remark-double-parenthesis-link](./packages/gatsby-remark-double-parenthesis-link): Transform `((page))` into a proper link.
- [react-stacked-pages-hook](./packages/react-stacked-pages-hook): Manage a stack of pages in Gatsby.
- [gatsby-transformer-markdown-references](./packages/gatsby-transformer-markdown-references): Extract references between markdown nodes.
- [gatsby-theme-garden](./packages/gatsby-theme-garden): A Gatsby theme bundling all of the above packages.

An example site for leveraging all of them is at [https://mathieudutour.github.io/gatsby-digital-garden/](https://mathieudutour.github.io/gatsby-digital-garden/).

## 🚀 Quick start

Quickly get started using the Gatsby garden theme! This starter creates a new Gatsby site that is preconfigured to work with the [Gatsby garden theme](https://www.npmjs.com/package/gatsby-theme-garden).

1.  **Create a Gatsby site.**

    Use the Gatsby CLI to create a new site, specifying the garden theme starter.

    ```shell
    # create a new Gatsby site using the garden theme starter
    gatsby new my-digital-garden https://github.com/mathieudutour/gatsby-starter-digital-garden
    ```

2.  **Start developing.**

    Navigate into your new site’s directory and start it up.

    ```shell
    cd my-digital-garden/
    gatsby develop
    ```

3.  **Open the code and start customizing!**

    Your site is now running at `http://localhost:8000`!

    To get started, check out the guide to [using a Gatsby theme](https://gatsbyjs.org/docs/themes/using-a-gatsby-theme), or the longer, [more detailed tutorial](https://gatsbyjs.org/tutorial/using-a-theme).

repository: mathieudutour/gatsby-digital-garden

repo_name: mathieudutour/gatsby-digital-garden


text:
= RealityShowdown

A phone app using Ionic, Angular, and Firebase to watch and enjoy Rupaul's drag race with friends. Points are acquired by predicting the winning queens.

The stuff is kind of a mess. I was in the middle of working on the scoring feature.

It does work in that people can create a login, and vote for a week that's open.

Things that would be great for anyone to work on if they have time:

* Chat Page
* A way to see previous predictions
* See What everyone guessed
* General look and feel. Theres' a lot of native Ionic functionality that could be added pretty easily and would make a big difference.
* better use of authentication, it could be more secure!
* Mobile login, this doesn't work, something to do with the pop-up on mobile.

Hopefully you can help with the project!!!

To make the app work you need to make a file called 'secret.js' and put it in the www folder. below are the contents of that file. Let me know if you need the address to the database. I don't feel safe puting it on the open where people could jones with it.
```
angular.module('App')
.constant('FURL', 'https://addresstotheapphere.firebaseio.com/')
```


text:
# mstr-rest-requests

A extension to the excellent `requests` `Session` object, to enable more straightforward interaction with MicroStrategy's REST API.

![Python package](https://github.com/paulbailey/mstr-rest-requests/workflows/Python%20package/badge.svg)

## Usage

### Installation

Simply install the package however you normally install them, for example:

`pip install mstr-rest-requests`

### Examples

#### Authentication

Here's how to get an authenticated session (currently only standard and anonymous authentication are supported):

```
from mstr.requests import MSTRRESTSession

session = MSTRRESTSession(base_url='https://demo.microstrategy.com/MicroStrategyLibrary/api/')
session.login(username='dave', password='hellodave')
session.has_session()
# returns True
```

#### Session handling

Several convenience methods are implemented to make dealing with Session objects easier.

`def has_session(self)`

Will return a boolean as to whether the session contains an authentication tokem.

`def destroy_auth_token(self)`

Removes the auth token from the session

`def json(self)`

Returns a JSON representation of the session that can be reconstituted with:

`update_from_json(self, data)`

where `data` is either a dict or a string containing JSON data.

#### HTTP requests

The MSTRRESTSession adds two parameters to all request methods:

`include_auth=True, project_id=None`

so you can specify a `project_id` on any request by adding the parameter.

#### Convenience methods for API calls

TODO

repository: paulbailey/mstr-rest-requests

gha_language: Python

repo_name: paulbailey/mstr-rest-requests


text:
---
sidebarDepth: 0
---
# Debugging

When debugging your code, you can use more than just `console.log` or attaching the node process to a debugger. Another option is to use `ctx.state.json` to provide a custom object for debugging.

## Using `ctx.state.json`

To pass a custom object to ctx.state.json for debugging, follow these steps:

1.  Create your custom object.
2.  Assign your object to `ctx.state.json`.
3.  Access the corresponding route + `.debug.json` to view your object. For example, if you want to debug the route `/furstar/characters/:lang?`, you can access the URL: `/furstar/characters/en.debug.json`

Here's an example of how to use `ctx.state.json` taken from [furstar/index.js](https://github.com/DIYgod/RSSHub/blob/master/lib/v2/furstar/index.js)

```js
const info = utils.fetchAllCharacters(res.data, base);

ctx.state.json = {
    info,
};
```

In the example above, we're passing the `info` object to `ctx.state.json`, which we can then access using the corresponding route + `.debug.json`.

repository: wdssmq/RSSHub

repo_name: wdssmq/RSSHub


text:
# Communicating With the Server

## Remoting

The simplest way to implement client-server communication with WebSharper is by remote method calls.
Add the `[Remote]` attibute on a static method and you will be able to call it from
JavaScript-translated code, all serialization will be handled automatically by the WebSharper runtime.
Customization of the remoting mechanism are possible for both the server and client side.

Remote calls can fall into three categories, depending on their return type.

### Send message

Remote methods returning `void` are sending data to the server without blocking on the client.
No callback is registered so there is no way to confirm success or error state.

### Synchronous request

Synchronous remote calls are possible, but not recommended, as they are blocking JavaScript execution on the client.
They give a deprecated warning with most current JavaScript engines.

### Asynchronous request

Remote methods with return types `Task` or `Task<T>` (or `FSharpAsync`) allow waiting on the result asynchronously.

Here is an example of an RPC call which runs a database query asynchronously on the server:

```csharp
public static class Server
{
    [Remote]
    public static async Task<string[]> GetTitlesByAuthor(string author)
    {
        {
            using (var ctx = new MyDataContext())
            {
                return await (
                    from a in ctx.Articles
                    where a.Author.Name = author
                    select a.Title).ToArrayAsync();
            }
        }
    }
}

[JavaScript]
public class SomeClientSideClass
{

	public async Task DisplayTitles(string author)
	{
		var titles = await Server.GetTitlesByAuthor(author);
		// ...
	}
}
```

Here `await` on the client-side code means that execution of the rest of the async
method will be resumed by a callback after the server has responded.
Task based remoting also propagates errors produced by the underlying XMLHttpRequest
as exceptions, such as the server responding with an error code.

## Features

### Supported types

Remote method arguments are serialized from/to JSON.
All types occurring in method parameters and return must be one of the following:

* `System` namespace numeric types, `string`, `bool`, `DateTime`, `TimeSpan`, `Guid`, `Nullable<T>`, `Tuple<...>`. Using `decimal` on the client side needs the `WebSharper.MathJS` package referenced.
* Enums.
* Collection types: `Array<T>` (one-dimensional arrays), `List<T>`, `Queue<T>`, `Stack<T>`, `LinkedList<T>`. Other collection types have to be converted to a supported one.
* Classes with a default constructor for which the values of all fields are themselves serializable
or marked with the `NonSerialized` attribute. The `Serializable` attribute is not required and does not affect behavior.
* F# union and record types (including those defined in `FSharp.Core`), `FSharpSet<>`, `FSharpMap<_>`.

### Security

Remote methods are exposed as http endpoints, so any security measures have to be integrated into the method body itself.
`WebSharper.Web.Remoting.GetContext().UserSession` exposes some utilities for tracking users.
This uses `System.Web.Security.FormsAuthentication` on the server and cookies in the browser. [See here](WebContext.md) for more information.

```csharp
//using WebSharper.Web;
[Remote]
public static async Task<bool> Login(string user, string password)
{
    var ctx = WebSharper.Web.Remoting.GetContext();
    if (await VerifyLogin(user, password)) {
        await ctx.UserSession.LoginUserAsync(user);
        return true;
    }
    return false;
}
```

### Server-side customization

You can also use instance methods for client-server communication.
The syntax for this is:

```csharp
//using static WebSharper.JavaScript.Pervasives;
Remote<MyType>().MyMethod(...)
```

The method invoked should be annotated with the `Remote` attribute and
follows the same convention as static methods:

```csharp
public class MyType
{
    [<Remote>]
    public a this.MyMethod(...) = //...
}
```

In this case, you must provide a single instance of each type you use, preferably when the web application starts (such as in `Global.asax`).

```csharp
WebSharper.Core.Remoting.AddHandler(typeof(MyType), new MyType());
```

Note: on ASP.Net Core, instead of calling `WebSharper.Core.Remoting.AddHandler`, you can add the handler to the dependency injection graph using `services.AddWebSharperRemoting<MyType>()`. [See here for more details.](AspNetCore.md#remoting)

Remote annotated methods can be abstract or virtual.
The instance that you provide by `AddHandler` can be of a subclass of the type in the first argument.
This way you can have parts of server-side RPC functionality undefined in a library, and have them implemented in your web project for better separation of concerns.

```csharp
// Common server and client code:

public abstract class MyType
{
    [Remote]
    public abstract ... MyMethod(...);
}

// Client consumer:

Remote<MyType>().MyMethod(...)

// Server implementation:

public class MyTypeImpl
{
    public ... MyMethod(...) { ... }
}

// App startup:

WebSharper.Core.Remoting.AddHandler(typeof(MyType), new MyTypeImpl());
```

### Client-side customization

If you want to change the URL that remoting calls target by default, set the value at the `WebSharper.Remoting.EndPoint` property at the startup of your client-side code.

You can You can further customize how RPC methods are called from the client-side code by writing a class implementing the
 customize how RPC methods are called from the client-side code by writing a class implementing the
`WebSharper.Remoting.IRemotingProvider` interface, then adding a `RemotingProvider` attribute on the remote method
with the custom remoting provider type as argument.

The `IRemotingProvider` provider has 4 methods for implementing synchronous, asynchronous (Task and F# Async), and send calls: `Sync`, `Task`, `Async`, `Send` respectively.
You have to implement only the methods that your RPC methods will be using depending on their signatures.

The `RemotingProvider` attribute can be also used on classes and assemblies, overriding client-side remote handling for
all RPC methods found in their scope.

The default implementation used is `WebSharper.Remoting.AjaxRemotingProvider`.

### Communication Protocol

The communication protocol used by WebSharper is a custom protocol
built on top of HTTP and JSON. The client sends HTTP POST requests
marked with a special HTTP header `x-websharper-rpc` to the current
URL of the page (`?`), with the bodies of the requests containing the
JSON-serialized method arguments. The server responds with a JSON
reply.

The URL to which the requests are sent can be customized modifying the value of `WebSharper.Remoting.EndPoint`
static property on client-side, the default implementation of `IRemotingProvider` uses this string value.

repository: dotnet-websharper/docs

gha_language: F#

repo_name: dotnet-websharper/docs


text:
---
tags: programming
layout: post
title: "Picking OSCON talks"
---

Names at OSCON - Gnat gives a peek into his heuristic for choosing talks for OSCON.

gha_language: CSS


text:
# xe-guest-utilities-git

## Purpose
xe-guest-utilities is an add-on package for the [Xen](https://xenproject.org/developers/teams/xen-hypervisor/) and [xcp-ng](https://xcp-ng.org/) hypervisors. As per [documentation](https://xenproject.org/developers/teams/xen-hypervisor/) these tools:
  - Report extra VM info (that only the Operating system can know, not your underlying hypervisor), like VM IP address, kernel version etc.
  - Communicate with the OS in case of quiesce snapshots (Windows and its VSS)
  - Allow sending signals to the OS (clean reboot, hotplug hardware etc.)
This package provides a service file which can be activated/enabled by systemd to provide these features to your VM running with Xen/xcp-ng.

## Source Code
xe-guest-utilities pulls its sourcecode from the [Xenserver](https://github.com/xenserver/xe-guest-utilities) github repository. The source code requires a [Go development environment](https://golang.org/doc/install) in order to successfully compile the code. This script should automatically download the go-pie package, compile and install the script.

## Installation
The PKGBUILD file is hosted on [github](https://github.com/kevdogg/xe-guest-utilities-git) and listed in the [AUR](https://aur.archlinux.org/packages/xe-guest-utilities-git/). The package file can be installed via:
  - Manual Installation - Download PKGBUILD, `makepkg -si` -- [Instructions for Manual Installation of PKGBUILD files](https://wiki.archlinux.org/index.php/Arch_User_Repository#Installing_packages)
  - Automated Installation - Through use of AUR Helper Utilities(yay, trizen, pacaur, etc) [AUR Helper List](https://wiki.archlinux.org/index.php/AUR_helpers)

The following files are installed by the package: (Listed here in case manual removal is necessary)
  - /usr/share/licenses/xe-guest-utilities-git/LICENSE
  - /usr/share/oem/xs/xe-daemon
  - /usr/share/oem/xs/xe-linux-distribution
  - /usr/lib/udev/rules.d/10-xen-vcpu-hotplug.rules
  - /usr/lib/systemd/system/xe-guest-utilities.service
  - /usr/bin/xenstore
  - /usr/bin/xenstore-exists
  - /usr/bin/xenstore-read
  - /usr/bin/xenstore-rm
  - /usr/bin/xenstore-write

## Activation
Once xe-guest-utilities-git is installed, the service can be started (as root):
```
systemctl start xe-guest-utilities.service
```

The service can be enabled so it will start on subsequent boots:
```
systemctl enable xe-guest-utilities.service
```

### References:
1. https://github.com/xcp-ng/xcp/wiki/Guest-Tools
2. https://github.com/xcp-ng/xe-guest-utilities
3. https://xen-orchestra.com/blog/install-xenserver-tools-in-your-vm/
4. Older version of utilities: https://aur.archlinux.org/packages/xe-guest-utilities/

repository: kevdogg/xe-guest-utilities-git

repo_name: kevdogg/xe-guest-utilities-git


text:
# defensio

Official Ruby library for Defensio 2.0

## Install

```
gem install defensio
```

or add to you Gemfile!

## Requirements

* httparty
* multi_json

## Help and Docs

* http://www.defensio.com/downloads/ruby/

repository: universal/defensio-ruby

repo_name: universal/defensio-ruby


text:
# Regular Expression Playground

A simple Javascript project that lets you play with regular expressions.

View the demo [on-line](https://bozar.github.io/RegExpPlayground/).

repository: Bozar/RegExpPlayground

repo_name: Bozar/RegExpPlayground


text:
# Serial-Plotter Package

Package for Atom text editor to show data from a serial port.

I did this to show data from an Arduino (or anything else), sent by this library: https://github.com/devinaconley/arduino-plotter

(+) Reads up to 5 continuous multi-variable plots against time

(-) No Support for XY-graphs yet

Dependencies:
- Python with Serial library installed
- Atom "file-icons" package

this thing is working but still work-in-progress...

![screenshot](screenshot.png)

in Settings.json you can change your standard baudrate, window height, resolution (number of data points in width), etc..

--------
Special thanks to wendlers 'Sermon' Package ( https://atom.io/packages/sermon ), where I found a way to read serial data inside Atom

repository: agent-r/Serial-Plotter

repo_name: agent-r/Serial-Plotter


text:
---
layout: post
title: "Pico Documentation"
tags: [pico, generative-art, procedural-generation, javascript, glsl, graphics]
---

## Required elements

In your code, you must define a function
```
color: (x, y, f, mx, my, md) => [r, g, b]
```
where:
- `x: int` is the index of the pixel along the x axis, with 0 on the left and increasing towards the right.
- `y: int` is the index of the pixel along the y axis, with 0 on the top and increasing moving downwards.
- `f: int` is the index of the current frame. This starts from zero and is incremented per frame. This allows you to create animations, where the color of a pixel depends not only on its position, but also how long it has been since the code started running.
- `mx: int` and `my: int` are the x- and y-coordinates of the mouse cursor, respectively. You can use these values to make your sketch interactive.
- `md: boolean` is true if any mouse buttons are clicked, false otherwise.
- `r: number`, `g: number`, and `b: number` are values representing the red,
	green, and blue color components of the pixel color, where 0 is the lowest,
	and 255 is the highest. These values will be rounded to integers and clamped
	to this range, so you don't have to worry about this unless you want to.

## Adjusting settings
There are three pre-defined global variables that can be adjusted to modify
various properties of the sketch. Their names, default values, and uses are
given in the table below.

| name     | default | purpose                                                 |
|----------|---------|---------------------------------------------------------|
| `width`  | `800`   | sets the width of the sketch, in pixels                 |
| `height` | `800`   | sets the height of the sketch, in pixels                |
| `loop`   | `true`  | whether or not the sketch should be rendered repeatedly |

## Other predefined functions
You have access to all JavaScript syntax and facilities (e.g. `Array`, `Set`,
`BigInt`, objects, classes, lambda functions) except for the `Math` library. In
place of the `Math` library, you are provided with the below functions, called
in the same way as their builtin `Math` counterparts. (They are in the global
namespace, e.g. just write `sin(x)` instead of `Math.sin(x)`.)
- `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`, `sinh`, `cosh`, `tanh`,
`asinh`, `acosh`, `atanh`, `log`, `pow`, `floor`, and `ceil`.


text:
# Super Mario Bros

## Info

* It is a game that I develop using web technology.
* It is a simple and uncomplicated game, it does not have levels, just get to the end without tripping over the enemy.

* The keys to move Mario are:

  * Walk left: ◄ (LEFT ARROW)
  * Walk right: ► (RIGHT ARROW)
  * Jump (SPACEBAR)

Videogame
----------
![Super Mario Bros](/mario.png)

## Requirements
* Web browser with HTML5 support
* Web browser with canvas support
* A monitor resolution of 1024x720 or more, (that is so that it does not look bad), if you use 800x600 you would see something about jumped

## Author

* `GproGamer12`<EMAIL_ADDRESS>

repository: GlobDark/Super-Mario-Bros

repo_name: GlobDark/Super-Mario-Bros


text:
---
layout: post
category: Bash
title: Arguments & Command Exit Status
tagline: by Pigbrain
tags: [Bash]
---

# Arguments
* parameter는 순서대로 $1, $2.. 에 할당 된다
* $0에는 스크립트명이 들어간다

# Example

	test.sh
	-----------------------------
		echo $0
		echo $1
		echo $2

	prompt> ./test.sh apple banana
			parameter0 : ./test.sh
			parameter1 : apple
			parameter2 : banana

# Command Exit Status
* 명령어 실행이 종료되면 숫자형태의 exit status를 반환한다
* exit status의 값
	* **0** : true / success
	* **0 외의 수** : false / failure

Numeric value	Meaning

0	success

2	Returned by built-in commands to indicate usage errors

126	Command was found but was not executable

127	Command not found

128 + N	Command died due to receiving signal number N

# Example

	prompt> testcommand
	-bash: testcommand: command not found
	prompt> echo $?
	127

# 참고
* [Bash Pocket Reference](http://www.amazon.com/bash-Pocket-Reference-OReilly/dp/1449387888)