text:
---
subtitle: SSL support
redirect_from: /documentation/ssl/
---
# SSL support

Maintaining a secure connection to your database is highly desirable in a production environment, even if not already
enforced by the database configuration. Flyway can easily be configured to
use SSL to establish a secure connection as and when required, provided the relevant database and JDBC driver also
support SSL. Although details will vary between databases, the process to configure them is as follows:

## Obtain a copy of the database's certificate

For on-premise databases, the certificate that you need to establish a trusted connection will have been installed
with the database and should be obtained from the relevant administrator. For cloud services, the provider will
publish the relevant certificate - for example [Azure](https://www.digicert.com/CACerts/BaltimoreCyberTrustRoot.crt.pem)
and [Amazon RDS](https://s3.amazonaws.com/rds-downloads/rds-combined-ca-bundle.pem).

## Import the certificate into a truststore

Your certificate is very likely already in a form in which it can be imported into a local trust store
(for example, `.pem` or `.der`). If not, then it can be converted using a tool such as `openssl`.

To import the certificate, use the `keytool` utility. This is included as part of the Java runtime environment that
is shipped with Flyway. If you're making a new store then you will be prompted for a password. Don't lose it - you
will need that password later!

> keytool -keystore myStorePath -alias "My database certificate" -import -file databaseCertificate.pem

If you don't specify a particular truststore then the default location is in your home directory:
`$HOME/.keystore` (Linux) or `%USER_HOME%\.keystore` (Windows)

You can also check which certificates have been imported already:

> keytool -keystore myStorePath -list

## Make sure Java can access the truststore

You now need to configure your Java environment to be able to access these stores. This simply requires
setting a couple of [JVM properties](https://flywaydb.org/blog/jvm-properties). If you're using the Flyway
command-line, then you can set the `JAVA_ARGS` environment variable which the command-line script reads.

> JAVA_ARGS='-Djavax.net.ssl.trustStore="myStorePath" -Djavax.net.ssl.trustStorePassword="myStorePassword"'

If you're using the Flyway Java API directly, or another tool which invokes Java, then you should add these arguments
to the place where you start the Java process:

> java -Djavax.net.ssl.trustStore="myStorePath" -Djavax.net.ssl.trustStorePassword="myStorePassword" myJavaApplication

## Configure Flyway's database connection to use SSL

Most JDBC drivers will only use SSL if explicitly instructed to do so. The way to do this differs between
drivers, but it is usually a matter of adding optional parameters to the URL. Details for specific databases
can be found in the relevant documentation pages. For example, with Postgres, to use SSL simply requires
the `ssl` parameter:

```
flyway.url=jdbc:postgresql://postgres.flyway.test:62079/flyway_db?ssl=true
```

And you should now have secure connections to your database! If you don't want to use SSL for particular databases -
say you need SSL for a production database, but don't need the overhead in a testing environment - then it is fine
to carry out all the above steps and then simply switch SSL on and off as required in the database URL.

## Flyway in Docker

Using SSL with the Flyway Docker image is a little more involved, as you will need to get the certificate into the
container you ultimately run. If you wish to do this, we can recommend an excellent
[guide by Joao Rosa](https://www.joaorosa.io/2019/01/13/using-flyway-and-gitlab-to-deploy-a-mysql-database-to-aws-rds-securely/)
who follows the process through step by step.

url: https://raw.githubusercontent.com/nycjay/flyway/16730ccdbbb3fbd079a0b21fd3f58d0ea8e5898d/documentation/Flyway CLI and API/Configuration/SSL support.md

repository: nycjay/flyway

filename: SSL support.md

gha_language: Java

repo_name: nycjay/flyway


text:
Cyphix Node Graph Editor
========================

A node graph editor built using PyQt5. Still in development.

Version
-------
0.0.1dev1

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

- Python >= 3.7
- PyQt5

Screenshots
-----------

![Screenshot from 2020-09-17 22-17-06](https://user-images.githubusercontent.com/10660257/93559767-60c00000-f935-11ea-9016-2b7bb9c36997.png)

license: MIT

repository: cyphix/cynodeeditor

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: cyphix/cynodeeditor


text:
# Flutter Phone Number Resolver

 ##### A flutter plugin for resolving user phone number from android telephony manager. Currently support only Android Platform.

### Usage

 ###### To use this plugin, add url_launcher as a [dependency in your pubspec.yaml file.](https://flutter.dev/docs/development/packages-and-plugins/using-packages)

### Example

```dart
PhoneNumberResolver.resolveLine1()
    .then((x){
      if (!mounted) return;
      setState(() {
        _phoneNumber = x;
      });
    }).catchError((e)=>
        print(e)
    );
```


text:
---
keyword: [csi-provisioner, csi-provisioner release notes]
---

# csi-provisioner

csi-provisioner allows you to automatically create volumes. This topic lists the latest changes to csi-provisioner.

## Introduction

The csi-provisioner component provided by Alibaba Cloud allows you to automatically create volumes. You can use csi-provisioner to create volumes from cloud disks and Apsara File Storage NAS file systems. The Kubernetes version of the cluster must be 1.14 or later.

## Usage notes

For more information, see [Overview](/intl.en-US/User Guide for Kubernetes Clusters/Storage management-CSI/Overview.md).

## Release notes

**April 2021**

|Version|Image address|Date|Description|Impact|
|-------|-------------|----|-----------|------|
|v1.1.2|registry.cn-hangzhou.aliyuncs.com/acs/csi-provisioner:v1.6.0-e360c7e43-aliyun|2021-04-08|-   Kubernetes 1.20 is supported. The `metadata.selflink` field is deleted.
-   The ClusterID tag is automatically added to cloud disks.
-   NAS volumes can be expanded when the quota is used.

|No impact on workloads.|

**January 2021**

|Version|Image address|Date|Description|Impact|
|-------|-------------|----|-----------|------|
|v1.1.1|registry.cn-hangzhou.aliyuncs.com/acs/csi-provisioner:v1.6.0-b6f763a43-aliyun|2021-01-13|-   DBFS volumes are supported.
-   By default, volume monitoring is enabled.
-   Local volumes of the QuotaPath type are supported.
-   The VolumeSnapshot List feature is supported.
-   Quota groups are supported by NAS volumes.
-   Custom disk types are supported.
-   NAS volumes of the Losetup type are supported.

|No impact on workloads.|

**November 2020**

|Version|Image address|Date|Description|Impact|
|-------|-------------|----|-----------|------|
|v1.1.0|registry.cn-hangzhou.aliyuncs.com/acs/csi-provisioner:v1.6.0-b6f763a43-aliyun|2020-11-02|-   The deployment template is updated to allow drivers to be merged into one container.
-   The issue that subdirectories fail to be created in Extreme NAS volumes is fixed.
-   Kubernetes 1.18 is supported.
-   Labels can be added to NAS volumes when you create NAS volumes.

|No impact on workloads.|

**August 2020**

|Version|Image address|Date|Description|Impact|
|-------|-------------|----|-----------|------|
|v1.0.7|registry.cn-hangzhou.aliyuncs.com/acs/csi-provisioner:v1.4.0-aliyun|2020-08-05|-   The issue that occurs when you create snapshots from disks is fixed.
-   The issue that dynamic NAS volumes fail to be created due to residual data is fixed.
-   The check logic of BDF nodes when the plug-in is started is fixed.
-   The use of universally unique identifier \(UUID\) to obtain device paths is no longer supported.

|No impact on workloads.|

**July 2020**

|Version|Image address|Date|Description|Impact|
|-------|-------------|----|-----------|------|
|v1.0.6|registry.cn-hangzhou.aliyuncs.com/acs/csi-provisioner:v1.4.0-aliyun|2020-07-13|-   EBS snapshots are supported. You can use EBS snapshots to restore data to the beta version.
-   Extreme NAS volumes are supported. You can create and delete Extreme NAS volumes.
-   The Config SysConfig of EBS volumes is supported when you configure PVs.
-   The issue that block volumes are loaded twice in the BDF mode is fixed.
-   EBS and NAS volumes are allowed to access APIs by using the internal domain.
-   The Cloud Paralleled File System \(CPFS\) driver is upgraded and the kernel dependency is removed.

|No impact on workloads.|

**April 2020**

|Version|Image address|Date|Description|Impact|
|-------|-------------|----|-----------|------|
|v1.0.5|registry.cn-hangzhou.aliyuncs.com/acs/csi-provisioner:v1.4.0-aliyun|2020-04-20|-   EBS volumes can be unmounted before you delete the volumes.
-   The disk provisioning policy is updated. SSDs are created in preference to ultra disks. Ultra disks are created only when no SSD is available.
-   UUID is supported to search devices that use EBS volumes.
-   The authentication management in managed Kubernetes clusters is updated.
-   Security Token Service \(STS\) is supported to connect to OSS buckets.
-   The issue of DuplicateMountPoint in EBS is fixed.
-   The BDF protocol is supported to bind EBS volumes after the volumes are connected.

|No impact on workloads.|

**February 2020**

|Version|Image address|Date|Description|Impact|
|-------|-------------|----|-----------|------|
|v1.0.4|registry.cn-hangzhou.aliyuncs.com/acs/csi-provisioner:v1.4.0-aliyun|2020-02-18|-   CSI clusters that have no Internet access are supported.
-   The issue of Mountpath check in EBS is fixed.

|No impact on workloads.|

**December 2019**

|Version|Image address|Date|Description|Impact|
|-------|-------------|----|-----------|------|
|v1.0.2|registry.cn-hangzhou.aliyuncs.com/acs/csi-provisioner:v1.2.2-aliyun|2019-12-20|-   The EBS PV name can be used as the disk ID. This feature is also supported by Flexvolume.
-   Mount options can be configured for EBS volumes in MKFS Stage.
-   MountOptions can be configured to have a higher priority than VolumeAttribute in NAS volumes.
-   Mount options of OSS volumes can be validated in OSS connectors.
-   Subdirectories of OSS buckets can be mounted as volumes.
-   Volume topology can be used to dynamically configure Logical Volume Manager \(LVM\).

|No impact on workloads.|

repository: sidealice/csk

path: /intl.en-US/Release notes/System Component change Records/Storage/csi-provisioner.md

repo_name: sidealice/csk


text:
# Onsi

Used to generate API responses from a Rails App.

[Documentation](https://www.rubydoc.info/gems/onsi)

***

[![CircleCI](https://circleci.com/gh/maddiesch/onsi.svg?style=svg)](https://circleci.com/gh/maddiesch/onsi)

[![Maintainability](https://api.codeclimate.com/v1/badges/8d21ec50b172146416c9/maintainability)](https://codeclimate.com/github/maddiesch/onsi/maintainability)

[![Test Coverage](https://api.codeclimate.com/v1/badges/8d21ec50b172146416c9/test_coverage)](https://codeclimate.com/github/maddiesch/onsi/test_coverage)

### Install

1. Add `gem 'onsi'` to your Gemfile

2. `bundle install`

## Getting Setup

### Controllers

`Onsi::Controller` handles rendering resources for you.

```ruby
class PeopleController < ApplicationController
  include Onsi::Controller

  # Optional. By default Onsi will render `:v1`
  render_version :v2

  def show
    @person = Person.find(params[:id])
    # You can pass an Object, Enumerable, or Onsi::Resource
    # Whatever you pass, the object or each element in the collection *MUST*
    # include `Onsi::Model`
    render_resource @person
  end
end
```

### Models

Used to define your API resources. Calling the class method `api_render` will
allow you to begin setting up a version of your API. You're able to define as
many API versions as you would like. The default rendered if nothing is
specified in the `render_resource` method is `:v1`.

```ruby
class Person < ApplicationRecord
  include Onsi::Model

  api_render(:v1) do
    # Passing the name of the attribute only will call that name as a method on
    # the instance of the method.
    attribute(:first_name)
    attribute(:last_name)
    # You can give attribute a block and it will be called on the object
    # instance. This lets you rename or compute attributes
    attribute(:full_name) { "#{first_name} #{last_name}" }

    # Relationship requires a minimum of 2 parameters. The first is the name
    # of the relationship in the rendered JSON. The second is the type.
    # When fetching the value, Onsi will add `_id` and call that method on the
    # object instance. e.g. `team_id` in this case.
    relationship(:team, :team)

    # Relationships can take a block that will be called on the object instance
    # and the return value will be used as the ID
    relationship(:primary_email, :email) { emails.where(primary: true).first.id }
  end
end
```

### Params

`Onsi::Params` can be used to flatten params that come into the API.

Calling `.parse` will give you an instance of `Onsi::Params` with whitelisted
attributes & relationships. The first argument is the params from the controller.
The second is an array of attributes and the third is an array of relationships.

Calling `#flatten` will merge the attributes & relationships.

```json
{
  "data": {
    "type": "person",
    "attributes": {
      "first_name": "Maddie",
      "last_name": "Schipper",
      "bad_value": "'); DROP TABLE `people`; --"
    },
    "relationships": {
      "team": {
        "data": {
          "type": "team",
          "id": "1"
        }
      },
      "unknown": {
        "data": [
          { "type": "foo", "id": "1" }
        ]
      }
    }
  }
}
```

Flattened gives you:

```ruby
{ "first_name" => "Maddie", "last_name" => "Schipper", "team_id" => "1" }
```

```ruby
class PeopleController < ApplicationController
  include Onsi::Controller

  def create
    attributes = Onsi::Param.parse(params, [:first_name, :last_name], [:team])
    render_resource Person.create!(attributes.flatten)
  end
end
```

repository: maddiesch/onsi

gha_language: Ruby

gha_license_id: MIT

repo_name: maddiesch/onsi


text:
# SampSharpDocker
Launch of the multiplayer game mod SA:MP in conjunction with the SampSharp game mod development plugin in the Docker environment.

# How to use
1. Configure your game script by adding it along the project path: "DockerSharp/server/sharpmodes/"
2. Configure your server.cfg file to suit your current needs, remembering to update the path to your SampSharp game mode.
3. Run your game script using the Docker-compose capabilities: `Docker-compose up -d`

repository: solomirrors/SampSharpDocker

repo_name: solomirrors/SampSharpDocker


text:
# StateSpaceRoutine.jl v0.4.3 Release notes
- Extensive tests for Tempered Particle Filter when run in parallel.
- Sped up computation when there's only 1 state or shock.

# StateSpaceRoutine.jl v0.4.2 Release notes
- Fix Tempered Particle Filter when run in parallel with multiple nodes.

# StateSpaceRoutines.jl v0.4.1 Release notes
- Fix Koopman disturbance smoother when Z is time-varying.
- Add further tests in time-varying cases.
- Sparse matrices allowed for Kalman filter

# StateSpaceRoutines.jl v0.4.0 Release notes
- Fix all smoothers to allow for time variation in any component of a Gaussian linear state space system. Previous attempts were incorrect.

# StateSpaceRoutines.jl v0.3.4 Release notes
- Generalize Durbin-Koopman smoother to allow temporary time variation in `CCC`

# StateSpaceRoutines.jl v0.3.3 Release notes
- Remove DSGE from dependencies

# StateSpaceRoutines.jl v0.3.2 Release Notes
- Raise compatibility to all Julia 1.x versions.

# StateSpaceRoutines.jl v0.3.1 Release Notes

## Patches
- Fix Kalman filter regime-switching bug
- Don't export resample method; assists with compatibility in DSGE.jl

# StateSpaceRoutines.jl v0.3.0 Release Notes

## New features and enhancements
- Allows compatibility with `PoolModel` type.
- Fix errors with compatibility in package loading.
- Now only compatible with Julia `v1.0` and `v1.1`.

# StateSpaceRoutines.jl v0.2.1 Release Notes

## New features and enhancements
- Methods are modified to accept `Real` types, enabling compatibility with autodifferentiation techniques.
- Removed dependence on QuantEcon package, resolves error loading package in Julia v1.1.

# StateSpaceRoutines.jl v0.2.0 Release Notes

## New features and enhancements
- Add option to specify a likelihood convergence tolerance (the keyword argument, `tol`) for the `kalman_filter` and `chand_recursion`.
- Save the `PZV` matrix in the `KalmanFilter` type, (`P_pred' * Z' * inv(V_pred)`), for state and state variance-covariance matrix updating without needing to recompute that matrix product.
- Write an additional `kalman_likelihood` set of methods for obtaining only the likelihood from the kalman filter. While `kalman_filter` can already do so, `kalman_likelihood` is optimized for performance, as it does not instantiate empty return values.

# StateSpaceRoutines.jl v0.1.1 Release Notes

## Performance changes

- `kalman_filter` runs about 20% more quickly
- `hamilton_smoother` and `carter_kohn_smoother` run about 5% more slowly
- `koopman_smoother` runs about 6% more quickly
- `durbin_koopman_smoother` runs about 13% more quickly

## Breaking changes

- `kalman_filter`
  + Replaced `allout::Bool` keyword argument with `outputs::Vector{Symbol}`. For `allout = false`, now specify `outputs = [:loglh]`
  + Return values have changed to `loglh, s_pred, P_red, s_filt, P_filt, s_0, P_0, s_T, P_T`. Note that `loglh` is the vector of conditional log-likelihoods, not the total log-likelihood. The outputs `yprederror, ystdprederror, rmse, rmsd` are no longer returned but can be calculated from the values that are returned
  + Unlike before, the same number of outputs are returned regardless of what's passed to `outputs`. However, some of the outputs may be empty arrays

# StateSpaceRoutines.jl v0.1.0 Release Notes

## New features

- Add tempered particle filter

## Breaking changes

- Upgrade all code for use with Julia v0.6 or higher
- `kalman_filter` returns an additional output variable, a vector of marginal log-likelihoods

branch_name: refs/heads/main

gha_language: Julia


text:
# dampack: an R package for decision-analytic modeling
The `dampack` R package implements useful functions to develop and analyze decision-analytic models in R. The current functions compute cost-effectiveness acceptability curves (CEAC) and frontier (CEAF), expected value of perfect information (EVPI), expected value of partial perfect information (EVPPI), sensitivity analysis (SA) using linear regression metamodeling including one- and two-way.

The package also includes functions to simulate state-transition models and produce expected outcomes of interested.

In addition, this package includes useful functions to obtain parameters of commonly used distributions

## Installation
To get the current development version from github:

```R
# install.packages("devtools")
devtools::install_github("feralaes/dampack")
```

## Documentation
Documentation is still under development but the most current description of the functions in this package appears in `vignettes`. Specifically, in the vignette `dampack_vignette`, we provide examples on how to use the different functions of the package and in the `Markov_CEA_example` vignette, we provide an example on how to run Markov models for cost-effectiveness analysis (CEA) in R using the functions of the dampack package.

## Example
Below, we provide a brief example on how to plot the cost-effectiveness acceptability curves (CEAC) and frontier (CEAF) of a three-strategy CEA using a probabilistic sensitivity analysis (PSA) dataset.
```R
library(dampack)
# Load PSA dataset
data(psa)
# Name of strategies
strategies <- c("Chemo", "Radio", "Surgery")
# Vector of WTP thresholds
v.wtp <- seq(1000, 150000, by = 10000)
# Matrix of costs
m.c <- psa[, c(2, 4, 6)]
# Matrix of effectiveness
m.e <- psa[, c(3, 5, 7)]
# Compute CEAF
out <- ceaf(v.wtp = v.wtp, strategies = strategies,
            m.e = m.e , m.c = m.c,
            ceaf.out = TRUE)
# Plot CEAF
out$gg.ceaf
```
## Full list of Contributors:

  * [Fernando Alarid-Escudero](https://github.com/feralaes)

  * [Eline Krijkamp](https://github.com/krijkamp)

  * Eric Jutkowitz

repository: david-aceituno/dampack

repo_name: david-aceituno/dampack


text:
  <big>|| Dad Joke Discord Bot ! || </big>

    ___________________________

      Mike Pingel |

      Morgan Bradford |

      Levi Kohler |

      Jeroen van Seeters

    ¨

    ¨

    ¨

    ¨

    ¨

  Initiated April 4th, 2021, Updated April 14th, 2021

    <big>Project Docs</big> ·
    <big>Report Bug</big> ·
    <big>Request Feature</big>

## 🌐 About the Project

### 📖 Description
A Discord bot that acts as a dad joke supplement to replace one of our retired instructors at [Epicodus](https://www.epicodus.com/). Written in C#/.NET, it utilizes an API via RESTful principles, WebSocket protocol, and Docker containerization for remote server hosting.

Although no setup is required to simply invite the bot to your Discord server, if you would like to download, alter, or deploy the source code yourself, follow along with the instructions detailed in the [Getting Started](#-getting-started) Section.

Otherwise, skip to the [Add OUR Bot](#%EF%B8%8F-add-our-bot) section to get started by adding the bot directly to your own Discord server.

### 🦠 Known Bugs

* It's too perfect.

### 🛠 Built With

* [Visual Studio Code](https://code.visualstudio.com/)
* [C#](https://docs.microsoft.com/en-us/dotnet/csharp/)
* [.NET Core 2.1](https://dotnet.microsoft.com/download/dotnet/2.1)
* [Discord.Net](https://docs.stillu.cc/)
* [RapidAPI](https://rapidapi.com/KegenGuyll/api/dad-jokes)
* [Docker](https://www.docker.com/)
* [DigitalOcean](https://cloud.digitalocean.com/)
* [Git & GitHub](https://github.com/)

------------------------------

## 🏁 Getting Started

### 📋 Prerequisites

  #### Install .NET Core 2.1

  * On macOS Mojave or later
    * [Click here](https://dotnet.microsoft.com/download/dotnet/2.1) to download the .NET Core SDK from Microsoft Corp for macOS.
  * On Windows 10 x64 or later
    * [Click here](https://dotnet.microsoft.com/download/dotnet/2.1) to download the 64-bit .NET Core SDK from Microsoft Corp for Windows.

  #### Install .NET Script

  Enter the command `dotnet tool install -g dotnet-script` in Terminal for macOS or PowerShell for Windows.

  #### Code Editor

  To view or edit the code, you will need a code editor or text editor. The popular open-source choices for code editors are Atom and Visual Studio Code.

  1) Code editor download:
      * Option 1: [Atom](https://atom.io/)
      * Option 2: [Visual Studio Code](https://code.visualstudio.com/)
  2) Click the download most applicable to your OS and system.
  3) Wait for download to complete, then install -- Windows will run the setup exe and macOS will drag and drop into applications.
  4) Open your editor, and open the Command Palette by pressing `Cmd+Shift+P` for Mac, or `Ctrl-shift-p` for Windows
      * For VS Code, type `Shell Command: Install 'code' command in PATH` into the Command Palette.
      * For Atom, type `Install Shell Commands` into the Command Palette.
  5) Optionally, create a [GitHub account](https://github.com)

  #### Install Docker

  (Optional) [Download and install Docker](https://www.docker.com/products/docker-desktop)

### ⚙ Setup and Use

  #### Cloning

  1) Navigate to the [Discord bot repository here](https://github.com/Pingel88/DadJokeDiscordBot.Solution).
  2) Click 'Code' to reveal the HTTPS url ending with .git and the 'Download ZIP' option.
  3) Open up your system Terminal or GitBash, navigate to your desktop with the command: `cd Desktop`, or whichever location suits you best.
  4) Clone the repository to your desktop: `$ git clone https://github.com/Pingel88/DadJokeDiscordBot.Solution.git`
  5) Run the command `cd DadJokeDiscordBot.Solution` to enter into the project directory.
  6) View or edit:
      * Code editor - Run the command `atom .` or `code .` to open the project in Atom or Visual Studio Code respectively for review and editing.
      * Text editor - Open by double clicking on any of the files to open in a text editor.

  #### Download

  1) Navigate to the [Discord bot repository here](https://github.com/Pingel88/DadJokeDiscordBot.Solution).
  2) Click 'Code' to reveal the HTTPS url ending with .git and the 'Download ZIP' option.
  3) Click 'Download ZIP' and extract.
  4) Open by double clicking on any of the files to open in a text editor.

  #### EnvironmentVariables

  1) Create a new file in the DadJokeDiscordBot.Solution/Bot/Models directory named `EnvironmentVariables.cs`.
  2) Add the following code snippet to the new EnvironmentVariables.cs file:

      ```
      namespace Bot.Models
      {
        public static class EnvironmentVariables
        {
          public static string ApiKey = "[YOUR API KEY]";

          public static string BotToken = "[YOUR BOT TOKEN]";
        }
      }
      ```
  3) Please note that you will have to replace the `[YOUR API KEY]` and `[YOUR BOT TOKEN]` placeholders with your own bot token and API key. Follow along with the subsequent instructions to obtain them.

  #### Acquire API Key

  1) [Create an account](https://rapidapi.com/auth/sign-up) with RapidAPI in order to obtain an API key.
  2) Visit the [pricing tab](https://rapidapi.com/KegenGuyll/api/dad-jokes/pricing) of the Dad Jokes page to subscribe to the API. The free tier should suffice for testing purposes.
  3) Navigate to the [endpoints tab](https://rapidapi.com/KegenGuyll/api/dad-jokes/endpoints) to obtain your API key -- you will have to copy it from the code snippets in the panel to the right.
  4) Replace the entire `[API KEY]` placeholder text in your EnvironmentVariables.cs file with the API key.

  #### Acquire Bot Token

  1) You will have to sign in with your Discord account in order to create a new bot app. If you don't have one already, sign up [here](https://Discord.com/).
  2) [This link](https://Discord.com/developers/applications) will take you to the developers dashboard to begin setting up your dad joke bot.
      * Select new application.
      * Name the application.
      * Select `Bot` on the left.
      * Select `Add Bot` on the right.
      * Select `Yes, do it!`.
  3) To acquire the bot token, click on `Copy` under **Build-A-Bot** to copy your token to your clipboard.
  4) Replace the entire `[BOT TOKEN]` placeholder text in your EnvironmentVariables.cs file with your bot token.

  #### Launch Application

  With your environment variables in place, you are only a few terminal commands away from launching the bot.
  1) In the DadJokeDiscordBot.Solution/Bot repository:
      * Enter `dotnet restore` in your terminal.
      * Enter `dotnet run` in your terminal.
  2) Invite the bot to your server, Back in the [developers dashboard](https://Discord.com/developers/applications), apply the following steps:
      * Select `OAuth2` on the left.
      * Select `Bot` under scopes.
      * Select `Send Messages` under **Text Permissions** inside of **Bot Permissions**.
  3) Copy the **URL** at the bottom of **Scopes**, and paste into the browser to invite the bot to servers you are an admin of.

  #### Deploy via Docker

  1) Install the Docker app if you haven't already, and create an account.
  2) Create a new repository.
  3) In the DadJokeDiscordBot.Solution/Bot repository, run `docker build -t <your-app-name> .`
      * Run `docker build -t <your_username>/<your_repo_name> . ` to build your Docker image.
      * Run `docker run <your_username>/<your_repo_name>` to test your Docker image locally.
      * Run `docker push <your_username>/<your_repo_name>` to push your Docker image to Docker Hub.
  4) Now you are ready to host this application remotely with any cloud provider that supports Docker!

## 🛰 Add OUR Bot

1) [Click here](https://Discord.com/api/oauth2/authorize?client_id=828681816235180082&permissions=2048&scope=bot).
2) If you are not logged in to Discord already, go ahead and do that now.
3) Select the server you wish to add the bot to.
4) Click `Continue`.
5) Click `Authorize`.
6) Enjoy!

