text:
---
author: thomas
comments: true
date: 2017-09-06 18:57:46+00:00
layout: article
image:
   teaser: gps_traces/horten_area_scanning-thumbnail.png
   path: /images/gps_traces/horten_area_scanning-thumbnail.png
published: true
title: WRSC 2017 Day 3 - Area scanning
categories:
- articles
---

It was raining before we left our hotel in the morning, and we were already
quite wet when we reached the competition venue. We were very grateful to our
hosts for finding some big space heaters to warm up the marquee and dry out
our coats and shoes a bit.

The rain wasn't stopping the competition, however. The boats need to be
waterproof anyway. The third challenge is to sail around an L-shaped grid,
entering as many 20×20m squares as possible in under half an hour and getting
back to the finish line.

On the first attempt, the boat appeared to be trying to *avoid* the target area,
curving neatly around it. We think that the compass may have been giving bad
readings; calibrating it correctly was tricky throughout the competition.
We returned to the tent to recalibrate it and have some lunch.

We made a second attempt in the afternoon. This time we could see the boat in
the right general area, sailing back and forth. But it was out of our wifi
range, and the competition's live tracking system wasn't working, so we couldn't
tell if it was really doing the right thing. We crossed our fingers and waited.

![small boat in a grey sea](/images/sailing_horten.jpg)

Once it was definitely out of the grid, we eagerly brought it back to the tent
to get the data off and see the result.

![area scanning GPS trace](/images/gps_traces/horten_area_scanning.png)

It could hardly be better! The blue markers are the official coordinates for
the L shaped grid and the finish line. The black spots are our waypoints:
one before the start line, 48 in the grid, and one either side of the finish
line.

After the challenge, we got a demonstration of 'Odin', a boat under development
for the Norwegian military. It's eventually going to be autonomous, but for now,
a human sailor can control it from a remote control that looks like a games
controller. Another team's boat had got stranded, so they went out on Odin to
retrieve it.

![US Navy getting a lift](/images/us_navy_gets_lift.jpg)

Finally, our hosts and sponsors laid on a barbeque in the competition marquee,
while we ogled 'Hugin', a large orange AUV (Autonomous Underwater Vehicle) made
by Kongsberg, one of the main sponsors of the competition.

repository: Maritime-Robotics-Student-Society/blog

branch_name: refs/heads/gh-pages

repo_name: Maritime-Robotics-Student-Society/blog


text:
# CountUp.js
CountUp.js is a dependency-free, lightweight Javascript class that can be used to quickly create animations that display numerical data in a more interesting way.

Despite its name, CountUp can count in either direction, depending on the start and end values that you pass.

CountUp.js supports all browsers. MIT license.

## [Try the demo](http://inorganik.github.io/countUp.js)

## New in 2.0

