text:
## ROVIOLI Introduction

### Introduction

**ROVIOLI - RObust Visual Inertial Odometry  with Localization Integration,** is a visual-inertial mapping front-end for maplab that consists of an estimator, which is an adaptation of an existing estimation pipeline, [ROVIO](https://github.com/ethz-asl/rovio), and additional maplab modules for binary feature extraction and tracking, map building and localization.

ROVIOLI has two main purposes:
 * to serve as a visual-inertial mapping front-end for maplab that can be used as is,
 * to serve as an example implementation of how to integrate other estimators into maplab.

### Features
 * Robust, real-time, visual-inertial 6DOF pose estimation
 * Builds maps for maplab
 * Localization from previous map of the environment.

### Workflow

 * Create one or more maps of the environment. (a)
 * Load the maps in maplab and improve them by aligning multiple maps and applying loop closure and optimization. (b)
 * Run ROVIOLI in LOC mode and localize based on the previously build map. (c)

### Design

We use ROVIO as the core of our estimator mainly because it has been reliably deployed on many flying platforms by Autonomous Systems Lab MAV (micro aerial vehicle) team over the past couple of years. ROVIO is lightweight, fast, reliable. The features it tracks, which are based on image patches, have some complementary qualities compared to maplabs binary features (Brisk, FREAK), such as a better resistance to motion-blur. The photometric description of ROVIOs features, however, makes then less ideal to build VIMaps that are used for efficient loop closure and localization. That's why in parallel to ROVIO we run our own feature tracking module to get features that later can be used for map building. So it's important to note that the ROVIO features (visualized as green rectangles) are **NOT** used for map building at all.

The map builder is composing a VIMap based on the keyframes and features tracked by the Feature Tracking module and the pose estimates of ROVIO, which serve as initial guess of the pose graph vertex poses. Even though a map is built at runtime, it only consists of vertices, edges and feature tracks. The landmarks are only initialized and triangulated right before saving the map, i.e. at shutdown time of ROVIOLI. Therefore ROVIOLI currently does not support any online mapping capabilities such as localizing from the map that is currently built.

For more details, please have a look at the [maplab](https://www.researchgate.net/profile/Marcin_Dymczyk/publication/321332545_Maplab_An_Open_Framework_for_Research_in_Visual-inertial_Mapping_and_Localization/links/5a1d46caa6fdcc0af326c67d/Maplab-An-Open-Framework-for-Research-in-Visual-inertial-Mapping-and-Localization.pdf) and [ROVIO](https://www.research-collection.ethz.ch/bitstream/handle/20.500.11850/155340/eth-48374-01.pdf?sequence=1) paper.

### Known Issues

 * **Planar motion/ground vehicles:** Visual inertial mapping from single cameras can only get scale from the IMU. If ROVIOLI is deployed on a ground vehicle, the IMU is not excited in Z direction and if the vehicle moves at constant velocity there are barely any useful measurements to be obtained from the IMU. This has a significant impact on the estimation and can result in divergence, large drift error and scale drift.

 * **Changing the number of patches or other core ROVIO parameters:** If you want to change the number of patches tracked by ROVIO or any of the other core ROVIO parameters, you will need to adapt the code directly. Unlike the normal ROVIO version where you can set it at compile time with variables like these (`ROVIO_PATCHSIZE=4 ROVIO_NMAXFEATURE=250`).

repository: ethz-asl/maplab

repo_name: ethz-asl/maplab


text:
# Overview
This quickstart describes how to deploy Cromwell on Azure and run a sample workflow.

The main steps are:
1. **Deploy.** Download prerequisites and use the deployment executable to configure the Azure resources needed to run Cromwell on Azure.
1. **Prepare your workflow.** Create a JSON trigger file with required URLs for your workflow.
1. **Execute.** Upload the trigger file so that Cromwell starts running your workflow.

# Deployment
## Prerequisites
1. You will need an [Azure Subscription](https://portal.azure.com/) to deploy Cromwell on Azure, if you don't already have one.
1. You must have the proper [Azure role assignments](https://docs.microsoft.com/en-us/azure/role-based-access-control/overview) to deploy Cromwell on Azure.  To check your current role assignments, please follow [these instructions](https://docs.microsoft.com/en-us/azure/role-based-access-control/check-access).  You must have one of the following combinations of [role assignments](https://docs.microsoft.com/en-us/azure/role-based-access-control/built-in-roles):
   1. `Owner` of the subscription

   1. `Contributor` and `User Access Administrator` of the subscription
   1. `Owner` of the resource group.
      1. *Note: this level of access will result in a warning during deployment, and will not use the latest VM pricing data.  [Learn more](https://github.com/microsoft/CromwellOnAzure/blob/master/docs/troubleshooting-guide.md#dynamic-cost-optimization-and-ratecard-api-access).  Also, you must specify the resource group name during deployment with this level of access (see below).*
   1.  Note: if you only have `Service Administrator` as a role assignment, please assign yourself as `Owner` of the subscription.
1. Install the [Azure Command Line Interface (az cli)](https://docs.microsoft.com/en-us/cli/azure/?view=azure-cli-latest), a command line experience for managing Azure resources.
1. Run `az login` to authenticate with Azure

## Download the deployment executable
1. Download the required executable from [Releases](https://github.com/microsoft/CromwellOnAzure/releases). Choose the runtime of your choice from `win-x64`, `linux-x64`, `osx-x64`
   1. *Optional: build the executable yourself.  Clone the [Cromwell on Azure repository](https://github.com/microsoft/CromwellOnAzure) and build the solution in Visual Studio 2019. Note that [VS 2019](https://visualstudio.microsoft.com/vs/) and [.NET Core SDK 3.0 and 2.2.x](https://dotnet.microsoft.com/download/dotnet-core) are required prerequisites. Build and [publish](https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-publish?tabs=netcore21#synopsis) the `deploy-cromwell-on-azure` project [as a self-contained deployment with your target RID](https://docs.microsoft.com/en-us/dotnet/core/deploying/#self-contained-deployments-scd) to produce the executable*

## Run the deployment executable
####
1. **Linux and OS X only**: assign execute permissions to the file by running the following command on the terminal:

`chmod +x <fileName>`
   1. Replace `<fileName>` with the correct name: `deploy-cromwell-on-azure-linux` or `deploy-cromwell-on-azure-osx.app`
1. You must specify the following parameters:
   1. `SubscriptionId` (**required**)
      1.  This can be obtained by navigating to the [subscriptions blade in the Azure portal](https://portal.azure.com/#blade/Microsoft_Azure_Billing/SubscriptionsBlade)
   1. `RegionName` (**required**)
      1. Specifies the region you would like to use for your Cromwell on Azure instance. To find a list of all available regions, run `az account list-locations` on the command line or in PowerShell and use the desired region's "name" property for `RegionName`.
   1. `MainIdentifierPrefix` (*optional*)
      1. This string will be used to prefix the name of your Cromwell on Azure resource group and associated resources. If not specified, the default value of "coa" followed by random characters is used as a prefix for the resource group and all Azure resources created for your Cromwell on Azure instance. After installation, you can search for your resources using the `MainIdentifierPrefix` value.

   1. `ResourceGroupName` (*optional*, **required** when you only have owner-level access of the *resource group*)
      1. Specifies the name of a pre-existing resource group that you wish to deploy into.

Run the following at the command line or terminal after navigating to where your executable is saved:
```
.\deploy-cromwell-on-azure.exe --SubscriptionId <Your subscription ID> --RegionName <Your region> --MainIdentifierPrefix <Your string>
```

**Example:**
```
.\deploy-cromwell-on-azure.exe --SubscriptionId 00000000-0000-0000-0000-000000000000 --RegionName westus2 --MainIdentifierPrefix coa
```

Deployment can take up to 40 minutes to complete.

## Cromwell on Azure deployed resources
Once deployed, Cromwell on Azure configures the following Azure resources:

* [Host VM](https://azure.microsoft.com/en-us/services/virtual-machines/) - runs [Ubuntu 16.04 LTS](https://github.com/microsoft/CromwellOnAzure/blob/421ccd163bfd53807413ed696c0dab31fb2478aa/src/deploy-cromwell-on-azure/Configuration.cs#L16) and [Docker Compose with four containers](https://github.com/microsoft/CromwellOnAzure/blob/master/src/deploy-cromwell-on-azure/scripts/docker-compose.yml) (Cromwell, MySQL, TES, TriggerService).  [Blobfuse](https://github.com/Azure/azure-storage-fuse) is used to mount the default storage account as a local file system available to the four containers.  Also created are an OS and data disk, network interface, public IP address, virtual network, and network security group. [Learn more](https://docs.microsoft.com/en-us/azure/virtual-machines/linux/)
* [Batch account](https://docs.microsoft.com/en-us/azure/batch/) - The Azure Batch account is used by TES to spin up the virtual machines that run each task in a workflow.  After deployment, create an Azure support request to increase your core quotas if you plan on running large workflows.  [Learn more](https://docs.microsoft.com/en-us/azure/batch/batch-quota-limit#resource-quotas)
* [Storage account](https://docs.microsoft.com/en-us/azure/storage/) - The Azure Storage account is mounted to the host VM using [blobfuse](https://github.com/Azure/azure-storage-fuse), which enables [Azure Block Blobs](https://docs.microsoft.com/en-us/rest/api/storageservices/understanding-block-blobs--append-blobs--and-page-blobs) to be mounted as a local file system available to the four containers running in Docker. By default, it includes the following Blob containers - `cromwell-executions`, `cromwell-workflow-logs`, `inputs`, `outputs`, and `workflows`.
* [Application Insights](https://docs.microsoft.com/en-us/azure/azure-monitor/app/app-insights-overview) - This contains logs from TES and the Trigger Service to enable debugging.
* [Cosmos DB](https://docs.microsoft.com/en-us/azure/cosmos-db/introduction) - This database is used by TES, and includes information and metadata about each TES task that is run as part of a workflow.

 All of these resources will be grouped under a single resource group in your account, which you can view on the [Azure Portal](https://portal.azure.com). Note that your specific resource group name, host VM name and host VM password for username "vmadmin" are printed to the screen during deployment. You can store these for your future use, or you can reset the VM's password at a later date via the Azure Portal.

Note that as part of the Cromwell on Azure deployment, a "Hello World" workflow is automatically run. The input files for this workflow are found in the `inputs` container, and the output files can be found in the `cromwell-executions` container.

# Run a sample workflow
To run a workflow using Cromwell on Azure, you will need to upload your input files and your WDL file to Azure Storage. You will also need to generate a Cromwell on Azure-specific trigger file which includes the path to your WDL and inputs file, and any workflow options and dependencies. Submitting this trigger file initiates the Cromwell workflow. In this example, we will run a sample workflow written in WDL that converts FASTQ files to uBAM for chromosome 21.

## Access input data
You can find publicly available paired end reads for chromosome 21 hosted here:

[https://msgenpublicdata.blob.core.windows.net/inputs/chr21/chr21.read1.fq.gz](https://msgenpublicdata.blob.core.windows.net/inputs/chr21/chr21.read1.fq.gz)
[https://msgenpublicdata.blob.core.windows.net/inputs/chr21/chr21.read2.fq.gz](https://msgenpublicdata.blob.core.windows.net/inputs/chr21/chr21.read2.fq.gz)

You can use these input files directly as they are publicly available.

Alternatively, you can choose to upload the data into the "inputs" container in your Cromwell on Azure storage account associated with your host VM.
You can do this directly from the Azure Portal, or use various tools including [Microsoft Azure Storage Explorer](https://azure.microsoft.com/features/storage-explorer/), [blobporter](https://github.com/Azure/blobporter), or [AzCopy](https://docs.microsoft.com/azure/storage/common/storage-use-azcopy?toc=%2fazure%2fstorage%2fblobs%2ftoc.json).

## Get inputs JSON and WDL files
You can find an inputs JSON file and a sample WDL for converting FASTQ to uBAM format in this [GitHub repo](https://github.com/microsoft/CromwellOnAzure/blob/master/samples/quickstart). The chr21 FASTQ files are hosted on the public Azure Storage account container.

You can use the "msgenpublicdata" storage account directly as a relative path, like the below example.

The inputs JSON file should contain the following:
```
{
  "FastqToUbamSingleSample.sample_name": "chr21",
  "FastqToUbamSingleSample.library_name": "Pond001",
  "FastqToUbamSingleSample.group_name": "GrA",
  "FastqToUbamSingleSample.platform": "illumina",
  "FastqToUbamSingleSample.platform_unit": "GrA.chr21",
  "FastqToUbamSingleSample.fastq_pair": [
    "/msgenpublicdata/inputs/chr21/chr21.read1.fq.gz",
    "/msgenpublicdata/inputs/chr21/chr21.read2.fq.gz"
  ]
}
```

The input path consists of 3 parts - the storage account name, the blob container name, file path with extension. Example file path for an "inputs" container in a storage account "msgenpublicdata" will look like
`"/msgenpublicdata/inputs/chr21/chr21.read1.fq.gz"`

If you chose to host these files on your own Storage account, replace the name "msgenpublicdata/inputs" to your `<storageaccountname>/<containername>`.

Alternatively, you can use http or https paths for your input files [using shared access signatures (SAS)](https://docs.microsoft.com/en-us/azure/storage/common/storage-sas-overview) for files in a private Azure Storage account container or refer to any public file location.

*Please note, [Cromwell engine currently does not support http(s) paths](https://github.com/broadinstitute/cromwell/issues/4184#issuecomment-425981166) in the JSON inputs file that accompany a WDL. **Ensure that your workflow WDL does not perform any WDL operations/input expressions that require Cromwell to download the http(s) inputs on the host machine.***

## Configure your Cromwell on Azure trigger file
Cromwell on Azure uses a JSON trigger file to note the paths to all input information and to initiate the workflow. [A sample trigger file can be downloaded from this GitHub repo](https://github.com/microsoft/CromwellOnAzure/blob/master/samples/quickstart/FastqToUbamSingleSample.chr21.json) and includes the following information:
- The "WorkflowUrl" is the url for your WDL file.
- The "WorkflowInputsUrl" is the url for your input JSON file.
- The "WorkflowOptionsUrl" is only used with some WDL files. If you are not using it set this to `null`.
- The "WorkflowDependenciesUrl" is only used with some WDL files. If you are not using it set this to `null`.

Your trigger file should be configured as follows:
```
{
 "WorkflowUrl": <URL path to your WDL in quotes>,
 "WorkflowInputsUrl": <URL path to your input json in quotes>,
 "WorkflowOptionsUrl": null,
 "WorkflowDependenciesUrl": null
}
```

When using WDL and inputs JSON file hosted on your private Azure Storage account's blob containers, the specific URL can be found by clicking on the file to view the blob's properties from the Azure portal. The URL path to "WorkflowUrl" for a test WDL file will look like:
`https://<storageaccountname>.blob.core.windows.net/inputs/test/test.wdl`

Alternatively, you can use any http or https path to a TES compliant WDL and inputs.json [using shared access signatures (SAS)](https://docs.microsoft.com/en-us/azure/storage/common/storage-sas-overview) for files in a private Azure Storage account container or refer to any public file location.

You can also host your WDL and JSON inputs files on your storage account container and use the `/<storageaccountname>/<containername>/blobName` format.

## Start a WDL workflow
To start a WDL workflow, go to your Cromwell on Azure Storage account associated with your host VM. In the `workflows` container, place the trigger file in the "new" virtual directory (note: virtual directories do not exist on their own, they are just part of a blob's name). This initiates a Cromwell workflow, and returns a workflow ID that is appended to the trigger JSON file name and transferred to the "inprogress" directory in the `workflows` container.

This can be done programatically using the [Azure Storage SDKs](https://azure.microsoft.com/en-us/downloads/), or manually via the [Azure Portal](https://portal.azure.com) or [Azure Storage Explorer](https://azure.microsoft.com/en-us/features/storage-explorer/).

### Via the Azure Portal
![Select a blob to upload from the portal](screenshots/newportal.PNG)

### Via Azure Storage Explorer
![Select a blob to upload from Azure Storage Explorer](screenshots/newexplorer.PNG)

For example, a trigger JSON file with name `task1.json` in the "new" directory, will be move to the "inprogress" directory with a modified name `task1.uuid.json`. This uuid is a workflow ID assigned by Cromwell.

Once your workflow completes, you can view the output files of your workflow in the `cromwell-executions` container within your Azure Storage Account. Additional output files from the Cromwell endpoint, including metadata and the timing file, are found in the `outputs` container. To learn more about Cromwell's metadata and timing information, visit the [Cromwell documentation](https://cromwell.readthedocs.io/en/stable/).

## Abort an in-progress workflow
To abort a workflow that is in-progress, go to your Cromwell on Azure Storage account associated with your host VM. In the `workflows` container, place an empty file in the "abort" virtual directory named `cromwellID.json`, where "cromwellID" is the Cromwell workflow ID you wish to abort.

license: MIT

branch_name: refs/heads/master

extension: md

gha_license_id: MIT

license_type: permissive


text:
---
author: Feng Wang
avatar: assets/images/people/Wang.jpg
date: 2014-01-10 14:10:38
excerpt: Feng was a visiting researcher from the Institute of Desertification Studies
  from the Chinese Academy of Forestry, located in Beijing, China.
portfolio-item-category:
- people
portfolio-item-tag:
- former member
- lab visitor
- Princeton
title: Feng Wang, Visiting Researcher (2015)
---

Feng is from the Institute of Desertification Studies from the Chinese Academy of Forestry, located in Beijing, China. He is currently a visiting fellow within the Ecohydrology Lab. His research focuses on 3D structure and behavior of plants and the interactions between plant growth and its surroundings. He is interested in the ecological and geographical processes that govern ecological population, communities, ecosystem, and landscape. His approach is to develop, calibrate and test mathematical models to explain ecological structures. He is also interested in plant isotope fractionation, isotope hydrology application in ecology field, especially in dryland ecosystems.

Lately, Feng has been concentrating his work on a new vegetation model. His goal is to scale up the so called Functional and Structural Plant Model (FSPM), developed at the individual scale. The new model will be used to estimate the carbon storage of a specific pine forest, and answer the following questions: How will vegetation respond to climate change, eg. precipitation, temperature? What patterns and distribution are there under future climate predictions?

The picture on the left was taken in the Kumtag Desert, located in Northwestern China. Feng is standing on the top of one of the so-called feather-like sand dunes.

gha_language: JavaScript


text:
[![Unit-Testing, Coverage, Linting](https://github.com/btr1975/pyats-genie-command-parse/actions/workflows/test-coverage-lint.yml/badge.svg)](https://github.com/btr1975/pyats-genie-command-parse/actions/workflows/test-coverage-lint.yml)

# pyats-genie-command-parse
This is a library to be able to parse NOS command output using the available
[Genie parsers](https://developer.cisco.com/docs/genie-docs/), it seperates out
needing to create a testbed.yml, and allows you to just get the output, and parse the
output with [Genie parsers](https://developer.cisco.com/docs/genie-docs/).

# Some options to get the data
1. You could use [netmiko](https://ktbyers.github.io/netmiko/) to get the command output
   from devices and then parse using the string parser.

2. You could use [Cisco Network Services Orchestrator "NSO"](https://developer.cisco.com/docs/nso/)
   to get the command output from devices and then parse using the string parser.

3. Use your imagination, as long as you can get the output data in a string format the string parser
   will work.

4. If you prefer you could store the data in a text file, and then using the file parser, you can also
   parse the output data.


text:
# HAProxy wrapper

HAProxy doesn't support reloading the configuration, it needs to be restarted in a special way. That doesn't play well when HAProxy is managed by upstart or something like that. Most of the solutions I found were tightly coupled to upstart which I don't like. I created a script which wraps HAProxy and which in turn can be used by upstart like any other executable.

My hope is that this becomes a thing ppl like me find easily and saves them hours of research.

This wrapper accepts `SIGHUB` and reloads HAProxy properly. Anything that kills the wrapper also kills HAProxy. It shall not surprise you!

## Usage

```
haproxywrapper /path/to/pid /path/to/config
```

repository: hanshasselberg/haproxy-wrapper

repo_name: hanshasselberg/haproxy-wrapper


text:
uuidtoa
=======

Optimized serialization of hyphenated UUID ASCII representation to `io::Write`
sinks.

The two functions exported by this crate are `write_lower` and `write_upper`;
here are their signatures:

```rust
fn write_lower<W: io::Write>(io: &mut W, uuid: &Uuid) -> io::Result<usize>;
fn write_upper<W: io::Write>(io: &mut W, uuid: &Uuid) -> io::Result<usize>;
```

An example of writing this out to a buffer would be

```rust
let uuid = Uuid::from_str("e098d1f6-7e49-4c34-99f6-e9c6cef8fcce").unwrap();
let mut buf: Vec<u8> = Vec::with_capacity(36);
write_lower(&mut buf, &uuid).unwrap();
```

This performs approximately 10x better than the equivalent `fmt::Display` impl
from the _uuid_ crate.

```rust
let uuid = Uuid::from_str("e098d1f6-7e49-4c34-99f6-e9c6cef8fcce").unwrap();
let buf = format!("{}", uuid.hyphenated());
```

The benchmarks from these two approaches are as follows.

```
test benches::bench_fmt   ... bench:         522 ns/iter (+/- 6)
test benches::bench_lower ... bench:          45 ns/iter (+/- 0)
```

To run them for yourself, the bench feature and nightly compiler should be used.

```sh
cargo bench --feature bench
```

repository: jwilm/uuidtoa

repo_name: jwilm/uuidtoa


text:
## Time

 The `Time` class provides utility functions for working with time.

### timeStringToSeconds(timeString: string): number

A time string supports weeks, days, hours, minutes and seconds.

##### Example time strings:

1 week: ***"1w"***

3 days:   ***"3d"***

6 hours:   ***"6h"***

30 minutes:   ***"30m"***

10 seconds:   ***"10s"***

1 week and 3 days: ***"1w:3d"***

12 hours, 30 minutes and 20 seconds: ***"12h:30m:20s"***

```javascript
let seconds = Time.timeStringToSeconds('5m');

console.log(seconds); // 300
```

repository: ieatstickers/phusion

gha_language: TypeScript

repo_name: ieatstickers/phusion


text:
---
ENTRYTYPE: inproceedings
abstract: Symbolic execution is an effective technique for exploring paths in a program and reasoning about all possible values on those paths. However,
  the technique still struggles with code that uses complex heap data structures, in which a pointer is allowed to refer to more than one memory object.
  In such cases, symbolic execution typically forks execution into multiple states, one for each object to which the pointer could refer. In this paper,
  we propose a technique that avoids this expensive forking by using a segmented memory model. In this model, memory is split into segments, so that each
  symbolic pointer refers to objects in a single segment. The size of the segments are bound by a threshold, in order to avoid expensive constraints. This
  results in a memory model where forking due to symbolic pointer dereferences is significantly reduced, often completely. We evaluate our segmented memory
  model on a mix of whole program benchmarks (such as m4 and make) and library benchmarks (such as SQLite), and observe significant decreases in execution
  time and memory usage.
added: 2021-03-15
address: New York, NY, USA
authors:
- Timotej Kapus
- Cristian Cadar
booktitle: Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering
doi: 10.1145/3338906.3338936
isbn: '9781450355728'
keywords: Symbolic execution, memory models, pointer alias analysis, KLEE
layout: paper
link: https://doi.org/10.1145/3338906.3338936
location: Tallinn, Estonia
numpages: '11'
pages: 774-784
publisher: Association for Computing Machinery
read: true
readings:
- 2021-03-18
series: ESEC/FSE 2019
title: A segmented memory model for symbolic execution
url: https://doi.org/10.1145/3338906.3338936
year: 2019
notes:
- symbolic execution
- KLEE verifier
- symbolic memory
papers:
- coppa:ase:2017
---

This paper provides a different solution to the problem in [coppa:ase:2017]:
how to handle symbolic addresses during symbolic execution.
Forking (the default behaviour of [KLEE][KLEE verifier])
every time the pointer target could refer to multiple objects ("multi-resolution")
causes a path explosion while treating the entire memory as a single flat object
is inefficient.

Their solution is to use a pointer analysis to partition all objects/pointers into
equivalence classes of objects that may alias.
A separate segment with its own memory management (including its own free list)
is created for each equivalence class and allocation is performed in the appropriate segment.
They allow for possible bugs in the pointer analysis by performing a search in each
segment: the performance benefit comes from the fact that only one will hit (in the absence
of bugs).

They evaluate on the Apache Portable Runtime (a sort of portability middleware layer),
GNU m4, GNU make and SQLite.
The new model is (significantly?) slower than standard KLEE on benchmarks that do not suffer from
multiresolution.
An alternative model that (aggressively?) merges paths is competitive with segmented memory
but it times out on some of the benchmarks.
They evaluate the impact of pointer analysis precision -- sometimes it matters.

{% include links.html %}

repository: alastairreid/RelatedWork

branch_name: refs/heads/main

gha_language: TeX

repo_name: alastairreid/RelatedWork


text:
# Flip-Flop
 A rotation based match three game, developed with Unity, for the [Kenney Jam 2021](https://itch.io/jam/kenney-jam-2021)

 You can [play the game here](https://johnnyx1991.itch.io/flip-flop)

gha_language: C#


text:
# FsharpWebApi

Compares two almost identical APIs in F# and C#.

Features:
* CRUD controller to access a simple Persons Entity.
* Background Job to call petstore api via apiClient and print a message to log

## C#

Uses EF core SQL server, ef migrations

## F#

Uses Swashbuckle for swagger and also FSharp.Data to read appsetting.json, and SwaggerTypeProvider for connecting to petstore test api, and Fsharp.Data.SqlProvider for an EF like experience for SQL query, and DBup for migrations.

## C# Friendlier

Uses ! at the beginning of constructs which discard the value, to avoid doing the more verbose (and very different from C#) |> ignore.

```fsharp
module TerseIgnore =
    //readability trick
    let (!) a = a |> ignore
```

repository: SCKelemen/FsharpWebApi

repo_name: SCKelemen/FsharpWebApi


text:
# Practical Aspects of Deep Learning
## Learning Objectives
Recall that different types of initializations lead to different results

Recognize the importance of initialization in complex neural networks.

Recognize the difference between train/dev/test sets

Diagnose the bias and variance issues in your model

Learn when and how to use regularization methods such as dropout or L2 regularization.

Understand experimental issues in deep learning such as Vanishing or Exploding gradients and learn how to deal with them

Use gradient checking to verify the correctness of your backpropagation implementation

# Setting up your machine learning application

## train/dev/test Sets
Working on a neural network is an interative process, with lots of options. Choices around # of layers, # of hidden units, learning rates, activation functions, and other hyperparameters.

Often, intuitions from one domain (e.g. NLP) don't transfer to another.

Often, will split your data into three sets:
- training (bulk of data)
- hold-out/crossvalidation ("dev")
- test

Best practices used to be 70/30 (train/test) or 60/20/20 (train/dev/test).

Dev just needs to be big enough to try out different algorithms, so 20% may be too much data. Similarly, test can also be typically much smaller, so as your overall data set increases in size you can start considering 98/1/1 (or greater) splits.

Also can have mismatched data sets (train high-res images, dev/test come from cellphone cameras), so should try to make dev and test come from the same data set.
## Bias/Variance
High bias - underfitting.
High variance - overfitting.

Easy to see this in 2-D data, can just plot and look at. With higher-dimensional data, this isn't really a workable approach. Here, can look at train and dev error rates -- low train error/high dev error is high variance/overfitting, high train and dev error is about the same rate is high bias/underfitting, and high train error and even higher dev error is both high bias *and* high variance. Part of what constitutes "high" error is a comparison to human, so if you have ~ 0.01% error then 15% is high error, but if a human has 15% error then a 15% error may be considered low.
## Basic Recipe for Machine Learning
High bias (training data) - then try things like a bigger network, or training longer (or looking at different architectures).

Then, after fixing bias ask if you have high variance (dev set performace). Best way to fix this is more data (not always possible), otherwise can regularize the data. Sometimes different NN architectures.

Usually a bigger network never hurts, it just takes longer computationally.
# Regularizing Your Neural Network
## Regularization
Remember logistic regression. Here, you're trying to minimize the cost function J(w, b):
$J(w, b) = \frac{1}{m} \sum_{i = 1}^{m} L(\hat{y}^{(i)}, y^{(i)})$
which now becomes
$J(w, b) = \frac{1}{m} \sum_{i = 1}^{m} L(\hat{y}^{(i)}, y^{(i)}) + \frac{\lambda}{2m}\Vert w \Vert^{2}_{2}$
where $\lambda$ is the regularization parameter and $\Vert w \Vert^{2}_{2}$ is the norm of w squared, which is just $\sum_{j = 1}^{n_{x}} w_{j}^{2}$, which works out to $w^{T} w$. Often referred to as L2 regularization.

W is usually a high dimension parameter, and b is just one parameter, so often it's just simpler to exclude this from regularization and just focus on w.

Now, if we move to a neural network then we have
$J(w^{[1]}, b^{[1]}....w^{[L]}, b^{[L]}) = \frac{1}{m} \sum_{i = 1}^{m} L(\hat{y}^{(i)}, y^{(i)})$
which becomes
$J(w^{[1]}, b^{[1]}....w^{[L]}, b^{[L]}) = \frac{1}{m} \sum_{i = 1}^{m} L(\hat{y}^{(i)}, y^{(i)}) + \frac{\lambda}{2m} \sum_{l = i}^{L}\Vert w^{[l]} \Vert^{2}_{F}$
and here the norm works out to be $\sum_{i = i}^{n^{[l - 1]}} \sum_{j= 1}^{n^{[l]}} (w_{ij}^{[l]})^{2}$, which is called the "Frobenius norm".

Now we also have to adjust for backprop as well, so that $dw^{[l]}$ = (from backprop) + $\frac{\lambda}{m} w^{[l]}$.
## Why Regularization Reduces Overfitting
What happens when you regularize? If you set $\lambda$ to be very large, that forces the weights to be very small [WHY?], which in a sense is equivalent to zeroing out nodes in your network, and force it to be simpler.
## Dropout Regularization
Set some probability for each node in your hidden nodes to be knocked out -- remove incoming and outgoing links to the node. Most common form is "inverted dropout".

   d3 = np.random.randn(a3.shape[0], a3.shape[1]) < keep_prob
   a3 = np.multiply(a3, d3)
   a3 /= keep_prob

Last step is needed because we're losing a number of nodes, so this will correct the value of z so that it's still in line with what's expected. Then, at test time you don't do the drop out.
## Understanding Dropout
What's really happening is that because you can't rely on any one particular input, that forces the weights to be spread out. Also, can vary your keep_prob by layer, and lower it (or eliminate completely) for layers where you are less worried about overfitting.

The downside is that the cost function is less well defined/harder to calculate. Typically will turn off dropout to verify that learning rate is monotonically decreasing, then turn it on.
## Other Regularization Methods
Data augmentation -- do things like flip pictures or take random distortions and transformations of the input, which gives you more data to train on but is not as good as getting more, new data.

Early stopping -- plot training and dev error, and often you find dev error goes down for a while, then starts to increase. Find point when increase starts, and just stop your training around that point. Drawback is that you're stopping the optimization of your cost function early.
# Setting up your optimization problem

## Normalizing Inputs
Typically two steps. First, subtract the mean.
$\mu = \frac{1}{m} \sum_{i = 1}^{m} x^{(i)}$
$x := x - \mu$
Then, normalize the variance.
$\sigma^{2} = \frac{1}{m} \sum_{i = 1}^{m} x^{(i)} ** 2$ (element-wise square)
$x /= \sigma^{2}$

Also, need to use this for your test set as well.

Why do we do this? Often, one set of input parameters could have a large range, and a second set a very small one (0 < x1 < 1000 versus 0 < x2 < 1), which gives you a much more elongated space to "step" with gradient descent. Normalizing makes this a much more regularized space, so that you can take fewer (and larger) steps to get to the minima.
## Vanishing/Exploding Gradients
Look at deep networks -- if W is even just a little bit bigger than the identity matrix, then your activations increase exponentially. Likewise, if it's just even a little bit smaller than I, then your activations start to decrease exponentially. This ends up impacting your training, and forces you to take a lot longer to work at learning due to higher (or lower) activations. This is one of the big challenges when working with larger neural networks.
## Weight Initialization for Deep Networks
Often find that setting the variance of your initial weight matrix to be $\frac{1}{n}$, helps to force the weight matrix to be constrained so that it doesn't explode or vanish. ReLU it works out that it's a bit better to use $\frac{2}{n}$. Can also look at Xavier initialization ($\tanh \sqrt{\frac{1}{n^{[l - 1]}}}$)
## Numerical Approximations of Gradients
Two-sided approximation a more accurate way to check your gradient's slope.
## Gradient Checking
Take all of your Ws and bs, reshape into vectors and concatenate them together ($\Theta$). Do the same for your dW and db (into vector d$\Theta$).

Now, for each element in the two vectors, calculate $\frac{J(\Theta + \epsilon) - J(\Theta - \epsilon)}{2\epsilon}$, and then see if this is approximately the same as your d$\Theta$.

## Gradient Checking Implementation Notes
Only do the grad checking for debugging, then turn off. This is a very slow check.

If you have a problem, need to start digging in, look at where things seem to be far apart (is it with db or dW?).

Grad check doesn't work with dropout.


text:
---
layout: simple
permalink: /contact/
title: Contact Us
description: The BioFoundry is a young, dynamic and growing research group. If you share our passion for innovation and sustainability, and are motivated to make a difference by conducting impactful research, we encourage you to reach out to us.
---

# Email
Please reach out to us by email. If you're interested in graduate studies, internships or post-doctoral research positions, kindly upload a copy of your CV as a PDF or Word file:
<a href="mailto:vikramaditya.yadav<EMAIL_ADDRESS>
# Links
Find us on social media and other sites:
- [Faculty Profile](http://www.chbe.ubc.ca/profile/vikramaditya-yadav/)
- [Twitter](https://twitter.com/biofoundry)
- [LinkedIn](https://www.linkedin.com/in/vgyadav/)
- [Facebook](https://www.facebook.com/biofoundry/)

# Location
If you are a student at the University of British Columbia, drop by our laboratory. We are located in room __634__ in the Department of Chemical & Biological Engineering.

gha_language: HTML


text:
Happy Birthday by Genetic Algorithm
===
A tool for printing 'Happy Birthday, (Your name)!' using genetic algorithm.
- 'Your name' can be given by command-line arguments

## Demo
![demo](https://github.com/upura/happy.birthday.ga/blob/master/demo/demo.mov.gif)

### Final Output
![final](https://github.com/upura/happy.birthday.ga/blob/master/demo/final.png)

Japanese blog can be seen from the following link:
https://upura.hatenablog.com/entry/happy-birthday-to-me

## Requirement
- Python 3.x
    - numpy

## License

[MIT](https://github.com/upura/happy.birthday.ga/blob/master/LICENSE)

## Author

[upura](https://github.com/upura)


text:
# grunt-upload-file [![Built with Grunt](https://cdn.gruntjs.com/builtwith.png)](http://gruntjs.com/)

[![NPM version](https://badge.fury.io/js/grunt-uncss.png)](http://badge.fury.io/js/grunt-uncss)
[![Build Status](https://travis-ci.org/addyosmani/grunt-uncss.png?branch=master)](https://travis-ci.org/addyosmani/grunt-uncss)
[![Dependency Status](https://david-dm.org/addyosmani/grunt-uncss.png?theme=shields.io)](https://david-dm.org/addyosmani/grunt-uncss)
[![devDependency Status](https://david-dm.org/addyosmani/grunt-uncss/dev-status.png?theme=shields.io)](https://david-dm.org/addyosmani/grunt-uncss#info=devDependencies)

> After we build the project, sometimes we may need to upload some files through form post method !

## Getting Started
This plugin requires Grunt.

If you haven't used [Grunt](http://gruntjs.com/) before, be sure to check out the [Getting Started](http://gruntjs.com/getting-started) guide, as it explains how to create a [Gruntfile](http://gruntjs.com/sample-gruntfile) as well as install and use Grunt plugins. Once you're familiar with that process, you may install this plugin with this command:

```shell
npm install grunt-upload-file --save-dev
```

Once the plugin has been installed, it may be enabled inside your Gruntfile with this line of JavaScript:

```js
grunt.loadNpmTasks('grunt-upload-file');
```

## The "upload_file" task

### Overview
In your project's Gruntfile, add a section named `upload_file` to the data object passed into `grunt.initConfig()`.

_Run this task with the `grunt upload_file` command._

This task was designed to be used in conjunction with one background management system. In Tencent.com when we publish our static resources to the cdn or webserver, we need go to the background management system to publish one zip file! What's the zip file for? We develop our app ,for examples wechat/mobile qq, by hybrid model! The 2g, 3g network connection is very slow, so users have to wait before the browser gets the web resources when he first open the related webview in the app. So when our app found the users' network connection is wifi, it does web resources prefetching by downloading the related updated zip containing the webview needed resources! when the users open the webview, if the related zip is there, no static resources network requests will be sent, the app simply offer the prefetched files contained in zip.

```js
grunt.initConfig({
  upload_file: {
    options: {
      // Task-specific options go here.
    },
    your_target: {
      // Target-specific file lists and/or options go here.
    },
  },
})
```

### Options

grunt-upload-file uses the [request](https://github.com/mikeal/request) module under the hood, and apart from a couple specific to grunt-upload-file options, the rest get passed straight to it. Here's a copy of the of the module's option docs. Otherwise, [go to the repo](https://github.com/mikeal/request) and have a look at what's it's capable of.

- `uri || url` - fully qualified uri or a parsed url object from url.parse(). REQUIRED.
- `callback` - A function that will receive an `error`, `response` and `body`, after a response if finished
- `qs` - object containing querystring values to be appended to the uri
- `method` - http method, defaults to GET
- `headers` - http headers, defaults to {}
- `body` - entity body for PATCH, POST and PUT requests. Must be buffer or string.
- `sourceField` - A field in the body or form to add the source files' contents to. Can contain full stops to separate object path. Ie "form.js\_code".
- `auth` - A hash containing values user || username, password || pass, and sendImmediately (optional). [See more info here](https://github.com/mikeal/request#http-authentication).
- `json` - sets body but to JSON representation of value and adds Content-type: application/json header. Additionally, parses the response body as json.
- `multipart` - (experimental) array of objects which contains their own headers and body attribute. Sends multipart/related request. See example below.
- `followRedirect` - follow HTTP 3xx responses as redirects. defaults to true.
- `followAllRedirects` - follow non-GET HTTP 3xx responses as redirects. defaults to false.
- `maxRedirects` - the maximum number of redirects to follow, defaults to 10.
- `encoding` - Encoding to be used on setEncoding of response data. If set to null, the body is returned as a Buffer.
- `pool` - A hash object containing the agents for these requests. If omitted this request will use the global pool which is set to node's default maxSockets.
- `pool.maxSockets` - Integer containing the maximum amount of sockets in the pool.
- `timeout` - Integer containing the number of milliseconds to wait for a request to respond before aborting the request
- `proxy` - An HTTP proxy to be used. Support proxy Auth with Basic Auth the same way it's supported with the url parameter by embedding the auth info in the uri.
- `oauth` - Options for OAuth HMAC-SHA1 signing. [See more info here](https://github.com/mikeal/request#oauth-signing). The `oauth-sign` module must be installed to use this functionality.
- `hawk` - Options for [Hawk signing](https://github.com/hueniverse/hawk). The credentials key must contain the necessary signing info, [see hawk docs for details](https://github.com/hueniverse/hawk#usage-example). You will need to install the `hawk` module to use this functionality.
- `strictSSL` - Set to true to require that SSL certificates be valid. Note: to use your own certificate authority, you need to specify an agent that was created with that ca as an option.
- `jar` - If true, remember cookies for future use (or define your custom cookie jar; [see mikeal/request's examples](https://github.com/mikeal/request#examples)). To get either of these functions working you'll need to install an optional dependecy `npm i tough-cookie`.
- `aws` - object containing aws signing information, should have the properties key and secret as well as bucket unless you're specifying your bucket as part of the path, or you are making a request that doesn't use a bucket (i.e. GET Services). You will need to install the `aws-sign2` module to use this functionality.
- `httpSignature` - Options for the [HTTP Signature Scheme](https://github.com/joyent/node-http-signature/blob/master/http_signing.md) using [Joyent's library](https://github.com/joyent/node-http-signature). The `http-signature` module must be installed and the keyId and key properties must be specified.
- `localAddress` - Local interface to bind for network connections.
- `ignoreErrors` - Ignore the status code returned (if any).

There are a few optional dependencies you'll need to install to get certain functionality from this module.

- if you wish to use cookies (`jar`) install `tough-cookie`
- if you want to pass `multipart/form-data` you'll need to install `form-data`
- if you wish to tunnel your requests install `tunnel-agent`
- if you want to use Joyent's HTTP Signature Scheme, install `http-signature`
- if you require oauth signing, you need to install the `oauth-sign` module
- to use Hawk signing, you must use the `hawk` module
- if you want to use AWS signing, you must install the `aws-sign2` module

### Usage examples

```javascript
// Project configuration.
grunt.initConfig({
    upload_file: {
        "zip-partly": {    // only the special QQ num user (usually the developer or tester) can be noticed the zip file has been updated !
            src: ['dist/qqcache/*.zip'],
            options: {
                url: 'http://admin.connect.oa.com/modules/public/uploadOfflinePackage.do',
                method: 'POST',
                paramObj: {
                    'publish': true,    // 这个参数用来告诉cgi，创建包的同时是否需要发布
                    'compatible': 0,    // 兼容版本
                    'bid': 118,    // 所属业务
					"qversionfrom": "0", // 手Q起始版本号
            		"qversionto": "0", // 手Q结束版本号
                    'platform': [2, 3],    // 支持平台， 2， 3表示ios android平台都都勾选上了
                    'loadmode': 2,    // 加载模式， 2表示拦截加载
                    'frequency': 1,    // 更新检测的时间频率， 1表示1分钟检测一次
					"verifyType": 0,
		            "expire_time":<PHONE_NUMBER>000, // 过期时间毫秒数，默认为 2020-1-1
		            "cdn": "defaultCDN", // 连线包使用cdn，默认为 defaultCDN
		            "note": "", // 备注
                    'gray': true,    // 是否灰度， true表示灰度
                    'uins': [
                        {"min":2568612250,"max":2568612250},
                        {"min":644323349,"max":644323349},
                    ]    // 要灰度的QQ号
                }
            }
        },
        "zip-totally": {
            src: ['dist/qqcache/*.zip'],
            options: {
                url: 'http://admin.connect.oa.com/modules/public/uploadOfflinePackage.do',
                method: 'POST',
                paramObj: {
                    'publish': true,    // 这个参数用来告诉cgi，创建包的同时是否需要发布
                    'compatible': 0,    // 兼容版本
                    'bid': 118,    // 所属业务
                    "qversionfrom": "0", // 手Q起始版本号
            		"qversionto": "0", // 手Q结束版本号
                    'platform': [2, 3],    // 支持平台， 2， 3表示ios android平台都都勾选上了
                    'loadmode': 2,    // 加载模式， 2表示拦截加载
                    'frequency': 1,    // 更新检测的时间频率， 1表示1分钟检测一次
					"verifyType": 0,
		            "expire_time":<PHONE_NUMBER>000, // 过期时间毫秒数，默认为 2020-1-1
		            "cdn": "defaultCDN", // 连线包使用cdn，默认为 defaultCDN
		            "note": "", // 备注
                    'gray': false    // 是否灰度， true表示灰度, false，不灰度，全量外网用户
                }
            }
        }
    },
});

grunt.registerTask('default', [
    'jshint',
    'test',
    'build',
    'upload_file:zip-partly'
]);

```

## Contributing
In lieu of a formal styleguide, take care to maintain the existing coding style. Add unit tests for any new or changed functionality. Lint and test your code using [Grunt](http://gruntjs.com/).

## Release History
* 2012-04-16   v0.0.2   correct some README spelling error.
* 2012-04-16   v0.0.1   initial release.

## About
grunt-upload-file is an open-source project by [Tencent](http://www.tencent.com/en-us/) which builds on top of [Node.js](https://nodejs.org).

## Used by people within (JOIN US)
![Tencent](http://upload.wikimedia.org/wikipedia/commons/thumb/2/22/Tencent_Logo.svg/200px-Tencent_Logo.svg.png)

## License
Copyright (c) 2014 materliu. Licensed under the MIT license.

---

Task submitted by [materliu](http://materliu.github.com)

*This file was generated on Fri Apr 16 2014 22:38:50.*

repository: materliu/grunt-upload-file

repo_name: materliu/grunt-upload-file


text:
---
title: "The Covid Chronicles: April 14"
date: 2020-04-14 11:18:59
description: "The Covid Chronicles for April 14"
---

### April 14

I refrained from posting COVID-19 news over Easter weekend. I figured it was a good time for a break.

[But the hits keep on coming](https://www.businessinsider.com/500000-zoom-accounts-sale-dark-web-2020-4?utm_source=reddit.com)

> [Cybersecurity firm] Cyble said many of the accounts it found were being sold for less than a penny, while others were being given away on hacker forums so people could use them for "Zoombombing," a form of trolling where malicious actors drop into Zoom calls and post graphic or offensive content.

Time to change those passwords.

For local golf fans, [there’s a little good news]( https://www.wfaa.com/mobile/article/sports/golf/pga-set-to-return-to-action-at-colonial/287-1fa9a12e-2b65-4974-a8cd-f2d9d9b04359)?

> PGA set to return to action at Colonial
>
> While golf may return at Colonial in June, safety precautions concerning COVID-19 would likely prevent fans from attending the event.

Hey, it’s something.

repository: quakerpunk/gatsby-blog

repo_name: quakerpunk/gatsby-blog


text:
# Release notes

## What's new in 1.2.2 March 19 2022

### GraphShape.Controls

#### Fixes:
* Fix the control flickering when changing the bound graph.

---

## What's new in 1.2.1 October 28 2021

### GraphShape

#### Fixes:
* Fix Sugiyama orthogonal edge routing on horizontal layout.

### GraphShape.Controls

* Update package dependencies.

---

## What's new in 1.2.0 March 31 2021

### GraphShape

#### New:
* Add support of .NET Core 3.1+.
* Add support of .NET 5+.

#### Updates:
* Update package dependencies.

### GraphShape.Controls

#### New:
* Add support of .NET Core 3.1+.
* Add support of .NET 5+.

---

## What's new in 1.1.0 June 7 2020

### GraphShape

#### New:
* Use signing key to strong name library assemby.

### GraphShape.Controls

#### New:
* Use signing key to strong name library assemby.

---

## What's new in 1.0.0 May 12 2020

### GraphShape

#### General:
* Fully clean the library code.
* Extend support of the library to .NET Framework 3.5+.
* Extend support of the library to .NET Standard 2.0+.
* Uniformize APIs and behaviors of algorithms implementations.

#### Fixes:
* Various fixes for layout algorithms implementations.
* Various fixes across the library.

#### Update:
* Algorithm parameters classes are equatable.
* Algorithm cancellation will stop run earlier if possible.

#### New:
* Add a Random layout algorithm implementation.

#### API Breaks
* Some public API breaks (but should remain simple to do a migration).
* Replace .NET framework base structs (Point, Vector, Size, Rect and Thickness) by equivalent ones to support .NET Standard.
* Some algorithm were not working well and has been removed (Sugiyama).
* Rename EfficientSugiyama to Sugiyama.
* Namespaces simplifications.

#### Misc:
* Use JetBrains annotations all over the library as much as possible.

### GraphShape.Controls

#### General:
* Fully clean the library code.
* Extend support of the library to .NET Framework 3.5+.
* Remove dependency to WPFExtensions package.

#### Fixes:
* Fix async compute mode on GraphLayout control.
* Fix handlers registrations/unregistrations.
* Various fixes across the library.

#### Misc:
* Use JetBrains annotations all over the library as much as possible.

---

## What's new in 0.1.2 August 5 2020

### GraphShape

#### Fixes:
* Fix a crash when using Efficient Sugiyama algorithm (with a graph having less than 2 layers).

### GraphShape.Controls

* Update package dependencies.

---

## What's new in 0.1.1 August 3 2020

### GraphShape

#### Fixes:
* Fix the orthogonal edge routing of Efficient Sugiyama algorithm (in horizontal layout).

### GraphShape.Controls

* Update package dependencies.

---

## What's new in 0.1.0 March 9 2020

This release is based on GraphSharp from CodePlex.

### GraphShape

Graph layout algorithms implementations.

Split GraphSharp package into 2 packages:
- GraphShape
- GraphShape.Controls

### GraphShape.Controls

WPF Controls to display graph using layout algorithms.

### API Breaks
* Namespace renamed to GraphShape (but should be easy to migrate).

### Misc:
* Generate a documentation for the library via DocFX.

repository: KeRNeLith/GraphShape

repo_name: KeRNeLith/GraphShape


text:
# Features

* Fully offline boilerplate for a video website
* Create pages and dated posts via [Cryogen](https://cryogenweb.org)
* Source of multimedia enriched RSS feeds
* RSS aggregator for multiple multimedia enriched feeds
* Scripts to import existing YouTube videos and playlists
* Integrates with CDN for unlimited read scalability
* Video guides help newbies become experts
* Lectures about scalable system design included [principles]
* One script to get started from a new RasPi... Go.sh

repository: harlanji/ispooge

repo_name: harlanji/ispooge


text:
## Repo / Columns API
[Back to the "Repos API"](../repos.md) | [Back to the navigation](../README.md)

This api is currently only available to developers in Early Access. To access the API during the Early Access period,
you must provide a custom media type in the Accept header.

Both repositories and organisations have projects. The api is only different for getting all project or retrieving a single project.
All the example use the repository projects column api but this also works form the organization api (`$client->api('org_projects')->columns()`)

```php
$client->api('repo')->projects()->columns()->configure();
```

### List all columns of a project

```php
$columns = $client->api('repo')->projects()->columns()->all($projectId);
```

### List one column

```php
$column = $client->api('repo')->projects()->columns()->show($columnId);
```

### Create a column

> Requires [authentication](../security.md).

```php
$column = $client->api('repo')->projects()->columns()->create($projectId, array('name' => 'Column name'));
```

### Edit a column

> Requires [authentication](../security.md).

```php
$column = $client->api('repo')->project()->columns()->update($columnId, array('name' => 'New name'));
```

### Remove a column

> Requires [authentication](../security.md).

```php
$column = $client->api('repo')->projects()->columns()->deleteColumn($columnId);
```

### Move a column

> Requires [authentication](../security.md).

```php
$column = $client->api('repo')->projects()->columns()->move($columnId, array('position' => 'first));
```

repository: KnpLabs/php-github-api

gha_language: PHP

repo_name: KnpLabs/php-github-api


text:
@title Where NetNewsWire data is stored
@template nnw5mac_en.html

NetNewsWire remembers your feeds and article read status, as well as your account information and preferences. This information is stored in two different locations on your Mac, but separately from the NetNewsWire app.

Feeds and accounts data
-----------------------

Information about your subscribed feeds, article read status and accounts (On my Mac and Feedbin) are stored in your account’s Application Support folder. This can be found in the Finder by going to:

*Your home folder* › Library › Application Support › NetNewsWire

### Exporting your feeds

If you just want to export your list of subscribed feeds, NetNewsWire [can export an OPML for you](export-opml).

Preferences file
----------------

Your NetNewsWire preferences file is called `com.ranchero.NetNewsWire-Evergreen.plist`. It’s stored in your account’s Preferences folder, which can be found in the Finder by going to:

*Your home folder* › Library › Preferences

### Can’t find the Library folder?

If you can’t see the Library folder in the Finder, you can open it by holding down the Option (⌥) key and choosing **Go › Library**. For more information, see the [Library folder][lib] note in the macOS Documentation.

[lib]: https://support.apple.com/en-gb/guide/mac-help/aside/mh35934/10.14/mac/10.14 "Library folder - Apple Support"

### Preferences caching

The contents in the preferences `.plist` file are cached by macOS. If you make any changes or delete the file, log out and log back in before relaunching NetNewsWire to make sure the old settings are fully cleared. (If you prefer, you can also run `killall cfprefsd` in Terminal to force the preferences cache to be flushed.)

Resetting or removing NetNewsWire
---------------------------------

If you are running into problems while using NetNewsWire, resetting your settings may help. By removing the preference file and the  data folder given above, you can start over again from scratch.

You may also want to delete these files if you wish to completely remove NetNewsWire from your Mac.

repository: tecumsehmaverick/NetNewsWireHelp

extension: markdown

repo_name: tecumsehmaverick/NetNewsWireHelp


text:
Static files dir
================

Files you put in /sources/static_files/ will be copied to the web visible /_static/

Be careful not to override pre-existing static files from the template.

Generally, layout related files should go in the /theme directory.

If you want to add images to your particular documentation page. Just put them next to
your .rst source file and reference them relatively.

gha_language: Go


text:
---
title: 'C #8 | I/O in C'
excerpt: "Further materials on how C handles user inputs, how users can pass input as arguments, and how program can save what users typed."
category: waga
layout: post
comments: true
tags: [tutorial, C]
visible: 0
---

For the complete list of the tutorial on this blog, you can check these following links:

[1. Introduction][00]

[2. First C-Program][02]

[3. Types and Variables][03]

[4. Conditional Statements][04]

[5. Function and Math Operations][05]

[6. Arrays][06]

[7. Pointers][07]

[**8. I/O in C**][08]

-----

Allright, so far we've just used all static values. Every values are staticly predefined and a program would be useless without some way to talk to the users of the program. If you consider yourself a user, and your colleague as a program, then you'll supply him with informations about stuffs. And your colleague has to be able to catch those supplies and do something as predetermined before else.

This way of communication is called **input output** (I/O). One way to communicate that we've learned and implemented is `printf()`, which tells the program to deliver some informations to users.

Let's start by knowing what `printf` can do.

{% highlight c %}
printf("Hello World");
{% endhighlight %}

That is pretty much regular usage of printf, printing **Hello World** string into the display. If you have a variable, then you can let printf to put it with help of format specifier `%`.

{% highlight c %}
int a = 5;
int b = 10;
int c = a + b;

printf("a is %d, b is %d, the sum would be %d", a, b, c);
{% endhighlight%}

And the output will exactly the same as this more efficient, less variable usage printf:

printf("a is %d, b is %d, the sum would be %d", a, b, a+b);

**Casting** also can be used, to let compiler treat some values to a different type, for example you want to print integer values from float (albeit the value will be rounded) like this:

float phi = 3.14;

printf("the value of phi is %d", (int)phi);

Always make sure that you watch your variables value, as rounded values could lead into different meaning from several constant, *e.g*, **phi** value. Always use float or double to represent these kind of constants.

Now, if printf display some informations to the user, C is capable to record users input using several methods, *e.g.* reading files, command-line argument and using run time function, `scanf()`. However, we'll gonna use only scanf for now to design some kind of computer-to-user interview program. Here, the program will ask user and user will have to prepare answers. Each of the answer is recorded using scanf and saved to a variable.

Basically, scanf requires you to include `#include <stdio.h>`, similar with printf.

{% highlight c %}
/* create a variable named userInput */
int userInput;

/* ask user about something */
printf("What is your age?");
{% endhighlight %}

When you compile above code and let it runs, the output will be a question **What is your age?** to any users who are using the program. When they want to answer with age numbers, program catch the entered value with scanf. Expected input should be stored in a memory address of correlated variable (with suitable data type), which in this case an integer.

{% highlight c %}
/* create a variable named userInput */
int userInput;

/* ask user about something */
printf("What is your age?");

/* retrieve the user input */
scanf("%d", &userInput);
{% endhighlight %}

The scanf function ignores blanks and tabs in its format string, and will skip over white space as it looks for the proper input values. Whenever the question appears on the screen, then the program will prompt user to provide an answer. Any valid numbers will then stored on the `userInput` variable.

Now, let's make a simple program that will ask user's informations, *e.g.* age, lastname and firstname. Then, at the end, we give the user the table-like summary (of course using command line).
First of all, we will learn how to retrieve user's name as string arrays. It's little bit different than how we record integer. Take a look at the complete program first:

{% gist 0097f3678b1c6b986b4e %}

First, declare two arrays variables, first is `char userLastName[256]` and the second is `char userFirstName[256]`. The number here means the length of the reserved memory for each variable is 256 `char` or equals to 256 bytes due to 1 char equals to 1 byte of memory space (1 char is 8 bits, 8 bits is 1 byte).

Then, after asking the user about his/her age, next question is for the name. We will use `%s` to capture strings or characters. We will store the user's name into declared variable arrays. As now we want to treat those input as sequence of some characters, we want to reserve memory space through the variable array. Now, we will point scanf to write the captured input to the address of the first index of the array. Thus we have to pass `&arrayName[0]` instead of just `&arrayName` as you can see on **line:19**.

Now, we have user's age, last name and first name. **line:26** to **29** are used to format the summary. Keep in mind that you can represent the summary as you wish with your own preferences.

Here's the output from my terminal:

{%highlight ruby%}
=====USER INFORMATION=====
Full Name	 : Janu Aditya
Age 		 : 27
==========================
{%endhighlight%}

Next, we will try to exploit another way to pass user's inputs into our program by [reading files and passing arguments][1].

[1]: http://yanuartadityan.github.io/waga/c-tutor-8
[00]: http://yanuartadityan.github.io/tutorial/c-tutor-1
[02]: http://yanuartadityan.github.io/waga/c-tutor-2
[03]: http://yanuartadityan.github.io/waga/c-tutor-3
[04]: http://yanuartadityan.github.io/waga/c-tutor-4
[05]: http://yanuartadityan.github.io/waga/c-tutor-5
[06]: http://yanuartadityan.github.io/waga/c-tutor-6
[07]: http://yanuartadityan.github.io/waga/c-tutor-7
[08]: http://yanuartadityan.github.io/waga/c-tutor-8


text:
# @ngx-extensions/screenfull

A simple wrapper around [screenfull.js](https://github.com/sindresorhus/screenfull.js) for Angular.

## Installation

```bash
npm install @ngx-extensions/screenfull
```

## Setup

Import `NgxScreenfullModule` into your module

```typescript
import { NgxScreenfullModule } from '@ngx-extensions/screenfull';

@NgModule({
 imports: [NgxScreenfullModule]
})
export class AppModule {}
```

## Usage

The most basic use case is to toggle the fullscreen mode through an element´s click event:

```html
<button ngxToggleFullscreen>Toggle fullscreen</button>
```

_Note: the host element of `ngxToggleFullscreen` does not necessarily have to be a `<button>`_

The state of the fullscreen mode can be tracked through the `ScreenfullService`

```typescript
import { ScreenfullService } from '@ngx-extensions/screenfull';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

@Component({
 template: `
    <span>Screenfull mode is currently {{ mode$ | async }}</span>
  `
})
export class DemoComponent {
 readonly mode$: Observable<string>;

 constructor(public readonly screenfullService: ScreenfullService) {
  this.mode$ = this.screenfullService.fullScreenActive$.pipe(
   map(active => (active ? 'active' : 'inactive'))
  );
 }
}
```

To interact with the fullscreen API, use the `ScreenfullService`:

```typescript
import { ScreenfullService } from '@ngx-extensions/screenfull';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

@Component({
 template: `
    <button (click)="screenfullService.request()">Enter fullscreen</button>
    <button (click)="screenfullService.exit()">Exit fullscreen</button>
    <button (click)="screenfullService.toggle()">Toggle fullscreen</button>
    <span>Screenfull mode is currently: {{ mode$ | async }}</span>
  `
})
export class DemoComponent {
 readonly mode$: Observable<string>;

 constructor(public readonly screenfullService: ScreenfullService) {
  this.mode$ = this.screenfullService.fullScreenActive$.pipe(
   map(active => (active ? 'active' : 'inactive'))
  );
 }
}
```

repository: ngx-extensions/ngx-extensions

branch_name: refs/heads/develop

repo_name: ngx-extensions/ngx-extensions


text:
# Strawberry GraphQL website

This is the repo for [Strawberry GraphQL](https://strawberry.rocks). If you want
to edit the documentation head to the
[main repository](https://github.com/strawberry-graphql/strawberry).

This repo only contains the template and design of the website.

## Docs

**This shows the latest released version and not the master branch docs.**

#### `https://strawberry.rocks/docs`

Shows the latest
[release](https://github.com/strawberry-graphql/strawberry/releases) from
[Strawberry Graphql Repo]. These pages are rendered at build time and
revalidated after 60 seconds. When a new release of Strawberry Graphql is done
then the site should update [Strawberry GraphQL](https://strawberry.rocks) site
by itself. Not requiring a re-deployment.

### Pull Requests

#### `https://strawberry.rocks/docs/pr/:pull-request-number`

Pull requests on [Strawberry Graphql Repo] with a label of
[ok-to-preview](https://github.com/strawberry-graphql/strawberry/pulls?q=is%3Apr+is%3Aopen+label%3Aok-to-preview)
can be viewed. Theses are rendered on-demand and cached. They will be
revalidated after 60 seconds.

### Version Releases

#### `https://strawberry.rocks/docs/tag/:release-tag`

[Releases](https://github.com/strawberry-graphql/strawberry/releases) of
Strawberry Graphql can be viewed. Theses are rendered on-demand and cached. But
are not revalidated on the server unless a new deployment is done.

## How to setup the project

Make sure to have `nodejs 14.16.0` (exact version shouldn't matter too much, you
can use [asdf](https://github.com/asdf-vm/asdf) to install it, in case).

You also need a GitHub token, this is used to fetch the list of contributors for
the repo, you can create one with the following scopes
`public_repo, read:packages, read:user, repo:status`, following
[this guide](https://docs.github.com/en/free-pro-team@latest/github/authenticating-to-github/creating-a-personal-access-token)
or by clicking
[this link](https://github.com/settings/tokens/new?description=Strawberry%20Docs&scopes=repo:status,public_repo,read:user,repo:status,read:packages)
directly (notice it will ask you for a password).

The token needs to be stored in a `.env` file, like this:

```env
GITHUB_TOKEN=123123123
```

### Installing the dependencies

We are using npm to manage dependencies, so can install the dependencies by
running

```sh
pnpm install
```

### Running the website

To run the website, you can use npm:

```sh
pnpm run dev
```

This should start the server on [http://localhost:3000](http://localhost:3000)

### GraphQL TypeScript Typings

We generate the TypeScript typings for any GraphQL queries using.

- [@octokit/graphql-schema](https://github.com/octokit/graphql-schema)
- [GraphQL Code Generator](https://graphql-code-generator.com/)

Outputted to [`./types/graphql.d.ts`](./types/graphql.d.ts)

To update them run.

```sh
pnpm run codegen
```

Any new GraphQL query will need a comment before it to generate theses typings.

```ts
/* GraphQL */ `query GoesHere {}`;
```

### Debugging

To run the website in debug mode:

```sh
pnpm run dev:inspect
```

See next.js docs on the different ways to
[connect to the debugger](https://nextjs.org/docs/advanced-features/debugging#step-2-connect-to-the-debugger).

[strawberry graphql repo]: https://github.com/strawberry-graphql/strawberry/

---

[<img src="https://www.datocms-assets.com/31049/1618983297-powered-by-vercel.svg">](https://vercel.com?utm_source=strawberry-graphql&utm_campaign=oss)


text:
# krip_funcs
Custom functions created by kripaar (kv_HK)
___
# sqlite.py
* The `database` and `table` objects are inside for now
### Quick Example
```py
from kripfunc.sqlite import database

db = database()  # Leave parameter blank => storing everything in ram, not opening any file

table = db.create_table("credit_card", {"card_number": "INT NON NULL", "expire": "TEXT", "CVC": "CHAR(3)"})

table.append(1234567890123456, "07/21", "051")
table.append_many((2345678901234567, "08/31", "028"),<PHONE_NUMBER>345678, "10/01", "777"))

print(table.get())   #<PHONE_NUMBER>123456, '07/21', '051')
print(table.get(0))  # [(1234567890123456, '07/21', '051'),<PHONE_NUMBER>234567, '08/31', '028'),<PHONE_NUMBER>345678, '10/01', '777')]
print(table.get(2))  # [(1234567890123456, '07/21', '051'),<PHONE_NUMBER>234567, '08/31', '028')]
```

# commander.py
* Convert a command-line form of string into running your commands
### Quick Example
```py
from kripfunc.commander import Commander

cmd = Commander("/")

@cmd(name="money")
def bank():
    print("You have no balance in your bank account")

@cmd(parent="money")
def top():
    print("The top is Li Ka Shing")

@cmd(name="give", parent="money")
def i_had_loan_from(account_payable, amount_to_give):
    print(f"You've given ${amount_to_give} to {account_payable}")

c.run("/money")                               # You have no balance in your bank account
c.run("/money top")                           # The top is Li Ka Shing
c.run("/money give \"Kripaar Bank\" 1000")    # You've given $1000 to Kripaar Bank
```

```py
from kripfunc.commander import Commander

cmd = Commander("Hey, ")

@cmd(name="what")
def a():
    print("What?")

@cmd(name="is", parent="what")
def b():
    print("Hello?")

@cmd(parent="what:is")
def going():
    print("Are you saying?")

@cmd(name="on?", parent="what:is:going")
def on():
    print("You meant \"What's going on?\"? There's nothing weird going on!")

c.run("Hey, what")                  # What?
c.run("Hey, what is going on?")     # You meant "What's going on?"? There's nothing weird going on!
```


text:
# Text Extracter

## Introduction

In order to count the number of words in a page, we need to extract the pure text content from the Rich Text.

Consider the following situation :arrow_down:

![DSL](https://user-images.githubusercontent.com/10103993/50403170-5e1f8d80-07d7-11e9-91d0-10cfb75fc9da.png)

There are some different markers that we want to trim.
- HTML Tags `</>  `
- Editor Markers
  - overstriking `'''overstriking_text'''`
  - italic `''italic_text''`
  - Secondary Title `==Title==`
  - Redirect `#REDIRECT [[text]]`
  - ...
- Spaces & Line Break
- Table Markers `| |- !`

## Question

- Q: Are there any packages that can be used to count the words ?
- A: Nope. We are counting both Chinese characters & alphanumeric characters, we can simply use `len()` function in **Python** . However, we need to extract the pure text first.

## Method

- HTML Tags
  For **HTML** contents, we use **HTMLParser** which is provided natively.
- Editor Markers
  For DSL(Domain Specific Language) Markers, we can only replace them one by one using Regular Expression.
- Spaces & Line break
  We can remove spaces & Line Break using Regular Expression.
- Table
  After Splitting the string into a list by space, we can filter out '|' and '|-' to skip the table markers.

## Usage

```python
from wikiglass_analyzer.utilities.text_extract import TextExtracter

text = '<p>hello, world!</p>'
length = TextExtracter.len(text)
```

repository: tsengkasing/wikiglass-analyzer

repo_name: tsengkasing/wikiglass-analyzer


text:
# Algorithm Playground

This repository will contain my solutions to various programming exercises (in Python, C++, Rust) and some of my personal notes about algorithms in general

# References

### Books
- Cracking the Coding Interview, Gayle Laakmann McDowell
- Elements of Programming Interviews, Adnan Aziz
- Introduction to Algorithms, Thomas Cormen
- The Algorithm Design Manual, Steven Skiena
- Algorithms, Robert Sedgewick
- Grokking Algorithms, Aditya Bhargava
- Learning Algorithms Through Programming and Puzzle Solving, Alexander S. Kulikov and Pavel Pevzner

### Repositories
- [Interactive Coding Challenge](https://github.com/donnemartin/interactive-coding-challenges)
- [System Design Primer](https://github.com/donnemartin/system-design-primer)
- [Interview](https://github.com/andreis/interview)

### Sites
- [LeetCode](https://leetcode.com/)
- [FireCode](https://www.firecode.io/)

### Videos
- [Princeton Algorithms and Data Structure Videos, 	Robert Sedgewick](https://www.youtube.com/channel/UCirCLaGiw_zT6vJNI_At6ag)
- [Coursera: Master Algorithmic Programming Techniques](https://www.coursera.org/specializations/data-structures-algorithms)

# Advanced
- - [Advanced Algorithms (Jelani Nelson, Harvard)](http://people.seas.harvard.edu/~minilek/cs224/fall14/lec.html)

repository: shabadrohithans/algorithm-playground

repo_name: shabadrohithans/algorithm-playground


text:
# Moe Music Player
- Readme Language

    [中文](README_zh-rCN.md)
- PackageName
```
    app.skynight.musicplayer
```
- Maintainer
```
    Github@152980358 (SkyNight)
```

repository: zhanngqi/MusicPlayer

repo_name: zhanngqi/MusicPlayer


text:
# PubSub

`guillotina` provides out of the box pubsub service with redis driver.

## Configuration

```yaml
applications:
- guillotina.contrib.redis
- guillotina.contrib.pubsub
```

## Usage

You can subscribe to channels and define who you are so you make sure that you do not receive the message.

Multiple tasks can subscribe to the same channel and `guillotina` will broadcast all the messages to all tasks.

```python
from guillotina.component import get_utility
from guillotina.interfaces import IPubSubUtility

MY_PROCESS_ID = 'me'

async def callback(*, data=None, sender=None):
    ...

util = get_utility(IPubSubUtility)
await util.subscribe('channel_name', MY_PROCESS_ID, callback)
await util.publish('channel_name', MY_PROCESS_ID, 'mydata')

```

repository: plone/guillotina

gha_language: Python

gha_license_id: NOASSERTION

repo_name: plone/guillotina


text:
---
layout: page
title: Week 26
author: Disha-maker
categories:
  - team
  - basics
tags:
  - week 26
---

Hello all,

- I started the week by restructing the training videos on the shared Google Drive and created a Google Doc on Accessing IAC Training Materials for review from manager and mentor Paula.

- I reviewed PRs for Ciaran on puppet_litmus and pdk-templates
   - [puppet_litmus](https://github.com/puppetlabs/puppet_litmus/pull/395)
   - [pdk-templates](https://github.com/puppetlabs/pdk-templates/pull/372)

- During the weekly 1:1 with Paula, I learnt about the best way of doing rebasing and how it works. I was also introduced by new commands; git stash apply and grep.

- I continued to work on restructing the training material and putting together a Google doc.

- I was on PTO on Thursday 11th and Friday 12th March 2021 :)

That's all for this week!

repository: puppetlabs/iac

gha_language: Ruby

repo_name: puppetlabs/iac


text:
envoy
============

Make a hosts file from Chef Server nodes.

Example command:

`envoy create -f output.txt -n node-name -s https://chef-server.example.com -e production -k key.pem`

This replaces a Ruby script that did this pretty well until we hit about 900 nodes. After that it used way too much memory and became a problem.

Binaries are available on the [releases page](https://github.com/darron/envoy/releases).

Also available as a [Docker image](https://hub.docker.com/r/darron/envoy/).

repository: darron/envoy

repo_name: darron/envoy


text:
# Development philosophy

Timbala aims to:

- prefer simplicity over complexity
- state assumptions explicitly
- use data to verify assumptions
- make operational visibility a first-class concern
- make usability a first-class concern
- document design decisions, including the 'why' behind changes
- make development as transparent as possible to encourage contributions
- keep user-supplied configuration to a minimum to ease operation

repository: PratikDhanave/timbala

repo_name: PratikDhanave/timbala


text:
# 17943-di-sample-retranscode-videos
In this sample, you will learn how to retranscode multiple videos using the Dynamic Ingest API.  Note that this sample for accounts using the Legacy Ingest system. For accounts using Dynamic Delivery. go to the Dynamic Delivery version instead.

This repository contains all the code for your convenience:

		File
		Description

		index.html
		The sample as working HTML page

		css/styles.css
		CSS used in the sample

		js/index.js
		JavaScript used in the sample

View the [documentation/working sample](https://support.brightcove.com/dynamic-ingest-api-sample-re-transcoding-videos-legacy-ingest).


text:
RoboDK Plug-In Interface
=========

The RoboDK Plug-In Interface allows you to extend or customize RoboDK software for industrial robots and simulation of robot arms.

RoboDK Plug-In interface documentation reference: https://robodk.com/doc/en/PlugIns/index.html

The RoboDK Plug-In interface is available in the [robodk_interface](./robodk_interface/) folder. However, it is recommended to use one of the sample projects in this repository to get started (such as the [PluginExample](./PluginExample/)).

**Important:** This Plug-In Interface and the [RoboDK API](https://github.com/RoboDK/RoboDK-API) are 2 different projects. This Plug-In Interface includes access to the RoboDK API and requires advanced programming skills in C++.

![](plugin-example.png)

Introduction
-------------

RoboDK Plug-Ins allow extending RoboDK by using the RoboDK Interface and the RoboDK API.
Contrary to the default RoboDK API (provided in Python, C#, C++, Matlab, etc), this RoboDK Plug-In interface is linked natively into the core of RoboDK.
Therefore, when the RoboDK API is used inside the Plugin Interface (using IItem and IRoboDK) the speed is faster than using the default API.
However, all RoboDK Plug-In applications must exist within RoboDK's environment.

Double click the .pro file in any of the sample projects to open the project with Qt Creator.
Make sure to follow the installation requirements section to install Qt as a C++ development environment.

You can load one of the sample plug-ins by selecting:
 * Tools - Plug-Ins

The default location for RoboDK plugins is C:/RoboDK/bin/plugins

Plug-In Interface vs. RoboDK API
-------------

The [RoboDK API](https://github.com/RoboDK/RoboDK-API) is a generic set of commands that allows you to interact with RoboDK and automate tasks. The RoboDK API is used by default when macros are used in RoboDK.
The RoboDK Plug-In interface includes an interface to the RoboDK API.

The main advantages of using the RoboDK API through a Plug-In Inteface are the following:
 * The RoboDK API is much faster because it is loaded as a library (a RoboDK Plug-In is actually a library loaded by RoboDK).
 * You can customize the appearance of RoboDK's main window (including the menu, toolbar, and add docked windows).
 * You can customize the 3D view using OpenGL

You should pay attention to the following when using the RoboDK API inside a Plug-In:
 * Items are pointers, not objects. You can check if an item is valid or not by checking if it is a null pointer (nullptr).
 * You must provoke a render event every time you want to update the screen (for example, if you change the position of a robot). Updating the screen is not done automatically.
 * Plug-Ins can only be deployed as C++ code using a DLL.

Timing tests
-------------

The PluginExample project shows how to implement a basic plugin. Among other things it performs some timing tests to calculate the speed of RoboDK on a specific computer.
By selecting the "Plugin Speed Information" button you'll obtain the timing statistics.
![](sampleoutput.png)

For example, forward and inverse kinematics are usually under 2 microseconds and 10 microseconds respectively (1 microsecond = 0.000001 seconds).

Requirements
-------------

Each RoboDK Plug-In must be developed using the Qt Creator and follow Qt's project guidelines.
It is recommended to use the [PluginExample](./PluginExample/) project to get started with your new RoboDK Plug-In (double click PluginExample.pro to open it with Qt Creator).

RoboDK must be installed to develop Plug-Ins. The free version of RoboDK is enough to develop a Plug-In as a proof of concept.

Installation Requirements
-------------

Requirements to make RoboDK Plug-Ins work:
 * Install RoboDK (v3.5.4 or later): https://robodk.com/download
 * Make sure you compile your plugin using the correct compiler and version of Qt:
  - Qt version 5.15 on Windows (MSVC2019).
  - Qt version 5.15 on Mac (clang 64 bit).
  - Qt version 5.12 on Linux.
 * It is possible to run in debug mode on Windows. Contact us for more information.

![](qtrun.png)

Qt Tips
-------------

A RoboDK Plug-In must be created using the Qt Plugin Framework (C++).

This list provides some useful links and tips for programming with Qt:
 * Double click the .pro file to open the example project using Qt Creator.
 * Use Qt signal/slots mechanism for action/button callbacks (http://doc.qt.io/qt-5/signalsandslots.html). Signals and slots are thread safe.
 * Wrap your strings using tr("your string") or QObject::tr("your string") to allow translation using Qt Linguist. For more information: http://doc.qt.io/qt-5/qtlinguist-index.html.
 * If you experience strange build issues it may be useful to delete the build folder that is automatically created to force a new build.
 * If you experience strange plugin load issues in RoboDK it is recommended to delete the libraries and create the plugin library with a new build.
 * More information about Qt: https://www.qt.io/.

Useful Links
-------------

Useful links involving the RoboDK API:
 * RoboDK Plug-In interface documentation reference: https://robodk.com/doc/en/PlugIns/index.html.
 * Standard RoboDK API Introduction: https://robodk.com/doc/en/RoboDK-API.html#RoboDKAPI.
 * Standard RoboDK API Reference (based on Python): https://robodk.com/doc/en/PythonAPI/index.html.
 * Latest RoboDK API on GitHub: https://github.com/RoboDK/RoboDK-API.
 * RoboDK API Introductory video: https://www.youtube.com/watch?v=3I6OK1Kd2Eo.

repository: RoboDK/Plug-In-Interface

gha_language: C

repo_name: RoboDK/Plug-In-Interface


text:
# Global Highres Mining Footprints

Mining is of major economic, environmental and societal consequence, yet  knowledge and understanding of its global footprint is still limited.
Here, we produce a global mining land use dataset via remote sensing analysis of high-resolution, publicly available satellite imagery. The
dataset comprises 74,548 polygons, covering ~66,000 km2 of features like waste rock dumps, pits, water ponds, tailings dams, heap leach pads and
processing/milling infrastructure. Our polygons finely contour the edges of mine features and do not include the space between them. This
distinguishes our dataset from others that employ broader definitions of mining lands. Hence, despite our database being the largest to date by
number of polygons, comparisons show relatively lower global land use. Our database is made freely available to support future studies of global
mining impacts. A series of spatial analyses are also presented that highlight global mine distribution patterns and broader environmental risks.

#### Citation

```
Tang, Liang, and Tim T. Werner. "Global mining footprint mapped from high-resolution satellite imagery."
Communications Earth & Environment 4, no. 1 (2023): 134.
```

#### Data citation

```
Tang, Liang, & Werner, Tim T. (2023). Global mining footprint mapped from high-resolution satellite imagery.
Communications earth & environment, 4(134). https://doi.org/10.5281/zenodo.7894216
```

![mining_resized](https://github.com/samapriya/awesome-gee-community-datasets/assets/6677629/dd6c7c34-14db-496d-a353-1ea58e2d4bec)

#### Earth Engine snippet

```js
var mining_footprints = ee.FeatureCollection("projects/sat-io/open-datasets/global-mining/global_mining_footprints");
```

Sample Code: https://code.earthengine.google.com/?scriptPath=users/sat-io/awesome-gee-catalog-examples:global-utilities-assets-amenities/GLOBAL-MINING-FOOTPRINTS

#### License
This dataset is available under a Creative Commons BY-4.0 license

Curated by: Tang, Liang, & Werner, Tim T.

Keywords: Mining, High Resolution, Global, coal, land-use, metal ores, minerals, raw material extraction

Last updated: April 26, 2023


text:
# Handwritten-Digit-Classifier
Detecting handwritten digits using a CNN model based on MNIST dataset in Keras

# Key Highlights
* A pattern classification system is built for handwritten digits using dataset from MNIST and the application GUI for inspection is created
* Trained and evaluated performances of SVM, KNN, Decision Tree, Random Forest and a CNN with a fully connected SoftMax layer
* Performed Data Augmentation and Batch Normalization for achieving classification accuracy of 89.35 % on Test Dataset

# Dataset
  The dataset is directly loaded from Keras.


text:
# USHCN-Data
## Finding the average amount of precipitation per day

### Setting up a virtual box
First install virtualbox

In Arch Linux

    sudo pacman -S virtualbox
    sudo modprobe vboxdrv #add Virtualbox to the kernel
In debian/Ubuntu

    sudo apt-get install virtualbox
In SUSE/REHL/CentOS

    wget http://download.virtualbox.org/virtualbox/rpm/rhel/virtualbox.repo > /etc/yum.d/virtualbox.repo
    yum update
    rpm -Uvh http://dl.fedoraproject.org/pub/epel/6/i386/epel-release-6-8.noarch.rpm  #Dependencies
    yum install binutils gcc make patch libgomp glibc-headers glibc-devel kernel-headers kernel-devel dkms
    yum install VirtualBox-4.3
    service vboxdrv setup

Then download a sandbox from HortonWorks

    wget http://hortonassets.s3.amazonaws.com/2.2.4/Sandbox_HDP_<IP_ADDRESS>_VirtualBox.ova
Once the virtual drive has been downloaded, open it with virtualbox

    VirtualBox Sandbox_HDP_<IP_ADDRESS>_VirtualBox.ova
Now simply ssh into the virtualbox

    ssh -p 2222 root@localhost

### Loading data into Hive
First download and decompress the gzip file

    wget http://cdiac.ornl.gov/ftp/ushcn_daily/state25_NE.txt.gz
    gzip -d state25_NE.txt.gz
Then we need to format the data to import it into Hive.
The data is formatted with an entire month worth of data in one record.
To help understand each row, this is the json equivalent:

    {
      COOPID: String,
      YEAR: Integer,
      MONTH: Integer,
      ELEMENT: String,
      VALUES: [{
        VALUE: Integer,
        MFLAF: Character,
        QFLAG: Character,
        SFLAG: Character
      }]
    }
I wrote a python script to convert the file to json.

    ./txtToJson.py
This script requires a lot of memory because it must store all records before it writes them to the file. It also creates a very large file. Because of this I chose to create csv files instead.  This format did not require more RAM because I could write each line to the file and then remove the line from memory. This caused the program to run slower because it was doing file IO each loop (Even on a SSD). I created one file per ELEMENT type because it is easier to do a join than to query over mismatched data.  This also removed excess data, such as if I do not need SNOW related data, I would be able to discard that file.

To run this csv script simply...

    ./state.py

Once this is created I imported each file by running Hive's CLI, creating each database, and importing the data

    $ hive
    hive> CREATE TABLE PRCP (value INT, date STRING, measurement STRING, quality STRING, source STRING)
        > ROW FORMAT DELIMITED FIELDS TERMINATED BY ',';

    hive> LOAD DATA LOCAL INPATH 'PRCP.csv' INTO TABLE prcp;

This is helpful in loading data, but not necessarily the smallest way to store data.  To help store the data in smaller amount lets convert our csv file into an ORC file.

    hive> CREATE TABLE PRECEP (value INT, date STRING, measurement STRING, quality STRING, source STRING)
        > STORED AS orc;
    hive> INSERT INTO TABLE precep SELECT * from prcp;

I grabbed the warehouse out of hdfs to check how much ORC compressed that one file.  Turns out to be quite a lot.  The original csv file is 32MB large. The compressed orc system is a total of 5MB, so about 1/6 the size.

### Running SQL queries

To start we must understand our problem.  Nebraska is large, and so there are many weather stations and groups that measure the amount of water it gets.  To get a good estimate for each day it rained an average can be taken. This means grouping our values by the date, then taking the average of those values.  In SQL this this is done like

    SELECT date, avg(value) FROM prcp WHERE date like '%-12-22' GROUP BY date ORDER BY date;
Luckily for us this translates to HiveQL exactly, so no changes are needed to run that from the CLI

To run this on spark we must simply import the HiveContext and run our sql queries

    $ pyspark
    >>> from pyspark.sql import HiveContext
    >>> cxt = HiveContext(sc)  #sc is your sparkContext, create for you when pyspark starts
    >>> result = cxt.sql("SELECT date, avg(value) as average \
                          FROM prcp \
                          WHERE date like '%-12-22' \
                          GROUP BY date ORDER BY date")
    >>> for row in result.collect():
    ....    print(row.date.split('-')[0], row.average)
    ....
    <A very nice output goes here>
    >>>exit()
Or if you have pyspark in your PYTHONPATH, just run the script in this repo

    $ ./SparkHiveQuery.py

To add pyspark to your PYTHONPATH use this export

    $ export PYTHONPATH=/usr/hdp/current/spark-client/python
    $ export SPARK_HOME=/usr/hdp/current/spark-client
The important question that still remains is how did converting to orc change our query?  From running the same query on both th csv file and the ORC file, they both ran at about 20 seconds per query, with csv having just Milliseconds faster time.

repository: jgimbel/USHCN-Data

repo_name: jgimbel/USHCN-Data


text:
---
title: Multicluster Installation
description: Configure an Istio mesh spanning multiple Kubernetes clusters.
weight: 30
aliases:
    - /docs/setup/kubernetes/multicluster-install/
    - /docs/setup/kubernetes/multicluster/
    - /docs/setup/kubernetes/install/multicluster/
keywords: [kubernetes,multicluster]
---

{{< tip >}}
Note that these instructions are not mutually exclusive.
In a large multicluster deployment, composed from more than two clusters,
a combination of the approaches can be used. For example,
two clusters might share a control plane while a third has its own.
{{< /tip >}}

Refer to the [multicluster deployment model](/docs/ops/deployment/deployment-models/#multiple-clusters)
concept documentation for more information.


text:
# Enhancing Sequential Recommendation with Graph Contrastive Learning

```
@inproceedings{gcl4sr_ijcai22,
title = {Enhancing Sequential Recommendation with Graph Contrastive Learning},
author = {Zhang, Yixin and Liu, Yong and Xu, Yonghui and Xiong, Hao and Lei, Chenyi and He, Wei and Cui, Lizhen and Miao, Chunyan},
booktitle = {Proceedings of the Thirty-First International Joint Conference on Artificial Intelligence (IJCAI)},
pages = {2398--2405},
year = {2022}
}
```

links
- [ijcai](https://www.ijcai.org/Proceedings/2022/333)

gha_language: Jupyter Notebook