------------------------------

## 🤝 Contributors

| Author | GitHub | Email |
|--------|:------:|:-----:|
| [Mike Pingel](https://www.linkedin.com/in/mikepingel/) | [Pingel88](https://github.com/Pingel88) | [mdpingel@gmail.com](mailto:mdpingel+github@gmail.com?subject=[GitHub]Epicodus%20Team%20Week%20-%20Dad%20Joke%20Discord%20Bot) |
| [Morgan Bradford](https://www.linkedin.com/in/morganjbradford/) | [MorganJBradford](https://github.com/MorganJBradford) | [morganjbradford95@gmail.com](mailto:morganjbradford95@gmail.com?subject=[GitHub]Epicodus%20Team%20Week%20-%20Dad%20Joke%20Discord%20Bot) |
| [Levi Kohler](https://www.linkedin.com/in/levikohler/) | [levi-kohler](https://github.com/levi-kohler) | [kohler.la01@gmail.com](mailto:kohler.la01@gmail.com?subject=[GitHub]Epicodus%20Team%20Week%20-%20Dad%20Joke%20Discord%20Bot) |
| [Jeroen van Seeters](https://linkedin.com/in/jeroenvanseeters) | [Jeroenemo](https://github.com/jeroenemo) |  [vanseetersjeroen@gmail.com](mailto:vanseetersjeroen@gmail.com?subject=[GitHub]Epicodus%20Team%20Week%20-%20Dad%20Joke%20Discord%20Bot) |

------------------------------

## ✉ Contact and Support

If you have any feedback or concerns, please contact one of the contributors.

  Report Bug ·
  Request Feature

------------------------------

## ⚖ License

This project is licensed under the [MIT License](https://opensource.org/licenses/MIT). Copyright (C) 2021 Mike Pingel, Morgan Bradford, Levi Kohler, Jeroen van Seeters. All Rights Reserved.

```
MIT License

Copyright (c) 2021 Mike Pingel, Morgan Bradford, Levi Kohler, Jeroen van Seeters.

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

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

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

------------------------------

## 🌟 Acknowledgements

#### [Epicodus](https://www.epicodus.com/)
>"A school for tech careers... to help people learn the skills they need to get great jobs."

#### [The Internet](https://webfoundation.org/)
>"...the first thing that humanity has built that humanity doesn't understand..."

-Eric Schmidt, Google (Alphabet Inc.)

------------------------------

Return to Top

gha_language: C#


text:
@annotate: Object.getOwnPropertyDescriptor(folktale.maybe.Just.prototype, 'value').get
category: Data fields
---

The value contained in a Just instance of the Maybe structure.

This is usually used to destructure the instance in a `.matchWith` call.

## Example::

    const Maybe = require('folktale/maybe');

    Maybe.Just(1).matchWith({
      Just: ({ value }) => value, // equivalent to (x) => x.value
      Nothing: () => 'nothing'
    });
    // ==> 1

repository: dChunikhin/folktale

repo_name: dChunikhin/folktale


text:
wasm-game-of-life

  A simple implementation of the game of life using wasm-pack.

  Built with 🦀🕸 by The Rust and WebAssembly Working Group

## 🚴 Usage

### 🐑 Use `wasm-pack build` to build wasm binaries

[Learn more about `wasm-pack` here.](https://github.com/rustwasm/wasm-pack">wasm-pack)

```
wasm-pack build
```

### 🛠 navigate to the www folder, run `npm install` after installation `npm run start`

```
npm install && npm run start
```

### 🔬 Test in Headless Browsers with `wasm-pack test`

```
wasm-pack test --headless --firefox
```

## 🔋 Batteries Included

* [`wasm-bindgen`](https://github.com/rustwasm/wasm-bindgen) for communicating
  between WebAssembly and JavaScript.
* [`console_error_panic_hook`](https://github.com/rustwasm/console_error_panic_hook)
  for logging panic messages to the developer console.
* [`wee_alloc`](https://github.com/rustwasm/wee_alloc), an allocator optimized
  for small code size.


text:
# watch-amazon

This is a command line program that watches Amazon for book prices.

## Usage

```
lein run <trigger price> <title>
```

The trigger price is the price at which the book will cause the system
to send out an email. It expects environment variables specifying the
mail server and recipient. See `sample-env.sh` for an example.

## License

Copyright © 2013 Kyle Isom<EMAIL_ADDRESS>
Distributed under the ISC license.

license: ISC

repository: achanu/watch-amazon

repo_name: achanu/watch-amazon


text:
Multiplayer Reactor
==================

Web App - must be portable to mobiles

NODEJS
------
Dependency
* socket.io
* require.js
But the pathing is also mannually done, which is not used in current running version.
Pass the onRequest function to createServer as parameter and require could be removed.

License
------
[The Mit License](http://opensource.org/licenses/MIT). Visit page for more info

Author
-------
[BigOmega](http://twitter.com/bigomega "Twitter")

repository: bigomega/multiplayerReactor

repo_name: bigomega/multiplayerReactor


text:
[![Edwards Lab](https://img.shields.io/badge/Bioinformatics-EdwardsLab-03A9F4)](https://edwards.sdsu.edu/research)
[![DOI](https://www.zenodo.org/badge/46241465.svg)](https://www.zenodo.org/badge/latestdoi/46241465)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
![GitHub language count](https://img.shields.io/github/languages/count/linsalrob/PyFBA)
[![PyPi](https://img.shields.io/pypi/pyversions/pyfba.svg?style=flat-square&label=PyPi%20Versions)](https://pypi.org/project/PyFBA/)
[![BioConda Install](https://img.shields.io/conda/dn/bioconda/pyfba.svg?style=flat-square&label=BioConda%20install)](https://anaconda.org/bioconda/pyfba)
[![Anaconda-Server Badge](https://anaconda.org/bioconda/pyfba/badges/version.svg)](https://anaconda.org/bioconda/pyfba)
[![Anaconda-Server Badge](https://anaconda.org/bioconda/pyfba/badges/installer/conda.svg)](https://conda.anaconda.org/bioconda)

# PyFBA
A python implementation of flux balance analysis to model microbial metabolism. [Read more ...](http://linsalrob.github.io/PyFBA/)

## About PyFBA

PyFBA is a Python flux-balance-analysis package that allows you to build models from genomes, gapfill models, and run
flux-balance-analysis on that model. The aim of PyFBA is to provide an extensible, python-based platform for
FBA work.

PyFBA is being developed by Daniel Cuevas, Taylor O'Connell, and Rob Edwards in [Rob's bioinformatics
group](http://edwards.flinders.edu.au/) initially at [San Diego State University](http://www.sdsu.edu/) and now at
[Flinders University](http://www.flinders.edu.au/). Amazing help was also provided by the developers of the ModelSEED,
in particular  Janaka Edirisinghe, Chris Henry, Ross Overbeek and others at [Argonne National Labs](http://www.theseed.org/).

You can [read more about PyFBA](http://linsalrob.github.io/PyFBA/) on our github.io pages.

## Installing PyFBA

PyFBA is available in [bioconda](https://bioconda.github.io/) and we recommend installing it that way. It's what we
use!

```commandline
conda create -n pyfba -c bioconda pyfba
conda activate pyfba
pyfba -v
pyfba help
```

There are other options described in the [installation documents](INSTALLATION.md), but just use conda!

## Getting Started with PyFBA

Once you have installed PyFBA, you will most likely want to build a model from a genome, gap fill that
model, and test it for growth on different media. We have [detailed instructions](GETTING_STARTED.md) that walk you through the step-by-step
procedures that you need to use to run flux balance analysis on your own genome.

### Citing PyFBA

Please use the command:

```commandline
pyfba citations
```

to get the citations for PyFBA. They are available in _plain text_ and _bibtex_ format, please let us know if you would like
other formats!

### Copyright and License

PyFBA is copyright Daniel Cuevas, Taylor O'Connell, and Rob Edwards, and is released under the MIT license.

repository: linsalrob/PyFBA

gha_language: Python

repo_name: linsalrob/PyFBA


text:
# d3-require

A minimal, promise-based implementation to require [asynchronous module definitions](https://github.com/amdjs/amdjs-api/blob/master/AMD.md) (AMD). This implementation is [about 50 lines of code](https://github.com/d3/d3-require/blob/master/index.js) and supports a strict subset of AMD. It is designed to work with browser-targeting libraries that implement one of the [recommended UMD patterns](https://github.com/umdjs/umd). The constraints of this implementation are:

* The `define` method must be called synchronously by the library on load.

* Only anonymous module definitions are allowed; no named modules.

* Only the built-in `exports` dependency is allowed; no `require` or `module` as in CommonJS.

By default, [d3.require](#require) loads modules from [unpkg](https://unpkg.com/); the module *name* can be any package (or scoped package) name optionally followed by the at sign (@) and a semver range. For example, `d3.require("d3@4")` loads the highest version of [D3](https://d3js.org) 4.x. You can change this behavior using [d3.requireFrom](#requireFrom).

## Installing

If you use NPM, `npm install d3-require`. Otherwise, download the [latest release](https://github.com/d3/d3-require/releases/latest). You can also load directly from [unpkg.com](https://unpkg.com/d3-require/). AMD, CommonJS, and vanilla environments are supported. In vanilla, `d3` and `define` globals are exported:

```html
<script src="https://unpkg.com/d3-require@0"></script>
<script>

d3.require("d3-array").then(d3 => {
  console.log(d3.range(100));
});

</script>
```

## API Reference

# d3.require(names…) [<>](https://github.com/d3/d3-require/blob/master/index.js#L6 "Source")

To load a module:

```js
d3.require("d3-array").then(d3 => {
  console.log(d3.range(100));
});
```

To load a module within a version range:

```js
d3.require("d3-array@1").then(d3 => {
  console.log(d3.range(100));
});
```

To load two modules and merge them into a single object:

```js
d3.require("d3-array", "d3-color").then(d3 => {
  console.log(d3.range(360).map(h => d3.hsl(h, 1, 0.5)));
});
```

Note: if more than one *name* is specified, the promise will yield a new object with each of the loaded module’s own enumerable property values copied into the new object. If multiple modules define the same property name, the value from the latest module that defines the property is used; it is recommended that you only combine modules that avoid naming conflicts.

If a module’s property value is null or undefined on load, such as [d3.event](https://github.com/d3/d3-selection/blob/master/README.md#event), the value will be exposed via [getter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get) rather than copied; this is to simulate ES module-style [live bindings](http://2ality.com/2015/07/es6-module-exports.html). However, property values that are neither null nor undefined on load are copied by value assignment, and thus **are not live bindings**!

# d3.requireFrom(source) [<>](https://github.com/d3/d3-require/blob/master/index.js#L22 "Source")

Returns a new [require function](#require) which loads modules from the specified *source*, which is a function that takes a module name and returns the corresponding URL. For example, the default implementation works something like this:

```js
var requireUnpkg = d3.requireFrom(name => `https://unpkg.com/${name}`);

requireUnpkg("d3-array").then(d3 => {
  console.log(d3.range(100));
});
```


text:
Hipster stack for Java developers
==========================

Presentation
------------------

This is a [Yeoman generator](http://yeoman.io), used to create a Yeoman + Maven + Spring + AngularJS project.

Our goal is to generate a complete and modern Web app, unifying:

- Maven on the server side
- Yeoman + Bower + Grunt on the client side

You can checkout a sample generated application [here](https://github.com/jdubois/jhipster-sample-app).

Technology stack on the server side
--------------------

A complete [Spring application](http://spring.io/):

- "development" and "production" profiles
- [Spring Security](http://docs.spring.io/spring-security/site/index.html)
- [Spring MVC REST](http://spring.io/guides/gs/rest-service/) + [Jackson](https://github.com/FasterXML/jackson)
- [Spring Data JPA](http://projects.spring.io/spring-data-jpa/) + Bean Validation
- Database updates with [Liquibase](http://www.liquibase.org/)

Ready to go into production :

- Monitoring with [Metrics](http://metrics.codahale.com/)
- Caching with [ehcache](http://ehcache.org/)
- Optimized static resources (gzip filter, HTTP cache headers)
- Log management with [Logback](http://logback.qos.ch/), configurable at runtime
- Builds a standard WAR file

Technology stack on the client side
--------------------

Single Web page application :

- Responsive Web Design
- [HTML5 Boilerplate](http://html5boilerplate.com/)
- [Twitter Bootstrap](http://getbootstrap.com/)
- [Compass](http://compass-style.org/) / Sass for CSS design
- [AngularJS](http://angularjs.org/)

Easy installation of new libraries with [Bower](http://bower.io/).
Build, optimization and live reload with [Grunt](http://gruntjs.com/).

Installation
-------------------

Install Node.js from [the Node.js website](http://nodejs.org/).

Install Yeoman:

```bash
npm install -g yo
```

Install JHipster:

```bash
npm install -g generator-jhipster
```

To find more information, tips and help, please have a look at
[the Yeoman "getting starting" guide](http://yeoman.io/gettingstarted.html) before
[submitting a bug](https://github.com/jdubois/generator-jhipster/issues?state=open).

Usage
-------------------

To generate your application, type:
```bash
yo jhipster
```

Once the application is generated, you can launch the Java server with Maven:
```bash
mvn jetty:run
```
The application will be available on [http://localhost:8080](http://localhost:8080)

You can also run Grunt to work on the client-side JavaScript application:
```bash
grunt server
```
This should open up your Web browser, with live reload enabled, on [http://localhost:9000](http://localhost:9000). This
Grunt server has a proxy to the REST endpoints on the Java server which we just launched (on
[http://localhost:8080/rest](http://localhost:8080/rest)), so it should be able to do live REST requests to the Java
back-end.

**If you want to go further, and use hot reloading both on the client and the server side, please [go to this Wiki page](https://github.com/jdubois/generator-jhipster/wiki/Hot-reloading).**

*Copyright (C) 2013 [Julien Dubois](http://www.julien-dubois.com/)*

repository: hrambelo/generator-jhipster

repo_name: hrambelo/generator-jhipster


text:
# ArithmeticParser
A simple parser for evaluating simple arithmetic expressions. Made to learn recursive-descent parsers, Backus-Naur form, and hopefully have fun along the way :)
Inspired by [this great tutorial](http://blog.roboblob.com/2014/12/16/recursive-descent-parser-for-arithmetic-expressions-with-real-numbers/).

## Extended Backus-Naur Form Representation
The EBNF representation of the syntax the parser should be able to parse is as follows.

```
Digit := '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
Integer := Digit{Digit}
Number := [-]Integer['.'Integer]

Operator := '+' | '-' | '*' | '/' | '**'

Factor := Number | '(' Expression ')'
Expression := Factor {Operator Factor}
```


text:
# Convey - a simple recipe for .NET Core microservices
## Read the docs [here](https://convey-stack.github.io) or [see it in action](https://www.youtube.com/watch?v=cxEXx4UT1FI).

# Roadmap

These are the features and integrations that we're planning to work on.

* [x] Consul - custom integration (remove the no longer support Consul package)

* [x] Outbox - implement the outbox pattern in a separate package

* [ ] RabbitMQ - improve the actual implementation using native client, including the support for queue retry, proper handling of connections, and parameters abstraction.

* [ ] Service Mesh - integration with Consul Connect, Envoy and other proxies/sidecars.

repository: Rachedtra/Convey

repo_name: Rachedtra/Convey


text:
[Database Structure](Database-Structure) > [World-Database](World-Database) > [creature_equip_template](creature_equip_template)

Column | Type | Description
--- | --- | ---
CreatureID | mediumint(8) unsigned |
ID | tinyint(3) unsigned |
ItemID1 | mediumint(8) unsigned |
ItemID2 | mediumint(8) unsigned |
ItemID3 | mediumint(8) unsigned |
VerifiedBuild | smallint(6) |


text:
# Omnipay: Transaction Storage

**Storage interface for cross-session transactions in the Omnipay PHP payment processing library**

[Omnipay](https://github.com/thephpleague/omnipay) is a framework agnostic, multi-gateway payment
processing library for PHP 5.3+. This package implements Authorize.Net support for Omnipay.

## Installation

Omnipay is installed via [Composer](http://getcomposer.org/). To install, simply add it
to your `composer.json` file:

```json
{
    "require": {
        "omnipay/storage": "~2.0"
    }
}
```

And run composer to update your dependencies:

    $ curl -s http://getcomposer.org/installer | php
    $ php composer.phar update

## Basic Usage

Many OmniPay drivers support a callback from the remote payment gateway to communicate
the results of the authorisation. This callback will not be sharing the same session as
the user making the payment. This package provides a consistent way to access the
storage that will work across multiple gateways and drivers.

repository: judgej/omnipay-storage

repo_name: judgej/omnipay-storage


text:
[![Python 3.5](https://img.shields.io/badge/Python-3.5-yellow.svg)](http://www.python.org/download/)
[![python](https://img.shields.io/badge/python-2.7-brightgreen.svg)](https://www.python.org/downloads/release/python-2714/)
[![OS](https://img.shields.io/badge/Tested%20On-Linux%20%7C%20Android-yellowgreen.svg)](https://termux.com/)

# Wifi-Hacking.py  ![alt tag](http://icons.iconarchive.com/icons/icons8/ios7/48/Network-Wifi-Logo-icon.png)

No Need To Ask Wifi Password, HACK it..! This Cyber Security Tool, Will Hack For You Any Wifi-Password..!

## Feutures and Contains :

```bash
1)Start monitor mode

2)Stop monitor mode

3)Scan Networks

4)Getting Handshake

5)Create wordlist