- Completely rewritten in **Typescript**! The distributed code is still Javascript.
- **New** cleaner [method signature](#example).
- Tests with **Jest**. As much code coverage as possible mocking requestAnimationFrame.
- **Smart easing**: CountUp intelligently defers easing until it gets close enough to the end value for easing to be visually noticeable. Configureable in the [options](#options).
- **Separate bundles** for with and without the requestAnimationFrame polyfill. Choose `countUp.min.js` for modern browsers or `countUp.withPolyfill.min.js` for IE9 and older, and Opera mini.

CountUp is now distributed as a `commonjs` module - [see below](#including) for how to include it in your project.

## See Also

- **[CountUp.js Angular ^2 Module](https://github.com/inorganik/countUp.js-angular2)**
- **[CountUp.js Angular 1.x Module](https://github.com/inorganik/countUp.js-angular1)**
- **[CountUp.js React](https://github.com/glennreyes/react-countup)**
- **[CountUp.js Vue component wrapper](https://github.com/xlsdg/vue-countup-v2)**
- **[CountUp.js WordPress Plugin](https://wordpress.org/plugins/countup-js/)**
- **[CountUp.js jQuery Plugin](https://gist.github.com/inorganik/b63dbe5b3810ff2c0175aee4670a4732)**

## Usage:

**On npm**: `countup.js`

**Params**:
- `target: string | HTMLElement | HTMLInputElement` - id of html element, input, svg text element, or DOM element reference where counting occurs
- `endVal: number` - the value you want to arrive at
- `options?: CountUpOptions` - optional configuration object for fine-grain control

**Options** (defaults in parentheses):

```ts
interface CountUpOptions {
  startVal?: number; // number to start at (0)
  decimalPlaces?: number; // number of decimal places (0)
  duration?: number; // animation duration in seconds (2)
  useGrouping?: boolean; // example: 1,000 vs 1000 (true)
  useEasing?: boolean; // ease animation (true)
  smartEasingThreshold?: number; // smooth easing for large numbers above this if useEasing (999)
  smartEasingAmount?: number; // amount to be eased for numbers above threshold (333)
  separator?: string; // grouping separator (',')
  decimal?: string; // decimal ('.')
  // easingFn: easing function for animation (easeOutExpo)
  easingFn?: (t: number, b: number, c: number, d: number) => number;
  formattingFn?: (n: number) => string; // this function formats result
  prefix?: string; // text prepended to result
  suffix?: string; // text appended to result
  numerals?: string[]; // numeral glyph substitution
}
```

**Example usage**:

```js
const countUp = new CountUp('targetId', 5234);
if (!countUp.error) {
  countUp.start();
} else {
  console.error(countUp.error);
}
```

Pass options:
```js
const countUp = new CountUp('targetId', 5234, options);
```

with optional callback:

```js
countUp.start(someMethodToCallOnComplete);

// or an anonymous function
countUp.start(() => console.log('Complete!'));
```

**Other methods**:

Toggle pause/resume:

```js
countUp.pauseResume();
```

Reset the animation:

```js
countUp.reset();
```

Update the end value and animate:

```js
countUp.update(989);
```

## Including CountUp

CountUp v2 is distributed as a `commonjs` module which means you need to include CountUp in your project using a build tool such as [Webpack](https://webpack.js.org/) or [Browserify](http://browserify.org/).

**Example using Browserify**

Install browserify and countup
```
npm i countup.js
npm i -g browserify
```

main.js:
```js
var countUpModule = require('countup.js');

window.onload = function() {
  var countUp = countUpModule.CountUp('target', 2000);
  countUp.start();
}
```

Build your bundle
```
browserify main.js -o bundle.js
```

Include in your html:
```
<script src="bundle.js"></script>
```
🎉 Done!

## Contributing

Before you make a pull request, please be sure to follow these instructions:

1. Do your work on `src/countUp.ts`
1. Run tests: `npm t`
1. Run `npm run build`, which copies and minifies the .js files to the `dist` folder.
1. Test the demo: run `npm run build:demo` then open index.html in a browser and make sure it works.

license: MIT

repository: Sasku/oyama

branch_name: refs/heads/master

extension: md

gha_license_id: NOASSERTION

license_type: permissive

repo_name: Sasku/oyama


text:
# LLNoteRandomizer
A script to help randomizing notes with swing icons.

## Usage
``python3 note.py [--mode MODE] path/to/note/json``

### Note JSON
This is a JSON file containing note information. It should be a list of key-value pairs.

### Mode
- f Forced random mode. Randomize all notes as regular notes including swing notes.
- w Random Walk mode. For swing notes, fix the beginning position and randomize the path with uncertain direction.
- p [default] Path mode. For swing notes, randomize the start and end position of paths. The direction remains uniform for each path.

### Output
The script outputs randomized JSON in the same directory as that of the input file.

repository: liaocm/LLNoteRandomizer

repo_name: liaocm/LLNoteRandomizer


text:
# Basic Tools for Development

> Download, install, update, and manage basic software tools on Windows.

- [Webpage](https://denisecase.github.io/basic-tools-for-webdev/)
- [Source](https://github.com/denisecase/basic-tools-for-webdev)

## Recommended Prerequisites

- [Windows Setup for Developers](https://github.com/denisecase/windows-setup)
- [Windows File Management](https://github.com/denisecase/windows-file-management)

## Read about Windows Software Automation

Installing software on Windows can be done by typing simple commands with [Chocolatey](https://chocolatey.org/), a software automation tool for Windows.

## Read about Common Tools for Development

If you don't have these tools installed (or even if you do), we recommend using Chocolately to install them.
Chocolatey makes it easy to keep your software up-to-date.

Web browsers

- Google Chrome
- Mozilla Firefox

Editors

- Notepad++
- Visual Studio Code (VS Code) - FIRST TIME DO THIS THE TYPICAL WAY

Working with Large Compressed Files

- 7zip

JavaScript without a Browser

- Node.js (includes npm, the Node package manager)

Web Utilities

- cURL - data transfer utility
- Wget - file retrieval utility (request HTTP, HTTPS, and FTP from scripts
- Postman - Web API Development Environment

Version Control

- Git for Windows (comes with Git Bash, a little bit of Linux on Windows :) ) - FIRST TIME DO THIS THE TYPICAL WAY
- TortoiseGit (integrates with Windows File Manager) -- FIRST TIME DO THIS THE TYPICAL WAY

Utilities

- PuTTY - terminal emulator, includes PuTTYGen for generating SSH public-private key pairs used with Git repos

All recommended tools are free.

## Install Chocolatey

Use powerful automation tools to make installing software easier. Install Chocolatey, the Windows Package Manager from <https://chocolatey.org/> by following the directions on the website.

## Install Software with Chocolatey

Right-click in your Documents folder, and select 'Open PowerShell as Administrator'.
If you don't have this option, see [Windows Setup for Developers](https://github.com/denisecase/windows-setup).

Using the -y flag is optional and will automatically answer 'yes' to install questions.

It's safe to install software you already have (e.g., typically Chrome is already installed). You can find additional information by going to the specific link from <https://chocolatey.org/packages>.

All at once:

```PowerShell
choco install googlechrome notepadplusplus (add all packages as desired) -y
```

Refresh environment variables if they have been modified.

```PowerShell
refreshenv
```

Or one at a time:

```PowerShell
choco install googlechrome -y
choco install notepadplusplus -y
choco install vscode -y
choco install 7zip -y
choco install nodejs -y
choco install curl -y
choco install wget -y
choco install git -y
choco install tortoisegit -y
choco install putty -y
choco install postman -y
```

### Optional: Browse Chocolatey Software Packages

Explore at <https://chocolatey.org/packages>.

### Optional: Verify Installation

1. View list of locally-installed programs. Open PowerShell here as Admin and run:

```PowerShell
choco list -local
```

1. Inspect the downloaded software - the default location is 'C:\ProgramData\chocolatey' (or for earlier installations, 'c:\chocolatey').

1. Inspect your updated Windows environment variables. Hit Win key and type env. Select "Edit System Environment Variables". From System Properties window Advanced tab, click "Environment Variables".

### Periodically: Upgrade All

To upgrade your versions, periodically run choco upgrade. You can [automate this script](https://github.com/denisecase/windows-daily-software-upgrade) to make it even easier.

```Powershell
choco upgrade chocolatey -y
choco upgrade all -y
refreshenv
```

## Installing Without Chocolatey

Alternatively, each tool can be installed in the traditional manner. Just go to the website for the software and follow instructions to download, install, and configure tools using provided installers.

## Installation Issues with VS Code and TortoiseGit

Important!

- Ensure VS Code installs right-click 'Open with Code' on folder context menus. If not, reinstall using traditional methods.
- Ensure full TortoiseGit context menus are available. If not, reinstall using traditional methods.

## Optional

Firefox Add-ons

- Firefox Multi-Account Containers (limit access across apps)
- uBlockOrigin (blocker) ensure name includes "Origin"
- HTTPS Everywhere (requires encryption)

Ruby + Dev kit (for Jekyll, etc.)

```Powershell
choco install ruby -y
refreshenv
choco install ruby2.devkit -y
refreshenv
```

Ananconda3 (for Python)

```Powershell
choco install anaconda3 -y
```

Professional Java Development

```PowerShell
choco install openjdk -y
choco install eclipse -y
choco install gradle -y
choco install maven -y
```

## Terms

- automation tools
- web browser
- Chocolatey
- editor
- environment variables
- package manager
- upgrade (get the latest version)
- Windows (operating system)

## Next Steps

Configure Git distributed version control system and automate software upgrades

- See [Git Started With Windows](https://github.com/denisecase/git-started-windows)
- [Automate daily choco upgrades](https://github.com/denisecase/windows-daily-software-upgrade)

## See Also

- [Setting Up for Professional Software Development](https://github.com/denisecase/pro-dev-list)

repository: denisecase/basic-tools-for-webdev

repo_name: denisecase/basic-tools-for-webdev


text:
# Note #

All examples do the following:

```
var amazonRedshift = require('../awssum-amazon-redshift');
```

... but you should do this if you have installed this module with npm:

```
var amazonRedshift = require('awssum-amazon-redshift');
```

Thanks.

(Ends)

repository: chilts/awssum-amazon-redshift

repo_name: chilts/awssum-amazon-redshift


text:
[![Dependencies Status](https://depending.in/IgorTimoshenko/IMTDataGridBundle.png)](http://depending.in/IgorTimoshenko/IMTDataGridBundle)

# IMTDataGridBundle #

## Overview ##

This bundle provides a simple integration of the [IMTDataGrid][1] library into
Symfony2. IMTDataGrid is a library that provides a simple, powerful and fully
customizable tool for generating data-bound grids. This means that you can use
such libraries as [jqGrid][2] in your Symfony2 application.

## Installation ##

### 1. Using Composer (recommended) ###

To install `IMTDataGridBundle` with [Composer][3] just add the following to
your `composer.json` file:

```json
{
    "require": {
        "imt/data-grid-bundle": "0.9.*"
    }
}
```

Then, you can install the new dependencies by running Composer's update command
from the directory where your `composer.json` file is located:

```sh
$ php composer.phar update imt/data-grid-bundle
```

Now, Composer will automatically download all required files, and install them
for you. All that is left to do is to update your `AppKernel.php` file, and
register the new bundle:

```php
<?php
// in AppKernel::registerBundles()
$bundles = array(
    // ...
    new IMT\DataGridBundle\IMTDataGridBundle(),
    // ...
);
```

## Usage ##

The bundle provides a new `imt_data_grid.manager` service that returns an
instance of `IMT\DataGrid\Manager\ManagerInterface`. So the only thing to do is
to request the `imt_data_grid.manager` service from the container to get an
instance of `IMT\DataGrid\Manager\ManagerInterface` and start using the
IMTDataGrid library:

```php
<?php
// ...
$dataGridManager = $container->get('imt_data_grid.manager');
// ...
```

## Testing ##

```sh
$ make test
```

## Contributing ##

Please see [CONTRIBUTING][4] for details.

## Credits

- [Igor Timoshenko][5]
- [All Contributors][6]

## License ##

This bundle is released under the MIT license. See the complete license in the
bundle:

    Resources/meta/LICENSE

[1]: http://github.com/IgorTimoshenko/IMTDataGrid
[2]: http://github.com/tonytomov/jqGrid
[3]: http://getcomposer.org
[4]: https://github.com/IgorTimoshenko/IMTDataGridBundle/blob/master/CONTRIBUTING.md
[5]: https://github.com/IgorTimoshenko
[6]: https://github.com/IgorTimoshenko/IMTDataGridBundle/graphs/contributor

repository: ihortymoshenko/IMTDataGridBundle

repo_name: ihortymoshenko/IMTDataGridBundle


text:
# gosec - Golang Security Checker

Inspects source code for security problems by scanning the Go AST.

<img src="https://securego.io/img/gosec.png" width="320">

## License

Licensed under the Apache License, Version 2.0 (the "License").
You may not use this file except in compliance with the License.
You may obtain a copy of the License [here](http://www.apache.org/licenses/LICENSE-2.0).

## Project status

[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/3218/badge)](https://bestpractices.coreinfrastructure.org/projects/3218)
[![Build Status](https://github.com/securego/gosec/workflows/CI/badge.svg)](https://github.com/securego/gosec/actions?query=workflows%3ACI)
[![Coverage Status](https://codecov.io/gh/securego/gosec/branch/master/graph/badge.svg)](https://codecov.io/gh/securego/gosec)
[![GoReport](https://goreportcard.com/badge/github.com/securego/gosec)](https://goreportcard.com/report/github.com/securego/gosec)
[![GoDoc](https://pkg.go.dev/badge/github.com/securego/gosec/v2)](https://pkg.go.dev/github.com/securego/gosec/v2)
[![Docs](https://readthedocs.org/projects/docs/badge/?version=latest)](https://securego.io/)
[![Downloads](https://img.shields.io/github/downloads/securego/gosec/total.svg)](https://github.com/securego/gosec/releases)
[![Docker Pulls](https://img.shields.io/docker/pulls/securego/gosec.svg)](https://hub.docker.com/r/securego/gosec/tags)
[![Slack](https://img.shields.io/badge/Slack-4A154B?style=for-the-badge&logo=slack&logoColor=white)](http://securego.slack.com)

## Install

### CI Installation

```bash
# binary will be $(go env GOPATH)/bin/gosec
curl -sfL https://raw.githubusercontent.com/securego/gosec/master/install.sh | sh -s -- -b $(go env GOPATH)/bin vX.Y.Z

# or install it into ./bin/
curl -sfL https://raw.githubusercontent.com/securego/gosec/master/install.sh | sh -s vX.Y.Z

# In alpine linux (as it does not come with curl by default)
wget -O - -q https://raw.githubusercontent.com/securego/gosec/master/install.sh | sh -s vX.Y.Z

# If you want to use the checksums provided on the "Releases" page
# then you will have to download a tar.gz file for your operating system instead of a binary file
wget https://github.com/securego/gosec/releases/download/vX.Y.Z/gosec_vX.Y.Z_OS.tar.gz

# The file will be in the current folder where you run the command
# and you can check the checksum like this
echo "<check sum from the check sum file>  gosec_vX.Y.Z_OS.tar.gz" | sha256sum -c -

gosec --help
```

### GitHub Action

You can run `gosec` as a GitHub action as follows:

```yaml
name: Run Gosec
on:
  push:
    branches:
      - master
  pull_request:
    branches:
      - master
jobs:
  tests:
    runs-on: ubuntu-latest
    env:
      GO111MODULE: on
    steps:
      - name: Checkout Source
        uses: actions/checkout@v3
      - name: Run Gosec Security Scanner
        uses: securego/gosec@master
        with:
          args: ./...
```

### Integrating with code scanning

You can [integrate third-party code analysis tools](https://docs.github.com/en/github/finding-security-vulnerabilities-and-errors-in-your-code/integrating-with-code-scanning) with GitHub code scanning by uploading data as SARIF files.

The workflow shows an example of running the `gosec` as a step in a GitHub action workflow which outputs the `results.sarif` file. The workflow then uploads the `results.sarif` file to GitHub using the `upload-sarif` action.

```yaml
name: "Security Scan"

# Run workflow each time code is pushed to your repository and on a schedule.
# The scheduled workflow runs every at 00:00 on Sunday UTC time.
on:
  push:
  schedule:
  - cron: '0 0 * * 0'

jobs:
  tests:
    runs-on: ubuntu-latest
    env:
      GO111MODULE: on
    steps:
      - name: Checkout Source
        uses: actions/checkout@v3
      - name: Run Gosec Security Scanner
        uses: securego/gosec@master
        with:
          # we let the report trigger content trigger a failure using the GitHub Security features.
          args: '-no-fail -fmt sarif -out results.sarif ./...'
      - name: Upload SARIF file
        uses: github/codeql-action/upload-sarif@v1
        with:
          # Path to SARIF file relative to the root of the repository
          sarif_file: results.sarif
```

### Local Installation

#### Go 1.16+

```bash
go install github.com/securego/gosec/v2/cmd/gosec@latest
```

#### Go version < 1.16

```bash
go get -u github.com/securego/gosec/v2/cmd/gosec
```

## Usage

Gosec can be configured to only run a subset of rules, to exclude certain file
paths, and produce reports in different formats. By default all rules will be
run against the supplied input files. To recursively scan from the current
directory you can supply `./...` as the input argument.

### Available rules

- G101: Look for hard coded credentials
- G102: Bind to all interfaces
- G103: Audit the use of unsafe block
- G104: Audit errors not checked
- G106: Audit the use of ssh.InsecureIgnoreHostKey
- G107: Url provided to HTTP request as taint input
- G108: Profiling endpoint automatically exposed on /debug/pprof
- G109: Potential Integer overflow made by strconv.Atoi result conversion to int16/32
- G110: Potential DoS vulnerability via decompression bomb
- G111: Potential directory traversal
- G112: Potential slowloris attack
- G113: Usage of Rat.SetString in math/big with an overflow (CVE-2022-23772)
- G114: Use of net/http serve function that has no support for setting timeouts
- G201: SQL query construction using format string
- G202: SQL query construction using string concatenation
- G203: Use of unescaped data in HTML templates
- G204: Audit use of command execution
- G301: Poor file permissions used when creating a directory
- G302: Poor file permissions used with chmod
- G303: Creating tempfile using a predictable path
- G304: File path provided as taint input
- G305: File traversal when extracting zip/tar archive
- G306: Poor file permissions used when writing to a new file
- G401: Detect the usage of DES, RC4, MD5 or SHA1
- G402: Look for bad TLS connection settings
- G403: Ensure minimum RSA key length of 2048 bits
- G404: Insecure random number source (rand)
- G501: Import blocklist: crypto/md5
- G502: Import blocklist: crypto/des
- G503: Import blocklist: crypto/rc4
- G504: Import blocklist: net/http/cgi
- G505: Import blocklist: crypto/sha1
- G601: Implicit memory aliasing of items from a range statement
- G602: Slice access out of bounds

### Retired rules

- G105: Audit the use of math/big.Int.Exp - [CVE is fixed](https://github.com/golang/go/issues/15184)
- G307: Deferring a method which returns an error - causing more inconvenience than fixing a security issue, despite the details from this [blog post](https://www.joeshaw.org/dont-defer-close-on-writable-files/)

### Selecting rules

By default, gosec will run all rules against the supplied file paths. It is however possible to select a subset of rules to run via the `-include=` flag,
or to specify a set of rules to explicitly exclude using the `-exclude=` flag.

```bash
# Run a specific set of rules
$ gosec -include=G101,G203,G401 ./...

# Run everything except for rule G303
$ gosec -exclude=G303 ./...
```

### CWE Mapping

Every issue detected by `gosec` is mapped to a [CWE (Common Weakness Enumeration)](http://cwe.mitre.org/data/index.html) which describes in more generic terms the vulnerability. The exact mapping can be found  [here](https://github.com/securego/gosec/blob/master/issue/issue.go#L50).

### Configuration

A number of global settings can be provided in a configuration file as follows:

```JSON
{
    "global": {
        "nosec": "enabled",
        "audit": "enabled"
    }
}
```

- `nosec`: this setting will overwrite all `#nosec` directives defined throughout the code base
- `audit`: runs in audit mode which enables addition checks that for normal code analysis might be too nosy

```bash
# Run with a global configuration file
$ gosec -conf config.json .
```

Also some rules accept configuration. For instance on rule `G104`, it is possible to define packages along with a list
of functions which will be skipped when auditing the not checked errors:

```JSON
{
    "G104": {
        "ioutil": ["WriteFile"]
    }
}
```

You can also configure the hard-coded credentials rule `G101` with additional patterns, or adjust the entropy threshold:

```JSON
{
    "G101": {
        "pattern": "(?i)passwd|pass|password|pwd|secret|private_key|token",
         "ignore_entropy": false,
         "entropy_threshold": "80.0",
         "per_char_threshold": "3.0",
         "truncate": "32"
    }
}
```

### Dependencies

gosec will fetch automatically the dependencies of the code which is being analyzed when go module is turned on (e.g.`GO111MODULE=on`). If this is not the case,
the dependencies need to be explicitly downloaded by running the `go get -d` command before the scan.

### Excluding test files and folders

gosec will ignore test files across all packages and any dependencies in your vendor directory.

The scanning of test files can be enabled with the following flag:

```bash
gosec -tests ./...
```

Also additional folders can be excluded as follows:

```bash
 gosec -exclude-dir=rules -exclude-dir=cmd ./...
```

### Excluding generated files

gosec can ignore generated go files with default generated code comment.

```
// Code generated by some generator DO NOT EDIT.
```

```bash
gosec -exclude-generated ./...
```

### Annotating code

As with all automated detection tools, there will be cases of false positives. In cases where gosec reports a failure that has been manually verified as being safe,
it is possible to annotate the code with a comment that starts with `#nosec`.
The `#nosec` comment should have the format `#nosec [RuleList] [-- Justification]`.

The annotation causes gosec to stop processing any further nodes within the
AST so can apply to a whole block or more granularly to a single expression.

```go

import "md5" //#nosec

func main(){

    /* #nosec */
    if x > y {
        h := md5.New() // this will also be ignored
    }

}

```

When a specific false positive has been identified and verified as safe, you may wish to suppress only that single rule (or a specific set of rules)
within a section of code, while continuing to scan for other problems. To do this, you can list the rule(s) to be suppressed within
the `#nosec` annotation, e.g: `/* #nosec G401 */` or `//#nosec G201 G202 G203`

You could put the description or justification text for the annotation. The
justification should be after the rule(s) to suppress and start with two or
more dashes, e.g: `//#nosec G101 G102 -- This is a false positive`

In some cases you may also want to revisit places where `#nosec` annotations
have been used. To run the scanner and ignore any `#nosec` annotations you
can do the following:

```bash
gosec -nosec=true ./...
```

### Tracking suppressions

As described above, we could suppress violations externally (using `-include`/
`-exclude`) or inline (using `#nosec` annotations) in gosec. This suppression
inflammation can be used to generate corresponding signals for auditing
purposes.

We could track suppressions by the `-track-suppressions` flag as follows:

```bash
gosec -track-suppressions -exclude=G101 -fmt=sarif -out=results.sarif ./...
```

- For external suppressions, gosec records suppression info where `kind` is
`external` and `justification` is a certain sentence "Globally suppressed".
- For inline suppressions, gosec records suppression info where `kind` is
`inSource` and `justification` is the text after two or more dashes in the
comment.

**Note:** Only SARIF and JSON formats support tracking suppressions.

### Build tags

gosec is able to pass your [Go build tags](https://golang.org/pkg/go/build/) to the analyzer.
They can be provided as a comma separated list as follows:

```bash
gosec -tags debug,ignore ./...
```

### Output formats

gosec currently supports `text`, `json`, `yaml`, `csv`, `sonarqube`, `JUnit XML`, `html` and `golint` output formats. By default
results will be reported to stdout, but can also be written to an output
file. The output format is controlled by the `-fmt` flag, and the output file is controlled by the `-out` flag as follows:

```bash
# Write output in json format to results.json
$ gosec -fmt=json -out=results.json *.go
```

Results will be reported to stdout as well as to the provided output file by `-stdout` flag. The `-verbose` flag overrides the
output format when stdout the results while saving them in the output file
```bash
# Write output in json format to results.json as well as stdout
$ gosec -fmt=json -out=results.json -stdout *.go

# Overrides the output format to 'text' when stdout the results, while writing it to results.json
$ gosec -fmt=json -out=results.json -stdout -verbose=text *.go
```

**Note:** gosec generates the [generic issue import format](https://docs.sonarqube.org/latest/analysis/generic-issue/) for SonarQube, and a report has to be imported into SonarQube using `sonar.externalIssuesReportPaths=path/to/gosec-report.json`.

## Development

### Build

You can build the binary with:

```bash
make
```

### Note on Sarif Types Generation

Install the tool with :

```bash
go get -u github.com/a-h/generate/cmd/schema-generate
```

Then generate the types with :

```bash
schema-generate -i sarif-schema-2.1.0.json -o mypath/types.go
```

Most of the MarshallJSON/UnmarshalJSON are removed except the one for PropertyBag which is handy to inline the additional properties. The rest can be removed.
The URI,ID, UUID, GUID were renamed so it fits the Golang convention defined [here](https://github.com/golang/lint/blob/master/lint.go#L700)

### Tests

You can run all unit tests using:

```bash
make test
```

### Release

You can create a release by tagging the version as follows:

``` bash
git tag v1.0.0 -m "Release version v1.0.0"
git push origin v1.0.0
```

The GitHub [release workflow](.github/workflows/release.yml) triggers immediately after the tag is pushed upstream. This flow will
release the binaries using the [goreleaser](https://goreleaser.com/actions/) action and then it will build and publish the docker image into Docker Hub.

The released artifacts are signed using [cosign](https://docs.sigstore.dev/). You can use the public key from [cosign.pub](cosign.pub)
file to verify the signature of docker image and binaries files.

The docker image signature can be verified with the following command:
```
cosign verify --key cosign.pub securego/gosec:<TAG>
```

The binary files signature can be verified with the following command:
```
cosign verify-blob --key cosign.pub --signature gosec_<VERSION>_darwin_amd64.tar.gz.sig  gosec_<VERSION>_darwin_amd64.tar.gz
```

### Docker image

You can also build locally the docker image by using the command:

```bash
make image
```

You can run the `gosec` tool in a container against your local Go project. You only have to mount the project
into a volume as follows:

```bash
docker run --rm -it -w /<PROJECT>/ -v <YOUR PROJECT PATH>/<PROJECT>:/<PROJECT> securego/gosec /<PROJECT>/...
```

**Note:** the current working directory needs to be set with `-w` option in order to get successfully resolved the dependencies from go module file

### Generate TLS rule

The configuration of TLS rule can be generated from [Mozilla's TLS ciphers recommendation](https://statics.tls.security.mozilla.org/server-side-tls-conf.json).

First you need to install the generator tool:

```bash
go get github.com/securego/gosec/v2/cmd/tlsconfig/...
```

You can invoke now the `go generate` in the root of the project:

```bash
go generate ./...
```

This will generate the `rules/tls_config.go` file which will contain the current ciphers recommendation from Mozilla.

## Who is using gosec?

This is a [list](USERS.md) with some of the gosec's users.

## Sponsors

Support this project by becoming a sponsor.

repository: securego/gosec

gha_language: Go

repo_name: securego/gosec


text:
---
title: 'Flatter'
layout: post
author: hendrik
categories: [Flatter, JavaFX]
excerpt: "For our JavaOne talk Claudine and I created a new JavaFX skin called Flatter. While AquaFX has it's main focus on desktop applications running on a Mac, Flatter is made for touch and embedded devices."
featuredImage: java-2
permalink: '2013/09/flatter/'
header:
  text: Flatter
  image: sample
---
For our [JavaOne talk]({{ site.baseurl }}{% post_url 2013-09-24-lets-get-wet %}) Claudine and I created a new JavaFX skin called Flatter. While [AquaFX](http://aquafx-project.com) has it's main focus on desktop applications running on a Mac, Flatter is made for touch and embedded devices.

Flatter is a skin that is as simple as it can be. There are no gradients or shiny effects in the skin of all the controls. Next to this the controls of flatter have a bigger appearance than all controls in the desktop skins. By doing so, they are prepared for touch. Here is a first screenshot of some of the default JavaFX controls skinned by Flatter:

![controls](/assets/posts/guigarage-legacy/controls.png)

To take care of a good user experience on touch based devices, Flatter changed the behavior of some default controls. Using a default combobox by touch isn't always easy. Because of this we changed the behavior and skin of the combobox and added a overlay where the data of the combobox is rendered in a special selection dialog. Here we found a way to provide a good UI and user experience for any combobox data. A developer doesn't need to change anything. The complete behavior and UI is managed by Flatter:

![combobox](/assets/posts/guigarage-legacy/combobox.png)

Additionally Flatter will include some new controls and specialized skins. One example is the AvatarView. You can use this view in login dialogs for example, to show the picture of a user. AvaterView matches perfectly in the Flatter skin and will show every avatar images in a good way. No matter what ratio the image has, for example. Here is a picture of the new AvatarView:

![avatarview](/assets/posts/guigarage-legacy/avatarview.png)

As I mentioned before we created some special skins. This skins can be used for default controls. The one that I will show here is the TagSkin for the Label. If you do some document tagging in your application you can use this skin to have your labels look like tags. The only thing you have to do here, is setting the Skin to your label. To make this even easier, Flatter will provide a facade like the one we introduced for AquaFX. Here is a preview of the tag skin:

![tags](/assets/posts/guigarage-legacy/tags.png)

Flatter is still in progress, but we will open source it in the next weeks after JavaOne. You can find more information about Flatter in our ["Let's get wet" JavaOne presentation]({{ site.baseurl }}{% post_url 2013-09-24-lets-get-wet %}). So if you want a flat user experience stay tuned for this one ;)

gha_language: CSS


text:
# State

## Parameters and base types
`Parameters` define the rules according to which votes are run. There can only
be one active parameter set at any given time. If governance wants to change a
parameter set, either to modify a value or add/remove a parameter field, a new
parameter set has to be created, and the previous one rendered inactive.

+++ https://github.com/cosmic.bet/ledger/blob/master/proto/cosmicbet/wta/v1beta1/params.proto#L10-L40

## Ticket
A single draw ticket is represented using the `Ticket` object. This contains a unique random generated id, the address of the ticket owner and the timestamp of the block in which the ticket has been created.

+++ https://github.com/cosmic.bet/ledger/blob/master/proto/cosmicbet/wta/v1beta1/models.proto#L10-L19

Tickets are created only when handling a `MsgBuyTickets` message. In order to generate a ticket id that's both unique and deterministic, the following process is used:

```
hash = sha_256(block_hash + tx_hash + index)
id = hex(hash[8:])
```

Each ticket is stored inside the state as

```
TicketsStorePrefix + ticket_id | Ticket
```

## Draw
A single draw is represented inside the store using different keys. Particularly, its end time is stored using the `CurrentDrawEndTimeStoreKey` key, and the current prize is the balance of the module account having name `PrizeCollectorName`.

```
CurrentDrawEndTimeStoreKey | time.Time
```

## Historical draws
Once the winner for the current draw is extracted, the draw data and the winning ticket are both saved as a `HistoricalDrawData` object.

+++ https://github.com/cosmic.bet/ledger/blob/master/proto/cosmicbet/wta/v1beta1/models.proto#L36-L40

It is possible that a `HistoricalDrawData` does not have any winning ticket associated to it, if that draw was not entered by anyone.

Historical draws data are stored using the following mapping:

```
HistoricalDrawsStoreKey + Draw end time | HistoricalDrawData
```

repository: cosmicbet/ledger

branch_name: refs/heads/main

gha_license_id: MIT

repo_name: cosmicbet/ledger


text:
# [Re] Ensuring Connectivity via Data Plane Mechanisms
[![paper](https://img.shields.io/badge/_-Paper-blue?logo=adobeacrobatreader)](https://doi.org/10.3929/ethz-b-000504320)
> J. Liu, A. Panda, A. Singla, B. Godfrey, M. Schapira, and S. Shenker. "Ensuring connectivity via data plane mechanisms." In:10th USENIX Symposium on Networked Systems Design and Implementation (NSDI 13).2013, pp. 113–126.

This is a replication work of above presented paper, which mainly proposed *Data-Driven Connectivity* (**DDC**) to ensure routing connectivity via data plane mechanisms.
Nowadays, against the backdrop of the development of [P4](https://p4.org), one can enable the programmabilitiy of network devices to perform simple but extremely fastpacket processing directly in the data plane.
In this reproduction, we apply DDC upon a software switch, [BMv2 target](https://github.com/p4lang/behavioral-model), using [P4_16](https://p4.org/p4-spec/docs/P4-16-v1.2.2.html).
We evaluate our implementation against several benchmarks from the original paper, i.e., path stretch and packet latency.
This README is organised as follows.
 - Repository Structure
 - Quick Guide

## Repository Structure
 - `src/` - DDC in P4_16
 - `controller/` - control plane in Python
 - `topo/` - topology data (AS1239, AS2914, FatTree, etc.)
    - `topology_generate.py` - generate configure file (in `json/`) for compiling p4 program based on the topology data
 - `json/` - configuration file which describes the topology we want to create with the help of mininet and p4-utils package
 - `actual_paths/`
    - `*.log` - records the actual (initial) paths that the packet takes between each two nodes. E.g., `[(1, 17), (17, 2)]` means that the packet sent from h1 to h2 will takes h1-s1-s17-s2-h2.
    - `actual_paths.py` - the simulation in the control plane to compute the paths that packet actually takes
 - `path_stretch/` - the evalution via path stretch (i.e., the ratio between the length of the path a packet takes throughthe network, and the shortest path between the packet’s source and destination in thecurrent network state)
 - `packet_latency/` - the evaluation via packet latency (the comparison of time that before and after link failures)
 - `acticle/` - the replication article uses the [ReScience C](https://rescience.github.io/) journal template. Instructions to reproduce the article are provided in the subfolder `README`.

## Quick Guide
### Environmental Setup
#### 1. VM setting
In order to be able to compile P4 code, run it in a software switch (bmv2) and create virtual topologies with hosts, several dependencies and open source tools need to be installed first. If you do not have a P4 VM yet, please follow the [instructions](https://github.com/nsg-ethz/p4-learning/blob/master/vm/README.md) given by Networked System Group, ETHz to set up the VM.

#### 2. Installing P4-utils

[P4 utils](https://github.com/nsg-ethz/p4-utils) is an extension to Mininet to support P4 devices.
It was strongly inspired by the original [p4app](https://github.com/p4lang/p4app) from the [p4lang](https://github.com/p4lang) repository.
See the [P4-utils](https://github.com/nsg-ethz/p4-utils) repository for more information.

If you build the VM with the above instructions, you will have `p4-utils` already installed, however if you already have the required software and use your own machine/VM you can manally install it:

```bash
git clone https://github.com/nsg-ethz/p4-utils.git
cd p4-utils
sudo ./install.sh
```

To update you just simply:

```bash
cd /home/p4/p4-tools/p4-utils
git pull
```

### Executing DDC
1. Compile the P4 program and start on the topology:

   ```bash
   sudo p4run --conf json/<conf file>
   ```

   This will call a python script that parses the configuration file, creates a virtual network of hosts and p4 switches using mininet, compile the p4 program and load it in the switch. After running p4run you will get the mininet CLI prompt. For simple tests, please choose `10-switches.json` since other topologies take much longer to initialize.
2. Start the controller in another terminal window:

   ```bash
   python controller/controller.py
   ```

3. Testing connectivity:

   ```bash
   mininet> h1 ping h2
   ```

   ```bash
   mininet> pingall
   ```

4. Failing links in the controller:

   ```bash
   fail s1 s2
   ```

   ```bash
   reset
   ```

### Evalution
#### 1. Path Stretch
Path stretch is defined as the ratio between the length of the path a packet takes throughthe network, and the shortest path between the packet’s source and destination in thecurrent network state.

For instance, after running `pingall`, to know the actual path length of the packet from h1 to h2.
1. Start a new terminal  (the thrift port for h1 is 9090, for h2 is 9091, etc.) :

   ```bash
   simple_switch_CLI ----thrift-port 9091
   ```

2. The hops information for h1 is stored in the first element of register `hops_number`, thus input:

    ```bash
    register_read MyEgress.hops_number 0
    ```

To know the logic of compute path stretch (i.e., obtain the actual path from above steps, using dijkstra's algorithm to compute shortest path), please refer to 'path_stretch/path_stretch.py'. The automation test (invoking subprocess to automate tests for large AS topo) is realized in `path_stretch/auto_test_ps.py`.

#### 2. Packet Latency
In the mininet CLI,
1. Send traffic from h1 to h2 (ip - <IP_ADDRESS>):

   ```bash
   h1 python packet_latency/scapy_files/send.py --dst_ip <IP_ADDRESS> --rate 4M &
   ```

2. Receiving at h2:
   ```bash
   h2 python packet_latency/scapy_files/receive.py
   ```

   This will generate the time log of each sending and receiving.

The automation test for large topo is realized in `packet_latency/auto_pkt_latency.py`


text:
# INFERING BASED ON PYTHON PREDICTION ENGINE

The inference model (the model saved by `paddle.jit.save`) is generally a solidified model saved after the model training is completed, and is mostly used to give prediction in deployment.

The model saved during the training process is the checkpoints model, which saves the parameters of the model and is mostly used to resume training.

Compared with the checkpoints model, the inference model will additionally save the structural information of the model. Therefore, it is easier to deploy because the model structure and model parameters are already solidified in the inference model file, and is suitable for integration with actual systems.

Next, we first introduce how to convert a trained model into an inference model, and then we will introduce mainbody detection, feature extraction based on inference model,
then we introduce a recognition pipeline consist of mainbody detection, feature extraction and vector search. At last, we introduce classification base on inference model.

- [CONVERT TRAINING MODEL TO INFERENCE MODEL](#CONVERT)
    - [Convert feature extraction model to inference model](#Convert_feature_extraction)
    - [Convert classification model to inference model](#Convert_class)

- [MAINBODY DETECTION MODEL INFERENCE](#DETECTION_MODEL_INFERENCE)

- [FEATURE EXTRACTION MODEL INFERENCE](#FEATURE_EXTRACTION_MODEL_INFERENCE)

- [CONCATENATION OF MAINBODY DETECTION, FEATURE EXTRACTION AND VECTOR SEARCH](#CONCATENATION)

- [CLASSIFICATION MODEL INFERENCE](#CLASSIFICATION)

## CONVERT TRAINING MODEL TO INFERENCE MODEL

### Convert feature extraction model to inference model
First please enter the root folder of PaddleClas. Download the product feature extraction model:
```shell script
wget -P ./product_pretrain/ https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/pretrain/product_ResNet50_vd_Aliproduct_v1.0_pretrained.pdparams
```

The above model is trained on AliProduct with ResNet50_vd as backbone. To convert the trained model into an inference model, just run the following command:
```
# -c Set the training algorithm yml configuration file
# -o Set optional parameters
# Global.pretrained_model parameter Set the training model address to be converted without adding the file suffix .pdmodel, .pdopt or .pdparams.
# Global.save_inference_dir Set the address where the converted model will be saved.

python3.7 tools/export_model.py -c ppcls/configs/Products/ResNet50_vd_Aliproduct.yaml -o Global.pretrained_model=./product_pretrain/product_ResNet50_vd_Aliproduct_v1.0_pretrained -o Global.save_inference_dir=./deploy/models/product_ResNet50_vd_aliproduct_v1.0_infer
```

When converting to an inference model, the configuration file used is the same as the configuration file used during training. In addition, you also need to set the `Global.pretrained_model` parameter in the configuration file.
After the conversion is successful, there are three files in the model save directory:
```
├── product_ResNet50_vd_aliproduct_v1.0_infer
│   ├── inference.pdiparams
│   ├── inference.pdiparams.info
│   └── inference.pdmodel
```

### Convert classification model to inference model

Download the pretrained model:
``` shell script
wget -P ./cls_pretrain/ https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/legendary_models/ResNet50_vd_pretrained.pdparams
```

the model is trained on ImageNet with ResNet50_vd as backbone, using config file `ppcls/configs/ImageNet/ResNet/ResNet50_vd.yaml`.
The model can be converted to the inference model in the same way as the feature extraction model, as follows:
```
# -c Set the training algorithm yml configuration file
# -o Set optional parameters
# Global.pretrained_model parameter Set the training model address to be converted without adding the file suffix .pdmodel, .pdopt or .pdparams.
# Global.save_inference_dir Set the address where the converted model will be saved.

python3.7 tools/export_model.py -c ppcls/configs/ImageNet/ResNet/ResNet50_vd.yaml -o Global.pretrained_model=./cls_pretrain/ResNet50_vd_pretrained -o Global.save_inference_dir=./deploy/models/class_ResNet50_vd_ImageNet_infer
```

After the conversion is successful, there are three files in the model save directory:
```
├── class_ResNet50_vd_ImageNet_infer
│   ├── inference.pdiparams
│   ├── inference.pdiparams.info
│   └── inference.pdmodel
```

## MAINBODY DETECTION MODEL INFERENCE

The following will introduce the mainbody detection model inference. All the command should be run under `deploy` folder of PaddleClas:
```shell script
cd deploy
```

For mainbody detection model inference, you can execute the following commands:

```shell script
mkdir -p models
cd models
# download mainbody detection inference model
wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/ppyolov2_r50vd_dcn_mainbody_v1.0_infer.tar && tar -xf ppyolov2_r50vd_dcn_mainbody_v1.0_infer.tar
cd ..
# predict
python3.7 python/predict_det.py -c configs/inference_det.yaml
```

The input example image is as follows:
[](../images/recognition/product_demo/wangzai.jpg)
The output will be:
```text
[{'class_id': 0, 'score': 0.4762245, 'bbox': array([305.55115, 226.05322, 776.61084, 930.42395], dtype=float32), 'label_name': 'foreground'}]
```
And the visualise result is as follows:
[](../images/recognition/product_demo/wangzai_det_result.jpg)

If you want to detect another image, you can change the value of `infer_imgs` in `configs/inference_det.yaml`,
or you can use `-o Global.infer_imgs` argument. For example, if you want to detect `images/anmuxi.jpg`:
```shell script
python3.7 python/predict_det.py -c configs/inference_det.yaml -o Global.infer_imgs=images/anmuxi.jpg
```

If you want to use the CPU for prediction, you can switch value of `use_gpu` in config file to `False`. Or you can execute the command as follows
```
python3.7 python/predict_det.py -c configs/inference_det.yaml  -o Global.use_gpu=False
```

### FEATURE EXTRACTION MODEL INFERENCE

The following will introduce the feature extraction model inference. All the command should be run under `deploy` folder of PaddleClas:
```shell script
cd deploy
```
For feature extraction model inference, you can execute the following commands:
```shell script
mkdir -p models
cd models
# download feature extraction inference model
wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/product_ResNet50_vd_aliproduct_v1.0_infer.tar && tar -xf product_ResNet50_vd_aliproduct_v1.0_infer.tar
cd ..
# predict
python3.7 python/predict_rec.py -c configs/inference_rec.yaml
```
You can get a 512-dim feature printed in the command line.

If you want to extract feature of another image, you can change the value of `infer_imgs` in `configs/inference_rec.yaml`,
or you can use `-o Global.infer_imgs` argument. For example, if you want to try `images/anmuxi.jpg`:
```shell script
python3.7 python/predict_rec.py -c configs/inference_rec.yaml -o Global.infer_imgs=images/anmuxi.jpg
```

If you want to use the CPU for prediction, you can switch value of `use_gpu` in config file to `False`. Or you can execute the command as follows
```
python3.7 python/predict_rec.py -c configs/inference_rec.yaml  -o Global.use_gpu=False
```

## CONCATENATION OF MAINBODY DETECTION, FEATURE EXTRACTION AND VECTOR SEARCH
 Please refer to [Quick Start of Recognition](./tutorials/quick_start_recognition_en.md)

### CLASSIFICATION MODEL INFERENCE
The following will introduce the classification model inference. All the command should be run under `deploy` folder of PaddleClas:
```shell script
cd deploy
```

For classification model inference, you can execute the following commands:

```shell script
python3.7 python/predict_cls.py -c configs/inference_cls.yaml
```
If you want to try another image, you can change the value of `infer_imgs` in `configs/inference_cls.yaml`,
or you can use `-o Global.infer_imgs` argument. For example, if you want to try `images/ILSVRC2012_val_00010010.jpeg`:
```shell script
python3.7 python/predict_cls.py -c configs/inference_cls.yaml -o Global.infer_imgs=images/ILSVRC2012_val_00010010.jpeg

```

If you want to use the CPU for prediction, you can switch value of `use_gpu` in config file to `False`. Or you can execute the command as follows
```
python3.7 python/predict_cls.py -c configs/inference_cls.yaml  -o Global.use_gpu=False
```

repository: youqingxiaozhua/PaddleClas

repo_name: youqingxiaozhua/PaddleClas


text:
![Vexil][vexil-logo]

Vexil (named for Vexillology) is a Swift package for managing feature flags
(also called feature toggles) in a flexible, multi-provider way.

## Features

* Define your flags in a structured tree
* Extensible to support any backend flag storage or platform
* Take and apply snapshots of flag states
* Get real-time flag updates using Combine
* Vexillographer: A simple SwiftUI interface for editing flags

## Documentation

In addition to this README, which covers basic usage and installation, you can find more documentation:

- On our documentation website: [https://unsignedapps.github.io/Vexil/](https://unsignedapps.github.io/Vexil/)
- Detailed documentation and guides in the [Documentation](Documentation) subdirectory

## Usage

### Defining Flags

If you've ever used [swift-argument-parser][swift-argument-parser] defining flags in Vexil will be a familiar experience.

Vexil supports a tree of flags, so we need a structure to hold them:

```swift
import Vexil

struct LoginFlags: FlagContainer {

    @Flag("Enables the forgot password button on the login screen and associated flows")
    var forgotPassword: Bool

}
```

**Side Note:** Vexil requires descriptions for all of its flags and flag groups. This is used by [Vexillographer](#vexillographer-a-swiftui-flag-manipulation-tool) for providing context for the flags you are enabling/disabling in the UI, but it also provides context for future developers (especially yourself in 12 months time) as to what flags mean and what their intended use is.

See the [full documentation for how to define flags][defining-flags] to read more

### Checking flags

To check your flags, you need to run them up a Flag Pole:

```swift
import Vexil

let flagPole = FlagPole(hoist: AppFlags.self)

// should we show the change password screen?
if flagPole.profile.password.changePassword {
    // ...
}
```

### Mutating flags

By default access to flags on the FlagPole is immutable from your source code. This is a deliberate design decision: flags should not be easily mutatable from your app as it can lead to mistakes (eg. `flag = true` instead of `flag == true`).

That said, it is still very easy to mutate any flags if you need to using a snapshot:

```swift
import Vexil

let flagPole = FlagPole(hoist: AppFlags.self)

var snapshot = flagPole.emptySnapshot()
snapshot.profile.password.changePassword = true

// insert it at the top of the hierarchy
flagPole.insert(snapshot: snapshot, at: 0)
```

For more info see [Snapshots](#snapshots).

## Flag Value Sources

The Vexil `FlagPole` supports multiple backend flag sources, and ships with the following sources built-in:

| Name | Description |
|------|-------------|
| `UserDefaults` | Any `UserDefaults` instance automatically conforms to `FlagValueSource` |
| `Snapshot` | All snapshots taken of a FlagPole can be used as a source. |

See the full documentation on [Flag Value Sources][flag-value-sources] for more on working with sources and how to define your own.

## Snapshots

Vexil provides a mechanism to mutate, save, load and apply snapshots of flag states and values.

**Important:** Snapshots only reflect values and states _that have been mutated_. That is, a snapshot is only applied to values that have been explicitly set within it. Any values that have not been set will defer to the next source in the list, or the default value. The exception is when you take a _full snapshot_ of a FlagPole, which captures the value of every flag.

Snapshots are implemented as a `FlagValueSource`, so you can easily apply multiple snapshots in a prioritised order.

Snapshots can do a lot. See our [Snapshots Guide][snapshots] for more.

## Creating snapshots

You can manually create snapshots and specify which flags are affected:

```swift
import Vexil

// create an empty snapshot
var snapshot = flagPole.emptySnapshot()

// update some values and states
snapshot.login.forgotPassword = false
snapshot.profile.password = false

// apply that snapshot - only the two values above will change
flagPole.insert(snapshot: snapshot, at: 0)
```

You can also take a snapshot of the current state of your FlagPole:

```swift
import Vexil

let flagPole = FlagPole(hoist: AppFlags.self)

// snapshot the current state - this will get the state of *all* flags
let snapshot = flagPole.snapshot()

// save them, mutate them, whatever you like
// ...
```

## Installing Vexil

To use Vexil in your project add it as a dependency in a Swift Package, add it to your `Package.swift`:

```swift
dependencies: [
    .package(url: "https://github.com/unsignedapps/Vexil.git", from: "1.0.0")
]
```

And add it as a dependency of your target:

```swift
targets: [
    .target(name: "MyTarget", dependencies: [
        .product(name: "Vexil", package: "Vexil")
    ])
]
```

### In Xcode 11+

To use Vexil in Xcode 11 or higher, navigate to the _File_ menu and choose _Swift Packages_ -> _Add Package Dependency..._, then enter the repository URL and version details for the release as desired.

## Vexillographer: A SwiftUI Flag Manipulation Tool

The second library product of Vexil is Vexillographer, a small SwiftUI tool for displaying and manipulating flags.

Read more about [Vexillographer][vexillographer].

## Contributing

We welcome all contributions! Please read the [Contribution Guide](CONTRIBUTING.md) for details on how to get started.

## License

Vexil is available under the MIT license. See the [LICENSE](LICENSE) file for more info.

[vexil-logo]: .github/vexil.png
[swift-argument-parser]: https://github.com/apple/swift-argument-parser
[vexil-cli]: https://github.com/unsignedapps/Vexil-cli

[defining-flags]: Documentation/Defining-Flags.md
[flag-value-sources]: Documentation/Sources.md
[snapshots]: Documentation/Snapshots.md
[vexillographer]: Documentation/Vexillographer.md


text:
# application

## Prologue Object

Prologue object

```nim
type
  Prologue* = ref object
    settings*: Settings
    router*: Router
    reversedRouter*: ReversedRouter
    reRouter*: ReRouter
    middlewares*: seq[HandlerAsync]
    startup*: seq[Event]
    shutdown*: seq[Event]
    errorHandlerTable*: ErrorHandlerTable
```
## Create a Prologue object

Use `newApp` to get Prologue instance.

```nim
proc newApp*(settings: Settings, middlewares: seq[HandlerAsync] = @[],
    startup: seq[Event] = @[], shutdown: seq[Event] = @[],
        errorHandlerTable = {Http404: default404Handler,
            Http500: default500Handler}.newErrorHandlerTable)
```

### Settings

Use `newSettings` to create application settings.

### Middlewares

Register `middlewares` for the whole application.The middlewares will
apply to every handler.

### Startup and ShutUp

Register event for startup and shutup.Support both sync and async proc.

```nim
type
  AsyncEvent* = proc(): Future[void] {.closure, gcsafe.}
  SyncEvent* = proc() {.closure, gcsafe.}
```

### Error Handler

Map status code to error handler.

repository: refaqtor/prologue

repo_name: refaqtor/prologue


text:
# God's Eye Trojan

## Introduction
This project provides two main functions which are showing `username` and `password` for Web Authorization and establishing a TCP connection with the controller (the Server).

## Developing Environment
- Golang Version 1.9

## Running Environment
- The Payload only works on MacOS

## Workflow
1. The developer needs to compile this project based on the Golang developing environment.
``` go build trojan.go ```
2. When an user downloaded the compiled software and run, `username` and `password` will be shown.
3. The TCP connnection between a victim's computer and the controller will be established after showing the `password`.

## Thanks
- Thanks to the project of [EggShell](https://github.com/neoneggplant/EggShell)
- Thanks to the project of fyne


text:
# spfx-promoted-links

This web part will display all links from Promoted Links lis, add images and allow to change tile size. Updated to SharePoint Framework 1.6

## Inspiration

Inspired by https://github.com/Constellation-Solutions/spfx-promoted-links

## Create Images with Office Fabric Icons

This is a great tool created by Josh McCarty that will allow to create an image with the icon: https://codepen.io/joshmcrty/pen/GOBWeV
Use https://developer.microsoft.com/en-us/fabric#/styles/icons to get the icon name

## Images

### Display mode

![](https://github.com/MichalExpP/spfx-promoted-links/blob/master/docs/images/Links1.png)

### Edit mode

![](https://github.com/MichalExpP/spfx-promoted-links/blob/master/docs/images/Links2.png)

### Tiles with Office Fabric icons

![](https://github.com/MichalExpP/spfx-promoted-links/blob/master/docs/images/Links3.png)

repository: MichalExpP/spfx-promoted-links

repo_name: MichalExpP/spfx-promoted-links


text:
## v0.6.1 - August 4, 2014

 * Fix `--numbers --debug` adding line numbers to debug info.
 * Fix `--numbers` putting an extra line
 * Always assume that small files (<24 lines) don't need a pager.
 * Don't wrap long lines when using the pager.

## v0.6.0 - August 4, 2014

 * Add the `--numbers` option for line numbers.

## v0.5.1 - August 3, 2014

 * Fix the pager not being on by default.

## v0.5.0 - July 31, 2014

 * Change comment color to cyan.
 * Add colors for javadoc tags.
 * (Internal) documentations and tests.

### v0.4.1

 * JSON: prevent symbols (`{ }`) from being colorized as green.

### v0.4.0

 * Add colors for javadoc comments.
 * Add support for Ruby string interpolation.
 * Make the output of the undocumented `--debug` switch more useful.
 * (Internal) Refactors to tests, color schemes, and many others.

### v0.3.2

 * Add colors for diffs (`--lang diff`).

## v0.3.1 - July 30, 2014

 * Fix piping not working.

### v0.3.0

 * Automatically page the output if the file is long.
 * Throw less-verbose error messages.

### v0.2.3

 * Add colors for Markdown files (`--lang markdown`).
 * Add colors for CSS tokens (`--lang css`).
 * Add colors for C pre-processor directives.

### v0.2.2

 * Fix `--lang` not working properly.

### v0.2.0

 * Add `--languages` option to list available languages.
 * Rename `--type` to `--lang`.

## v0.1.0 - July 30, 2014

 * Initial release.

repository: vrigzalejo/hicat

repo_name: vrigzalejo/hicat


text:
+++
# A Skills section created with the Featurette widget.
widget = "featurette"  # See https://sourcethemes.com/academic/docs/page-builder/
headless = true  # This file represents a page section.
active = false  # Activate this widget? true/false
weight = 30  # Order that this section will appear.

#title = "Interests"
#subtitle = "What we do"

title = "Business & venture development"
subtitle = "lean, people-centered, data- & innovation-focused"

# Showcase personal skills or business features.
#
# Add/remove as many `[[feature]]` blocks below as you like.
#
# For available icons, see: https://sourcethemes.com/academic/docs/page-builder/#icons

[[feature]]
  #icon = "r-project"
  #icon_pack = "fab"
  #pic = "mustcato_simple0006.png" # by jueewo
  pic = "research0001.png" # by jueewo
  name = "Research"
  description = "innovate"

#[[feature]]
#  icon = "camera-retro"
#  icon_pack = "fas"
#  name = "xxx"
#  description = "AI VR blockchain"

[[feature]]
  #icon = "camera-retro"
  #icon_pack = "fas"
  #pic = "logo-jueewo.png" # by jueewo
  pic = "development0001.png" # by jueewo
  name = "Development"
  description = "create"

[[feature]]
  #icon = "chart-line"
  #icon_pack = "fas"
  #pic = "predicma_simple0003.png" # by jueewo
  pic = "consulting0001.png" # by jueewo
  name = "Consulting"
  description = "empower"

+++

repository: jueewo-web/tet

repo_name: jueewo-web/tet


text:
# Day 178 \[Hard\]

This problem was asked by Two Sigma.

Alice wants to join her school's Probability Student Club. Membership dues are computed via one of two simple probabilistic games.

 Stop rolling once you get a five followed by a six. Your number of rolls is the amount you pay, in dollars.

The second game: same, except that the stopping condition is a five followed by a five.

Which of the two games should Alice elect to play? Does it even matter? Write a program to simulate the two games and calculate their expected value.

# Explanation:

To see which game is better, consider the possibilities that Alice faces.

There are three possible states:
1. Initial state. (A first five must be rolled.)
2. Potential victory state. (The previous roll was a five.)
3. Winning state. (A five followed by the required number was rolled.)

Regardless of choice of game, Alice must first enter into the potential victory state by rolling a 5.

In the 5-5 game, once Alice has entered the potential victory state, she wins if she rolls a 5. She returns to the initial state if she rolls a 1, 2, 3, 4, or 6.

In the 5-6 game, once Alice has entered the potential victory state, she wins if she rolls a 6. She remains in the potential victory state if she rolls a 5. She returns to the initial state if she rolls a 1, 2, 3, or 4.

Thus, the 5-6 game is the better choice of game.

repository: sraaphorst/daily-coding-problem

repo_name: sraaphorst/daily-coding-problem


text:
# Read 10 Notes

# CallStack
A call stack is a mechanism for an interpreter (like the JavaScript interpreter in a web browser) to keep track of its place in a script that calls multiple functions — what function is currently being run and what functions are called from within that function

https://www.freecodecamp.org/news/understanding-the-javascript-call-stack-861e41ae61d4/

The call stack is primarily used for function invocation (call). Since the call stack is single, function(s) execution, is done, one at a time, from top to bottom. It means the call stack is synchronous.

a call stack is a data structure that uses the Last In, First Out (LIFO) principle to temporarily store and manage function invocation (call).

LIFO: When we say that the call stack, operates by the data structure principle of Last In, First Out, it means that the last function that gets pushed into the stack is the first to be pop out, when the function returns.

<img src="./images/reading10.png">

# stack overflow
A stack overflow occurs when there is a recursive function (a function that calls itself) without an exit point.

## error messages
https://codeburst.io/javascript-error-messages-debugging-d23f84f0ae7c

## Reference errors
This is as simple as when you try to use a variable that is not yet declared you get this type os errors.

## Syntax errors
I know it’s in the name of the errors, but like it says itself, this occurs when you have something that cannot be parsed in terms of syntax, like when you try to parse an invalid object using JSON.parse.

## Range errors
Try to manipulate an object with some kind of length and give it an invalid length and this kind of errors will show up.

## Type errors
Like the name indicates, this types of errors show up when the types (number, string and so on) you are trying to use or access are incompatible,

## Debugging
To debug your JS code, the easiest and maybe the most common way its to simply console.log() the variables you want to check or

## Call stack
The red part of our first example represents the call stack, which is the path that your program has taken to reach the point were you set a breaking point or were you have an error.

## Tools to avoid runtime errors
JS is not a compiled language like Java so your errors will happen at runtime, that means that you can only see whatever is wrong with your code after your run it.
Thankfully, to save us quite some time you can use tools like:
* quokka to evaluate your code as you type
* eslint to make sure your style guide is consistency and it will grab you an error or two along the way and
* For those of you looking to make JS a more strong typed experience you can check out stuff like TypeScript (like I said in a previous article, when learning I rather avoid libraries that abstract the core language so I wouldn’t recommend this last one when starting).

### [home](https://misalz.github.io/reading_notes2/)


text:
# Kubernetes on Fedora Vagrant Lab
Automatically deploy a local k8s cluster on Fedora VMs with Vagrant and Ansible

Uses [Jeff Geerling's k8s Ansible role](https://github.com/geerlingguy/ansible-role-kubernetes)

## Requirements
- [Vagrant](https://www.vagrantup.com/)
- [Vagrant libvirt provider](https://github.com/vagrant-libvirt/vagrant-libvirt)
- [Libvirt, QEMU/KVM etc.](https://wiki.libvirt.org/page/Main_Page)
- Possibly more...

## How do I use it?
In theory:

`git clone https://github.com/bcrisp4/k8s-vagrant-lab.git && cd k8s-vagrant-lab`
`vagrant up`

## Caveats
- Written to use libvirt provider, not the default VirtualBox. Why? Personal preference. Would probably work with Virtual box with limited effort
- Only tested on Fedora 30, your milage on other OSs may vary
- May require some manual network reconfiguration, especially for bridged network interfaces (if you need that)

## Helpful links
- [Fedora 22 libvirt with bridge](https://lukas.zapletalovi.com/2015/09/fedora-22-libvirt-with-bridge.html)
- [Libvirt networking](https://wiki.libvirt.org/page/Networking)
- [Configuring QEMU bridge helper after “access denied by acl file” error](https://blog.christophersmart.com/2016/08/31/configuring-qemu-bridge-helper-after-access-denied-by-acl-file-error/)

## License
MIT


text:
# Overview

The program reads a byte stream from a given COM port and emits it as an LSL stream. This program does not currently support sending a startup sequence to the device or any other kind of 2-way handshake.

# Usage
  * Start the SerialPort app. You should see a window like the following.
    ![serialport.png](serialport.png)

  * Make sure that your device is plugged in and that you know its COM port (you can usually check this in the Device Manager).

  * Select the COM port and the BAUD rate (data rate). If you know the nominal sampling rate of your stream (in bytes per second), you can set this in the Stream Sampling Rate (0 means irregular/unknown).

  * The output data will be batched into chunks of the given Chunk Size -- you can reduce or increase this setting according to your application's needs. The remaining settings can often be left untouched, except for devices with special requirements.

  * Click the "Link" button. If all goes well you should now have a stream on your lab network that has the name that you entered under Stream Name and type "Raw". Note that you cannot close the app while it is linked.

  * For subsequent uses you can save the settings in the GUI via File / Save Configuration. If the app is frequently used with different settings you might can also make a shortcut on the desktop that points to the app and appends to the Target field the snippet `-c name_of_config.cfg`.

repository: labstreaminglayer/App-SerialPort

repo_name: labstreaminglayer/App-SerialPort


text:
---
layout: post
date: 2017-08-04 00:00
title: 파이썬과 말해봐요 - (에러) 오류를 읽어보아요
---
{:.summary}
```python
>>> "friend" + 5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't convert 'int' object to str implicitly
    ^              ^       ^              ^
```
* ‘int’ is an integer
* ‘str’ is a string
* Python cannot concatenate objects of different types

Now let’s take a look at that error message and see what it’s really telling us.

The first two lines are pretty common to all error messages, so they won’t really help us much here.  But the last line gives us some valuable information.

We tried to concatenate two pieces of data - which Python calls ‘objects’ - the string “friend” and the number 5.  But Python isn’t able to concatenate those two objects because they’re of different types.  And so we get what’s called a “TypeError”.

repository: corazzon/PYCONKR-YoungCoder

repo_name: corazzon/PYCONKR-YoungCoder


text:
# cl-md-notes
A simple Markdown notes editor in Common Lisp inspired by the [React Server Components demo](https://github.com/reactjs/server-components-demo)

![cl-md-notes.gif](cl-md-notes.gif)

## Usage
```lisp
(ql:quickload :cl-md-notes)
(cl-md-notes:start :port 3000)
```

You can view the demo app in action at `http://localhost:3000`.

## Installation
```
cd ~/quicklisp/local-projects/
git clone https://github.com/rajasegar/cl-md-notes
```

## Author

* Rajasegar Chandran

## Copyright

Copyright (c) 2021 Rajasegar Chandran

repository: rajasegar/cl-md-notes

extension: markdown

repo_name: rajasegar/cl-md-notes


text:
[![Netlify Status](https://api.netlify.com/api/v1/badges/6969484f-7f93-41f8-a021-5c082599eab2/deploy-status)](https://app.netlify.com/sites/speelpleingids-deinze/deploys)

# Playground guide Deinze (Flanders, Belgium)

This application is an unofficial playground guide for the city of Deinze (Flanders, Belgium).

Visit at http://speelpleingids-deinze.mrjean.be.

The application is developed as a Progressive Web App, which means it's installable on most modern devices without the use of an app store.

# Application state

**Fully in development.**

# Technology used

* Ionic Framework
* PWA (Progressive Web App)
* Netlify

# Disclaimer

This application is an after hours project and a way to learn out in the open. This means I don't have any obligations about the development of the app or the direction it is going.

repository: MrJean/ionic-speelpleingids-deinze

gha_language: TypeScript

repo_name: MrJean/ionic-speelpleingids-deinze


text:
# item\_instance

[<-Back-to:Characters](database-characters.md)

**The \`item\_instance\` table**

This table holds individual item instance information for all items currently equipped in some kind of character bag or bank, in auction houses, in guild banks or in mails.

**Structure**

| Field                  | Type      | Attributes | Key | Null | Default | Extra | Comment |
| ---------------------- | --------- | ---------- | --- | ---- | ------- | ----- | ------- |
| [guid][1]              | INT       | UNSIGNED   | PRI | NO   | 0       |       |         |
| [itemEntry][2]         | MEDIUMINT | UNSIGNED   |     | NO   | 0       |       |         |
| [owner_guid][3]        | INT       | UNSIGNED   |     | NO   | 0       |       |         |
| [creatorGuid][4]       | INT       | UNSIGNED   |     | NO   | 0       |       |         |
| [giftCreatorGuid][5]   | INT       | UNSIGNED   |     | NO   | 0       |       |         |
| [count][6]             | INT       | UNSIGNED   |     | NO   | 1       |       |         |
| [duration][7]          | INT       | SIGNED     |     | NO   | 0       |       |         |
| [charges][8]           | TINYTEXT  | SIGNED     |     | YES  |         |       |         |
| [flags][9]             | MEDIUMINT | UNSIGNED   |     | NO   | 0       |       |         |
| [enchantments][10]     | TEXT      | SIGNED     |     | NO   |         |       |         |
| [randomPropertyId][11] | SMALLINT  | SIGNED     |     | NO   | 0       |       |         |
| [durability][12]       | SMALLINT  | UNSIGNED   |     | NO   | 0       |       |         |
| [playedTime][13]       | INT       | UNSIGNED   |     | NO   | 0       |       |         |
| [text][14]             | TEXT      | SIGNED     |     | YES  |         |       |         |

[1]: #guid
[2]: #itementry
[3]: #ownerguid
[4]: #creatorguid
[5]: #giftcreatorguid
[6]: #count
[7]: #duration
[8]: #charges
[9]: #flags
[10]: #enchantments
[11]: #randompropertyid
[12]: #durability
[13]: #playedtime
[14]: #text

**Description of the fields**

### guid

The GUID of the item. This number is unique for each item instance.

### itemEntry

[Item_template.entry](item_template#entry).

### owner\_guid

The GUID of the character who has ownership of this item. See [characters.guid](characters#guid).

### creatorGuid

[Characters.guid](characters#guid) of character who created the item.

### giftCreatorGuid

[Characters.guid](characters#guid) of character who created the [item](character_gifts#item_guid).

### count

Current number of item copies in the stack.

### duration

`field-no-description|6`

### charges

The number of charges for each of the five possible spellcharges on an item, specified via five space separated integers.

### flags

`field-no-description|8`

### enchantments

Enchantments from SpellItemEnchantment.dbc see: [item_instance_enchantments](item_instance_enchantments.md)

### randomPropertyId

`field-no-description|10`

### durability

Current item durability.

### playedTime

Time in seconds.

### text

The text contained in that specific item.

repository: azerothcore/wiki

repo_name: azerothcore/wiki


text:
# InfraBlockchain - General Purpose Public Blockchain for Business

* [InfraBlockchain Website - https://infrablockchain.com](https://infrablockchain.com)
* [Technical White Paper Version 2.4 - InfraBlockchain_Technical_White_Paper_Version_2_4_ENG_202008.pdf](https://infrablockchain.com/documents/InfraBlockchain_Technical_White_Paper_Version_2_4_ENG_202008.pdf)

### No Native Cryptocurrency
Using programmable fiat-pegged stable tokens (e.g. USD, EUR, CNY) as base currencies

### Proof-of-Transaction (PoT)-based Blockchain Consensus
To overcome the shortcomings of current public blockchains, we developed a more reasonable and fair consensus algorithm, Proof-of-Transaction (PoT)

### General Financial Platform
Smart contract based blockchain system designed for enterprise uses

## Key Features of InfraBlockchain

#### No Native Cryptocurrency
 New method of public blockchain design that avoids issuing native cryptocurrency minted by the blockchain itself.
 There is no single distinguished built-in native token, only user-created tokens are issued and circulated on the InfraBlockchain.
 In other smart contract based blockchains like Ethereum and EOS, custom tokens implemented as smart contracts are totally separate from the native cryptocurrency (ETH, EOS) used for executing blockchain transactions.
 In contrast, InfraBlockchain lets any custom user token conforming to the InfraBlockchain Standard Token interface become a Transaction Fee Token just as a native cryptocurrency can in other blockchain systems.

#### InfraBlockchain Standard Token Model
 The InfraBlockchain provides a unique InfraBlockchain Standard Token model.
 Every account created can mint a InfraBlockchain Standard Token and inherently run standard token operations natively supported at the blockchain core level.
 Interoperability among the tokens on the InfraBlockchain is enforced and guaranteed by the blockchain core system.

#### Fiat-Pegged Stable Tokens, Asset-Backed Security Tokens
 User-created fiat-pegged stable tokens (e.g. USD tokens backed by an equivalent amount of USD held in reserve)
 issued by trusted entities (e.g. enterprises, financial institutions, governments) are selected as the transaction fee tokens.
 Asset-backed security tokens (e.g. company shares, gold backed tokens, ...) can be also issued and traded through on-chain token exchange
 using fiat-pegged stable tokens as base currencies.

#### Transaction Fee Tokens Selected from User-Created Tokens
 Among the user-issued tokens, the elected block producers can select some tokens to be used for blockchain transaction fee payment, whereas typically a pre-built native cryptocurrency is used in other blockchain systems.
 Whenever any blockchain transaction is executed on the InfraBlockchain, the block-producer-designated transaction fee tokens are collected as a transaction fee from users.

#### Proof-of-Transaction (PoT) Consensus Mechanism
 The block producers of the InfraBlockchain are elected by a unique consensus mechanism: Proof-of-Transaction (PoT) using Transaction-as-a-Vote (TaaV).
 The block producers are continuously elected and evicted by the transparent and fair vote index, the proof of generating meaningful transactions. The PoT mechanism incentivizes the application service providers,
 who are directly contributing to the blockchain ecosystem by generating blockchain transactions associated with real economic activity.

#### Delegable Transaction Fee Payment
 The transaction fee payer is always specified separately from the accounts directly involved in a transaction, the transaction fee payment can be delegated to some other account.
 For the sake of a seamless and convenient user experience, blockchain service providers can pay blockchain transaction fees on behalf of the service’s users.

#### Smart Contract Enabled General Financial Platform
 The InfraBlockchain is designed to be a general financial platform supporting smart contracts.
 Business entities can process their financial transactions on the InfraBlockchain using the fiat-pegged stable tokens
 and custom smart contract codes developed to meet the needs of their business process.

#### Integrated KYC/AML Support and Account Recovery
 The integrated KYC/AML process for InfraBlockchain accounts is provided by trusted Identity Authorities designated by block producers,
 which lays the foundation for the secure and reliable financial transactions maintaining regulatory compliance. The blockchain account recovery is provided by the Identity Authorities mitigating the blockchain key loss problem.

#### Scalable Blockchain Architecture
 The enterprise level blockchain scalability enabled by the PoT-based BFT consensus with short block time and fast block finality,
 the InfraBlockchain’s off-chain state-channel exchange technology and the future multi-blockchain architecture.
 The InfraBlockchain enables financial transaction processing at global scale.

InfraBlockchain code base is forked from [EOSIO](https://github.com/EOSIO/eos)

InfraBlockchain is released under the open source MIT license and is offered “AS IS” without warranty of any kind, express or implied.
Any security provided by the InfraBlockchain software depends in part on how it is used, configured, and deployed.
InfraBlockchain is built upon many third-party libraries such as Binaryen (Apache License) and WAVM (BSD 3-clause) which are also provided “AS IS” without warranty of any kind.
Without limiting the generality of the foregoing, Blockchain Labs Inc. makes no representation or guarantee that InfraBlockchain or any third-party libraries will perform as intended or will be free of errors,
bugs or faulty code. Both may fail in large or small ways that could completely or partially limit functionality or compromise computer systems.
If you use or implement InfraBlockchain, you do so at your own risk. In no event will Blockchain Labs Inc. be liable to any party for any damages whatsoever,
even if it had been advised of the possibility of damage.

## InfraBlockchain 'Sentinel' Test-net
* [http://testnet-sentinel-explorer.yosemitelabs.org](http://testnet-sentinel-explorer.yosemitelabs.org)

## InfraBlockchain Explorer
1. [InfraBlockchain Explorer Backend](https://github.com/InfraBlockchain/yosemite-explorer-backend)
1. [InfraBlockchain Explorer Web Frontend](https://github.com/InfraBlockchain/yosemite-explorer-web)

## Client Library
1. [Java Client Library](https://github.com/InfraBlockchain/yosemite-j)

## Supported Operating Systems
1. Centos 7
2. Ubuntu 18.04
3. MacOS 10.13 and higher (MacOS 10.14.x recommended)

## Resources

## Getting Started
InfraBlockchain is based on [EOSIO software](https://github.com/EOSIO/eos). So instructions detailing the process of getting the software, building it, running a simple test network that produces blocks, account creation to the blockchain can be helped by [Getting Started](https://developers.eos.io/eosio-nodeos/docs/overview-1) on the [EOSIO Developer Portal](https://developers.eos.io).
But the names of programs and scripts are changed.
```
nodeos -> infra-node
cleos  -> infra-cli
keosd  -> infra-keystore
```
### Client Tool
infra-cli : https://developers.eos.io/eosio-nodeos/docs/cleos-overview

### Key Store Daemon
infra-keystore : https://developers.eos.io/eosio-nodeos/docs/keosd-overview

## Build and Install
To build InfraBlockchain, use `infrablockchain_build.sh`. To install and unsintall, use `infrablockchain_install.sh` and `infrablockchain_uninstall.sh`.

repository: hajunho/infrablockchain

repo_name: hajunho/infrablockchain


text:
# Release Notes - Version 0.38.0

_Released on April 6, 2021_

- **Download Installer**: [Windows](https://dist.hummingbot.io/hummingbot_v0.38.0_setup.exe) | [macOS](https://dist.hummingbot.io/hummingbot_v0.38.0.dmg)
- **Install via Docker**: [Linux](/installation/docker/#linuxubuntu) | [Windows](/installation/docker/#windows) | [macOS](/installation/docker/#macos)| [Raspberry Pi](/installation/raspberry-pi/#install-via-docker)

---

## New Exchange Connector: DigiFinex

Hummingbot has added more exchanges in this release and is planning to add a lot more exchanges this year! Hummingbot now supports [DigiFinex](https://www.digifinex.com/en-ww) connector. DigiFinex is the world's top 10 crypto exchange by trading volume and liquidity, offering spot, leverage, perpetual swap trading, and fiat to crypto trading. DigiFinex is widely loved for being stable, secure, and easy to use.

DigiFinex is compatible with [pure market making](https://docs.hummingbot.io/strategies/pure-market-making/), [cross-exchange market-making](/strategies/cross-exchange-market-making/), [arbitrage](/strategies/arbitrage/), [amm arbitrage](/strategies/amm-arbitrage/), and [spot perpetual arbitrage](/strategies/spot-perpetual-arbitrage/).

Read more about how to use the DigiFinex connector [here](/exchanges/digifinex/).

## New Exchange Connector: HitBTC

We are glad to present to you that Hummingbot now supports [HitBTC](https://hitbtc.com/) exchange! HitBTC, founded in 2013 by experienced system architects and technology experts, is one of the oldest and fastest-growing crypto exchanges in existence. With an unparalleled track record of reliability, HitBTC offers clients a comprehensive range of services that are accented by our smooth order execution, state-of-the-art trading terminal, and unmatched liquidity. HitBTC exchange is the largest spot trading market in the industry, with over 800 trading pairs and 500+ spot instruments supported, including Bitcoin, Ethereum, EOS, Litecoin, Tron, and others.

HitBTC is compatible with [pure market making](https://docs.hummingbot.io/strategies/pure-market-making/), [cross-exchange market-making](/strategies/cross-exchange-market-making/), [arbitrage](/strategies/arbitrage/), [amm arbitrage](/strategies/amm-arbitrage/), and [spot perpetual arbitrage](/strategies/spot-perpetual-arbitrage/).

Read more about how to use the HitBTC connector [here](/exchanges/hitbtc/).

## New Exchange Connector CoinZoom

[CoinZoom](https://www.coinzoom.com/) is an institutional-grade digital currency trading platform that uses the team’s vast experience in providing superb trade quality and customer-focused tools and technology to help our customers to become successful digital currency traders. CoinZoom will offer services in Buying, Selling, and Trading Bitcoin, Ripple, Ethereum, and other top digital currency pairs. In addition, our decades of experience in financial technology security are equally important in safeguarding customer funds and customers’ digital currency positions.

The CoinZoom team has extensive global exchange and trading experience and proven capabilities of designing, building, and operating a global financial services company. We have “done this before” in foreign exchange markets and use our know-how to create a reliable, safe, compliant, and innovative digital currency exchange.

CoinZoom is compatible with [pure market making](https://docs.hummingbot.io/strategies/pure-market-making/), [cross-exchange market-making](/strategies/cross-exchange-market-making/), [arbitrage](/strategies/arbitrage/), [amm arbitrage](/strategies/amm-arbitrage/), and [spot perpetual arbitrage](/strategies/spot-perpetual-arbitrage/).

Read more about how to use the CoinZoom connector [here](/exchanges/coinzoom/).

## Bitmax connector changed to AscendEx

We have updated Bitmax to AscendEx in line with the exchange’s change in the brand name. It has been updated in the client and also in the documentation.

Learn more about it [here](/exchanges/ascend-ex/)

## Introducing the new Avellaneda Market Making strategy (Beta)

The new Avellaneda Market Making strategy is designed to maintain inventory ratios between trading pairs given min/max spread restrictions by the user while at the same time maximizing profitability.

This is the first (of many to come!) strategies based on an academic paper aiming to use industry-standard market-making algorithms to achieve the highest profit while keeping control of inventory
It comes in 2 modes:

- Beginner (Where the user leaves algorithm to automate parameters)
- Expert for more technical users who want to try different approaches.

Learn more about the new strategy [here](/strategies/avellaneda-market-making/)

## Introducing the new Rate Oracle feature

In this release, we introduce to the users the rate oracle feature. This new feature provides a real-time, most up-to-date exchange rate on any given token or currency from a reliable and trustworthy data source.

If enabled, the bot will use a real-time conversion rate from the oracle when the trading pair symbols mismatch. For example, if markets are set to trade for LINK-USDT and LINK-USDC, the bot will use the oracle conversion rate between USDT and USDC.

Rate Oracle is compatible with [cross-exchange market-making](/strategies/cross-exchange-market-making/), [arbitrage](/strategies/arbitrage/).

Learn more about the feature [here](/strategy-configs/rate-oracle/).

## New global configuration: `autofill_import`

The new global configuration lets you choose from `start` and `config` when importing a strategy already created.

Learn more about it [here](/operation/config-files/#autofill-import).

## Bug Fixes

- [#3011](https://github.com/CoinAlpha/hummingbot/pull/3011) When using `inventory_cost`, the bot will prompt for the `inventory_price` as well
- [#3135](https://github.com/CoinAlpha/hummingbot/pull/3135) Fix Binance `perpetual_market_making` funding payment function
- [#3151](https://github.com/CoinAlpha/hummingbot/pull/3151) Fix reverse `perpetual_market_making` long and short profit spreads and logs
- [#3056](https://github.com/CoinAlpha/hummingbot/pull/3056) Fix sort exchanges alphabetically in the create autocomplete
- [#3073](https://github.com/CoinAlpha/hummingbot/pull/3073) Fix Beaxy float rounding

repository: matthewbackhouse/hummingbot

repo_name: matthewbackhouse/hummingbot


text:
# Gautam Mittal's Home Page

This is the source code for my personal website and blog. If you have any questions or concerns, either [email<EMAIL_ADDRESS>or [file an issue](https://github.com/gmittal/gautam.cc/issues).

Feel free to use this website as a template for your own, just add a link back to [my website](https://gmittal.github.io).

### License
The MIT License ([MIT](https://tldrlegal.com/license/mit-license))

Copyright (c) 2011-present [Gautam Mittal](http://git.io/gautam)

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

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

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


text:
# Greece jails elected Muslim religious leader for usurping authority

Published at: **2019-11-07T05:57:24+00:00**

Author: **Anadolu Agency**

Original: [The Express Tribune](https://tribune.com.pk/story/2095230/3-greece-jails-elected-muslim-religious-leader-usurping-authority/)

ANKARA: An elected Muslim religious leader in Greece’s Western Thrace region was given 80 days of a prison sentence for usurping authority.
Ibrahim Serif is the elected mufti of Komotini (Gumulcine) which is one of the three major cities of the Western Thrace region in Greece, home to a Muslim-Turkish minority of around 150,000 people.
Serif tweeted on Wednesday that he was convicted by a court in Alexandroupoli (Dedeagac) on Tuesday on the basis of his participation in a Friday prayer in one of the villages of Evros province in March 2016.
Serif also shared a copy of the court summons.
His lawyer has appealed the decision in a higher court.
Serif previously won a case in 1999 over the same charge after appealing to the European Court of Human Rights.
He was elected mufti of Komotini in 1990 by the local Muslim Turkish community.
In Western Thrace, the election of muftis has been a bone of contention for the Muslim Turkish community since 1991. Muftis have the jurisdiction to decide on family and inheritance matters of local Muslims.
The election of muftis by Muslims in Greece was regulated in the 1913 Treaty of Athens between Greece and the Ottoman Empire and was later included in the Greek Act 2345/1920.
However, Greece annulled this law in 1991 and started appointing the muftis itself.
The majority of Muslim Turks in the cities of Komotini (Gumulcine) and Xanthi (Iskece) do not recognize the appointed muftis and elect their own instead, who are not recognized by the Greek state.

license: Unlicense

repository: dsadlollioygjmzvcxv/tdc-exported

repo_name: dsadlollioygjmzvcxv/tdc-exported


text:
# Plugin Schema

The plugin schema defines metadata, installation, and configuration details about a plugin.

## Plugin Fields

### `name`

The unique name for the plugin, this must be the same name as the filename and can not be changed later.

It should also match the regex `[a-zA-Z][a-zA-Z0-9\.-_]*`, start with alphabetic character and followed by any number of alphanumeric characters, `.`, `-`, or `_`.

Declaration: `name: string;`

---

### `displayName`

The name used for display purposes

Declaration: `displayName?: string;

---

### `type`

The type of the plugin, the only current type of plugin is a `shell` plugin

Declaration: `type: "shell"`

---

### `description`

A short description of a plugin, this should breifly explain what the plugin is in less than 100 characters.

Declaration: `description?: string`

---

### `icon`

The icon of a plugin used in the plugin store

This should either be an emoji or a url to a square image

Declaration: `icon?: string`

---

### `screenshots`

An array of screenshots that will be displayed along with the plugin.

Declaration: `screenshots?: string[];`

---

### `site`

A url to the offical site of a plugin

Declaration: `site?: string`

---

### `docs`

A url to the offical docs for a plugin

Declaration: `docs?: string`

---

### `github`

The `owner/repo` of the plugin, this is both used for metadata and determining where to clone the plugin from

Declaration: `github?: string`

---

### `twitter`

The twitter handle for the plugin

Declaration: `twitter?: string`

---

### `authors`

A list of authors who created the plugin

Declaration: `authors?: Author[]`

#### `Author` type

The authors is a list of the following type:

```typescript
type Author =
  | string
  | {
      name: string;
      twitter?: string;
      github?: string;
    };
```

If the author is a string that is their name, the twitter should be their twitter handle, and github should be the github username

---

### `license`

The license is a list of the licences of the plugin

The string should follow the [SPDX License syntax](https://en.wikipedia.org/wiki/Software_Package_Data_Exchange#License_syntax)

Declaration: `license?: string[]`

---

### `shells`

This is an inclusive list of the shells that a plugin supports

Declaration: `shells?: Shell[]`

#### `Shell` type

```typescript
type Shell = "bash" | "zsh" | "fish";
```

---

### `categories`

The categories is a list of the catagories that a plugin falls under, this array should contain at least one category

Declaration: `categories?: Category[]`

#### `Category` type

```typescript
type Category =
  | "Completion"
  | "Prompt"
  | "Color"
  | "Alias"
  | "Convenience Function"
  | "Productivity Hack"
  | "Framework"
  | "Other";
```

---

### `keywords`

Keywords act as additional metadata for a plugin that is fully user definable

Declaration: `keywords?: string[]`

---

### `installation`

See [Installation](installation_schema.md)

---

### `configuration`

See [Configuration](configuration_schema.md)

repository: withfig/plugins

repo_name: withfig/plugins