text:
---
Module Name: Az.DataFactoryV2
Module Guid: e3c0f6bc-fe96-41a0-88f4-5e490a91f05d
Download Help Link: https://docs.microsoft.com/en-us/powershell/module/az.datafactoryv2
Help Version: <IP_ADDRESS>
Locale: en-US
---

# Az.DataFactoryV2 Module
## Description
Azure Data Factory V2 is the data integration platform that goes beyond Azure Data Factory V1's orchestration and batch-processing of time-series log data, with a general purpose app model supporting modern data warehousing patterns and scenarios, lift-and-shift SSIS, and data-driven SaaS applications. Compose and manage reliable and secure data integration workflows at scale. Use native ADF data connectors and Integration Runtimes to move and transform cloud and on-premises data that can be unstructured, semi-structured, and structured with Hadoop, Azure Data Lake, Spark, SQL Server, Cosmos DB and many other data platforms.

## Az.DataFactoryV2 Cmdlets
### [Get-AzDataFactoryV2](Get-AzDataFactoryV2.md)
Gets information about Data Factory.

### [Get-AzDataFactoryV2ActivityRun](Get-AzDataFactoryV2ActivityRun.md)
Gets information about activity runs for a pipeline run.

### [Get-AzDataFactoryV2Dataset](Get-AzDataFactoryV2Dataset.md)
Gets information about datasets in Data Factory.

### [Get-AzDataFactoryV2IntegrationRuntime](Get-AzDataFactoryV2IntegrationRuntime.md)
Gets information about integration runtime resources.

### [Get-AzDataFactoryV2IntegrationRuntimeKey](Get-AzDataFactoryV2IntegrationRuntimeKey.md)
Gets keys for a self-hosted integration runtime.

### [Get-AzDataFactoryV2IntegrationRuntimeMetric](Get-AzDataFactoryV2IntegrationRuntimeMetric.md)
Gets metric data for an integration runtime.

### [Get-AzDataFactoryV2IntegrationRuntimeNode](Get-AzDataFactoryV2IntegrationRuntimeNode.md)
Gets an integration runtime node infomation.

### [Get-AzDataFactoryV2LinkedService](Get-AzDataFactoryV2LinkedService.md)
Gets information about linked services in Data Factory.

### [Get-AzDataFactoryV2Pipeline](Get-AzDataFactoryV2Pipeline.md)
Gets information about pipelines in Data Factory.

### [Get-AzDataFactoryV2PipelineRun](Get-AzDataFactoryV2PipelineRun.md)
Gets information about pipeline runs.

### [Get-AzDataFactoryV2Trigger](Get-AzDataFactoryV2Trigger.md)
Gets information about triggers in a data factory.

### [Get-AzDataFactoryV2TriggerRun](Get-AzDataFactoryV2TriggerRun.md)
Returns information about trigger runs.

### [Invoke-AzDataFactoryV2IntegrationRuntimeUpgrade](Invoke-AzDataFactoryV2IntegrationRuntimeUpgrade.md)
Upgrades self-hosted integration runtime.

### [Invoke-AzDataFactoryV2Pipeline](Invoke-AzDataFactoryV2Pipeline.md)
  Invokes a pipeline to start a run for it.

### [New-AzDataFactoryV2IntegrationRuntimeKey](New-AzDataFactoryV2IntegrationRuntimeKey.md)
Regenerate self-hosted integration runtime key.

### [New-AzDataFactoryV2LinkedServiceEncryptedCredential](New-AzDataFactoryV2LinkedServiceEncryptedCredential.md)
Encrypt credential in linked service with specified integration runtime.

### [Remove-AzDataFactoryV2](Remove-AzDataFactoryV2.md)
Removes a data factory.

### [Remove-AzDataFactoryV2Dataset](Remove-AzDataFactoryV2Dataset.md)
Removes a dataset from Data Factory.

### [Remove-AzDataFactoryV2IntegrationRuntime](Remove-AzDataFactoryV2IntegrationRuntime.md)
Removes an integration runtime.

### [Remove-AzDataFactoryV2IntegrationRuntimeNode](Remove-AzDataFactoryV2IntegrationRuntimeNode.md)
Remove a node with the given name on an integration runtime.

### [Remove-AzDataFactoryV2LinkedService](Remove-AzDataFactoryV2LinkedService.md)
Removes a linked service from Data Factory.

### [Remove-AzDataFactoryV2Pipeline](Remove-AzDataFactoryV2Pipeline.md)
Removes a pipeline from Data Factory.

### [Remove-AzDataFactoryV2Trigger](Remove-AzDataFactoryV2Trigger.md)
Removes a trigger from a data factory.

### [Set-AzDataFactoryV2](Set-AzDataFactoryV2.md)
Creates a data factory.

### [Set-AzDataFactoryV2Dataset](Set-AzDataFactoryV2Dataset.md)
Creates a dataset in Data Factory.

### [Set-AzDataFactoryV2IntegrationRuntime](Set-AzDataFactoryV2IntegrationRuntime.md)
Updates an integration runtime.

### [Set-AzDataFactoryV2LinkedService](Set-AzDataFactoryV2LinkedService.md)
Links a data store or a cloud service to Data Factory.

### [Set-AzDataFactoryV2Pipeline](Set-AzDataFactoryV2Pipeline.md)
Creates a pipeline in Data Factory.

### [Set-AzDataFactoryV2Trigger](Set-AzDataFactoryV2Trigger.md)
Creates a trigger in a data factory.

### [Start-AzDataFactoryV2IntegrationRuntime](Start-AzDataFactoryV2IntegrationRuntime.md)
Starts a managed dedicated integration runtime.

### [Start-AzDataFactoryV2Trigger](Start-AzDataFactoryV2Trigger.md)
Starts a trigger in a data factory.

### [Stop-AzDataFactoryV2IntegrationRuntime](Stop-AzDataFactoryV2IntegrationRuntime.md)
Stops a managed dedicated integration runtime.

### [Stop-AzDataFactoryV2PipelineRun](Stop-AzDataFactoryV2PipelineRun.md)
Stops a pieline run in a data factory.

### [Stop-AzDataFactoryV2Trigger](Stop-AzDataFactoryV2Trigger.md)
Stops a trigger in a data factory.

### [Sync-AzDataFactoryV2IntegrationRuntimeCredential](Sync-AzDataFactoryV2IntegrationRuntimeCredential.md)
Synchronizes credentials among integration runtime nodes.

### [Update-AzDataFactoryV2](Update-AzDataFactoryV2.md)
Updates the properties of a data factory.

### [Update-AzDataFactoryV2IntegrationRuntime](Update-AzDataFactoryV2IntegrationRuntime.md)
Updates an integration runtime.

### [Update-AzDataFactoryV2IntegrationRuntimeNode](Update-AzDataFactoryV2IntegrationRuntimeNode.md)
Updates self-hosted integration runtime node.

repository: yaakoviyun/azure-powershell

gha_license_id: NOASSERTION

repo_name: yaakoviyun/azure-powershell


text:
# redtail
> a data application