6)Install Wireless tools

7)WPS Networks attacks

8)Scan for WPS Networks

9)Crack Handshake with rockyou.txt

10)Crack Handshake with wordlist

11)Crack Handshake without wordlist
```

## Tested On :

* Kali Linux
* BlackArch Linux
* Ubuntu
* Kali Nethunter
* Termux
* Parrot OS

# Installation

### Kali Linux / Ubuntu / Parrot OS

```bash
1) sudo apt-get update && apt-get install git
2) sudo git clone https://github.com/Abhayindia/Wifi-Hacking
3) cd Wifi-Hacking/
4) sudo python3 Wifi-Hacking.py
```
# Disclaimer

Wifi-Hacking tool not responsible for misuse and for illegal purposes. Use it only for Pentest or Educational purpose :smile: !!!

repository: Abhayindia/Wifi-Hacking

repo_name: Abhayindia/Wifi-Hacking


text:
---
title: VMWare View Client
subtitle:
date: 2018-08-05
tags:
bigimg: [{src: "", desc: ""}]
---

The VMWare View client allows you to log in to the desktop you see on the Polytech PC's from your own machine over the internet. There are two desktops available - the standard Polytech desktop and one set up for ICT students which has some programming software, including Visual Studio 2013, installed onto it. You have access to everything as normal, but most importantly your H: drive. You can copy and paste files between your own pc and drives at Polytech allowing easy sending of your work and submitting of assessments.

We don't support local mode so don't bother downloading the local mode client. You may be tempted to log in to View, log into the ICT Desktop, and then fire up Visual Studio and start coding. We do not recommend this. It will be very slow and a loss of connection *may* cause you to lose work. Always work in locally installed applications and copy your work over when done.

		Link

		view.op.ac.nz

		Supported Platforms

		Windows, Mac, iOS and Android

		Connection Server

		view.op.ac.nz

		Username

		Your Polytech username

		Password

		Your Polytech password

		View Client Software

		Download from here

		Connect via

		Microsoft RDP


text:
---
sidebar_position: 5
title: Kubernetes
description: Migrate transparently from Podman to Kubernetes, and continue using familiar workflows.
keywords: [podman desktop, podman, containers, migrating, kubernetes]
tags: [migrating-to-kubernetes]
---

# Migrating containers to Kubernetes

Podman Desktop and Podman have many features allowing easy migration from containers to Kubernetes:

- [Kind support](kubernetes/kind)
- [Lima support](kubernetes/lima)
- [Minikube support](kubernetes/minikube)

repository: containers/podman-desktop

gha_language: TypeScript

repo_name: containers/podman-desktop


text:
---
layout: default
---

# 1993-07-28 - PGP Shell for the Amiga

## Header Data

From: "Jeremy R. Smith"<EMAIL_ADDRESS>To: Cypherpunks<EMAIL_ADDRESS>Message Hash: 722edc807a4f2d69e5aa90e4d2f0ecd08923c07c47c901c963162f79d1275b66

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1993-07-28 05:46:31 UTC

Raw Date: Tue, 27 Jul 93 22:46:31 PDT

## Raw message

```
{% raw  %}From: "Jeremy R. Smith"<EMAIL_ADDRESS>Date: Tue, 27 Jul 93 22:46:31 PDT
To: Cypherpunks<EMAIL_ADDRESS>Subject: PGP Shell for the Amiga
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

   Hi, I'm new to this forum and I was wondering if there was a front end
for the Amiga version of PGP.  I am currently using ver2.2 of PGP for the
Amiga under OS2.04.  Please let me know as this would make life a little
bit easier.  Thank you.

                                                    Jeremy Smith
<EMAIL_ADDRESS>
-----BEGIN PGP PUBLIC KEY BLOCK----- Version: 2.2

mQCNAixVlqsAAAEEAMlqS9nz+2dADwxwOglWVJk7xugtC9SMQX6rkJiv/0wkOhSB
RSQcUL5bVfRKJGa4YrnHefmBZaTSvwtFmSUCSqm4yN9n258xda+niz6pJwPDaTIX
7Gr1V8Xr9/J7K3grm8H1VCXJjKTUVt+zPns5KS4K+tQZgdcPQJefZlD5h/jTAAUV
tCdKZXJlbXkgU21pdGggPGplcnNtaXRAZWlzLmNhbHN0YXRlLmVkdT4=
=J0/4
-----END PGP PUBLIC KEY BLOCK-----

{% endraw %}
```

## Thread

+ Return to [July 1993](/archive/1993/07)

+ Return to "["Jeremy R. Smith" <jersmit@eis.calstate.edu>](/authors/jeremy_r_smith_jersmit_at_eis_calstate_edu_)"

+ 1993-07-28 (Tue, 27 Jul 93 22:46:31 PDT) - PGP Shell for the Amiga - _"Jeremy R. Smith"<EMAIL_ADDRESS>


text:
---
title:  "War of the words"
tags: [aliens, language, shannon, information theory, zipf]
published: true
---

## Takeaway

Zipf's law and Shannon's information entropy can help us find alien life

## How can we find alien life?

We've talked about [how machine learning companies use data to recognise text](https://avoidboringpeople.substack.com/p/the-next-machine-learning-startup "ML") and how [investors use data to pick companies.](https://avoidboringpeople.substack.com/p/not-everything-is-insider-trading "invest")

This week, let's talk about how scientists are using data to look for aliens. Some of the content below will draw from [Laurance Doyle's talk with the Long Now group.](http://longnow.org/seminars/02020/apr/29/interspecies-communication-and-search-extraterrestrial-intelligence/ "Long")

### Framing the problem

The search for extraterrestrial intelligence institute (SETI) is the most famous of the research institutes that are looking for alien life. Its mission is to ["to explore, understand and explain the origin and nature of life in the universe and the evolution of intelligence."](https://www.seti.org/about-us/mission "mission")

How do we even go about scoping a problem like that?

Well, if we're trying to find alien life, they have to exist on a planet somewhere else. So we know that trying to find planets is a potential starting point.

From elementary science we also know that planets form around stars. So we know that trying to find stars that can support planets is also a relevant point.

We know that most planets have harsh environments. So let's restrict that list just down to planets we think can support life \[1\].

Of those planets, not all of them will actually have life appear, so let's take the proportion that actually do.

We might think that we're good here, and have enough features to start looking. There are still some features we can add though to narrow down our search precision.

When we're looking at planets, we want to find some signal coming from the planet, as that will be much stronger proof that the planet has life. Imagine you were looking at a house vs a house where someone was playing music. It's much easier to conclude that there's a living thing in the second scenario.

So, let's narrow down the planets where life actually appears, to the planets where "intelligent" species appear.

And of those "intelligent species", let's only take the ones that end up developing communications technology.

Lastly, even if the species developed communications, if they're no longer alive to send those communications, we'd never receive them. So we need to account for how long those civilisations live for as well.

That was a lot. But now we have all the major factors we need to frame our problem, and look for the number of intelligent alien civilisations that can send signals.

Putting it all together, what we've done is come up with the [Drake equation](https://en.wikipedia.org/wiki/Drake_equation#:~:text=The%20Drake%20equation%20is%20a%20statement%20that%20stimulates%20intellectual%20curiosity,a%20part%20of%20that%20universe. "Drake"), a famous way of estimating intelligent life \[2\]. Notice how all the points we just covered are multiplied together to get a guess of how many smart aliens are out there:

![post]({{ site.url }}{{ site.baseurl }}/assets/images/Long Now drake equation.jpg)

### Narrowing the scope

That's a lot of variables though, so let's just focus on one part of that equation for today, that of the fraction of "intelligent" species.

We need to find a way to distinguish "intelligent" signals from "non-intelligent" ones. For example, I'd want to differentiate between singing on a microphone vs [audio feedback](https://en.wikipedia.org/wiki/Audio_feedback "audio").

It'd be helpful if we had examples of alien communication, or knew what we were looking for. We obviously don't have the former \[3\], but there are ways for us to further narrow down the latter. What we want to find are characteristics that an intelligent signal might have in contrast to random noise.

One way of doing so is by looking at non-human intelligent life all around us. [We use Antarctica as a proxy for Mars,](https://www.cnn.com/2015/12/09/health/white-mars-antarctica-concordia/index.html "Mars") and can similarly use animals as a proxy for alien language.

If we had rules that we believe intelligent communications have to follow, we can test those rules against animal communications, and see how well they work. This will let us know if we need to broaden or narrow our search criteria.

It turns out there are 2 major rules in language theory - Zipf's Law, and Shannon's information theory entropy. Let's look at each in turn.

### Zipf's law about the frequency of words

What Zipf's law proposes is that for every language, the frequency of a word's occurence is inversely proportional to the word's ranking, if you ranked all the words by frequency of occurrence. For example, if "the" is the most common word, it has rank #1. If "I" is the second most common word, it has rank #2. The rank #1 word, "the", will occur twice as many times in the language as the rank #2 word, "I". It will occur thrice as many times in the language as the ran #3 word, and so on.

With such a law, we can test it on sample texts from that language. For example, someone plotted the frequency of words in Romeo and Juliet:

![post]({{ site.url }}{{ site.baseurl }}/assets/images/zipf law example.png)

Not content to rely on some rando from the internet, I went ahead to analyse my own newsletter posts. With some simple python code \[4\], I extracted the text from all my substack posts, pulled the top 50 words I used, and graphed them against their frequency. The relationship isn't perfect, but it's pretty close to what Zipf's law predicts. As you can imagine, “the”, “to”, “a”, “and”, “of” all occur frequently.

![post]({{ site.url }}{{ site.baseurl }}/assets/images/zipf law abp example.png)

Great, so now we have one law. We can test that against animals such as dolphins and whales, and see if it still holds. [Researchers did that,](https://www.seti.org/animal-communications-information-theory-and-search-extraterrestrial-intelligence-seti#:~:text=We%20also%20found%20that%20bottlenose,Zipf's%20Law%20distribution%20of%20signals.&text=In%20other%20words%2C%20baby%20bottlenose,start%20to%20whistle%20like%20adults. "dolphin") and found that they do! \[5\] In other words, it's likely that Zipf's law will apply to alien languages as well. By applying it to signals from outer space, we can filter out some of the noise.

### Shannon's information theory on predicting the next word

Shannon's information theory \[6\] proposes that knowing the words before another word will give you some clue as to what that word is. Put another way, words in a sentence will depend on each. For example, you probably understand the previous sentence just fine, even though I omitted the last word "other."

Knowing that there's some relation between words, [we can also derive a way to score the language based on those relationships.](https://langev.com/pdf/plotkin00languageEvolution.pdf "shannon") I'm hand waving on the math here becauase I don't understand it myself, but the main takeaway that we can understand is that languages have a score.

By plotting those scores, we can see what range most languages fall in. We can do the same process as before, scoring dolphins and whales, and seeing how their languages perform as well:

![post]({{ site.url }}{{ site.baseurl }}/assets/images/Long Now zipf law.png)

As you can see, there's a range in which most languages fall under. If we apply the same scoring system to signals, we can also filter out the ones that are unlikely to be languages.

### Finding aliens is not so different from machine learning

We started out with a broad goal - wanting to find aliens.

We then framed the problem, and came up with the various components that might be helpful to look at.

We narrowed down to just one part of the problem, and looked for ways to increase the precision of our search. We came up with two main criteria from human languages, and then cross validated it against other non-human languages. Moving forward, we can use a similar approach to narrow down the signals that we want to study further.

In case you thought this was all hypothetical, the above approach is [exactly what one team at SETI is using to analyse signals.](https://www.seti.org/animal-communications-information-theory-and-search-extraterrestrial-intelligence-seti#:~:text=We%20also%20found%20that%20bottlenose,Zipf's%20Law%20distribution%20of%20signals.&text=In%20other%20words%2C%20baby%20bottlenose,start%20to%20whistle%20like%20adults. "SETI")

As you can see, the process itself can be similar to other data analysis problems. First, you start with a goal. Then, you frame what you might need. Next, you come up with an algorithm. Lastly, you test it to see if it holds up. Problem solving in one field isn't that different to problem solving in another.

## Footnotes

1. Defining what is habitable vs not [is difficult of course,](https://en.wikipedia.org/wiki/Circumstellar_habitable_zone "zone") since what works for us may not work for alien life. Some people might believe in silicon-based life rather than carbon-based (what we are), though [there are difficulties with that assumption](https://astronomy.stackexchange.com/questions/20858/why-do-aliens-have-to-be-carbon-based-lifeforms "carbon")
2. Note that "the usefulness of the Drake equation is not in the solving, but rather in the contemplation of all the various concepts which scientists must incorporate when considering the question of life elsewhere, and gives the question of life elsewhere a basis for scientific analysis"
3. Unless you know something that I don't, in which case I'm interested to know more...
4. By simple, I mean it took <30 min to write, and then 3 hours for me to troubleshoot. The code is [here](https://github.com/leonlinsx/ABP-code/blob/master/Python-projects/File%20extractor.py "git") if you're interested in adapting it for your own purposes.
5. They also tested it against baby babbling, both human and dolphin babies. They find that neither of these follow Zipf's law.
6. Yes, this is *the* [Claude Shannon, the guy who essentially taught us how to create electronic communications](https://www.itsoc.org/about/shannon "Shannon")

*If you liked this, sign up for my [finance and tech newsletter:](https://avoidboringpeople.substack.com/ "ABP")*

repository: leonlinsx/avoid-boring-people

gha_language: JavaScript

repo_name: leonlinsx/avoid-boring-people


text:
---
title:  "JHO's AC prep Week 2 Day 1"
date:   2017-02-13 15:04:23
categories: [crossfit]
tags: [JHO, deadlift, clean]
published: true
---
Day 1- Hip Hinge

A: Single Leg DL; 3 X 20; **_built up to 20kg/h_**

B: DL- 3 X 3, 3 X 2 @ 87.5%; rest 3 minutes; **137.5 KG**

C: HPS, HS, Snatch; E2MOM; **built to 65kg**

D: Hanging L-sit hold + Ring Support Hold; 4X 20s hold;

Two rounds for time:
200m farmer's walk (32kg/h)
200m Dead ball Carry (50kg)
Score: **19:04**

repository: ohjho/jekyll-uno

repo_name: ohjho/jekyll-uno


text:
# Caves of Zircon Tutorial

This project is part of the [How to Make a Roguelike](https://hexworks.org/posts/tutorials/2018/12/04/how-to-make-a-roguelike.html)
tutorial. Check out the article series if you want to make the most ouf of this project.

For each article there is a release in this repository. Releases so far:

- [Project Setup](https://github.com/Hexworks/caves-of-zircon-tutorial/releases/tag/PROJECT_SETUP)
- [Views, Screens, Inputs](https://github.com/Hexworks/caves-of-zircon-tutorial/releases/tag/2_VIEWS_SCREENS_INPUTS)
- [Generating Random Caves](https://github.com/Hexworks/caves-of-zircon-tutorial/releases/tag/3_GENERATING_RANDOM_CAVES)
- [The Player](https://github.com/Hexworks/caves-of-zircon-tutorial/releases/tag/4_THE_PLAYER)
- [Moving Around](https://github.com/Hexworks/caves-of-zircon-tutorial/releases/tag/5_MOVING_AROUND)


text:
# redis-tag

Tagging is the perfect job for Redis, wouldn't you agree? This library makes it
easy to implement a tagging system into any node appication. It has only 4
public methods and sets up all the associations for you.

## Installation

I always recommend you bundle your dependencies with your application. To do
this, create a `package.json` file in the root of your project with the minimum
information...

    {
      "name": "yourapplication",
      "verson": "0.0.1",
      "dependencies": {
        "redis-tag": "0.2.0"
      }
    }

Then run the following command using npm...

    npm install

OR, if you just want to start playing with the library run...

    npm install redis-tag

## Docs

To create a taggable object we must first require the library and then
instantiate a new Taggable object. A taggable object can be any model in your
system. For example: book, post, person, etc.

    var redisTag   = require("redis-tag")
    var bookTagger = new redisTag.Taggable("book")

Now we have 4 methods on the `bookTagger` object that give us tagging abilities.

### set([scope,] id, tags, callback)

The `set` method applies tags to an `id` (which is your first argument). The id
should correspond with the resource you are tagging. The id does not have to be
an integer but this will usually be the case. `tags` must come in the form of
an array (it is up to your application how this array is formed. redis-tag does
not do this for you). The last argument is a callback with an argument that is
the response of the `set` call. It will return `true` or `false`. `scope` is an
optional argument for if you want to do something like delicious where eash
user has their own set of tags. If a `scope` is used when tagging. you still
have avaiable to you all the other methods in a non-scoped or scoped manner.

    // sets tags on book 12
    bookTagger.set(12, ["fiction", "fantasy"], function(response){
      console.log(response) //=> true
    })

#### OR (with scope)

    // sets tags on book 12 for user 42
    bookTagger.set("user:42", 12, ["fiction", "fantasy"], function(response){
      console.log(response) //=> true
    })

### get([scope,] id, callback)

The `get` method simply takes an `id` and a callback with a list of tags as the
response. This will always be in the form of an array.

    // gets tags for book 12
    bookTagger.get(12, function(tags){
      console.log(tags) //=> ["fiction", "fantasy"]
    })

#### OR (with scope)

Please note that this is only effective if you have used a scope on the `set`
method.

    // gets tags for book 12
    bookTagger.get("user:42", 12, function(tags){
      console.log(tags) //=> ["fiction", "fantasy"]
    })

### find(tags, callback)

The `find` method will take an array of tags and find all the resources that
have those tags in common. The callback function taken as the second argument
will return with an array of ids.

    // finds resources that have been tagged "fiction"
    bookTagger.find(["fiction"], function(ids){
      console.log(ids) //=> ["12", "27", "42", "18"]
    })

#### OR (with scope)

Please note that this is only effective if you have used a scope on the `set`
method.

    // finds resources that have been tagged "fiction"
    bookTagger.find("user:42", ["fiction"], function(ids){
      console.log(ids) //=> ["12", "27", "42", "18"]
    })

### popular(count, callback)

The `popular` will retrieve all the tags on that resource and order them from
most to least most popular. It accepts an `integer` as its first argument
describing the number of tags you want returned. The `callback` is called with
a `nested array` listing the tags in decending order.

    bookTagger.popular(25, function(tags){
      console.log(tags) //=> [ ["fiction", 892], ["non-fiction", 423], ["fantasy", 315], ... ]
    })

#### OR (with scope)

Please note that this is only effective if you have used a scope on the `set`
method.

    bookTagger.popular("user:42", 25, function(tags){
      console.log(tags) //=> [ ["fiction", 27], ["non-fiction", 23], ["fantasy", 15], ... ]
    })

## License

Copyright 2011 Brock Whitten
All rights reserved.

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

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

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

repository: sintaxi/node-redis-tag

repo_name: sintaxi/node-redis-tag


text:
# Packet Handler

This is a simple application that works with the supplied pcap files.
This will probably not work with all pcap files.

## Installation

Make sure you have the following things installed:

* pip install pypcapfile
* python2.7

* apt-get install tcpdump

## Requirements

Before running, make sure you run `split_pcap.bash`.

### Running split_pcap.bash

Create a directory called gzpcaps and place all of your `.gz.pcap` files in
this directory. From there, all you need to do is run the following command:

```./split_pcap.bash gzpcaps```

This will create a pcap[number] folder for each `.gz.pcap` file. In each folder
you will find the original `.gz.pcap` file split into multiple files, each file
no larger than 1 Megabyte. This is to make the files easier to work with
and take up way less memory.

## Modifying the Program

In `main.py` you will find the following function:

```
def primary_function(packet):
    print packet.get_obj()