The redtail application tracks reports of rodents throughout Baltimore City,
and their proximity to local food establishments. The application pulls data
from three data sets on [Open Baltimore](https://data.baltimorecity.gov):

  * [Neighborhoods](https://data.baltimorecity.gov/dataset/nhood_2010/h3fx-54q3):
    all of the communities in the city, and their geographic details.

  * [Restaurants](https://data.baltimorecity.gov/resource/abuv-d2r2):
    used to populate the list of "establishments" tracked in the application.
    Includes restaurant name and location.

  * [311 Service Requests](https://data.baltimorecity.gov/resource/q7s2-a6pd):
    used to populate the list of "rodents" in the city by filtering down the
    data set to only those requests that mention rodents. Includes the location
    of the report, how the report was made, and the current state of the report.

Redtail aggregates this information together into a search-able, sortable
listing, and maps each rodent sighting and food establishment on a map using
coordinates pulled from the [US Census Geocoder](https://geocoding.geo.census.gov).
Maps are pulled from [Mapbox](https://www.mapbox.com/).

Users may also submit new rodent reports, edit existing reports, or delete
reports through the browser-based application, or through the REST API.

## Overview

The application includes two components:

  1. A browser-based application built on [Riot](http://riotjs.com/).
  2. A server-side application implemented using REST-ful concepts, built on
    [express](http://expressjs.com/).

The two applications are separate; however, for convenience while developing,
the express application serves the client application.

Source code is divided into modules, where each module is intended to
encapsulate all related (client and server) capabilities. The client and
server side share code, where applicable.

## Getting started

### Requirements

* Node 6.9
* MySQL 5.7

### Installing and running

To install and run locally:

  1. Install package dependencies: `npm install`.
  2. Create a MySQL database and user for the application to connect to. The
     user will need privileges to read and write data, and to create
     tables.
  3. Configure the database connection by either:
    1. Setting the following environment variables:
      * `DB_NAME`: the name of the database (defaults to "redtail")
      * `DB_USERNAME`: the name of the database user (defaults to "redtail")
      * `DB_PASSWORD`: the password for the database user (**required**)
      * `DB_HOST`: the server address (defaults to "localhost")
      * `DB_PORT`: the port to conenct to (defaults to 3306)
    2. Creating a "config/local.json" file, and including the following
      (replacing the appropriate values as needed):

      ```json
        {
          "models": {
            "db": {
              "database": "redtail",
              "username": "redtail",
              "password": "password",
              "options": {
                "host": "localhost",
                "port": 3306
              }
            }
          }
        }
      ```

  4. Initialize the database:
    1. From a database baseline (fast): `npm run bin:initData`.
    2. From Open Baltimore (slow): `npm run bin:refreshData`.
  5. Start the application: `npm start`.
  6. Open the application in a browser: http://localhost:3000.

### Serving on a different port

By default, the application is served on port 3000. This can be overridden by
setting the "PORT" environment variable:

```
%> PORT=8080 npm start
```

### Rebuilding the application

* Rebuild the entire application: `npm run build`.
* Rebuild only the client application: `npm run build:client`.
* Rebuild only the server application: `npm run build:server`.

The client application is built using [webpack](https://webpack.github.io/).

ES6 and ES7 code is compiled into browser-compatible and Node-compatible
Javascript using [babel](https://babeljs.io/).

### Logging

Redtail uses [bunyan](https://github.com/trentm/node-bunyan) for logging. The
default configuration writes "info" level logs to both stdout and a log file
("./redtail.log").

Bunyan writes logs in a JSON format, making it easy to search logs, but
difficult to read them. Log output can be piped through the
[Bunyan CLI](http://trentm.com/node-bunyan/bunyan.1.html) to pretty-print:

```
%> npm start | ./node_modules/.bin/bunyan
%> tail -f redtail.log | ./node_modules/.bin/bunyan
```

(To avoid referencing the node_modules directory, install bunyan globally:
`npm install -g bunyan`).

The Bunyan CLI also includes the ability to search logs for specific
conditions. For example, every request to the redtail server is given an
unique identifier, which is returned to the client in the `X-Request-Id` header.
To find all logs for a request with an ID of "A1234":

```
%> cat redtail.log | ./node_modules/.bin/bunyan -c 'this.reqId == "A1234"'
```

### Configuration

Redtail uses [nconfig](https://github.com/hyubs/nconfig) for configuration.
The default configuration file is set in "config/default.json". Local
applications can override defaults by setting the appropriate keys in a
"config/local.json" file, which is automatically merged with the default
configuration on application startup.

The server exposes a subset of the configuration to the client through the
`GET /config` endpoint.

## Instrumentation

The server component includes rudimentary instrumentation detailing the memory
and time it takes to process a request. Each server response includes a
`X-Instr-Tag` header, which can be traced back to the logs to lookup
instrumentation for that request:

```
%> cat redtail.log | ./node_modules/.bin/bunyan -c 'this.name == "profiler" && this.tag == "A1234"'
```

(The instrumentation tag is different from the request ID, even if they both
serve the same purpose - it just has to do with where the value is generated
in the execution flow.)

## Documentation

Source code is documented using [esdoc](https://esdoc.org/). The build source
code documentation is served through the server at "/docs".

## Unit testing

The application includes (limited) unit tests, which can be run using
`npm run test`.

Unit tests are run using the [mocha](https://mochajs.org/) framework, with
[chai](http://chaijs.com/) assertions, and [sinon](http://sinonjs.org/)
for spies, stubs, and mocks.

Test coverage reports are generated by
[istanbul](https://github.com/gotwarlost/istanbul), and are available through
the server at "/coverage".

license: MIT

repository: cthierer/redtail

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: cthierer/redtail


text:
### Twitter Clone Project
Twitter clone but a cat theme! Users can meow(tweet) , see other users profiles, like, retweet and follow other profiles!
User logged in as: Gladstone - treasurymog
### Getting Started
These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.

Go to the server directory. Run npm install/yarn install followed by npm start/yarn start. The server will be running on port 31415

Go to the client directory. Run npm install/yarn install followed by npm start/yarn start. Accept to listen to FE on port 3000

### Flow for user.

## Home
### Home Page

## Tweet
### Users can tweet by clicking on either MEOW buttons.

## Like & Retweet
### Users can like and retweet other tweets.

## Tweet Details
### Users can see more details about a particular tweet.

## User profiles
### Users can click and see other users profiles.

## Followers/Following
### Users can follow and unfollow other users.

## Search bar
### Users can search for tweets based on content and then click to see more details.

## Responsive Design

### Known Error:
-A known issue is after unfollowing a user, then trying to retweet something that user said, and then clicking on the profile page. There will be an error on the profile page because, that user no longer exists in state.

### Prerequisites
-node.js, npm/yarn

### Built With
Node.js - Backend
React - FrontEnd

### Authors
Manider Dheer.
Josh Commeau - Back End.

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

### Acknowledgments
Big thank you to Scott and Josh!

gha_language: JavaScript


text:
# Texture Loading/Management

This guide discusses [TextureResource][api.type.TextureResource] objects which provide a handle to manually manage and access information about textures.

* [Overview](#overview)
* [Creation and Usage](#usage)
* [Examples](#examples)

Note

The methods outlined in this guide are intended for <nobr>finer-grained</nobr> control of managing textures in very specific situations. For general app development, these will not be necessary, but we provide them for more advanced purposes.

## Overview

[TextureResource][api.type.TextureResource] objects give you control over the lifetime of textures in memory while also providing abstraction over file names and directories. The primary purpose of these objects is to <nobr>pre-load</nobr> textures into memory so that creating display objects using them will be virtually instantaneous.

Essentially, when you create a [TextureResource][api.type.TextureResource] object with [graphics.newTexture()][api.library.graphics.newTexture], a reference to the texture is retained in memory — this is similar to the reference that display objects hold if they utilize a texture. The key difference is that a texture which is __not__ loaded as a [TextureResource][api.type.TextureResource] object will be disposed/released when there are no display objects using the texture, while a texture loaded as a [TextureResource][api.type.TextureResource] object will remain in memory until you explicitly release it via [object:releaseSelf()][api.type.TextureResource.releaseSelf] or [graphics.releaseTextures()][api.library.graphics.releaseTextures].

## Creation and Usage

### Creating

[TextureResource][api.type.TextureResource] objects are easily created using the [graphics.newTexture()][api.library.graphics.newTexture] method. The sole argument is a table containing the required parameters for the [TextureResource][api.type.TextureResource] object. For example:

``````lua
local texture = graphics.newTexture( { type="image", filename="background.png" } )
``````

``````lua
local texture = graphics.newTexture( { type="canvas", width=128, height=128 } )
``````

This code will create the texture resource object under the variable handle `texture`. Once created, you can utilize the underlying texture with various properties and methods associated with the [TextureResource][api.type.TextureResource] itself.

### Using/Accessing

From the [TextureResource][api.type.TextureResource] object, the [filename][api.type.TextureResource.filename] and [baseDir][api.type.TextureResource.baseDir] properties let you create images, image sheets, custom fills/strokes, and other objects which accept a file name and directory constant. For instance:

``````lua
-- TextureResource-based image
local background = display.newImageRect(
	texture.filename,  -- "filename" property required
	texture.baseDir,   -- "baseDir" property required
	display.contentWidth,
	display.contentHeight
)

-- TextureResource-based fill
local circle = display.newCircle( 200, 100, 50 )
circle.fill = {
	type = "image",
	filename = texture.filename,  -- "filename" property required
	baseDir = texture.baseDir     -- "baseDir" property required
}
``````

Note that these <nobr>texture-related</nobr> properties should not be used to reference the same file or directory constant in <nobr>non-texture-related</nobr> methods — for example, if you specify `"background.png"` as the `filename` for the texture, do not attempt to use `texture.filename` as a reference to the same file in [system.pathForFile()][api.library.system.pathForFile]. Essentially, these properties refer to internal memory, not the file system.

### Managing Lifetime

To prevent memory leaks, it's important to dispose/release [TextureResource][api.type.TextureResource] objects if they are no longer required. This can be done either on an individual basis or in a wider scope:

* Release an individual texture resource object by calling [texture:releaseSelf()][api.type.TextureResource.releaseSelf] on the handle:

``````lua
texture:releaseSelf()
``````

* Release all texture resource objects sharing the same [type][api.type.TextureResource.type] property by calling [graphics.releaseTextures()][api.library.graphics.releaseTextures]:

``````lua
graphics.releaseTextures( { type="image" } )
graphics.releaseTextures( { type="canvas" } )
``````

Note that if any display objects are currently using the released texture, they will not be corrupted — instead, they will hold on to the texture under the hood, and if/when they are removed, the texture will be automatically disposed.

### Texture Types

Calling [graphics.newTexture()][api.library.graphics.newTexture] actually produces objects of different types, depending on the specified `type` parameter. All types contain the shared properties/methods of [TextureResource][api.type.TextureResource]  plus additional properties/methods depending on the type:

* [TextureResourceBitmap][api.type.TextureResourceBitmap] — The texture resource object created by `type="image"`.
* [TextureResourceCanvas][api.type.TextureResourceCanvas] — The texture resource object created by `type="canvas"`.

## Examples

##### Pre-loading Images

``````lua
-- This simplified example pre-loads textures into memory

-- These files are high-resolution images which may affect performance if loaded normally
local filenames = {
	"splat1.png",
	"splat2.png",
	"splat3.png",
	"splat4.png",
	"splat5.png"
}

-- Pre-load textures to memory
local textures = {}
for i = 1,#filenames do
	textures[i] = graphics.newTexture(
		{
			type = "image",
			filename = filenames[i],
			baseDir = system.ResourceDirectory
		})
	textures[i]:preload()
end

-- Sometime later, display the images
-- Because the images were pre-loaded, no performance impact will occur
local objects = {}
for i = 1,#textures do
	local texture = textures[i]
	objects[i] = display.newImageRect( texture.filename, texture.baseDir, 100, 100 )
end

-- If the textures are no longer needed, release them to prevent memory leaks
for i = 1,#textures do
	textures[i]:releaseSelf()
end
textures = {}
``````

##### Render to Canvas Resource

``````lua
local tex = graphics.newTexture( { type="canvas", width=128, height=128 } )

-- Create display object with texture as contents
local rect = display.newImageRect(
	tex.filename,  -- "filename" property required
	tex.baseDir,   -- "baseDir" property required
	display.contentWidth,
	display.contentHeight
)
rect.x = display.contentCenterX
rect.y = display.contentCenterY

-- Create a circle and draw/render it to the texture
local circ = display.newCircle( 0, 0, 64 )
circ:setFillColor( { type="gradient", color1={0,0.2,1}, color2={0.8,0.8,0.8}, direction="down" } )
tex:draw( circ )

-- Schedule texture objects to be rendered to texture before next frame
tex:invalidate()
``````

##### Advanced Management

The advanced example, available on [GitHub](https://github.com/coronalabs/samples-coronasdk/tree/master/Graphics/TextureLoad), downloads images from the web and has the capability to <nobr>pre-load</nobr> and release textures on runtime for optimized performance purposes.

repository: coronalabs/corona-docs

extension: markdown

gha_language: HTML

gha_license_id: MIT

repo_name: coronalabs/corona-docs


text:
---
title: "ffuf filters"
layout: post
categories:
  - hacking
tags:
  - hacking
---

I’ve been wanting to write more here to be helpful, practice writing, and clarify my thoughts. However, I have a hard time making time to actually do it. I tweeted something about removing false positives from ffuf, and it’s blowing up a little bit. I immediately knew I wanted to clarify it a bit.

Here’s the tweet: [https://twitter.com/rez0\_\_/status/1321236534855639041](https://twitter.com/rez0__/status/1321236534855639041)

I essentially said the best way to remove false positives from ffuf is the autocalibrate `-ac` flag + 302, 400, 404, 429, and 500-504 would get 99% of the noise. But that is a very general answer which covers most cases. That said, it misses the really interesting behavior that often leads to bugs other people are missing. Here’s a few ffuf clarifications to the above simplification.

## First, the ones I left off that I sometimes filter.

**401 & 403** - If the whole host is 401 or 403, I filter it, but that will usually be caught by -ac. I left it off because I like to try and bypass it via path traversal or verb tampering. If it’s not caught by -ac, it’s likely a rule in the ACL.

**301** - Some hosts hit 301 way too frequently to be directories, but usually they represent directories, which means more fuzzing :) 301 is probably the next best return code besides 200.

## Now, the reasoning behind the codes in the list and why they are sometimes actually awesome.

**302** is almost always junk, but I’ve seen 302s to other hosts that were not in my subdomain list.

**400 & 404** are often noise, but if you have -ac in your request and you see a 400 or 404, that’s interesting because it’s a different response size. I will usually check into it.

**429** is always a false positive, but it DOES let you know you’re being rate limited, so it’s useful to see them so you know to slow down you’re fuzzing or to stop fuzzing that host.

**500** can sometimes return if a server is erroring due to a weird fuzz payload, etc. but it’s often something interesting. I will often do a parameter brute force on paths which return 500.

**502-504** are often false positives due to too much traffic on a weak server or something similar, but they can sometimes be interesting.
.
## Other Tips

1. Always use `-mc all -ac`. You’re not at much risk of false positives due to matching every response code since the autocalibrate will catch most issues it would cause. Also, I’ve seen response codes that are non-standard like 999.
2. If you’re using `-mc all -ac` and there’s a small number of results, look into them! It's often interesting behavior.
3. Honestly, watching the results come in is really useful. I like a terminal which auto-makes links into links so I can click the results to go straight to the site. Ubuntu’s terminal does this. I also like to ffuf multiple sites at the same time so I can watch it all in split tmux windows.

I have lots of tips for how to save off all your ffuf data and also parse it after the fact, but most of that will be in my bash alias / bash profile blog post that I plan to do soon.

Thanks! I hope you learned something. If you enjoyed this, you can tweet or follow me at [https://twitter.com/rez0\_\_](https://twitter.com/rez0__) and/or subscribe to [my newsletter](http://eepurl.com/c5WVgj)

rez0

repository: jthack/hydeout

gha_language: SCSS

repo_name: jthack/hydeout


text:
## Intro

Real time speech to text with multi language translation by using Google Speech-to-Text API and Google Text-Translation API,
this version will recognize Thai speech and translate to English and Deutsch. (If you want another language just change in code)

## Dependencies

Python3, google-cloud-speech, google-cloud-translate, opencv-python, pyaudio, pillow

### Getting started

1. Clone this project and create virtualenv (recommended) and activate virtualenv.
    ```
    virtaulenv -p python3 env

    Linux
    source env/bin/activate

    Windows
    env\Scripts\activate
    ```

2. Install require dependencies.
    ```
    pip install -r requirements.txt
    ```

3. You must sign up Google Cloud account and create project with Google Speech-to-Text API and Google Text-Translation API and download json secret key to use with google api (just following google quick start).

4. Run code and speech (have fun).
    ```
    python transcribe_streaming_mic.py
    ```

ps. you must load json secret key in every session then you can run script (if you dont it will error).

ps2. if you dont understand how to load json secret key in session just follow google cloud api quick start.

repository: dwisan/real-time-speech-translator

repo_name: dwisan/real-time-speech-translator


text:
# Introduction

User-Managed Access ([UMA]) is an OAuth-based web-based access management protocol. The protocol is defined in a draft version 1.0 specification. A corresponding specification defines obligations of legally responsible parties that engage in UMA-conforming interactions. Gluu Server implements UMA protocol and use it actively for protecting resources. It's possible to hook up authorization interception script which may contain logic when to grand (or forbid) access. All terminology used by this page is borrowed from UMA and Connect specs.

## UMA in Action

![UMA Authorization Workflow](http://www.gluu.org/docs/img/uma/uma_parts.png "UMA Parts")
![Detailed authorization overview](http://www.gluu.org/docs/img/uma/uma_flow.png "UMA Parts")
![UMA Authorization token workflow](http://www.gluu.org/docs/img/uma/uma_token_workflow.png "UMA Parts")
![UMA Authorization complete sequence diagram](http://www.gluu.org/docs/img/uma/uma_very_detailed_flow.png "UMA Parts")

## References
- [UMA Specifications](http://kantarainitiative.org/confluence/display/uma/UMA+1.0+Core+Protocol)
- [UMA Requestion Party Sample implementation](https://svn.gluu.info/repository/openxdi/oxUmaDemo/RP/)
- [UMA Resource Server Sample implementation](https://svn.gluu.info/repository/openxdi/oxUmaDemo/RS/)
- [Gluu Server](http://gluu.org)
- [Juju Application Security Framework (JASF) Overview](http://www.gluu.co/juju-draft-overview)

[UMA]: http://kantarainitiative.org/confluence/display/uma/UMA+1.0+Core+Protocol

repository: Ziaurgluu/docs

repo_name: Ziaurgluu/docs


text:
# go-safecast
Library for safe type conversion in Go

# What is this
The type of `int` equals `int64` on 64-bit machine in Go.
When you convert `int`(`int64`) to `int32`, `int8` or `int6`, Your code could have Integer Overflow vulnerability.

In 2019, [Kubernetes](https://kubernetes.io/) had the vulnerability. and the vulnerability was found on [Security Audit Project](https://github.com/kubernetes/community/blob/master/sig-security/security-audit-2019/findings/Kubernetes%20Final%20Report.pdf) by Trail of Bits.
You can use this library to prevent the vulnerability creation.

**(This library is inspired by Kubernetes's Security Audit Report by Trail of Bits)**

# Usage

```go
import "github.com/rung/go-safecast"
```

## Convert int to int32 (instead of native int32() type conversion)
```go
	i :=<PHONE_NUMBER>
	i32, err := safecast.Int32(i) // convert int to int32 in a safe way
	if err != nil {
		return err
	}
```
The function returns error when the value is out of the 32-bit range.
This library also has `safecast.Int16` and `safecast.Int8`. You can use the functions in the same way as `safecast.Int32`

## Convert string to int32 (instead of strconv.Atoi())
```go
	s := "2147483647"
	i, err := safecast.Atoi32(s) // convert string to int32 in a safe way
	if err != nil {
		return err
	}
```
The function returns error when the value is out of the 32-bit range.
This library also has `safecast.Atoi16` and `safecast.Atoi8`. You can use the functions in the same way as `safecast.Atoi32`

# What happens when overflows
## Range of each integer
|       | int32 (32bit signed integer)         | int16 (16bit signed integer) | int8 (8bit signed integer) |
| :---: | :----------------------------------: | :--------------------------: | :------------------------: |
| Range | From -2,147,483,648 to 2,147,483,647 | From -32,768 to 32,767       | From -128 to 127           |

## When using native int32(), the code causes overflows
[](https://play.golang.org/p/tyATM4dL33x)
Native int32() type conversion doesn't return error when the code cause integer overflow.

Link: [Go Playground](https://play.golang.org/p/tyATM4dL33x)

---

## When using safecast.Int32() on this library, your code is safe
[](https://play.golang.org/p/1xeeyt-feLI)
This library returns error when the value is out of the 32-bit range.
So you can convert integer in a safe way.

Link: [Go Playground](https://play.golang.org/p/1xeeyt-feLI)

# License
[MIT License](LICENSE)

repository: TrendingTechnology/go-safecast

branch_name: refs/heads/main

repo_name: TrendingTechnology/go-safecast


text:
jQuery minimap
==============

> This plugin provides a "minimap" for in-page navigation, similar to that in
> Sublime Text 2.

[_View it in action_](http://goldenapples.github.io/jquery.minimap/)

This came from UX discussions while redesigning Janrain's documentation site.
Specifically, we tried to include long-form narrative content as much as
possible, with lots of screenshots, tables, and inline graphics. We made good
use of jQuery waypoints for in-page navigation, but we felt that even so, users
would want a better way to orient themselves to where they are on the page, and
an easier way to jump to the section they want.

### Usage:

Usage is as simple as possible. Just target the body column element and call the
plugin like this:

    $('#body_column').minimap();

Or pass the body column to the plugin as an _option_:

    $.minimap({ body_col: '#body_column' });

### Options:

Options can be passed to the plugin to override a number of defaults.

| Option         | Meaning                                                 | Default Value                                                                                |
|----------------|---------------------------------------------------------|----------------------------------------------------------------------------------------------------------|
| `body_col`     | element to use as the body                              | The current context of _this_                                                                            |
| `map_col`      | custom element to draw the map in                       | If not specified, will insert the following element: `<aside class="map_col"></aside>` before `body_col` |
| `toggle_btn`   | An element to use to toggle visibility of the minimap   | None                                                                                |
| `draggable`    | Whether to use jQuery.ui.draggable controls             | True if jQuery.ui is loaded, false otherwise                                                             |
| `scrollto`     | Whether to use jQuery.scrollTo to animate scrolling     | True if jQuery.scrollTo is loaded, false otherwise.                                                      |
| `map_header`   | Custom content to put in a "header" of the map column   |                                                                                |
| `minimap_opacity` | Opacity of the minimap vis-à-vis the underlying page (between 0 and 1) | 1
| `minimap_left_border` | Specifies the CSS for the border between the minimap and the page body (e.g. `1px solid black`)| `none` |
| `overlay_background_color` | The background color of the minimap | `rgba(26, 45, 58, .1)`|

### Utility functions:

The plugin uses a localStorage entry to determine the users' preference for
showing or hiding the minimap. The following utility functions update that value
as well as showing or hiding the map.

- `$.minimap.show()`: show the minimap.
- `$.minimap.hide()`: hide the minimap.
- `$.minimap.toggle()`: toggle the minimap.

### Styling:

View the stylesheet provided for some tips.

Some caveats:

- For the effect to work, the minimap column should have a fixed position and be
  set to 100% of the window height. This works best if the `html` and `body`
  elements have heights defined to 100%.
- Depends on CSS scaling transforms, so will not work in browsers that don't
  support that (IE <= 8, Android <= 2.3): http://caniuse.com/#search=transform
- Because this clones the entire content of the page, in-page search may behave
  somewhat unexpectedly (Ctrl-F will find every search term twice; once in the
  minimap and once in the page itself).


text:
# awesome-machine-learning-*interpretability* [![Awesome](https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg)](https://github.com/sindresorhus/awesome)

A curated, but probably biased and incomplete, list of awesome machine learning interpretability resources.

If you want to contribute to this list (*and please do!*) read over the [contribution guidelines](contributing.md), send a pull request, or contact me [@jpatrickhall](https://twitter.com/jpatrickhall).

**An incomplete, imperfect blueprint for a more human-centered, lower-risk machine learning.** The resources in this repository can be used to do many of these things today. *The resources in this repository should not be considered legal compliance advice.*
![alt-text](https://github.com/h2oai/mli-resources/blob/master/blueprint.png)
</br>Image credit: H2O.ai Machine Learning Interpretability team, https://github.com/h2oai/mli-resources.

## Table of Contents

* [Comprehensive Software Examples and Tutorials](https://github.com/jphall663/awesome-machine-learning-interpretability#comprehensive-software-examples-and-tutorials)
* Explainability- or Fairness-Enhancing Software Packages
  * [Browser](https://github.com/jphall663/awesome-machine-learning-interpretability#browser)
  * [Python](https://github.com/jphall663/awesome-machine-learning-interpretability#python)
  * [R](https://github.com/jphall663/awesome-machine-learning-interpretability#r)
* [Free Books](https://github.com/jphall663/awesome-machine-learning-interpretability#free-books)
* [Other Interpretability and Fairness Resources and Lists](https://github.com/jphall663/awesome-machine-learning-interpretability#other-interpretability-and-fairness-resources-and-lists)
* [Review and General Papers](https://github.com/jphall663/awesome-machine-learning-interpretability#review-and-general-papers)
* [Teaching Resources](https://github.com/jphall663/awesome-machine-learning-interpretability#teaching-resources)
* Interpretable ("Whitebox") or Fair Modeling Packages
  * [C/C++](https://github.com/jphall663/awesome-machine-learning-interpretability#cc)
  * [Python](https://github.com/jphall663/awesome-machine-learning-interpretability#python-1)
  * [R](https://github.com/jphall663/awesome-machine-learning-interpretability#r-1)

## Comprehensive Software Examples and Tutorials

* [Getting a Window into your Black Box Model](http://projects.rajivshah.com/inter/ReasonCode_NFL.html)
* [IML](https://mybinder.org/v2/gh/christophM/iml/master?filepath=./notebooks/tutorial-intro.ipynb)
* [Interpretable Machine Learning with Python](https://github.com/jphall663/interpretable_machine_learning_with_python)
* [Interpreting Machine Learning Models with the iml Package](http://uc-r.github.io/iml-pkg)
* [Machine Learning Explainability by Kaggle Learn](https://www.kaggle.com/learn/machine-learning-explainability)
* [Model Interpretability with DALEX](http://uc-r.github.io/dalex)
* Model Interpretation series by Dipanjan (DJ) Sarkar:
  * [The Importance of Human Interpretable Machine Learning](https://towardsdatascience.com/human-interpretable-machine-learning-part-1-the-need-and-importance-of-model-interpretation-2ed758f5f476)
  * [Model Interpretation Strategies](https://towardsdatascience.com/explainable-artificial-intelligence-part-2-model-interpretation-strategies-75d4afa6b739)
  * [Hands-on Machine Learning Model Interpretation](https://towardsdatascience.com/explainable-artificial-intelligence-part-3-hands-on-machine-learning-model-interpretation-e8ebe5afc608)
* [Partial Dependence Plots in R](https://journal.r-project.org/archive/2017/RJ-2017-016/)
* [Visualizing ML Models with LIME](http://uc-r.github.io/lime)

## Explainability- or Fairness-Enhancing Software Packages

### Browser

* [What-if Tool](https://pair-code.github.io/what-if-tool/index.html#about)

### Python

* [aequitas](https://github.com/dssg/aequitas)
* [AI Fairness 360](http://aif360.mybluemix.net)
* [anchor](https://github.com/marcotcr/anchor)
* [casme](https://github.com/kondiz/casme)
* [ContrastiveExplanation (Foil Trees)](https://github.com/MarcelRobeer/ContrastiveExplanation)
* [deeplift](https://github.com/kundajelab/deeplift)
* [deepvis](https://github.com/yosinski/deep-visualization-toolbox)
* [eli5](https://github.com/TeamHG-Memex/eli5)
* [fairml](https://github.com/adebayoj/fairml)
* [fairness](https://github.com/algofairness/fairness-comparison)
* [foolbox](https://github.com/bethgelab/foolbox)
* [Integrated-Gradients](https://github.com/ankurtaly/Integrated-Gradients)
* [lofo-importance](https://github.com/aerdem4/lofo-importance)
* [L2X](https://github.com/Jianbo-Lab/L2X)
* [lime](https://github.com/marcotcr/lime)
* [PDPbox](https://github.com/SauceCat/PDPbox)
* [pyBreakDown](https://github.com/MI2DataLab/pyBreakDown)
* [PyCEbox](https://github.com/AustinRochford/PyCEbox)
* [shap](https://github.com/slundberg/shap)
* [Skater](https://github.com/datascienceinc/Skater)
* [rationale](https://github.com/taolei87/rcnn/tree/master/code/rationale)
* [tensorfow/cleverhans](https://github.com/tensorflow/cleverhans)
* [tensorflow/lucid](https://github.com/tensorflow/lucid)
* [tensorflow/model-analysis](https://github.com/tensorflow/model-analysis)
* [tensorflow/privacy](https://github.com/tensorflow/privacy)
* [Themis](https://github.com/LASER-UMASS/Themis)
* [themis-ml](https://github.com/cosmicBboy/themis-ml)
* [treeinterpreter](https://github.com/andosa/treeinterpreter)
* [woe](https://github.com/boredbird/woe)
* [xai](https://github.com/EthicalML/xai)

### R

* [ALEPlot](https://cran.r-project.org/web/packages/ALEPlot/index.html)
* [breakDown](https://pbiecek.github.io/breakDown/index.html)
* [DALEX](https://github.com/pbiecek/DALEX)
* [ExplainPrediction](https://github.com/rmarko/ExplainPrediction)
* [featureImportance](https://github.com/giuseppec/featureImportance)
* [forestmodel](https://cran.r-project.org/web/packages/forestmodel/index.html)
* [fscaret](https://cran.r-project.org/web/packages/fscaret/)
* [ICEbox](https://cran.r-project.org/web/packages/ICEbox/index.html)
* [iml](https://github.com/christophM/iml)
* [lightgbmExplainer](https://github.com/lantanacamara/lightgbmExplainer)
* [lime](https://github.com/thomasp85/lime)
* [live](https://cran.r-project.org/web/packages/live/index.html)
* [mcr](https://github.com/aaronjfisher/mcr)
* [pdp](https://bgreenwell.github.io/pdp/index.html)
* [shapleyR](https://github.com/redichh/ShapleyR)
* [shapper](https://cran.r-project.org/web/packages/shapper/index.html)
* [smbinning](https://cran.r-project.org/web/packages/smbinning/index.html)
* [vip](https://github.com/koalaverse/vip)
* [xgboostExplainer](https://github.com/AppliedDataSciencePartners/xgboostExplainer)

## Free Books

* [Beyond Explainability: A Practical Guide to Managing Risk in Machine Learning Models](https://go.immuta.com/beyond-explainability-white-paper)
* [Fairness and Machine Learning](http://fairmlbook.org/)
* [Interpretable Machine Learning](https://christophm.github.io/interpretable-ml-book/)

## Other Interpretability and Fairness Resources and Lists

* [8 Principles of Responsible ML](https://ethical.institute/principles.html)
* [ACM FAT* 2019 Youtube Playlist](https://www.youtube.com/playlist?list=PLXA0IWa3BpHk7fE8IH6wXNEfAZyr3A5Yb)
* [An Introduction to Machine Learning Interpretability](https://pages.dataiku.com/oreilly-introduction-to-machine-learning-interpretability)
* [Awesome interpretable machine learning](https://github.com/lopusz/awesome-interpretable-machine-learning) ;)
* [Awesome machine learning operations](https://github.com/EthicalML/awesome-machine-learning-operations)
* [algoaware](https://www.algoaware.eu/)
* [criticalML](https://github.com/rockita/criticalML)
* [Fairness, Accountability, and Transparency in Machine Learning (FAT/ML) Scholarship](https://www.fatml.org/resources/relevant-scholarship)
* [Machine Learning Ethics References](https://github.com/radames/Machine-Learning-Ethics-References)
* [Machine Learning Interpretability Resources](https://github.com/h2oai/mli-resources)
* [MIT AI Ethics Reading Group](https://mitaiethics.github.io/)
* [private-ai-resources](https://github.com/OpenMined/private-ai-resources)
* [You Created A Machine Learning Application Now Make Sure It's Secure](https://www.oreilly.com/ideas/you-created-a-machine-learning-application-now-make-sure-its-secure)
* [XAI Resources](https://github.com/pbiecek/xai_resources)

## Review and General Papers

* [A Comparative Study of Fairness-Enhancing Interventions in Machine Learning](https://arxiv.org/pdf/1802.04422.pdf)
* [A Survey Of Methods For Explaining Black Box Models](https://arxiv.org/pdf/1802.01933.pdf)
* [A Marauder’s Map of Security and Privacy in Machine Learning](https://arxiv.org/pdf/1811.01134.pdf)
* [Challenges for Transparency](https://arxiv.org/pdf/1708.01870.pdf)
* [Explaining Explanations: An Approach to Evaluating Interpretability of Machine Learning](https://arxiv.org/pdf/1806.00069.pdf)
* [Explanation in Human-AI Systems: A Literature Meta-Review, Synopsis of Key Ideas and Publications, and Bibliography for Explainable AI](https://arxiv.org/abs/1902.01876v1)
* [On the Art and Science of Machine Learning Explanations](https://arxiv.org/pdf/1810.02909.pdf)
* [On the Responsibility of Technologists: A Prologue and Primer](https://algo-stats.info/2018/04/15/on-the-responsibility-of-technologists-a-prologue-and-primer/)
* [Please Stop Explaining Black Box Models for High-Stakes Decisions](https://arxiv.org/pdf/1811.10154.pdf)
* [The Mythos of Model Interpretability](https://arxiv.org/pdf/1606.03490.pdf)
* [The Promise and Peril of Human Evaluation for Model Interpretability](https://arxiv.org/pdf/1711.07414.pdf)
* [Towards A Rigorous Science of Interpretable Machine Learning](https://arxiv.org/pdf/1702.08608.pdf)
* [The Security of Machine Learning](https://people.eecs.berkeley.edu/~adj/publications/paper-files/SecML-MLJ2010.pdf)
* [Trends and Trajectories for Explainable, Accountable and Intelligible Systems: An HCI Research Agenda](https://dl.acm.org/citation.cfm?id=3174156)

## Teaching Resources

* [An Introduction to Data Ethics](https://www.scu.edu/ethics/focus-areas/technology-ethics/resources/an-introduction-to-data-ethics/)
* [Fairness in Machine Learning](https://fairmlclass.github.io/)
* [Human-Center Machine Learning](http://courses.mpi-sws.org/hcml-ws18/)
* [Practical Model Interpretability](https://github.com/jphall663/GWU_data_mining/blob/master/10_model_interpretability/10_model_interpretability.md)

## Interpretable ("Whitebox") or Fair Modeling Packages

### C/C++

* [Certifiably Optimal RulE ListS](https://github.com/nlarusstone/corels)

### Python

* [Bayesian Case Model](https://users.cs.duke.edu/~cynthia/code/BCM.zip)
* [Bayesian Ors-Of-Ands](https://github.com/wangtongada/BOA)
* [Bayesian Rule List (BRL)](https://users.cs.duke.edu/~cynthia/code/BRL_supplement_code.zip)
* [fair-classification](https://github.com/mbilalzafar/fair-classification)
* [Falling Rule List (FRL)](https://users.cs.duke.edu/~cynthia/code/falling_rule_list.zip)
* H2O-3
  * [Penalized Generalized Linear Models](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/modeling.html#h2ogeneralizedlinearestimator)
  * [Sparse Principal Components (GLRM)](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/modeling.html#h2ogeneralizedlowrankestimator)
* [Monotonic](http://xgboost.readthedocs.io/en/latest/tutorials/monotonic.html) [XGBoost](http://xgboost.readthedocs.io/en/latest/)
* [pyGAM](https://github.com/dswah/pyGAM)
* [Risk-SLIM](https://github.com/ustunb/risk-SLIM)
* Scikit-learn
  * [Decision Trees](http://scikit-learn.org/stable/modules/tree.html)
  * [Generalized Linear Models](http://scikit-learn.org/stable/modules/linear_model.html)
  * [Sparse Principal Components](http://scikit-learn.org/stable/modules/decomposition.html#sparse-principal-components-analysis-sparsepca-and-minibatchsparsepca)
* [sklearn-expertsys](https://github.com/tmadl/sklearn-expertsys)
* [skope-rules](https://github.com/scikit-learn-contrib/skope-rules)
* [Super-sparse Linear Integer models (SLIMs)](https://github.com/ustunb/slim-python)

### R

* [arules](https://cran.r-project.org/web/packages/arules/index.html)
* [Causal SVM](https://github.com/shangtai/githubcausalsvm)
* [elasticnet](https://cran.r-project.org/web/packages/elasticnet/index.html)
* [gam](https://cran.r-project.org/web/packages/gam/index.html)
* [glmnet](https://cran.r-project.org/web/packages/glmnet/index.html)
* H2O-3
  * [Penalized Generalized Linear Models](http://docs.h2o.ai/h2o/latest-stable/h2o-r/docs/reference/h2o.glm.html)
  * [Sparse Principal Components (GLRM)](http://docs.h2o.ai/h2o/latest-stable/h2o-r/docs/reference/h2o.glrm.html)
* [Monotonic](http://xgboost.readthedocs.io/en/latest/tutorials/monotonic.html) [XGBoost](http://xgboost.readthedocs.io/en/latest/)
* [quantreg](https://cran.r-project.org/web/packages/quantreg/index.html)
* [rpart](https://cran.r-project.org/web/packages/rpart/index.html)
* [RuleFit](http://statweb.stanford.edu/~jhf/R_RuleFit.html)
* [Scalable Bayesian Rule Lists (SBRL)](https://users.cs.duke.edu/~cynthia/code/sbrl_1.0.tar.gz)


text:
#
Game Grid

*
The game grid is a board mechanic which is designed to offer a large number of movable game pieces to be present at once, offering advantages when it comes to stragtegic placement, full range movement, and quick implementation and understanding.
*

---

## Description
The

## Advantages
A descriptive list of advanges this mechanics makes available for the game.
* Somtimes written as a bullet point list.
  * With footnotes.
* And more elements.

## Limitations
The descriptive list of limitations this mechanic imposes on the game.
* Also often written as a bullet point list.

## Implementation
How the game developer would implemente this feature into a board game.

## Conflictions
How does this mechanic play with others? Does this mechanic offer anything that would work well with other specific mechanics? Does this mechanic prevent any other mechanics from being implemented, or prevent them from utilizing their full potential?

---

## Authors Notes
An optional section in which the author can provide any additional details they wish to add.

If you want to spice up your game mechanic with some better formatting or even some example images, you can find a good overview of using markdown [here](https://guides.github.com/features/mastering-markdown/) and [here](https://help.smash.gg/en/articles/1987102-customizing-text-with-markdown).

repository: TheDudeFromCI/Meks

path: /Manual/Game Grid.md

filename: Game Grid.md

repo_name: TheDudeFromCI/Meks


text:
# expvar-pca

Extension of PCA class from `scikit-learn` to fit data according to target explained variance

## Installation

There is no installation for this package.

To use it, simply clone this repository by

```
git clone https://github.com/ddfabbro/expvar-pca.git
```

and add the root directory to your `PYTHONPATH` environment variable

```
export PYTHONPATH=$PYTHONPATH:$(pwd)/expvar-pca
```

Alternatively, you can drop the source code directory in your project and use it directly.

## Usage

Import `numpy` and `PCA`
```
import numpy as np
from expvarpca import PCA
```
Initialize PCA as you would normally do using `scikit-learn`
```
pca = PCA(whiten=True,svd_solver='randomized')
```
Initialize random data `X` and specify target explained variance `target_exp_var`
```
X = np.random.rand(64,27)
target_exp_var = .8
```
Fit the model with `X` according to target explained variance
```
pca.fit_exp_var(X,target_exp_var)
```
(optional) You can also specify search bounds for faster convergence
```
bounds = [10,20]
pca.fit_exp_var(X,target_exp_var,bounds)
```

repository: ddfabbro/expvar-pca

repo_name: ddfabbro/expvar-pca


text:
# Apache Kafka Producer/Consumer example for (Node.js)

## Getting started

Setup your free Apache Kafka instance here: https://www.cloudkarafka.com

Configuration

* `export CLOUDKARAFKA_BROKERS="host1:9094,host2:9094,host3:9094"`
  Hostnames can be found in the Details view in for your CloudKarafka instance.
* `export CLOUDKARAFKA_USERNAME="username"`
  Username can be found in the Details view in for your CloudKarafka instance.
* `export CLOUDKARAFKA_PASSWORD="password"`
  Password can be found in the Details view in for your CloudKarafka instance.
* `export CLOUDKARAFKA_TOPIC_PREFIX="<username>-"`
  Topic prefix should be the same as your username.

These export commands must be run in both of the terminal windows below.

```
git clone https://github.com/CloudKarafka/nodejs-kafka-example.git
cd nodejs-kafka-example
npm install
node consumer.js
```

Open another terminal window
```
# setup ENV variables for the new terminal window (from above)
cd nodejs-kafka-example
node consumer.js
```


text:
# Book contents

## Title
**_Python3 Object-oriented Programming 2nd Edition_**

## Author
**_Dusty Phillips_**

## Table of contents:
1. Object-oriented Design
2. Objects in Python
3. When Objects are Alike
4. Expecting the Unexpected
5. When to Use Object-oriented Programming
6. Python Data Structures
7. Python Object-oriented Shortcuts
8. Strings and Serialization
9. The Iterator Pattern
10. Python Design Patterns I
11. Python Design Patterns II
12. Testing Object-oriented Programs
13. Concurrency


text:
---
{
  "title": "CoinJoin Legal Concern",
  "description": "A legal analysis on the regulation of companies utilizing CoinJoin transactions. This is the Wasabi documentation, an archive of knowledge about the open-source, non-custodial and privacy-focused Bitcoin wallet for desktop."
}
---

# CoinJoin Legal Concern

[[toc]]

---

Using Bitcoin and other cryptocurrencies in the everyday course of businesses is becoming more and more popular.
Digital money has a lot of advantages, from unstoppable transactions to relatively low fees, and quick final settlement of international payments.
But all come at a price: the blockchain stores sensitive information like the amount and involved addresses of a transaction, giving away too much business-related information to the public.
However, this does not necessarily need to be the case.

## Overview

A CoinJoin transaction obfuscates the history of a given coin, making it hard to trace the coin back to the originator of the funds.
The implementation of Wasabi Wallet CoinJoin allows the original user to get back his funds with an obfuscated history.

It is often assumed that the main problem with an obfuscated transaction history is that financial regulators may have concerns about money laundering.
However, this is only the first impression, if we go into the details it can become more transparent why institutions should not worry about violating AML rules and why companies could have a direct competitive advantage using CoinJoin transactions.

With a transparent financial track record, companies paying with cryptocurrencies may find themselves in a squeezing situation, where their suppliers, clients, and competitors are aware of all of their payment steps and prices.
For institutional investors, each step would be scrutinized by the market causing intentional or unintentional price manipulation.

While the Bitcoin blockchain does not store personal information about the owners of the specific Bitcoin addresses, using metadata makes it possible to link Bitcoin addresses to certain companies and individuals.
If such a link can be established, all past and future transactions can be traced.

## CoinJoin transactions

### Difference between ordinary banking and blockchain

The ordinary banking system is closed, a very non-transparent system, where the data inside this system is hidden from outside observers.
“Only” the bank and the user know the transactions made inside the system.
In opposition, the blockchain is transparent and open to everyone.
This means not only the “bank” (custodial service provider) but also outsider 3rd party observers are capable of tracking these transactions.

### Service providers' obligations regarding privacy

There is no question a service provider who keeps a record of personal information needs to deal with the different privacy regulations and act according to them.
In the ordinary banking system personal financial information is handled as a secret thus preserving individual privacy from third parties.
Whereas in the open blockchain system this information by the nature of the technology cannot be kept secret, so there is a large risk of a privacy leak of sensitive financial information.
This is obviously not intentional and even though the personal information might be protected, the financial information is nevertheless leaked due to the pseudonym nature of the system.
This information has similar sensitivity as name, address, gender, etc. so it should be handled with great care.

### CoinJoin as a privacy-preserving tool

Since the Bitcoin blockchain is transparent, transactions cannot be kept secret.
Currently, one prevalent solution in Bitcoin to gain privacy is to CoinJoin the different coins to obfuscate their history.
By the use of this tool, a custodial service provider can at least start to protect its users' financial privacy.

## Privacy perspective from the companies' point of view

The essence of competitive advantages is to keep and hold business secrets.
Each and every successful company has developed its own mechanism to deliver the best products and services to its customers.
To reach this, they usually use a secret sauce, called the business secret to deliver the results.
If anything, when a financial payment becomes fully transparent this business secret is evaporating
Let’s look a bit deeper into what exactly this means for companies, who would like to use Bitcoin as the payment method, where all transactions are recorded on the blockchain.

### Suppliers

Companies use suppliers to acquire products and services they use in their own production stages.
For these products and services, of course, they pay a reasonable price.
However, this price is usually negotiable, especially in B2B relationships or large scale orders.
What would happen if all of a sudden, the price of raw materials for a company becomes fully public?
Other competitors can now demand similar discounts, forcing industries into a vicious cycle of price reduction.
As each and every price discount is negotiated on a case by case basis, considering factors as creditworthiness and timing of payment, transparent supplier prices would only cause enormous pressure on suppliers to deal with negotiations.

Beyond the price of products, the timing of payments is also fully transparent on the blockchain.
However, in certain circumstances, it is also a crucial business secret to keep the information on the sequence of invoice payments indoors.
Considering cash flow implications, it can happen that one invoice is paid on time, while other invoices are still pending payment.
In the case of blockchain transactions however all payments are transparent, so it can be clear for each counterparty that only a selected number of invoices has been paid even if the sufficient funds are available which can cause unnecessary tension between business partners.

Additionally, if all historical transactions of a company are known, its creditworthiness might be considered incorrectly.
It can happen that the creditworthiness is considered better than it is if the incoming funds to a specific address are extraordinarily high, but these funds are needed in other parts of the business, so the overall solvency of the business can be still negative despite the large funds.
On the other hand, creditworthiness can be considered worse than it actually is, if only a handful of addresses are taken into consideration for the solvency analysis, neglecting other forms of wealth, like other Bitcoin addresses, or fiat accounts.

### Clients

From the client’s perspective, the factors listed under suppliers are all applicable.
If a client knows the revenue stream of the company, they can draw an incorrect conclusion about the actual financial situation of a company and make a decision of purchasing a product based on this assumed financial situation.
If for example, there are no incoming funds for a given period, clients may stay away from purchasing products and services, solely because they might consider the company dormant or insolvent.
But in reality, the seasonality of incoming funds is not disclosed for all companies, so it can be a  perfectly stable business situation to receive incoming funds only in a given period of a year, while still being able to deliver service throughout the year.

Another aspect is the possible price negotiations on the client-side.
If a client finds out that another client is paying less for a service or product, they can demand similar discounts which can result in downward price pressure in the industry.
This can ultimately result in companies going out of businesses if they cannot adjust to the lower price levels which are below the equilibrium prices.

### Competitors

Everyone can agree that the pricing structure of services is a very sensitive topic and is the core of the business secret which makes a company successful.
If all competitors can look at the transactions of the company, it also means they can adjust their own pricing structure to follow the successful market leaders in the industry, causing turbulence in competition.
Each company has its own pricing structure which should be coming from the internal processes, know-how, and resources.
Although external factors should be considered in pricing, they should not be the main driving force in pricing decisions.

### Employees

There is now a growing number of companies that are paying their employees salaries in bitcoin due to the trustless transactions with relatively low fees, especially with international transactions.

With transparent transaction history, employees would be aware of each other’s salaries without the company disclosing this information.
Although there are some theories supporting a transparent salary structure, up to now the majority of the companies prefer to keep salaries as secret and obligate employees to keep salary and wage information confidential.
Obfuscated transaction history can help companies to keep salary information confidential which can keep a relaxed atmosphere among employees with no wage pressures.

### Phishing attacks

Disclosing financial information for a company makes them more vulnerable to phishing attacks.
If the exact time and amount of payment are publicly known, attackers can use this information to build trust with the company and squeeze out other crucial business information pretending to be a trusted partner.

## Privacy perspective from the institutional investor’s point of view

The Bitcoin market is considered [fairly concentrated](https://bitinfocharts.com/top-100-richest-bitcoin-addresses.html) in the sense that out of the millions of Bitcoin addresses, less than 1% holds 87% of bitcoins.

![Bitcoin address distribution](/AddressDistribution.png "Bitcoin address distribution")

Institutional investors and cryptocurrency exchanges are holding large sums of bitcoin on a blockchain where transactions are completely transparent.
These so-called whales sometimes need to move large amounts of coins for any reason which can often lead to unintentional price manipulation.
If a large bitcoin holding is on the move, it can always raise concern in the media regarding the future of Bitcoin, causing unnecessary price fluctuations.
In the case of unintentional price manipulation, it is difficult to prove there has been no insider trading on the institutional side, which can cause loss of faith from the clients.

Using obfuscated transaction history in large bitcoin transactions can help to keep the market stable and avoid unintentional price manipulations.

## Resolving AML conflicts

Privacy is not just for criminals.
One of the major critiques against using CoinJoin is that if the transaction history is not known for a company, it may be used as a way to launder money.
From the above-listed cases, we already see that currently using fiat payments, during the normal course of businesses, companies do not disclose all financial information as that would result in a loss of business secrets.
Why would they need to do this if they are just using a new method of payment, called Bitcoin?
Using privacy tools to obfuscate Bitcoin transactions is completely legal and in accordance with the current legal framework.

### User privacy

In all jurisdictions, there are different laws and acts that are made to protect customers privacy.
This is not limited only to personal data but also financial data.
In the EU there is GDPR, in the USA there is the Privacy Act of 1974, in Canada, there is the Privacy Act of 1985, etc.
These set different rules to be kept in order to preserve individual privacy both on personal and financial levels.

### KYC/AML

By now in mainly all jurisdictions, custodial cryptocurrency service providers (wallet, exchange, payment processor, etc.) are requested to run KYC/AML checks on users and their transactions.
The KYC process and inner policies should ensure personal data protection.
The accounts are assigned to these individual users, who are verified by the provider.
This means the provider identifies the user just like a legacy bank would do.
The different AML checks are run on deposits or withdrawals.
The suspicious transactions can be linked to users based on the transactions that are initiated by them personally.
KYC and AML procedures now ensure that all transactions involving fiat (like buying and selling bitcoin on exchanges for fiat currency) have a detailed background in terms of who is sending what money to whom, the identification of transactions are even more strict than in the current banking world, where two companies or individuals can send even large funds without the need to verify their source.

### Using CoinJoin as a custodial service provider

As soon as a user deposits the funds to any of these service providers, the funds are in one large cluster.
From now on the funds are possessed by the service provider and the actual user balances are only kept on internal records.
At this point all KYC/AML procedures are done, funds should be considered “clean”.
The funds are controlled by the service provider and different policies are set for securing these funds (hot and cold storage, multisig, etc.).
The record system of the provider will show the exact value of funds belonging to the different users.
This is the time when a provider could preserve its users’ privacy by applying CoinJoin on these funds.
In case of a withdrawal, coinjoined UTXOs could be sent to the user.
Again, this user is already KYC-ed, the provider has full knowledge about the user.
In case of a law enforcement request, all data can be provided, since the deposit history of the user in question is still available.
The only thing CoinJoin does, in this case, is protecting the user from third-party observers, while the service provider is still enabled to provide data for law enforcement if requested.

### FinCEN guidance on legal framework

The Financial Crimes Enforcement Network (FinCEN) is a bureau of the United States Department of the Treasury that collects and analyzes information about financial transactions.
It is claimed that its job is to combat domestic and international money laundering, terrorist financing, and other financial crimes.
Its latest regulation regarding cryptocurrencies is in effect since May 2019.
The regulation places money transmitting in the center of the discussion.
Money transmitters must develop a certain process in terms of reporting and monitoring to help combat money laundering and terrorist financing.
FinCEN guidance explicitly states that those persons and businesses who provide the delivery, communication, or network access services used by a money transmitter to support money transmission services are NOT considered money transmitters.
Furthermore, in section 4.5 anonymity-enhanced cryptocurrency transactions are detailed and concluded that they are subject to the same AML and KYC regulations as any other transactions.
This means in an investigation even the obfuscated transaction history can be given out to authorities upon request if it is needed for a procedure, so it can be concluded that using CoinJoin transactions will not help money-laundering.
The KYC-ed participant’s data and pre-obfuscated transaction history can be given away to the authorities.

## Conclusion

Companies using Bitcoin as a method of payment currently do not have sufficient privacy regarding their financial information.
Outsiders can get valuable business-related information by studying the public transaction history of a company, causing economic damage in the long run.
Using CoinJoin transactions can help businesses to keep their privacy while still enjoying the benefits that Bitcoin transactions can provide.
Concerns from the AML perspective are not valid, as the necessary data can be provided to authorities upon investigation requests.

repository: zkSNACKs/WasabiDoc

repo_name: zkSNACKs/WasabiDoc


text:
# Final Project
## Rambam classifier

A research project deteined to create general classifier that can calssify Shutim to Halachot from the Rambam.
For more information, see דו"ח סופי.pdf

## Dependencies
* argparse==v.1.1
* sklearn==v.0.20.1
* numpy==v.1.15.4

## User guide
To use the program first put the train and test set in their respective folder. you can also specify the location for the train and test set as well as the folder the program will use when building the set for the classifier. The program then build the sets, train and test the set for the optimal parameters. To load a pipe put the pipe in the main folder and use the appropriate flag. For more information, see ספר משתמש.pdf

### Additional flags
Flag | Default | Choices | Description
--- | --- | --- | ---
--train_path | ./data/train_data/ | - | Set the path to the data that the classifier will use for training.
--test_path | ./data/test_data/ | - | Set the path to the data that the classifier will be tested on.
--set_path | ./data_set/ | - | Set the path that the program will use to storeage the data set. NOTE: will be deleted when finished.
--no_shuffle | FALSE | TRUE, FALSE | The train sets Will NOT be shuffled. NOTE:if divided train to train-test it's best to use shuffle.
--train_ratio | 1.0 | 1.0 to 0.5 | set the ratio for the train-test divider. NOTE: putting 1 will send all the files to the train set.
--test_amount | 20 | any | set the amount for the test-train divider. NOTE: putting 0 will send all the files to the test set.
--only_rambam | FALSE | TRUE, FALSE | will use only the rambam for the train set.
--test_sorter | fit | full, amount, rambam | set the test-train divider.
--test_source | rambam | rambam, ben, kizur, tur | set the source for the test.
--classification | LinearSVC | LinearSVC, SVC | The type of classification that will be use. The classification can be LinearSVC or SVC.
--pipe | fit | fit, load, search | Set the operation to set the pipe. fit - Fit a pipe with the recommenet value. load - Load a pickled pipe the pickle should be named 'pipe.pickle' and put in the main folder. search - Search for the best values for the train data.
--show_results | FALSE | TRUE, FALSE | Show all the result of the search for the best arguments for the pipe. NOTE: used with search option.
--save_pipe | FALSE | TRUE, FALSE | Save the fitted pipe. NOTE: used with search option.
--print_report | FALSE | TRUE, FALSE | Print the classification report.

## Sources
* Rambam               - https://www.mechon-mamre.org/i/0.htm
* Chinuch              - http://www.daat.ac.il/daat/mitsvot/sefer.asp?sefer=1
* Noda_Biyhudah        - https://www.sefaria.org.il/Noda_BiYhudah_I?lang=he
* Ben-Ish Hai          - http://www.daat.ac.il/daat/vl/tohen.asp?id=771
* Kizur Shulchan Aruch - http://www.daat.ac.il/daat/vl/tohen.asp?id=670
* Tur                  - http://www.daat.ac.il/daat/vl/tohen.asp?id=770


text:
##Spray and Wait Simulation
###Description:
This simulation implements the Spray and Wait Routing Protocol.  Protocol Description:

* Randomly selected source node selects a random node to send message to
* Source node hands out L copies of the message to relay nodes it encounters
* Source will deliver the message directly if it encounters the destination node
* Relay nodes will hang on to message until they encounter the destinatioin node
* Destination node will send an ack to notify source if it find source directly
* If destination node recieves message from a relay, it will use spray and wait to send the ack back to the original source
* Each test ends when the source hears an acknowledgement from either the relay or the destination node

###Setting up and Compiling:

The C source code uses four macros for easy tweaking of the configuration simulation variables:

* **SIZE_MAX 50** - Maximum size allowed for number of nodes and length and width of simulation grid (if using gdb for debugging it will throw an error if this set too large, this is due to Gdb memory stack limits.)
* **HELLO_WAIT 3** - The timer interval used by nodes in how long to wait before sending a hello "I am here" message.
* **START_TIME 40** - How long for source to wait before it starts spraying, used to ensure system is in stable state before test begins.
* **ACK_WAIT 10** - How long nodes wait to send a buffered message.
* **SEEN_TIME_MAX 50** - Max counter value for how long its been since a node has seen a specific node. Set to zero everytime it sees it.

To compile simply run the makefile:

**make** - Use this command for compilation

**make clean** - For cleaning up object and executable files

###Testing:

To run the simulation use the following command line arguments:
(I didn't test very many combinations of these arguements, there may be edge case errors that exist through weird combinations)

**./sim00 "RANGE"   "# of Trials"   "# of Copies"   "# of Nodes"   "Grid Length"**

1. **Range** - How far can nodes hear and send?  Accepts a range of 1 or more
2. **Number of Trials** - 1 or greater
3. **Copies** - Number of copies for source to spray, no more than number of nodes minus source
4. **Number of nodes** - 1 or more
5. __"*Length*" of Testing Grid__ - 2 or more (Won't accept nodes greater than what the area of the grid)

###Code Structure:

* Five arguments are read in from command line
* Initialization:
 * Source node is randomlly selected
 * The destination node is randomly selected
 * The hello timer is randomly initalized
* The outermost loop tracks each test run through
* A timing loop tracks time by iterations of that loop
* Grid movement
 * Nodes move in random selected directions for each iteration
 * The movement on the grid allows for multiple nodes to be in the same grid position
* Nodes use carrier sense:
 * Nodes scan an area sourrounding its location on the grid with a radius equal to the range parameter
 * They won't hear anything if there is a collision
 * Nodes won't talk if the medium is busy
* Spraying:
 * After time interval reaches the designated start time the source will begin spraying
 * The source node will change its routine hello message to a delivery message
* The Spray message contains:
 * the ID of the final destination node
 * the number of copies the source has left to give
 * Nodes will ignore the message if they are not the destination node and if there are no copies left

###Output:

* The outcome tracking:
 * How the Destination node heard the original message
 * How the Source heard back from the Destination node
* A grid depicting the locations of the nodes
 * A node's location is shown by its ID
 * Nodes will not be displayed if they are stacked on the same space as another node
* Number of Hops
 * Number of Hops for Destination to recieve message
 * Number of Hops for Source to hear back
* Average Timing Iterations:
 * Iterations for the destination to hear the message
 * Iterations for the source to hear back

###Assumptions and Simplifications:

* If the source does not hear an ack from a relay that took a copy, it will retain the same number of copies.  The relay waits for no ack reponse from the source
* There is no expiration timer for waiting to get an ack
* Nodes that carry a message send it in one simple hello, there is no handshake before sending messages.

###To do:

* There seems to be a random seeding issue where results between tests in one batch are the same while batches differ between eachother
* I did not have time to implement simulated traffic, where every node starts a test with a random chance to send a message and random start time for doing that
* The nodes use a message buffer for storing messages if the medium is very busy, an expiration timer eradicates messages when it times out.  Perhaps this should have been better used for waiting for ack replies.

repository: raveious/delay-tolerant-network

repo_name: raveious/delay-tolerant-network


text:
---
title: Authentication & Authorisation
keywords: spine, security
tags: [integration]
sidebar: overview_sidebar
permalink: integration_authentication_authorisation.html
summary: "Authentication and Authorisation"
---

## Authentication and Authorisation ##

### Introduction ###

Access to the NRLS will not be without restriction. The [security](development_api_security_guidance.html) section outlines the need for any client to be able to take part in a mutual authentication session at the transport layer. This will protect traffic flowing between client and server and to some extent gives the NRLS server confidence in the identity of the client system. However, this transport layer security does not address authorisation. Additionally the level of granularity in terms of establishing identity stops at the system level.

<!--
Authentication of a user and subsequent Authorisation of that identified user are important aspects of system security and the NRLS is tackling these aspects with a tactical approach and a longer term strategic approach. -->

### Authentication ###

<!--
#### Tactical ####

The NRLS' preference is any client (Consumer or Provider) interacting with the API has had their identity established by a national identity provider. At the moment NHS Digital's identity provider platform is the Care Identify Service which is based around smartcards.

The NRLS project understands that for some clients the use of smartcards may not be practical. This is why the use of smartcards to establish a national identity is stated as a preference. Where a client is unable to provide a national identity then that client's individual circumstances will be considered and it may be possible to allow that client to connect without a national identity however this would be on the understanding that over time they commit to align with the NRLS' strategic plans for authentication.

#### Strategic ####
-->

The NRLS is aligning itself with the Care Access Service which will become NHS Digital's national Authentication and Authorisation service. As well as providing support for existing smartcard-based mechanisms CAS will provide an array of other authentication types. Clients will need to integrate with CAS to access the NRLS.

### Authorisation ###

<!--
#### Tactical ####
-->

The NRLS uses the well established ASID + interactionId approach to control access to the API. Each RESTful endpoint is associated with a unique interactionId. Each system that is accredited by NHS Digital as being a Consumer or Provider will have a set of interactions that they have been authorised to perform. These interactions are mapped to interactionIds. Each ASID is associated with a set of interactionIds. It is this combination of interactionIds that govern what RESTful endpoints a particular system can interact with.

<!--
#### Strategic ####

As well as providing an authentication service, CAS also provides an authorisation service. Longer term the NRLS is looking into making use of this capability. However, no decision has been taken as of yet and for now the ASID + interactionId mechanism will be used. -->


text:
---
title: Stuff that I plan to write about in 2023 and beyond
date: 2023-02-27 11:00:00 +1000
categories: [Writing]
tags: []     # TAG names should always be lowercase
---
## The Idea
It is often said that the first step is always the hardest - and my blog endeavour confirms that. I've created a place to share my thoughts in November 2022 with a plan to post regularly. Deciding on a platform (substack vs. medium vs. own site) and potential blog post ideas were the easy part. But publishing the actual content is the challenging bit. My internal perfectionist says that whatever I create is not yet fit for publishing and I need to spend few more days on another draft.

This post is an experiment that could help me break this vicious cycle. The rules are simple:
- Start small & easy - Listing ideas and areas of my expertise is relatively easier than going deep into a selected topic.
- Accountability - Thanks to listing topics I immediately feel pushed to turn them into actual blog posts. If I share my goals with my audience I have a higher chance to keep my promise.
- It's an experiment - By calling it an experiment I'm not scared of failure. It can either jump-start my blogging habit or become a learning opportunity that will fuel the next experiment.

Enough theory, let's move to the essence of this post. I've grouped my ideas into themes that I plan to expand whenever new ideas come up. I encourage you to leave a comment if you would like me to focus on a particular topic first.

## Growth - How I keep to self-improve
- Feedback - A powerful tool for self-improvement. How to ask for it, receive it and give it.
- My sources of knowledge - List of places of my inspiration and growth, newsletters, blogs, books, podcasts, etc.
- Making time for professional growth as a fresh father - My journey on making space for reading, writing, and expanding my expertise while sustaining (most of the time) work-life balance

## Hiring - Distilling my 2-year journey of owning the overall hiring process in a digital agency
- Building a scorecard - How to describe the role
- Candidate Packet - A set of materials that will help convince people to join your team
- Running interviews
- Building onboarding experience - How as a team we've managed to create a unified onboarding experience and gradually improve it

## Productivity
- Owning your calendar
- My focus rituals & how I fight distractions
- Separation of work and personal life
- How I managed 50 people and not went crazy
- Small steps are key to completing big projects

## Management & Leadership
- Running 1 on 1's
- Coaching, mentoring, sponsorship
- How to run effective meetings
- Lessons learned from change management


text:
# Music Server
The collaborative music queue

With *Music Server* you can host a single Node server and stream music to multiple devices at once,
each being able to control music or add to the queue - syncing across all other clients.

## Technology
#### Server
A [NodeJS](https://nodejs.org/en/) backend for hosting an API and websocket connection,
which also downloads music that can be streamed to the clients.

Music is not streamed over a websocket, but rather using a HTML `<audio>` element for simplification.

#### Client
A website hosted by the server, using a websocket to keep up-to-date with the queue and current song
state (*e.g. paused, seek position*).

## Requirements
 - [NodeJS](https://nodejs.org/en/)

## License
This project uses the [MIT](./LICENSE) license

## Credits
Built using
 - [NodeJS](https://nodejs.org/)
 - [Simple Websocket](https://github.com/feross/simple-websocket)
 - [FFMPEG](https://www.ffmpeg.org/)\*
 - [YouTube MP3 Downloader](https://github.com/ytb2mp3/youtube-mp3-downloader)\*

\* via `npm` packages

repository: lcomstive/MusicServer

repo_name: lcomstive/MusicServer


text:
[![Build Status](https://travis-ci.org/jbn/banner_comment.svg?branch=master)](https://travis-ci.org/jbn/banner_comment)
[![Coverage Status](https://coveralls.io/repos/github/jbn/banner_comment/badge.svg?branch=master)](https://coveralls.io/github/jbn/banner_comment?branch=master)
<!-- LOL: Coverage on a one function module -->

# What is this?

I like banner comments in my code. Modern IDE's have fancier ways of doing this like code collapsing and such. And, Python style guides generally prohibit this style of commenting. But, I like to see the big test while scrolling (or, in [`subl`](https://www.sublimetext.com/)).

# Example

Running this:

```python
from banner_comment import *
banner_comment("hello")
```

Prints:

```
###############################################################################
#                             _          _ _                                  #
#                            | |__   ___| | | ___                             #
#                            | '_ \ / _ \ | |/ _ \                            #
#                            | | | |  __/ | | (_) |                           #
#                            |_| |_|\___|_|_|\___/                            #
#                                                                             #
###############################################################################
```

The package also installs a command line entry point, allowing:

```bash
banner_comment "hello"
```

# Installation

This (one function) package just wraps [figlet](http://www.figlet.org/). You need to install figlet first. It exists on lots of package managers. E.g.

```sh
brew install figlet    # for OSX
apt-get install figlet # for ubuntu
```

After installing figlet, do
```sh
pip install banner_comment
```


text:
# gitignore

The `.gitignore` file allows you to include file to it that you do not want to commit to the Github repository.

## Useful files to include in the `.gitingore`

```
.env # environment variables
node_modules/ # application packages can be re-install using `npm install` so no need to include them to the repository
```

repository: alexpaul/JavaScript

repo_name: alexpaul/JavaScript


text:
# NoSleepRun

Simple console utility to prevent Windows from sleeping while running a process

## Usage

    nosleeprun [OPTIONS] process [args]

## Options

* **--silent**: silent output, do not print anything
* **-s|--shellexecute**: use ShellExecute
* **-u|--username <username>**: execute as <username>
* **-p|--password <password>**: use <password>
* **-64|--64bit**: disable syswow64 redirection

## Remarks:
 - Username and Password cannot be used in conjunction with ShellExecute. This is a Windows restriction.
 - Use the -64 switch only if you need to run a 64 bit process which needs access to 64 bit Windows system libraries.
  - This option is only available if the binary is compiled as AnyCPU and executed on a 64bit system

Report bugs to <jcl@javiercampos.info>

repository: javiercampos/NoSleepRun

repo_name: javiercampos/NoSleepRun


text:
## HingeJointParameters

Derived from [JointParameters](jointparameters.md).

```
HingeJointParameters {
  SFVec3f anchor                    0 0 0   # any vector
  SFVec3f axis                      1 0 0   # unit axis
  SFFloat suspensionSpringConstant  0       # [0, inf)
  SFFloat suspensionDampingConstant 0       # [0, inf)
  SFVec3f suspensionAxis            1 0 0   # unit axis
  SFFloat stopERP                   -1      # -1 or [0, inf)
  SFFloat stopCFM                   -1      # -1 or (0, inf)
}
```

### Description

The [HingeJointParameters](#hingejointparameters) node can be used to specify the hinge rotation axis and various joint parameters (e.g., angular position, stop angles, spring and damping constants etc.) related to this rotation axis.

### Field Summary

- `anchor`: This field specifies the anchor position, i.e. a point through which the hinge axis passes.
Together with the `axis` field inherited from the [JointParameters](jointparameters.md) node, the `anchor` field determines the hinge rotation axis in a unique way.
It is expressed in relative coordinates with respect to the closest upper [Pose](pose.md) node's frame.

- `suspensionSpringConstant`: This field specifies the suspension spring constant along the suspension axis.

- `suspensionDampingConstant`: This field specifies the suspension damping constant along the suspension axis.

- `suspensionAxis`: This field specifies the direction of the suspension axis.

- `stopERP`: This field specifies the local `ERP` used by joint limits. By default it imposes the global `ERP` (value -1) but can be different from it.

- `stopCFM`: This field specifies the local `CFM` used by joint limits. By default it imposes the global `CFM` (value -1) but can be different from it.

The `suspensionSpringConstant` and `suspensionDampingConstant` fields can be used to add a linear spring and/or damping behavior *along* the axis defined in `suspensionAxis`.
These fields are described in more detail in [JointParameters](jointparameters.md)'s ["Springs and Dampers"](jointparameters.md#springs-and-dampers) section.

repository: cyberbotics/webots

repo_name: cyberbotics/webots


text:
---
layout: default
---

# 1994-09-15 - Re: Running PGP on Netcom (and Similar)

## Header Data

From: Phil Karn<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 23351de5f1d9bd434ae9f308dc713636bacd7c3ce4a42746d53cec2db84b2058

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1994-09-15 18:39:29 UTC

Raw Date: Thu, 15 Sep 94 11:39:29 PDT

## Raw message

```
{% raw  %}From: Phil Karn<EMAIL_ADDRESS>Date: Thu, 15 Sep 94 11:39:29 PDT
To<EMAIL_ADDRESS>Subject: Re: Running PGP on Netcom (and Similar)
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

This discussion is ridiculous. If you can crunch keys on your own
trusted machine, why not just run PGP there? Or at least the RSA
secret key operations?

I've been saying for a long time that there is a role for the latter
device.  It would hold your PGP secret key and do all RSA secret key
operations (signing, decryption) locally, taking requests from and
communicating the results back to hosts running PGP that do the rest:
RSA public key operations such as signature verification and
encryption, and IDEA encryption/decryption.

Ideally this device would be a smart card, but a small palmtop might
make a good prototype (except for speed). The big win is in much
better protection of the RSA secret key; it would never have to leave
the device, except perhaps in encrypted form for backup.

By plugging this device into a (possibly hacked) host you could use
your RSA key without risking all of the traffic you have ever
protected or will protect with a particular RSA secret key if that
particular host happens to be compromised.

But any traffic that passed through the hacked host would still be
compromised, as it would if the link between the secret key device and
the host were tapped.  There's simply nothing you can do about it.

Phil

{% endraw %}
```

## Thread

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

+ Return to "[Adam Shostack <adam@bwh.harvard.edu>](/authors/adam_shostack_adam_at_bwh_harvard_edu_)"
+ Return to "[Alex de Joode <usura@xs4all.nl>](/authors/alex_de_joode_usura_at_xs4all_nl_)"
+ Return to "[Andrew Brown <a.brown@nexor.co.uk>](/authors/andrew_brown_a_brown_at_nexor_co_uk_)"
+ Return to "[Phil Karn <karn@unix.ka9q.ampr.org>](/authors/phil_karn_karn_at_unix_ka9q_ampr_org_)"
+ Return to<EMAIL_ADDRESS>(Timothy C. May)](/authors/tcmay_at_netcom_com_timothy_c_may_)"

+ 1994-09-12 (Mon, 12 Sep 94 03:58:11 PDT) - [Re: Running PGP on Netcom (and Similar)](/archive/1994/09/e6edef2b770c8e21482a8d2ae2e9203294a3ca0b581cab992549843d0a65f2ae) - _Alex de Joode<EMAIL_ADDRESS>  + 1994-09-12 (Mon, 12 Sep 94 08:55:58 PDT) - [Re: Running PGP on Netcom (and Similar)](/archive/1994/09/f14411345f6aea22dcdfc28f46a054c99d495bc0b1b1b87c6b547c624feb9eb2) - _Adam Shostack<EMAIL_ADDRESS>    + 1994-09-14 (Wed, 14 Sep 94 04:30:01 PDT) - [Re: Running PGP on Netcom (and Similar)](/archive/1994/09/bb23defb2d526c6dd3b99c1c52ea052ffd0537804b7e66ca3f4cd00c543d63ee) - _Andrew Brown<EMAIL_ADDRESS>      + 1994-09-14 (Wed, 14 Sep 94 08:44:27 PDT) - [Re: Running PGP on Netcom (and Similar)](/archive/1994/09/4d28c3968e5763603cd2b2075f59bd029eb5d32ea48baf37ba590c828a2a8b89) - _Adam Shostack<EMAIL_ADDRESS>        + 1994-09-15 (Thu, 15 Sep 94 11:39:29 PDT) - Re: Running PGP on Netcom (and Similar) - _Phil Karn<EMAIL_ADDRESS>  + 1994-09-12 (Mon, 12 Sep 94 10:43:21 PDT) - [Re: Running PGP on Netcom (and Similar)](/archive/1994/09/6660a995adfaa967949b5f23ee97fd96cf50a38358c575fffe526d96cc3fecc7) -<EMAIL_ADDRESS>(Timothy C. May)_


text:
#sinaWeibo

Crawl Weibo user and their tweets, and store in Mysql.
**Maybe Sina has modified the dom setting or ajax of their website, so my code may not work. But it's still can be a helpful demo**

## Usage
* Build Mysql database and tables, execute sina_weibo.sql. Insert a line in table `user`, the id is short id (length=10) of Weibo. This is the root of breadth-first search.
* Fill your cookies in cookies.txt.
* Modify userCrawler.py, including Mysql config and MY_UID.
* Runing userCrawler.py for 3~4 times. Each time is one level deeper of breadth-first search.

The weiboCrawler.py can be used in almost the same way as userCrawler.py. It will crawl tweets of users in table `user`.

## Acknowledge
Based on work of https://github.com/chyanju/wCrawler, Thanks Yanju Chen.

repository: IamJYC/sinaWeibo

repo_name: IamJYC/sinaWeibo


text:
## dfdaemon gen-ca

generate CA files, including ca.key and ca.crt

### Synopsis

generate CA files, including ca.key and ca.crt

```
dfdaemon gen-ca [flags]
```

### Options

```
      --cert-output string         destination path of generated ca.crt file (default "/tmp/ca.crt")
      --common-name string         subject common name of the certificate, if not specified, the hostname will be used
      --expire-duration duration   expire duration of the certificate (default 87600h0m0s)
  -h, --help                       help for gen-ca
      --key-output string          destination path of generated ca.key file (default "/tmp/ca.key")
      --overwrite                  whether to overwrite the existing CA files
```

### SEE ALSO

* [dfdaemon](dfdaemon.md)	 - The dfdaemon is a proxy that intercepts image download requests.

gha_language: Go


text:
Ti=European Union

Note=The EU is a jurisdiction, but also different than a national jurisdiction.  Should it be classified at the same level, in the same way as a national jurisdiction?

One could reuse the /00 | BE | NL / notion within the EU - as if the Member States were subjurisdictions.  Which in a sense they are, but they are also independent jurisdictions and already present in the folder system.

A somewhat different question arises with respect to the various languages.  Many EU documents are formally and carefully translated into a variety of languages.  We should use the same language codes, of course.

So, as a first approximation, we will use /EU/00/NL/ for EU documents in Dutch.  We leave open the issue of EU documents that might be both translated and adapted for a particular jurisdiction.  They could be /EU/BE/NL/ for a Dutch language doc adapted to use in Belgium.  But could also be in /BE/00/NL/.

Now for some substance:

The EU is said to be ground zero for multi-lingual legal.  The same laws, translated into a few dozen languages.

The EU IP Helpdesk has many suggested form documents, notably for use in connection with EU contracts.  They include a Mutual NDA and a One-Way NDA. http://www.iprhelpdesk.eu/node/1107 (Mutual) and http://www.iprhelpdesk.eu/node/1106 (One-Way).   The Mutual NDA is in rough Prose Object form in English and French at http://www.commonaccord.org/index.php?action=list&file=G/EU-IP-HelpDesk/NDA/Mutual/

repository: CommonAccord/Cmacc-Org

gha_language: CSS

repo_name: CommonAccord/Cmacc-Org


text:
---
layout: default
---

# 1994-04-02 - InVisible Basic 1.0

## Header Data

From: Blanc Weber<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 68825a1dc001107009bd18a1acc23dc7f23cd8d5d7f8c0f6ac463c6f4f93723f

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-04-02 01:20:22 UTC

Raw Date: Fri, 1 Apr 94 17:20:22 PST

## Raw message

```
{% raw  %}From: Blanc Weber<EMAIL_ADDRESS>Date: Fri, 1 Apr 94 17:20:22 PST
To<EMAIL_ADDRESS>Subject: InVisible Basic 1.0
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

<Sender composed mail containing characters not in the US-ASCII set.>
<These characters have been transformed into a printable form.>

FYI.   I am not making this up.  I can only imagine how this will =

impact society.   ~ Blanc
-------------------------------------------------
Microsoft Announces InVisible Basic 1.0

Using the slogan "Not Seeing Is Believing," Microsoft Corporation today =

is announcing InVisible Basic 1.0, a completely new use of "stealth" =

technology in an object-oriented development environment.

"We're taking code transparency to new heights," enthused Product =

Manager C. R. as she began an impressive product demo. After just five =

minutes of moving a mouse around what appeared to be a blank screen, =

selecting unseen menu items, placing indiscernible controls on =

inevident forms, and typing in unapparent code, the alleged application =

was able to access an undisclosed database, perform a series of =

unspecified queries and display whatever data it supposedly encountered =

in a completely undetectable format.

The only evidence that the application existed at all was the use of =

disk space and CPU cycles. "And we're working on that for version 2.0," =

C. R. said.

"The applications are obvious," said "Jim," a developer with "General =

Enterprises," a defense-industry supplier that lists its address as a =

P.O. Box somewhere near Bakersfield, Calif. "I mean, if you were =

developing a sensitive application--not that we are currently engaged =

in any such contracts--and you wanted to ensure complete security--not =

that we currently have any clients who have any need for such =

security--this would enable you to make an application that was =

completely protected--not that I am implying that any of the clients =

that I cannot confirm or deny we might have would need this level of =

data security--from outside intrusion. It also really saves on screen =

real estate."

Developed under the code name "Provo," the product was due to ship =

concurrently with Visual Basic 3.0, but was lost when the development =

team moved to its new offices in the D Level of Building 25. "That =

ended up being a thrilling beta test," said C.R. . "I mean, if the =

development team can't find the product, then it's pretty darn =

invisible, right?"

InVisible Basic 1.0 is currently available at an undisclosed location =

for an unspecified amount. For technical support, leave an ad in the =

personals section of the Miami Herald reading, "Marjoe: all is =

forgiven. Bunny." You will receive in the mail a postcard of the =

Ballard Fish Locks. At midnight, exactly two days after receiving this =

card, be waiting at the "G" concourse of Mile High Stadium in Denver. A =

PSS representative will contact you there. The password is "blibbett."
	--------------------------------
	|			|
	|			|
	|			|
	--------------------------------
Clear as a bell, the InVisible Basic product development team shows off =

its enthusiasm at a recent ship party.
---------------------------------------------------------------------- =

----------
Copied from MicroNews, Copyright =A9 1994 Microsoft Corporation

"Never say a humorous thing to a man who does not possess humour.  He =

will always use it in evidence against you.
-- Sir Herbert Beerhohm-Tree (1853-1917) English actor-manager

{% endraw %}
```

## Thread

+ Return to [April 1994](/archive/1994/04)

+ Return to "[Blanc Weber <blancw@microsoft.com>](/authors/blanc_weber_blancw_at_microsoft_com_)"

+ 1994-04-02 (Fri, 1 Apr 94 17:20:22 PST) - InVisible Basic 1.0 - _Blanc Weber<EMAIL_ADDRESS>


text:
[VIRC411E termid UPLOAD FAILED FOR USER userid](https://virtel.readthedocs.io/en/latest/manuals/virtel/Virtel459MG/messages.html?highlight=VIRC411E#VIRC411E)

`Module`
- 	VIR0041C

`Meaning`
- Upload of an HTML page has failed. The page was received from user userid on terminal termid.

`Action`
- See message sent by VIRTEL to the user.

repository: olepicard/tldrZ

repo_name: olepicard/tldrZ