```

this is where you should write your code. When you run main.py, you will be
prompted to enter a directory. You should enter a pcap[number] directory.
For every sequential packet this function will be called and will pass
that packet as a `Packet` object.

You can call the following functions on the packet object and it will
return the data.

```
# Returns the source IP of the packet.
temp = packet.get_src_ip()

# Returns the destination ip of the packet.
temp = packet.get_dst_ip()

# Returns the protocol for the packet. ('UDP', 'TCP', etc)
temp = packet.get_protocol()

# Returns the EPOCH time the packet arrived.
temp = packet.get_time()

# Returns the payload contents in hex.
temp = packet.get_payload()
```

## Running The Program

To run the program, just do:

```
python main.py
```


text:
# week5_Homework Work Day Scheduler

A simple calendar application that allows the user to save events for each hour of the day. This app will run in the browser and feature dynamically updated HTML and CSS(Bootstrap) powered by jQuery.

You'll need to use the [Moment.js](https://momentjs.com/) library to work with date and time. Be sure to read the documentation carefully and concentrate on using Moment.js in the browser.

## User Story

```
AS AN employee with a busy schedule
I WANT to add important events to a daily planner
SO THAT I can manage my time effectively
```

## Acceptance Criteria

```
GIVEN I am using a daily planner to create a schedule
WHEN I open the planner
THEN the current day is displayed at the top of the calendar
WHEN I scroll down
THEN I am presented with timeblocks for standard business hours
WHEN I view the timeblocks for that day
THEN each timeblock is color coded to indicate whether it is in the past, present, or future
WHEN I click into a timeblock
THEN I can enter an event
WHEN I click the save button for that timeblock
THEN the text for that event is saved in local storage
WHEN I refresh the page
THEN the saved events persist
```
## Installation
Given Repo consists of
* index.html
* style.css
* calender.js

### License
 MIT License

Copyright (c) [2020] [VasaviSindhu Saladi]

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

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

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

## Review

Following are the URLs:

* The URL of the deployed application: https://vasavi245.github.io/week5_DayPlanner/

* The URL of the GitHub repository: https://github.com/vasavi245/week5_DayPlanner
- - -


text:
# Nethereum.BlockchainStorage

## Summary

This repo is for projects that extend block chain processing.  The core Nethereum libraries (e.g. within Nethereum.Web3) provide crawling, retrieval and filtration mechanisms whilst projects in this repo provide storage for the data.

For examples of block chain processing see:

 * The docs (http://docs.nethereum.com/en/latest/nethereum-log-processing-detail/)
 * Samples on Nethereum Playground (http://playground.nethereum.com/)


text:
# CodeExpert_Solver

(c) Philipp Schilk, 2020

https://github.com/TheSchilk/CodeExpert_Solver/

***"Because the most important thing is a good come-back"***

# Overview

Parses the test report from the ETH CodeExpert Grader and generates a custom
C++ program that will defeat that specific auto-grader.

This is done by hard-coding the required responses.

For an example program generated for "Bonus Exercise 1: Dots and Boxes" see [example.cpp](https://github.com/TheSchilk/ETHCodeExpert_Solver/blob/master/example.cpp)

# Disclaimer

I really hope the following is unnecessary, but on the off-chance it is not obvious:

I don't encourage cheating, and this is not meant to actually complete your homework.
This is a tongue-in-cheek programming project, and while it's results will most likely
pass the auto-grader, they will not be accepted upon actual review.

*Not associated with ETH or Code Expert*

# Requirements and Installation

Only Requirement is Python 3

Simply download the repository to install.

The CPPTemplate.cpp file must be in the same directory as the script.

# Usage

### 1: Get the auto-grader Report
- Implement an empty main method to get the auto-grader to run:
```c++
int main(){
   return 0;
}
```
- Run the auto-grader

- Copy and Paste the auto-grader report into a text file,
and save the text file into the same directory as this script.
(for example as grader.txt)

### 2: Run ETHCodeExpert_Solver

```console
~$ python CodeExpert_Solver grader.txt
```

where grader.txt is whatever you called the text file.
### 3: ...?

### 4: *Profit!*
A file called CheatyCode.cpp will be generated.


text:
# Calendar
The `Calendar` component is a thin wrapper around https://github.com/wojtekmaj/react-calendar.
## Usage
| Name        | Type           | Description  |
| ----------- |:--------------:| ------------:|
|isBlockedDay|func|Indicates if a day is blocked. Expects a function which is invoked with a `Date` object and should return a boolean *
Default: () => false
|tileDisabled|func|Proxied from `react-calendar` prop types *
Default: () => false

repository: dan-lee/elements

repo_name: dan-lee/elements


text:
# Quasar Form Builder

The product named SlickQua, it's a Quasar based form designer, its mainly feature we can described below:

1) based on vue-gridlayout framework to drag and drop;
2) can be integrated with Slickflow.Net engine;
3) database persistence can be used to save form template and form inputing data;
4) provided datasource binding and cascading features for dropdown, list, checkbox and radio control;
5) provided event binding feature for onchange/onclick event;
6) implemented activity/field permission feature to show/hide, write/readonly form inputing controls;

# Edition

There are two editions for software users:
## Community Edtiton
It's free for community users, you can customized based the basic features.

## Enterprise Edtion
It's for commercial users, we provide full source code, database script, document and support service. Please you can access the online demo page below url:

http://demo.slickflow.com/sqd/

The online demo example

![AskForLeave Form Approval](https://github.com/besley/besley.github.io/blob/master/Gif/SlickQua-Ask4Leave-Demo.gif)

# Contact
We provide commercial license for enterprise users, you can contact us by email<EMAIL_ADDRESS>
# Website
http://www.slickflow.net

(This is our open source workflow engine product website, the form designer can be integrated with the workflow engine together)

repository: besley/SlickQua

repo_name: besley/SlickQua


text:
---
{
  "title": "Deterministic Build",
  "description": "A step by step guide on how to reproduce the deterministic builds of Wasabi. This is the Wasabi documentation, an archive of knowledge about the open-source, non-custodial and privacy-focused Bitcoin wallet for desktop."
}
---

# Deterministic Build

The guide for the deterministic builds can be found in the [WalletWasabi repository](https://github.com/zkSNACKs/WalletWasabi/blob/master/WalletWasabi.Documentation/Guides/DeterministicBuildGuide.md).

repository: zkSNACKs/WasabiDoc

repo_name: zkSNACKs/WasabiDoc


text:
# PintS

Portable intrinsics for SIMD

Doxygen documentation: http://lemaitre-thesis.github.io/pints/

## What is it?

PintS is an abstraction library to write SIMD code.
It is fully compatible with both C and C++ and it is a header only library.

The main goal is to provide a library to have the same code
on multiple SIMD architecture or even without SIMD.

## How does it work?

The library consists in definitions of the functions for non SIMD architectures,
and specialization of some of them for SIMD architectures.
These specializations are done by undefining the previous macro
(which can be an alias to a function)
and redefining it for the target architecture.

The library is able to detect the target architecture using information
given by the compiler and loads automatically the required header files.

## How does it look?

~~~c
float dotprod_v8f(const float* a, const float* b, int n) {
  // Local var declarations
  int i;
  v8f va, vb, s;
  m8f vmask;

  // initialization
  s = v8f_zero();

  // main loop
  for (i = 0; i < n - 8; i += 8) {
    va = v8f_loadu(&a[i]);
    vb = v8f_loadu(&b[i]);
    s = v8f_fmadd(va, vb, s);

  } /* remainder */ {
    vmask = m8f_cvt_m8i(m8i_gt(v8i_set1(n-i), v8i_set(0, 1, 2, 3, 4, 5, 6, 7)));
    va = v8f_loadu(&a[i]);
    vb = v8f_loadu(&b[i]);
    va = v8f_maskz_move(vmask, va);
    s = v8f_fmadd(va, vb, s);
  }

  // reduce s
  return sf_reduce_add_v8f(s);
}
~~~

## How can I use it in my project?

You need to copy the folder `include` of this repository into your project
and include the file `pints.h` wherever you want to use it.

## Supported compilers

This library has only been tested on the following compilers:
- gcc (5.1)
- icc (16.0)

However, this library is written with compatibility in mind
and should also be compatible with other compilers

## Supported architectures

For now, the supported architectures are:
- SSE
- SSE2
- SSE3
- SSSE3
- SSE4.1
- SSE4.2
- AVX
- AVX2
- FMA (AVX)

It is planned to also support in the future:
- KNC
- AVX512 (all variants)
- Neon

## Future features

It is planned to add the following features to the library:
- Reductions (eg: full horizontal sum)
- Transpositions (of vectors)
- Masks primitives (for AVX512 and KNC support)
- Shuffles with vector of indices
- per instruction Rounding method? (only when supported)

## Disclaimer

This project is still in development and might not be stable enough
for a production use.

repository: lemaitre-thesis/pints

repo_name: lemaitre-thesis/pints


text:
# Convext
A ContextAPI-like package for Vue.js modules and dependency injection

This package creates mixins for dependency injection in Vue js components. Other ContextAPI
attempt to mimic the original functionality. This module attempts to leverage the
Provide/Inject api of Vue and creates Mixins so you can quickly add reactive data to your
Vue app.

To use Convext you only need to import it:

```javascript
// name-convext.js
import Convext from 'convext'

export default Convext('name',{defaultValue:'Sally'});
```

Then to add the reactive properties you can simply add it to your components.

```vue
<!-- get-name.vue -->
<template>
  <div>
    <label for="name">Name</label>
    <input type="text" id="name" v-model="name">
    <name-display />
  </div>
</template>
<script>
  import NameConvext from "./name-convext"
  import NameDisplay from "./name-display"
  export default {
    // since this is Parent we want to Provide the data.
    mixins:[NameConvext.provideMixin()],
    components:{NameDisplay}
  }
</script>
```

```vue
<!-- name-display.vue -->
<template>
  <p>Hi, my name is {{ name }}</p>
</template>
<script>
  import NameConvext from "./name-convext.js"
  export default {
    // since this is a child component we want to inject the data.
    mixins:[NameConvext.injectMixin()]
  }
</script>
```

repository: fimion/convext

repo_name: fimion/convext


text:
# FloorFilterView

The FloorFilter component simplifies visualization of GIS data for a specific floor of a building in your application. It allows you to filter down the floor aware data displayed in your GeoView to a site, a building in the site, or a floor in the building.

The ArcGIS Runtime SDK currently supports filtering a 2D floor aware map based on the sites, buildings, or levels in the map.

## Workflow 1

The simplest workflow is to just instantiate a `FloorFilterView` and call `FloorFilterView.addToGeoView(GeoView)`
to display it within the GeoView. This causes default settings to be used. Optionally, setter methods may be
called to override some of the default settings. The app has limited control over the position of the
`FloorFilterView` (bottom-left, bottom-right, top-left, or top-right).

For example in Kotlin:

```kotlin
val floorFilterView = FloorFilterView(mapView.context)
floorFilterView.setMaxDisplayLevels(3) // optionally override default settings
floorFilterView.addToGeoView(mapView, FloorFilterView.ListPosition.TOP_END)
```

## Workflow 2

Alternatively, the app could define a `FloorFilterView` anywhere it likes in its view hierarchy, because `FloorFilterView` extends the
Android `LinearLayout` class. The app then calls `FloorFilterView.bindTo(GeoView)` to make it come to life as a `FloorFilterView` for
the given GeoView. This workflow gives the app complete control over where the `FloorFilterView` is displayed - it could be positioned
on top of any part of the GeoView, or placed somewhere outside the bounds of the GeoView.

Here's example XML code that puts a 'FloorFilterView' in the bottom-left corner of a MapView :

```xml
<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">

    <androidx.constraintlayout.widget.ConstraintLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@android:color/background_dark">

        <com.esri.arcgisruntime.mapping.view.MapView
            android:id="@+id/mapView"
            android:layout_width="0dp"
            android:layout_height="0dp"
            app:layout_constraintTop_toTopOf="parent"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintEnd_toEndOf="parent" />

        <com.esri.arcgisruntime.toolkit.floorfilter.FloorFilterView
            android:id="@+id/floorFilterView"
            android:layout_width="wrap_content"
            android:layout_height="0dp"
            android:layout_marginBottom="40dp"
            android:layout_marginStart="20dp"
            android:layout_marginEnd="20dp"
            android:layout_marginTop="20dp"
            app:layout_constraintTop_toTopOf="parent"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintHeight_max="wrap"
            app:layout_constraintVertical_bias="1"
            app:closeButtonPosition="top"
            android:background="@drawable/floor_filter_rounded_background"
            android:elevation="4dp"/>

    </androidx.constraintlayout.widget.ConstraintLayout>

</layout>
```

Here's example Kotlin code to bind the `FloorFilterView` to the GeoView:

```kotlin
val floorFilterView = findViewById(R.id.floorFilterView)
floorFilterView.bindTo(mapView)
```

To see it in action, try out the floorfilter test in the [toolkit-test-app](https://github.com/Esri/arcgis-runtime-toolkit-android/tree/master/toolkit-test-app/src/main/java/com/esri/arcgisruntime/toolkit/test)


text:
```properties
author: Freya Arbjerg
date: 2019-07-17T00:05:18.217Z
```

# My plans to create a new Wayland compositor

Ever since I switched from Windows to Linux 1½ years ago I have been using a tiling X11 window manager. Initially, I was using [i3wm](https://i3wm.org/), and found the configuration options to be too lacking. I needed something that would let me have more or less complete control, and [AwesomeWM](https://awesomewm.org/) would give me that with its Lua scripting.

However, AwesomeWM comes with its own set of problems in my experience. While it uses a comprehensive API for managing the window manager, the scripting context is rather limited. It appears that there has been an attempt to sandbox the scripting context, while still allowing me to run arbitrary commands. Methods for things like accessing the filesystem is normally part of the default Lua environment.

I also don‘t like the scripting language itself. I started my very early career as a developer working on games with Lua. I have spent maybe thousands of hours with this language, and yet I still find it tedious to work with. Lua is dynamically typed, and in many ways feels like a more clunky alternative to JavaScript.

I would not consider it a problem that AwesomeWM is an X11 window manager rather than a Wayland compositor, as it appears that [way-cooler](https://github.com/way-cooler/way-cooler) will eventually solve that problem.

## My alternative compositor

The fundamental thing that would set my compositor apart from awesome and way-cooler is that mine would rely on [Kotlin](https://kotlinlang.org/) for configuration. More specifically, I will be using a flavor of Kotlin called [Kotlin/Native](https://kotlinlang.org/docs/reference/native-overview.html) that compiles to a native binary. It is not unheard of to use a compiled language for a window manager or compositor.

I have yet to figure out a proper name for it. For now, I am using the codename “kaiju”, which roughly means ”strange beast“ in Japanese and fits with its frankly quite strange design. Kotlin libraries usually have a name starting with 'K'.

Kotlin is normally used as a language for the JVM (Java Virtual Machine), and is basically like Java without many of its shortcomings. Here is a list of reasons why I think Kotlin would make a great configuration language:

### The good

Example Kotlin code:
```kotlin
// Use the Compositor type as the receiver for this function
fun Compositor.configure() {
    //   Provide a function as an argument for the keybinds function
    // which has a different receiver
    keybinds {
        //   Within this scope, the add() higher-order function can be called
    	// which would add a listener
        add(SUPER, Keys.Q) { focusedWindow.close() }
        add(CTRL + SHIFT, Keys.ENTER) { openFirefox() }
    }

    onNewWindow {
        // Event listener
    }

    // Calls a setter with side-effects within Compositor
    wallpaper = "~/wallpaper.png"
}
```

* Kotlin has many features that allow for type-safe domain-specific languages (DSLs). Its higher-order functions and custom function receivers allow for an intuitive builder pattern.
* Like Lua, Kotlin is very extensible. Where Lua uses dynamic “meta tables” to define extensions on a per-object basis, Kotlin offers operator overloading functions resolved at compile-time. In the above example, `CTRL` and `SHIFT` can be of a class that has a custom `plus()` operator.
* Not everything has to be in a class. The configuration entry point can just be a function like in the above example.
* Excellent IDE integration that would never work with a dynamic language. Development becomes much easier when you can read the documentation in the context of your code.
* Even though K/N may not be very optimized, we may still be able to expect a level of performance where graphics rendering directly from Kotlin becomes feasible.

### The bad

* Interoperability with external native libraries is a bit tedious. I plan to work with native libraries like wayland-server and [wlroots](https://github.com/swaywm/wlroots) from C. More on that later.
* Kotlin/Native is not very mature.
* K/N provides garbage collection. I am not sure how well that will work together with C.
* K/N comes with some baggage from the JVM world. For instance, the necessary build tools (including the compiler) requires Java on the host system.
* No support for BSD.

## Planned design

As mentioned, the compositor will be based on [wlroots](https://github.com/swaywm/wlroots) which serves as a good base for a Wayland compositor. This project will be split into 3 pieces of software: The core, the bridge, and the config.

### The core

The core is an executable and the only part written in C. It will expose an API via its headers which the bridge will link to. The core will also be responsible for loading and reloading the bridge at runtime with `dlfcn.h`. This is sort of like a “thick” but opinionated wrapper.

### The bridge

The bridge is a shared library loaded by the core and linked by the config. It contains the DSL for the configuration, and also contains a default configuration in case the user-defined config is missing or fails to load.

### The config

This contains all of the user's code. When the user wants to run their new configuration, the Gradle task runner can be used to compile a shared object and notify the running core about the new binary.

### How to resolve the dependencies

This is a very complicated dependency graph between 3 pieces of software. Here is how they will interact together:

* The core loads the bridge (with or without config attached) and invokes a single function with `dlsym()`. This call to dlsym will return a struct with function references so that the core can invoke the bridge.
* The `dlsym()` call will be used on a fixed entry point in the bridge, using a header provided by the core. This prevents circular header dependency.
* I believe that the bridge can depend on the headers of the core. It is usually not a problem to import C headers in K/N.
* The bridge can either be compiled as a shared object to be loaded directly by the core or as a klib to be linked by the config.
* The config can use a singleton to make the bridge aware of its presence. If K/N has support for reflection, this can probably be done more elegantly.

repository: tobiramalebg/blog

repo_name: tobiramalebg/blog


text:
# KnowYourAngles
KnowYourAngles is designed to help students in Trigonometry learn the values of the Unit Circle. It selects a random problem and displays it. The user writes their answer in the given space. The answer is made beautiful using [MyScript's Interactive Ink SDK 1.3](https://developer.myscript.com/docs/interactive-ink/1.3/overview/about/), and the result can be used to check if the user's answer is correct.

## Getting started
To download some of the frameworks necessary to run KnowYourAngles, you will need [Git LFS](https://git-lfs.github.com/).  Detailed instructions are available from [GitHub Help](https://help.github.com/articles/installing-git-large-file-storage/).

Additionally, you will need to visit the [MyScript Developer site](https://developer.myscript.com/getting-started/ios) to obtain a certificate to use for development/testing purposes.  Other resources and documentation about the [MyScript APIs](https://developer.myscript.com/) is available.

## Branches
- master: deployable, working version of the KnowYourAngles app
- Version2: Includes a Launch Screen, Summary Page, and Scratch Paper
- Version3:
- Version4: Big Revision of Summer 2018 which includes
    - using a tab controller for the main screen
    - user interface icons from icons8.com
    - app now has a quiz mode and a study mode
    - study mode allows users to practice with immediate feedback and the ability to look back at previously completed problems
    - settings now includes options for left-handed users and inverse trig functions
    - "high score" is now "statistics" so users know which trig functions they need to work on
- revision2019: Big Revision of Summer 2019 which includes
    - Implementing the latest version (1.3) of MyScript's Interactive Ink SDK
    - "Save Screenshot" in Quiz Mode now saves the score, time used, and summary table as a picture in Photos
    - Tutorial has been updated to include scratch paper and button for clearing the scratch paper
    - About page has been updated to include the correct version of MyScript's Interactive Ink SDK
    - Grouped files for Study Mode together
    - Grouped files for Quiz Mode together
    - squashed some bugs

repository: IolaniDev/KnowYourAngles

gha_language: Swift

gha_license_id: NOASSERTION

repo_name: IolaniDev/KnowYourAngles


text:
# Selly Ruby

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'selly'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install selly

## Usage

Visit the [API documentation](https://selly.gg/developer/docs) for complete method lists

```ruby
require 'selly'

# Set API credentials
Selly.api_key = 'your api key'
Selly.api_email = 'your account email'

# List orders
Selly::Orders.list

# Pagination
Selly::Orders.list(page: 10)

# Get single resource
Selly::Orders.show('order id')
```

## License

The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

repository: Selly/selly-ruby

repo_name: Selly/selly-ruby


text:
# Bandstand

## Contributor(s):
1. Paul Ogawa (https://github.com/Pogawa)

## Installation

Retrieve the included Gemfile and Run the following command
```
bundle install
```

## Usage

To use the app run
```
ruby app.rb
```
Navigate in your browser to localhost:4567. Once page loads enter your package dimensions and weight and  click calculate to find the cost of shipping.

### Bug reports

If you discover any bugs, feel free to create an issue on GitHub. Please add as much information as
possible to help us fixing the possible bug. We also encourage you to help even more by forking and
sending us a pull request.

## License

MIT License. Copyright 2015

repository: POgawa/bandstand

repo_name: POgawa/bandstand


text:
---
layout: post
title: ioredis.js tutorial
published: true
---

### Introduction
ioredis.js is a new, performance focused Redis client for Node.js. It is used by the online commerce company, Alibaba. It also supports ES6 types such as Map and Set and also implements support for Promises, which the other big Redis client, node_redis, is not.
ioredis.js is newly released so in the next sections of this blog post I will show you some basic usage of this client.

### Installing the client

``` bash
npm install ioredis
```

### Instantiating the client

``` javascript
var Redis = require("ioredis");
//basic constructor - Connect to <IP_ADDRESS>:6379
var redis = new Redis();
```

There are multiple ways to instantiate the Redis client. Above I presented the basic method of doing it and bellow I will show you more methods:

``` javascript
//<IP_ADDRESS>:6400
var Redis = new Redis(6400);
```

``` javascript
// <IP_ADDRESS>:6379
var Redis = new Redis(6379, '<IP_ADDRESS>');
```

``` javascript
// <IP_ADDRESS>:6379
var Redis = new Redis(6379, '<IP_ADDRESS>');
```

``` javascript
// <IP_ADDRESS>:6380, db 4
new Redis('redis://:authpassword@<IP_ADDRESS>:6380/4');
```

``` javascript
new Redis('/tmp/redis.sock');
```

``` javascript
new Redis({
  port: 6379,          // Redis port
  host: '<IP_ADDRESS>',   // Redis host
  family: 4,           // 4(IPv4) or 6(IPv6)
  password: 'auth'
  db: 0
})
```

I also suggest, as best practice in general to use environment variables for connectivity credentials/urls/ports.

### Basic functionality

The two basic Redis operations set and get can be done pretty straight forward with ioredis.js.

Set:

``` javascript
redis.set('key', 'value');
```

Get using callbacks:

``` javascript
redis.get('key', function (err, result) {
  console.log(result); //will display 'value'
});
```

Get using promises:

``` javascript
redis.get('key').then(function (result) {
  console.log(result); //will display 'value'
});
```

Adding a set of values:

``` javascript
// Arguments to commands are flatten, so the following are same
redis.sadd('set', 1, 3, 5, 7);
// or
redis.sadd('set', [1, 3, 5, 7]);
```

Getting a set of values using callback:

``` javascript
redis.smembers('set', function(err, result) {
  console.log(result); //will display '1, 3, 5, 7'
});
```

Getting a set of values using promises:

``` javascript
redis.smembers('set').then(function(result) {
  console.log(result); //will display '1, 3, 5, 7'
});
```

All Redis commands are supported by ioredis.js, both using callbacks or promises. Just use each command as a method name for the Redis client.

### Handling binary data

ioredis.js also handles binary data by adding and retrieving buffers.

Adding:

``` javascript
redis.set('key', new Buffer('value'));
```

Every command has a method that returns a buffer. By doing that you have to append "Buffer" to the command name.

Retrieving:

``` javascript
redis.getBuffer('key', function (err, result) {
  // result is a buffer.
});
```

ioredis.js also supports pipelining, transactions, offline queues, Sentinel and Cluster. For these advanced operations you can find a pretty detailed description here.

I hope this tutorial is informative enough to give you a start with ioredis.js.


text:
# pyMOR

git clone --recursive https://github.com/wghou/pyMOR

pip install ./pyMOR

ACKNOLEDGEMENTS:

This project uses HRPD: "Hyper-Reduced Projective Dynamics" by Christopher Brandt, Elmar Eisemann and
Klaus Hildebrandt.

repository: wghou/pyMOR

repo_name: wghou/pyMOR