text:
# WAGI: WebAssembly Gateway Interface

_WAGI is the easiest way to get started doing cloud-side WASM web apps._

**WARNING:** This is experimental code put together on a whim.
It is not considered production-grade by its developers, neither is it "supported" software.
This is a project we wrote to demonstrate another way to use WASI.

> DeisLabs is experimenting with many WASM technologies right now.
> This is one of a multitude of projects (including [Krustlet](https://github.com/deislabs/krustlet))
> designed to test the limits of WebAssembly as a cloud-based runtime.

## tl;dr

WAGI allows you to run WebAssembly WASI binaries as HTTP handlers.
Write a "command line" application that prints a few headers, and compile it to WASM32-WASI.
Add an entry to the `modules.toml` matching URL to WASM module.
That's it.

You can use any programming language that can compile to WASM32-WASI.

## What Is WebAssembly Gateway Interface (WAGI)

Like fashion, all technologies eventually make a comeback.
WAGI (pronounced "waggy") is an implementation of CGI for WebAssembly and
WebAssembly System Interface (WASI).

In the current specification, WASI does not have a networking layer.
It has environment variables and file handles, but no way of creating a server.
Further, current WASM implementations are single-threaded and have no support for concurrency.
So it would be difficult to write a decent web server implementation anyway.

But these problems are nothing new.
In the 1990s, as the web was being created, a standard arose to make it easy to attach scripts to a web server, thus providing dynamic server-side logic.
This standard was the [Common Gateway Interface](https://tools.ietf.org/html/rfc3875), or CGI.
CGI made it dead simple to write stand-alone programs in any language, and have them answer Web requests.
WASM + WASI is suited to implementing the same features.

WAGI provides an HTTP server implementation that can dynamically load and execute WASM modules using the same techniques as CGI scripts.
Headers are placed in environment variables.
Query parameters, when present, are sent in as command line options.
Incoming HTTP payloads are sent in via STDIN.
And the response is simply written to STDOUT.

Because the system is so simple, writing and testing WAGI is simple, regardless of the language you choose to write in.
You can even execute WAGIs without a server runtime.

WAGI is designed to be higher in security than CGI.
Thus WAGIs have more security restrictions.

- They cannot access many things (including the filesystem) without explicit access grants.
- They cannot make outbound network connections.
- They cannot execute other executables on the system.
- They cannot access arbitrary environment variables--only ones that are explicitly passed in.

In the future, as WASI matures, we will relax the restrictions on outbound networking.

## Getting Started

To run the WAGI server, use `cargo run -- --config path/to/modules.toml`.
You can also `cargo build` WAGI and run it as a static binary.

Once you are running WAGI, you can test it out with your browser or `curl`. By default,
WAGI runs on `localhost:3000`: You can override this with `--listen`/`-l`.

```console
$ curl http://localhost:3000/hello/world
hello world
```

To get a look at the HTTP request and response, use the `-v` flag on `curl`:

```
$ curl -v http://localhost:3000/hello/world
*   Trying <IP_ADDRESS>...
* TCP_NODELAY set
* Connected to localhost (<IP_ADDRESS>) port 3000 (#0)
> GET /hello/world HTTP/1.1
> Host: localhost:3000
> User-Agent: curl/7.64.1
> Accept: */*
>
< HTTP/1.1 200 OK
< content-type: text/plain
< content-length: 12
< date: Wed, 14 Oct 2020 22:00:59 GMT
<
hello world
* Connection #0 to host localhost left intact
* Closing connection 0
```

### Examples and Demos

- [env_wagi](https://github.com/deislabs/env_wagi): Dump the environment that WAGI sets up, including env vars and args.
- [hello-wagi-as](https://github.com/deislabs/hello-wagi-as): AssemblyScript example using environment variables and query params.

If you want to understand the details, read the [Common Gateway Interface 1.1](https://tools.ietf.org/html/rfc3875) specification.
While this is not an exact implementation, it is very close.
See the "Differences" section below for the differences.

## Configuring the WAGI Server

The WAGI server uses a `modules.toml` file to point to the WAGI modules that can be executed.
(A WAGI module is just a WASM+WASI module that prints its output correctly.)

Here is an example `modules.toml`:

```toml
[[module]]
route = "/"
module = "/absolute/path/to/root.wasm"

[[module]]
route = "/foo"
module = "/path/to/foo.wasm"

[[module]]
# The "/..." suffix means this will match /bar and its subpaths, like /bar/a/b/c
route = "/bar/..."
module = "/path/to/bar.wasm"
# You can give WAGI access to particular directories on the filesystem.
volumes = {"/path/inside/wasm": "/path/on/host"}
# You can also put static environment variables in the TOML file
environment.TEST_NAME = "test value"

[[module]]
# You can also execute a WAT file directly
route = "/hello"
module = "/path/to/hello.wat"
```
### TOML fields

- Top-level fields
  - Currently none
- The `[[module]]` list: Each module starts with a `[[module]]` header. Inside of a module, the following fields are available:
  - `route`: The path that is appended to the server URL to create a full URL (e.g. `/foo` becomes `https://example.com/foo`)
  - `module`: The absolute path to the module on the file system
  - `environment`: A list of string/string environment variable pairs.
  - `repository`: RESERVED

## Writing WAGI Modules

A WAGI module is a WASM binary compiled with WASI support.

A module must have a `_start` method. Most of the time, that is generated by the compiler.
More often, an implementation of a WAGI module looks like this piece of pseudo-code:

```javascript
function main() {
    println("Content-Type: text/plain") // Required header
    println("")                         // Empty line is also require
    println("hello world")              // The body
}
```

Here is the above written in Rust:

```rust
fn main() {
    println!("Content-Type: text/plain\n");
    println!("hello world");
}
```

In Rust, you can compile the above with `cargo build --target wasm32-wasi --release` and have a WAGI module ready to use!

And here is an [AssemblyScript](https://www.assemblyscript.org) version:

```typescript
import "wasi";
import { Console } from "as-wasi";

Console.log("content-type: text-plain");
Console.log(""); // blank line separates headers from body.
Console.log("hello world");
```

Note that the AssemblyScript compiler generates the function body wrapper for you.
For more, check out the AssemblyScript WASI [docs](https://wasmbyexample.dev/examples/wasi-hello-world/wasi-hello-world.assemblyscript.en-us.html).

## The Enviornment Variables

These are the environment variables set on WAGI requests:

```bash
X_MATCHED_ROUTE="/envwasm"  # for example.com/envwasm
HTTP_ACCEPT="*/*"
REQUEST_METHOD="GET"
SERVER_PROTOCOL="http"
HTTP_USER_AGENT="curl/7.64.1"
CONTENT_TYPE=""             # Usually set on POST/PUT
SCRIPT_NAME="/path/to/env_wagi.wasm"
SERVER_SOFTWARE="WAGI/1"
SERVER_PORT="80"
SERVER_NAME="localhost:3000"
AUTH_TYPE=""
REMOTE_ADDR="<IP_ADDRESS>"
REMOTE_HOST="<IP_ADDRESS>"
PATH_INFO="/envwasm"
QUERY_STRING=""
PATH_TRANSLATED="/envwasm"
CONTENT_LENGTH="0"
HTTP_HOST="localhost:3000"
GATEWAY_INTERFACE="CGI/1.1"
REMOTE_USER=""
X_FULL_URL="http://localhost:3000/envwasm"
```

## Differences from CGI 1.1

- We use UTF-8 instead of ASCII.
- WAGIs are not handled as "processes", they are executed internally with multi-threading.
- WAGIs do _not_ have unrestricted access to the underlying OS or filesystem.
    * If you want to give a WAGI access to a portion of the filesystem, you must configure the WAGI's `wagi.toml` file
    * WAGIs cannot make outbound network connections
    * Some CGI env vars are rewritten to remove local FS information
- WAGIs have a few extra CGI environment variables, prefixed with `X_`.
- A `location` header from a WAGI must return a full URL, not a path. (CGI supports both)
    * This will set the status code to `302 Found` (per 6.2.4 of the CGI specification)
    * If `status` is returned AFTER `location`, it will override the status code
- WAGI does NOT support NPH (Non-Parsed Header) mode
- The value of `args` is NOT escaped for borne-style shells (See section 7.2 of CGI spec)

It should be noted that while the daemon (the WAGI server) runs constantly, both the `modules.toml` and the `.wasm` file are loaded for each request, much as they were for CGI.
In the future, the WAGI server may cache the WASM modules to speed loading.
But in the near term, we are less concerned with performance and more concerned with debugging.

## Contributing

We hang out in the [#krustlet](https://kubernetes.slack.com/messages/krustlet) channel of the [Kubernetes Slack](https://kubernetes.slack.com).
If WAGI gains popularity, we'll create a dedicated channel (probably on a more fitting Slack server).

WAGI is experimental, and we welcome contributions to improve the project.
In fact, we're delighted that you're even reading this section of the docs!

For bug fixes:

- Please, pretty please, file issues for anything you find. This is a new project, and we are SURE there are some bugs to work out.
- If you want to write some code, feel free to open PRs to fix issues. You may want to drop a comment on the issue to let us know you're working on it (so we don't duplicate effort).

For refactors and tests:

- We welcome any changes to improve performance, clean up code, add tests, etc.
- For style/idiom guidelines, we follow the same conventions as [Krustlet](https://github.com/deislabs/krustlet)

For features:

- If there is already an issue for that feature, please let us know in the comments if you plan on working on it.
- If you have a new idea, file an issue describing it, and we will happily discuss it.

Since this is an experimental repository, we might be a little slow to answer.

## Code of Conduct

This project has adopted the [Microsoft Open Source Code of
Conduct](https://opensource.microsoft.com/codeofconduct/).

For more information see the [Code of Conduct
FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact
[opencode<EMAIL_ADDRESS>with any additional questions or comments.

repository: VishnuJin/wagi

repo_name: VishnuJin/wagi


text:
# ansible-etckeeper

Install and configure etckeeper.

Forked from [groover.etckeeper](https://github.com/silpion/ansible-etckeeper).

## Requirements

None.

## Installation

To install it, run:

    ansible-galaxy install https://github.com/solooboroten/ansible-etckeeper.git

## Role Variables

* ``etckeeper_vcs``: Configure the VCS etckeeper shall use (string, default: ``git``, values: [``git``, ``mercurial``, ``bzr``, ``darcs``])
* ``etckeeper_git_commit_options``: Configure Git commit options for etckeeper (string, default: "")
* ``etckeeper_hg_commit_options``: Configure Mercurial commit options for etckeeper (string, default: "")
* ``etckeeper_bzr_commit_options``: Configure Bazaar commit options for etckeeper (string, default: "")
* ``etckeeper_darcs_commit_options``: Configure Darcs commit options for etckeeper (string, default: "")
* ``etckeeper_avoid_special_file_warning``: Configure etckeeper to set AVOID_SPECIAL_FILE_WARNING=1 (bool, default: ``false``)
* ``etckeeper_avoid_daily_autocommits``: Configure etckeeper to set AVOID_DAILY_AUTOCOMMITS=1 (bool, default: ``false``)
* ``etckeeper_avoid_commit_before_install``: Configure etckeeper to set AVOID_COMMIT_BEFORE_INSTALL=1 (bool, default: ``false``)

## Example Playbook

    - hosts: servers
      roles:
         - { role: etckeeper, etckeeper_vcs: darcs }

## License

Apache Version 2.0

## Integration testing

This role provides integration tests using the Vagrant.

    # run the complete test suite with Vagrant
    vagrant up

## Author information

[Aleksey Avdeev](https://github.com/solooboroten)

### Contributions

Thanks for their thoughts and work goes to...

* Mark Kusch @mark.kusch silpion.de (the author of the original `groover.etckeeper`)
* [Karl Goetz](https://github.com/goetzk)
* [ypid](https://github.com/ypid)

<!-- vim: set nofen ts=4 sw=4 et: -->

repository: solooboroten/ansible-etckeeper

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: solooboroten/ansible-etckeeper


text:
# Project and Backend Setup <!-- omit in toc -->

We'll now setup the backend environment for our application as well as establish our initial Pinpoint configuration.

## Table of Contents
- [Create Project](#create-project)
  - [Initialize the project](#initialize-the-project)
- [Backend Setup](#backend-setup)
  - [Inspect Configuration](#inspect-configuration)
  - [Create resources in AWS](#create-resources-in-aws)
  - [Pinpoint Initial Setup](#pinpoint-initial-setup)

# Create Project

## Initialize the project

We're now going to clone our e-commerce store and the backend environment to support it.

Simply `git clone` the repo `https://github.com/aws-samples/aws-amplify-ecommerce` into another folder using the following commands:

```Shell
git clone https://github.com/aws-samples/aws-amplify-ecommerce
cd aws-amplify-ecommerce
```

Run this command inside the project folder to initialise your environment.

**IMPORTANT**: Ensure you are in the **`aws-amplify-ecommerce`** directory.

```Shell
amplify init
```

Follow the commands in the follwing code block, taking note of the answers.

**NOTE**: Use your arrow keys to select from a list of options, followed by the enter key

```
? Enter a name for the environment reinvent
? Choose your default editor: None
Using default provider  awscloudformation
AWS access credentials can not be found.
? Setup new user Yes
Follow these steps to set up access to your AWS account:

Sign in to your AWS administrator account:
https://console.aws.amazon.com/
Press Enter to continue

Specify the AWS Region
? region:  us-west-2
Specify the username of the new IAM user:
? user name:  amplify-XXXX
Complete the user creation using the AWS console
https://console.aws.amazon.com/iam/home?region=undefined#/users$new?step=final&accessKey&userNames=amplify-6AJCR&permissionType=policies&policies=arn:aws:iam::aws:policy%2FAdministratorAccess
Press Enter to continue

Enter the access key of the newly created user:
? accessKeyId:  **********************
? secretAccessKey:  ************************************
This would update/create the AWS Profile in your local machine
? Profile Name:  default

Successfully set up the new user.

For more information on AWS Profiles, see:
https://docs.aws.amazon.com/cli/latest/userguide/cli-multiple-profiles.html

? Do you want to use an AWS profile? Yes
? Please choose the profile you want to use default
Adding backend environment reinvent to AWS Amplify Console app: d1d99z1dndh7mk
⠏ Initializing project in the cloud...
```

From here Amplify will initialize your project in the cloud.  When complete you should see the following question:

```
✔ Successfully created initial AWS cloud resources for deployments.
✔ Initialized provider successfully.
? Do you want to configure Lambda Triggers for Cognito? No
Initialized your environment successfully.

Your project has been successfully initialized and connected to the cloud!
```

# Backend Setup

We should now have an initialized project in the cloud.

Run **`amplify status`** to get a list of resources that Amplify has detected in the project.  You should see a table like the one below:

```Shell
| Category  | Resource name           | Operation | Provider plugin   |
| --------- | ----------------------- | --------- | ----------------- |
| Auth      | awsamplifyecommerceauth | Create    | awscloudformation |
| Analytics | awsamplifyecommerce     | Create    | awscloudformation |
| Storage   | dynamodbitems           | Create    | awscloudformation |
| Function  | lambdaitems             | Create    | awscloudformation |
| Api       | awsamplifyecommerceapi  | Create    | awscloudformation |
```

The table above indicates that 5 backend features have been detected in the project.  As these features have not been deployed to the cloud yet they have *Create* listed as the next operation.

## Inspect Configuration

We can view the configuration and CloudFormation created for each of these services by exploring the `/amplify/backend` directory.

Go ahead and explore the services to be provisioned.  You should see:

1. A parameter file with specific settings for the service to be provisioned

2. A CloudFormation template for creating the resouce in the cloud

## Create resources in AWS

Let's go ahead and create our resources in AWS now.  To do so we will push our config up to the cloud which will launch our CloudFormation and provision our defined resources in the cloud.

Type in the follwing in your Cloud9 terminal to kick off the provisioning:
```
amplify push
```

You should see your resouces being provisioned now, this should take a couple minutes to complete.

Run another **`amplify status`** and you should now see the following

```Shell
| Category  | Resource name           | Operation | Provider plugin   |
| --------- | ----------------------- | --------- | ----------------- |
| Auth      | awsamplifyecommerceauth | No Change | awscloudformation |
| Analytics | awsamplifyecommerce     | No Change | awscloudformation |
| Storage   | dynamodbitems           | No Change | awscloudformation |
| Function  | lambdaitems             | No Change | awscloudformation |
| Api       | awsamplifyecommerceapi  | No Change | awscloudformation |

Pinpoint URL to track events https://us-west-2.console.aws.amazon.com/pinpoint/home/?region=us-west-2#/apps/*****************/analytics/overview
```

An operation of *No Change* means that all our resources have been provisioned in our AWS account.

Go ahead and take a look at the new services that have been created:

- [Amazon Cognito](https://us-west-2.console.aws.amazon.com/cognito/users/?region=us-west-2)
- [Amazon DynamoDB](https://us-west-2.console.aws.amazon.com/dynamodb/home?region=us-west-2)
- [AWS Lambda](https://us-west-2.console.aws.amazon.com/lambda/home?region=us-west-2)
- [Amazon API Gateway](https://us-west-2.console.aws.amazon.com/apigateway/home?region=us-west-2)

## Pinpoint Initial Setup

Once everything has been successfully provisioned you should have a URL for the new Pinpoint endpoint we'll be using.

Copy the URL for Pinpoint and open it in a new browser window.

You should see the default layouy with no data

![Pinpoint](images/aws-pinpoint-1.png)

Let's go ahead and setup the e-mail configuration and verify your email address for use with Pinpoint.

1. Navigate to **Settings** and click on **Manage**
   ![Settings](images/aws-pinpoint-2.png)

2. Under **Identity details** click **Edit**

3. Enable the email channel and type in the email address you have access to.

>**NOTE**: We'll be using this email address for Pinpoint as well as for your registration for the Store.  Make sure you select one you're able to check for mail on.

4. Click on **Verify email address**

5. Finally, click on the **Save** button

5. You should receive an e-mail with a link to verify your email address, go ahead and check your email and follow the link to verify your email address.

![Email Verification](images/aws-pinpoint-3.png)

6. Refesh your Pinpoint screen and you should see the following, confirming you are able to send email using your email address

![Email Validated](images/aws-pinpoint-4.png)

You've now completed the backend setup, head to [Hosting for E-commerce Store](/documentation/hosting/) to setup hosting for the frontend.

repository: JacobMiske/worklighttools-ecommerce

gha_language: JavaScript

repo_name: JacobMiske/worklighttools-ecommerce


text:
# BottomSheetCoordinatorLayout

**24/11/16 This is not a fully working implementation**

An attempt to use Coordinator Layouts in Bottom Sheets!
There is also a [question][stckovrflw] on Stack Overflow that is yet waiting for a decent answer.

| Custom behavior                           | (Issues)                                         |
| ----------------------------------------- | ------------------------------------------------ |
| :heavy_check_mark: nested scrolling works | :x: toolbar sometimes collapses too early        |
| :heavy_check_mark: toolbar can be dragged | :x: toolbar cannot be collapsed through drags    |
|                                           | :x: main coordinator layout consumes some scroll |
| ![Custom behavior](assets/custom.gif)     | ![Behavior issues](assets/issues.gif)            |

| Android default behavior (unsupported)    |
| ----------------------------------------- |
| :x: cannot close by nested scrolling      |
| ![Default behavior](assets/default.gif)   |

[stckovrflw]: <http://stackoverflow.com/q/36229911/4744332>


text:
```
<Router.Animate
    waitForParent // dont start this animation until parent is started // will hold off on mounting if haven't mounted yet
    parentOffset={200} // ms - time to offset from start of parent animation if any // will hold off on mounting if havent mounted yet
    onChange={when(isVisible, (id, finished) => anime({ targets: `#${id}`, translateX: 200 }).finished )}
>
    <Animateable>
        ...blah
    </Animateable>
<Router.Animate>
```

RefAnimation => (ref, finished) => any // gets the ref of the child and exposes a function to animate the child by it
CSSAnimation => string[] | string // applies a string or array of strings to the className of the child

1. Wait for component to mount
2. Run animation
3. Wait for animation to finish

https://reactjs.org/docs/refs-and-the-dom.html#exposing-dom-refs-to-parent-components

license: MIT

repository: erhathaway/router-primitives-react

gha_language: TypeScript

gha_license_id: MIT

repo_name: erhathaway/router-primitives-react


text:
[![Build Status](https://travis-ci.org/tandrewnichols/readdirs.png)](https://travis-ci.org/tandrewnichols/readdirs) [![downloads](http://img.shields.io/npm/dm/readdirs.svg)](https://npmjs.org/package/readdirs) [![npm](http://img.shields.io/npm/v/readdirs.svg)](https://npmjs.org/package/readdirs) [![Code Climate](https://codeclimate.com/github/tandrewnichols/readdirs/badges/gpa.svg)](https://codeclimate.com/github/tandrewnichols/readdirs) [![Test Coverage](https://codeclimate.com/github/tandrewnichols/readdirs/badges/coverage.svg)](https://codeclimate.com/github/tandrewnichols/readdirs) [![dependencies](https://david-dm.org/tandrewnichols/readdirs.png)](https://david-dm.org/tandrewnichols/readdirs)

# readdirs

Read several directories at once asynchronously

## Installation

`npm install --save readdirs`

## Summary

This module is essentially a convenience wrapper for using [async](https://github.com/caolan/async) in combination with `fs.readdir`. It reads the directories you pass it and concatenates and sorts the results.

## Usage

Require `readdirs` and pass an array of directories (relative to pwd, as with `fs.readdir`), optionally an options object, and a callback, and you'll get an optional error and the list of files back.

The default usage returns only the file name, as readdir does.

```js
var readdirs = require('readdirs');

readdirs([__dirname + '/a', __dirname + '/b'], function(err, files) {
  // Files is an array of file names (just as with readdir)
});
```

But you can also request absolute paths if you need to be able to sort out which ones are in which directory.

```js
var readdirs = require('readdirs');

readdirs([__dirname + '/a', __dirname + '/b'], { absolute: true }, function(err, files) {
  // Files is an array of absolute file names
});
```

Or you can leave the arrays unmerged (i.e. an array of arrays instead of file names).

```js
var readdirs = require('readdirs');

readdirs([__dirname + '/a', __dirname + '/b'], { nested: true }, function(err, files) {
  // Files is an array of arrays. The first array is the files in __dirname/a
  // and the second is files in __dirname/b.
});
```

And of course, you could combine these options as well.

If you want more finely grained control of the resultant file structure, you should check out [file-manifest](https://github.com/tandrewnichols/file-manifest), which can do a lot more.

## Contributing

Please see [the contribution guidelines](CONTRIBUTING.md).

repository: tandrewnichols/readdirs

repo_name: tandrewnichols/readdirs


text:
# cNutanix: Automated VM Provisioning

cNutanix is a PowerShell Desired State Configuration (DSC) Resource Module enabling the automated provisioning of Nutanix virtual machines, including the creation of VM Disk's, and VM NIC's. This module includes three resources:

* NewVM
* NewVMDisk
* NewVMNic

## NewVM

````` PowerShell
NewVM [String] #ResourceName
{
    Ensure                  = [string]{ Absent | Present }
    vmName                  = [string]
    MemoryMB                = [Int32]
    [Description            = [string]]
    [NumberOfVCpu           = [Int32]]
    [NumberOfCoresPerVCpu   = [Int32]]
    [VmCustomizationConfig  = [string]]
    ClusterUri              = [string]
    ClusterCredential       = [PSCredential]
    [DependsOn              = [string[]]]
}
`````

## NewVMDisk

````` PowerShell
NewVMDisk [String] #ResourceName
{
    Ensure              = [string]{ Absent | Present }
    BusId               = [string]
    vmName              = [string]
    ContainerName       = [string]
    [DiskSizeGB         = [Int32]]
    [SourceVmName       = [string]]
    ClusterUri          = [string]
    ClusterCredential   = [PSCredential]
    [DependsOn          = [string[]]]
}
`````

## NewVMNic

````` PowerShell
NewVMNic [String] #ResourceName
{
    Ensure              = [string]{ Absent | Present }
    vmName              = [string]
    [vlanID             = [Int32]]
    [vlanName           = [string]]
    ClusterUri          = [string]
    ClusterCredential   = [PSCredential]
    [DependsOn          = [string[]]]
}
`````

repository: EmmaRenee/cNutanix

repo_name: EmmaRenee/cNutanix


text:
---
layout: post
title:  "ClassLoader trees"
author: Neil C Smith
main_image_path: "/assets/classloader-tree.jpg"
description: Exploring ClassLoader trees in the forest of actors
---

_...exploring ClassLoader trees in the [forest of actors](/blog/a-forest-of-actors/)..._

PraxisCORE v5.2 added the ability to share code and types across components (actors)
in a graph. This is a feature that's been requested for a while, but took some
thinking to work out how to implement. And it's a key ingredient in how
[Codelerity](https://www.codelerity.com) is supporting general purpose programming
usage of the PraxisLIVE suite of tools.

It's been possible to add compiled libraries to PraxisCORE projects for a while,
even at runtime, and v5.1 added the ability to
[include dependencies from Maven Central](https://docs.praxislive.org/coding-libraries/).
However, such pre-compiled code is not editable. With the shared code feature
we want to allow components to share features and types, while still allowing that
code to be rewritable safely at runtime like the code of individual components.

## Sharing code

Here we have a simple example of shared code usage in PraxisLIVE v5.2 (click to
enlarge). We have a shared `ID` type passed between two components, `id-source` and
`id-consumer` using data ports. This is somewhat contrived as data ports are usually
used for packets of continuous data. We also have a shared `Utils` class for utility
methods that can be static imported into our component code.

The problem to be solved was allowing the shared code to be edited and recompiled
at any point, while ensuring that at any instant, all components in the graph are
linked to the same shared type. We also want to ensure that any changes to shared
code are always valid - not removing types or methods in use by any component.

Part of addressing these concerns is the limitation that shared code is only shared
across the components within a single graph / root. As within our forest of actors
architecture each root is guaranteed to be only active on a single thread at any
time, we can ensure atomic replacement. It also shields us from having to deal with
the problem of some roots being local and others remote. Shared code is currently
stored as a property of the root component, although in theory we could also support
shared code on sub-containers.

Implementing shared code involved some rethinking of the ClassLoader hierarchy used
for dynamic code in components, as well as significant changes to the compiler service
and other services used in the updating of component code.

## A ClassLoader tree

In versions of PraxisCORE prior to v5.2, we have the following (truncated) hierarchy
of ClassLoaders for each component.

- System ClassLoader(s)
- Library ClassLoader
- Code delegate ClassLoaders

The system ClassLoaders are obviously the JDK and modules that make up the PraxisCORE
runtime, on modulepath or classpath. The library ClassLoader is used for adding
pre-compiled libraries to a project, or strictly to the RootHub - this is currently
a subclass of `URLClassLoader` that allows for dynamic addition (not removal), and
there is a single instance that exists for the lifetime of each hub.

Finally, the code delegate ClassLoaders are lightweight in-memory ClassLoaders that
contain a single iteration of one component's code. Every code update involves replacing
this ClassLoader and the classes it contains. There can be many active code delegate
ClassLoaders at any one time - one for every component in the graph that has customized
code.

For more on the use of code delegates to support real-time programming / code hotswap
see the related post on [Just-in-Time Programming](/blog/just-in-time-programming)
systems in Java.

From v5.2 this ClassLoader tree has changed - we now have a shared code
ClassLoader inserted in the hierarchy.

- System ClassLoader(s)
- Library ClassLoader
- _Shared code ClassLoader_
- Code delegate ClassLoaders

That is, _some_ component ClassLoaders may now have the shared code ClassLoader as a
parent. As mentioned, shared code is currently attached to each root, so we now
have a ClassLoader tree that roughly follows our forest of actors hierarchy -
system (process) → library (root hub) → shared code (root) → code delegate (component).

Like the code delegate ClassLoaders, the shared code ClassLoader is lightweight and
in-memory (in fact the same type, wrapping a PMap of PByte). Whenever any shared
code type is updated, we have to recompile all the shared code types, and create
a new ClassLoader. This also means that we need to recompile and create new
ClassLoaders for every dependent code delegate - we cannot just reload the delegate
bytecode in a new ClassLoader or we run the risk of `NoSuchMethodError` and other
problems when the shared code changes incompatibly.

Because of the overhead of recompilation and atomic replacement, the shared code
ClassLoader is kept as an optional element of the hierarchy - only components that
require linking to shared code types have this ClassLoader as a parent. Likewise,
because the code delegate ClassLoader remains separate and has the shared code
ClassLoader as a parent, we can update component code without needing to recompile
and reload any shared code. So, the shared code addition has minimal impact on
runtime code updates that were possible prior to v5.2.

## Compiler and context service rewrites

PraxisCORE has the concept of Protocols, akin to interfaces exposed by actors, and
Services that are Protocol implementations that can be registered and located by
other actors. There are two services involved in runtime code updates - a service
that can create new CodeContexts (wrappers for CodeDelegate instances loaded from
the above mentioned ClassLoaders) and a service that exposes the Java compiler. Both
work with source and bytecode in memory rather than on disk.

The context service deals with actual Java references so must be in the same process
(so one will exist in each PraxisCORE process across a distributed hub). The compiler
service can run in a separate process, or even on a separate machine, so there will
usually only be one.

Prior to v5.2, the compiler service accepted a single Java class body (ie. no
imports, class definition, etc.) and the class name of a type that could be used
to assist in wrapping the class body into valid Java source for compilation. A
legacy of an earlier iteration of compilation where everything was handled in-process,
this had the limitation of not working for full Java sources, or multiple classes.
For v5.2 the compiler service was extended to accept a map of Java sources to compile.
It can also accept an optional map of pre-existing classes to compile against.

The context service had to be rewritten to handle the wrapping of class bodies itself,
as well as extended to provide a shared code context service that also handles
recompilation and reloading of all dependent component code. This also required
changes to how classes are identified. Assume a component with the following action -

```java
@T(1) void logClass() {
    log(INFO, "Class : " + getClass().getName());
}
```

In versions prior to v5.2, if you trigger that action you will see -

```
INFO : /data/custom
Class : $
```

From v5.2 you will see something like -

```
INFO : /data/custom
Class : CODEa255.data.custom.code.$
```

Every component with custom code prior to v5.2 was backed by a delegate class named
`$` in the default package. This was fine, because a class is actually identified
by both its name and the ClassLoader that loaded it. However, now we want to support
compiling multiple components' code at the same time, along with our shared code,
we have a problem. Instead, we switch to a package name based on the component address,
with a partially randomized root package (`a255` here is random hex).

Going back to the basic patch shown in our image above, whenever the `.code` property
on `id-source` or `id-consumer` receives a new iteration of code, that code will be
sent to the code context service actor. That actor will wrap the code in its context,
adding default imports, package location (eg. `package CODExxxx.data.id_source.code;`),
and class definition (eg. `class $ extends CoreCodeDelegate`). This source will
then be passed to the compiler service, along with the previously compiled bytecode
for the `SHARED` package. On successful response, the compiled code delegate is
created, wrapped, and passed back to the component.

On the other hand, when the code of either `ID` or `Utils` is updated, the
`.shared-code` property will collect all shared code dependent components (in this
case both `id-source` and `id-consumer`) and pass their source along in a task for the
code context service. The service will wrap all component code as before, and add
to a source code map along with all shared code, for passing to the compiler. On
successful receipt, the returned bytecode map is partitioned to create the shared
code parent ClassLoader and each individual delegate ClassLoader. Delegates are
created, wrapped, and passed back in one message for atomic replacement. As the
process is asynchronous, the response is validated against the current graph before
each component is updated.

Whether or not a component is compiled and loaded against code from the `SHARED`
package is currently triggered by a search for the String `"SHARED."` in the source
code. This obviously has the possibility for false positives - it might change in
future!

## A note on Data

Data ports allow for continuous data packets to be passed from one component to
another. They are typed by their generic signature, and if that changes then the
configuration is invalidated and all connections are removed. Because class identity
is actually a product of name and ClassLoader, this would have caused all `ID` ports
to be disconnected on every shared code change. In v5.2 data ports have been updated
to retain connections where the type is in the `SHARED` package and has the same
name - atomic code replacement ensures that an `ID.class` reference is always
identical across all components at any one time.

## Inside the PraxisLIVE IDE

The PraxisLIVE IDE has been updated to support shared code editing - right-click
on the graph editor to show / add shared types. PraxisLIVE uses Apache NetBeans'
memory file system to allow editing of shared types in the same way as used for
component code. The shared code memory file system is separate to the ones used
for components, but added in to the IDE's class path support in a similar
hierarchy as used in PraxisCORE for class loading. One difference is that shared
code is always included in the class path, so that completion and code navigation
works, whether the code currently references shared code or not. Imports will be
correctly added on code completion if required, and CTRL-click on shared types or
their members will open them in the editor.

## Next steps

As you might gather from the length of this post, finding the right way to
implement shared code was complicated and took time to get right.
However, it really opens some interesting options for the future as we expand
general purpose coding support in PraxisCORE.

One initial thing currently being looked at is using shared code to support component
prototypes - effectively a way for multiple components to share the same code, but
keeping some ability to override at a component level.

Keep an eye on the
[docs for shared code](https://docs.praxislive.org/coding-shared/) as these
features evolve.

If you're interested in the actual implementations of the processes outlined above,
check out
[CodeProperty](https://github.com/praxis-live/praxiscore/blob/master/praxiscore-code/src/main/java/org/praxislive/code/CodeProperty.java),
[SharedCodeContext](https://github.com/praxis-live/praxiscore/blob/master/praxiscore-code/src/main/java/org/praxislive/code/SharedCodeContext.java),
[SharedCodeProperty](https://github.com/praxis-live/praxiscore/blob/master/praxiscore-code/src/main/java/org/praxislive/code/SharedCodeProperty.java),
[DefaultCodeFactoryService](https://github.com/praxis-live/praxiscore/blob/master/praxiscore-code-services/src/main/java/org/praxislive/code/services/DefaultCodeFactoryService.java),
and
[DefaultCompilerService](https://github.com/praxis-live/praxiscore/blob/master/praxiscore-code-services/src/main/java/org/praxislive/code/services/DefaultCompilerService.java).

Thanks for reading!

repository: praxis-live/website

gha_language: CSS

repo_name: praxis-live/website


text:
Ampersand

Another markdown editor

__Note: Ampersand is WIP and not close to something usable at the moment.__

Ampersand is a _lightweight_ [markdown](https://daringfireball.net/projects/markdown/) editor for Windows, Mac & Linux focused on a minimal & clean interface for distraction-free writing.

![ampersand screenshot](media/screenshot.png)

## Features

* Live Preview
* Github Flavored Markdown
* Dark/Light/Split Mode
* Full screen mode
* Emoji support
* Export as html

## Build

1. Clone repo ```git clone https://github.com/jackd248/electron-ampersand.git```
2. Change to repo ```cd electron-ampersand```
3. ```npm install && npm start```

## Download

You can [download](https://github.com/jackd248/electron-ampersand/releases) the latest stable version of Ampersand for Windows, Mac OS and Linux.

## Credits

This application uses code from several open source projects:

* [Electron](http://electron.atom.io/)
* [CodeMirror](http://codemirror.net/)
* [Markdown-It](https://github.com/markdown-it/markdown-it)
* [Hack Typeface](https://github.com/chrissimpkins/Hack)

## License

Copyright (c) 2016 Konrad Michalik, This software is licensed under the [MIT License](LICENSE).


text:
# CRediTas (development version)

# CRediTas 0.2.0

## Breaking changes

- Package name changed to CRediTas (#1)
- All function renamed to follow object_verb() convention. (#4)
    - `create_template` is `template_create`
    - `read_template` is `template_read`
    - `write_cras` is `cras_write`
- `file` argument in `cras_write` and in `template_create` no longer default to `NULL`, they are not provided by default. If missing, they behave like the old `NULL` value.

## New features

- `cras_write` integrates better with literate programming such as rmarkdown and
quarto. When file is NULL (new default), instead of writing a file, the
function returns a string with the CRediT Author Statement. It works well with
inline code in rmarkdown and quarto documents:
`r cras_write(cras_table, markdown = TRUE)` (#2
- `cras_write` includes a new argument `drop_authors`, if set to `FALSE`, the authors without contributions are not removed from the statement. (#6)

## Minor improvements and fixes

- The roles are created using the function roles_get() instead of hard coded. (#3)
- The former allows to check if authors’ roles are up-to-date comparing with
[CRediT] (https://credit.niso.org/) (#3)
- Improvements on the documentation of all functions (#6)
- In `cras_write`, the default of `markdown` argument is `TRUE`.
- Added some checks to `template_read` to ensure that the format is correct. (#6)
- Added reviewers of ROpenScience to `DESCRIPTION`.
- CSS fixed in pkgdown.
- Description added to `template_create` documentation.
- Option to use `fix()` to edit the template is added to `README` and `get_started` vignette.
- Related packages added to `README`.
- `template_create` is more performant thanks to using `matrix` instead of `data.frame` to create the empty contributions.

repository: ropensci/CRediTas

repo_name: ropensci/CRediTas


text:
---
layout: post
title: "Please, no more jet"
date: 2016-04-30
categories: coding
tags: python,ncl
---
{::comment}
The filename must be on this format:
2010-01-01-some-sort-of-title.md
the title in the header will be the one displayed on the web pag.
{:/comment}

When I wrote my bachelor thesis in 2009,
I was a big fan of jet,
the go--to colormap for many scientist.
I guess a big reason why it ever became popular
was that it was the default colormap in matlab.
In addition, it's quite pretty to look,
unless you actually want to understand your data that is.
The truth is, there are plenty of problems with jet,
perhaps one of the most well known is the problem with colourblind viewers.

During my master project (2010) I experimented a bit with different colormaps;
when you do that, you soon realize that changing the colormap
can have a huge effect on how you interpret your data.
Furthermore, if you print your figures in grey-scale,
the differences are even clearer.

## Grey scale readable
Two year ago, while working on paper for my PhD,
I came a accross [a blog post by Jake Vanderplas](https://jakevdp.github.io/blog/2014/10/16/how-bad-is-your-colormap/)
where he provided a python function to return "luminance--correct" grayscale version of any given colormap.
It turns out that many of the default colormaps shipped with matplotlib
(or any other visualization tool for that matter)
are quite bad at highlighting important patterns in your data.

This is probably why Mathworks decided to replace the default colormap "jet"
with a completely new one, called "parula", in the 2014b release.
The new colormap solves many of the problems which the more "traditional" colormaps have.

## Perceptually awesome
The developers of Matplotlib released four new perceptually uniform colormaps,
with the 2.0 release.
Nathaniel Smith held a [great talk about colormaps](https://www.youtube.com/watch?v=xAoljeRJ3lU)
at SciPy2015 (you should really check it out!);
where he explained the concept behind perceptually uniform colormaps
and why you should use them.

As an example, take the picture below,
it shows the same data plotted with two different colormaps;
the left figure uses the (still very common) "jet"
while right figure uses the new default colormap from matplotlib.
Notice how the part that stands out most in the left hand figure is the yellow/green somwhere in the middle.
You get a completely different impression from the the figure on the right,
there is not really any part which stands out more than the rest
and you can easily find the extreme points.

These figures were made using the [NCAR Command Language (NCL)](http://www.ncl.ucar.edu/),
so I had to export the colormaps to rgb-lists.
In case you want to use the new matplotlib colormaps in NCL,
you can find them here:

|[Viridis]({{ site.baseurl }}/assets/blogposts/2016-04-30/viridis.rgb)|[Plasma]({{ site.baseurl }}/assets/blogposts/2016-04-30/plasma.rgb)|[Magma]({{ site.baseurl }}/assets/blogposts/2016-04-30/magma.rgb)|[Inferno]({{ site.baseurl }}/assets/blogposts/2016-04-30/inferno.rgb)|

These colormaps have 254+2 colours (2 are reserved for foreground/background).
You can install them by placing them under $NCARG_ROOT/lib/ncarg/colormaps/
or, if you prefer,
put them anywhere you like and set your environment accordingly, e.g.:

~~~ bash
export NCARG_COLORMAPS=$HOME/ncl/colormaps:$NCARG_ROOT/lib/ncarg/colormaps
~~~

## A final word
I am truly grateful that someone finally put some serious work into colormaps.
However, "jet" will probably live on for a couple of more years since habits are hard to break,
even for scientists.
So please, do everyone a favour, and inform your peers/teachers/students
that there are better alternatives to 'jet' and the other traditional
(or should I say 'old-school'?) colormaps.

## Update May 3, 2017: Now also for ncview
[ncview](http://meteora.ucsd.edu/~pierce/ncview_home_page.html)
is a handy tool for quickly visualizing netcdf or hdf data.
A nice thing abount ncview is that it allows you to add your own colormaps,
so I exported a set of 256-colour versions of the maps as well:
|[Viridis]({{ site.baseurl }}/assets/blogposts/2016-04-30/viridis.ncmap)|[Plasma]({{ site.baseurl }}/assets/blogposts/2016-04-30/plasma.ncmap)|[Magma]({{site.baseurl }}/assets/blogposts/2016-04-30/magma.ncmap)|[Inferno]({{ site.baseurl }}/assets/blogposts/2016-04-30/inferno.ncmap)|
Install these by copying them to /usr/share/ncview or put them
anywhere you like and set your environment accordingly, e.g.:

~~~ bash
export NCVIEWBASE=$HOME/colormaps/ncview
~~~

Enjoy!


text:
# National checklists and red lists for European butterflies

## Rationale

This repository contains the functionality to standardize the _National checklists and red lists for European butterflies_ to a [Darwin Core checklist](https://www.gbif.org/dataset-classes) that can be harvested by [GBIF](http://www.gbif.org).

The repository also includes the script to integrate red lists, calculate weighted red list values, and create the tables and figures for [Maes et al. (2019)](https://doi.org/10.1007/s10841-019-00127-z).

## Workflow

[source data](https://github.com/inbo/eurobutt-checklist/tree/master/data/raw) (maintained as a [Google Spreadsheet](https://docs.google.com/spreadsheets/d/1RvxpOYf2ZrTu9nsTLumoi-G-GGhh6_lV37TNtPiVES4/edit?usp=sharing)) → Darwin Core [mapping script](https://inbo.github.io/eurobutt-checklist/dwc_mapping.html) → generated [Darwin Core files](https://github.com/inbo/eurobutt-checklist/tree/master/data/processed)

[source data](https://github.com/inbo/eurobutt-checklist/tree/master/data/raw) → [analysis script](https://inbo.github.io/eurobutt-checklist/integrating_rl.html) → [tables and figures for Maes et al. (2019)](https://github.com/inbo/eurobutt-checklist/tree/master/reports)

## Published dataset

* [Dataset on the IPT](https://ipt.inbo.be/resource?r=eurobutt-checklist)
* [Dataset on GBIF](https://doi.org/10.15468/ye7whj)

## Repo structure

The repository structure is based on [Cookiecutter Data Science](http://drivendata.github.io/cookiecutter-data-science/) and the [Checklist recipe](https://github.com/trias-project/checklist-recipe). Files and directories indicated with `GENERATED` should not be edited manually.

```
├── README.md              : Description of this repository
├── LICENSE                : Repository license
├── eurobutt-checklist.Rproj : RStudio project file
├── .gitignore             : Files and directories to be ignored by git
│
├── data
│   ├── raw                : Source data from Google Spreadsheet, input for scripts GENERATED
│   ├── interim            : Interim data created for analysis GENERATED
│   └── processed          : Darwin Core output of mapping script GENERATED
│
├── docs                   : Repository website GENERATED
│
├── reports                : Figures and tables as output of analysis GENERATED
│
└── src
    ├── dwc_mapping.Rmd    : Darwin Core mapping script
    ├── integrating_rl.Rmd : Analysis script to integrate red lists
    ├── _site.yml          : Settings to build website in docs/
    └── index.Rmd          : Template for website homepage
```

## Installation

1. Clone this repository to your computer
2. Open the RStudio project file
3. Open the `dwc_mapping.Rmd` [R Markdown file](https://rmarkdown.rstudio.com/) in RStudio
4. Install any required packages
5. Click `Run > Run All` to generate the processed data
6. Alternatively, click `Build > Build website` to generate the processed data and build the website in `docs/`

## Contributors

[List of contributors](https://github.com/inbo/eurobutt-checklist/contributors)

## License

[MIT License](https://github.com/inbo/eurobutt-checklist/blob/master/LICENSE)

repository: inbo/eurobutt-checklist

repo_name: inbo/eurobutt-checklist


text:
### [CVE-2021-40835](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-40835)
![](https://img.shields.io/static/v1?label=Product&message=F-Secure%20Mobile%20Security&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=18.3%3C%2018.5%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Vulnerability&message=URL%20Address%20Bar%20Spoofing%20in%20F-Secure%20SAFE%20Browser%20for%20iOS&color=brighgreen)

### Description

An URL Address bar spoofing vulnerability was discovered in Safe Browser for iOS. When user clicks on a specially crafted a malicious URL, if user does not carefully pay attention to url, user may be tricked to think content may be coming from a valid domain, while it comes from another. This is performed by using a very long username part of the url so that user cannot see the domain name. A remote attacker can leverage this to perform url address bar spoofing attack. The fix is, browser no longer shows the user name part in address bar.

### POC

#### Reference
- https://www.f-secure.com/en/business/support-and-downloads/security-advisories

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

branch_name: refs/heads/main

gha_language: HTML

repo_name: trickest/cve


text:
# Robowflex Dart

Modeling and planning through [DART (Dynamic Animation and Robotics Toolkit)](https://dartsim.github.io/).
Robots (`robowflex::darts::Robot`) and scene geometry (`robowflex::darts::Structure`) are added to a world (`robowflex::darts::World`), which is then used as the base for planning.
An [OMPL](http://ompl.kavrakilab.org/) state space is provided for worlds (`robowflex::darts::StateSpace`) which can control any joint in the world, for multiple robots.
Constraints and inverse kinematics are given through a Task Space Region specification (`robowflex::darts::TSR`).
For convenience, a helper class (`robowflex::darts::PlanBuilder`) makes it easy to specify motion planning queries.

# Scripts

There are a few example scripts to demonstrate the module, in the `scripts` directory.
- `fetch_plan.cpp`: Plan for 1 to 4 Fetch robots. Demonstrates how to do multi-robot planning by cloning robots (`robowflex::darts::Robot::clone()`) and adding more groups to the planning group.
- `fetch_robowflex_plan.cpp`: Constrained planning for a Fetch robot, where that Fetch robot is loaded via `robowflex_library` as a _MoveIt_ robot.

# Installation Instructions

DART can either be installed via a PPA or be added as a catkin package in your local workspace.
See [DART's own installation instructions for more details](https://dartsim.github.io/install_dart_on_ubuntu.html#install-dart).

If you are using an old OMPL (e.g., on Kinetic), either download the source into your local catkin workspace:
```sh
wget -O - https://github.com/ompl/ompl/archive/1.5.0.tar.gz | tar zxf -
```
Or clone from the repository:
```sh
git clone git:://github.com/ompl/ompl.git
```

repository: KavrakiLab/robowflex

gha_license_id: NOASSERTION

repo_name: KavrakiLab/robowflex


text:
---
layout: default
---

# 1996-01-16 - Re: Crypto anarchist getting through customs

## Header Data

From: "James A. Donald"<EMAIL_ADDRESS>To: attila<EMAIL_ADDRESS>Message Hash: 8be42847786f51a92c40df8dd2a7d598f82097e7e9e393620eef58fad12f5407

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-01-16 16:40:02 UTC

Raw Date: Wed, 17 Jan 1996 00:40:02 +0800

## Raw message

```
{% raw  %}From: "James A. Donald"<EMAIL_ADDRESS>Date: Wed, 17 Jan 1996 00:40:02 +0800
To: attila<EMAIL_ADDRESS>Subject: Re: Crypto anarchist getting through customs
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

At 08:20 AM 1/16/96 +0000, attila wrote:
> Bubba signed PPD 25 which permits UN control of US
> forces, _in America_!  and allows the UN to bring in UN troops.

While there are undoubtedly people plotting a one world government,
the miserable performance of the blue helmets means that there
is no present danger.  Soldiers are just not willing to die for
the greater glory of the United Nations.
 ---------------------------------------------------------------------
              				|
We have the right to defend ourselves	|   http://www.jim.com/jamesd/
and our property, because of the kind	|
of animals that we are. True law	|   James A. Donald
derives from this right, not from the	|
arbitrary power of the state.		|<EMAIL_ADDRESS>

{% endraw %}
```

## Thread

+ Return to [January 1996](/archive/1996/01)

+ Return to "[hallam@w3.org](/authors/hallam_at_w3_org)"
+ Return to "["James A. Donald" <jamesd@echeque.com>](/authors/james_a_donald_jamesd_at_echeque_com_)"

+ 1996-01-16 (Wed, 17 Jan 1996 00:40:02 +0800) - Re: Crypto anarchist getting through customs - _"James A. Donald"<EMAIL_ADDRESS>  + 1996-01-16 (Tue, 16 Jan 96 09:04:03 PST) - [Re: Crypto anarchist getting through customs](/archive/1996/01/8fce9b8557bab797f14763f56a3114b7618878b0fd594dd8c7ef6b5cc88b715f) -<EMAIL_ADDRESS>


text:
# Enumerable

## Introduction
In this project, I will implement my own version of Ruby’s enumerable methods.

## Built With
[Ruby](https://www.ruby-lang.org/en/)

## Assignment Page
[The Odin Project: Advanced Building Blocks](https://www.theodinproject.com/courses/ruby-programming/lessons/advanced-building-blocks)

## License
Distributed under the MIT License. See [LICENSE](https://github.com/yirano/mv-09-ruby-bubblesort/blob/master/LICENSE) for more information.

## Authors
Maryfel Mendoza - [Github](https://github.com/maryfelmendoza) | [LinkedIn](https://www.linkedin.com/in/maryfelmendoza/detail/recent-activity/posts/) | [Twitter](https://twitter.com/maryfelmendoza)

repository: maryfelmendoza/enumerables

repo_name: maryfelmendoza/enumerables


text:
# Accessing raw models

traintool is built on top of powerful machine learning libraries like scikit-learn or p
ytorch. After training, it gives you full access to the raw models with:

```python
model.raw()
```

This returns a dict of all underlying model objects. It usually contains the model
itself (`model.raw()["model"]`) but might also contain some other
objects, e.g. data scalers (`model.raw()["scaler"]`).


text:
---
title: 'Manual Installation'
description: 'Create your own @nuxt/content blog in seconds!'
position: 2
category: 'Getting started'
---

So you want to start a blog, right? Let's go for it! This themes relies on NuxtJS, so you need:

### `package.json`

> This file can be created with `npm init`.

Install `nuxt` and `@nuxt/content-theme-docs`:

<code-group>
  <code-block label="Yarn" active>

  ```bash
  yarn add nuxt @64robots/nuxt-content-blog
  ```

  </code-block>
  <code-block label="NPM">

  ```bash
  npm install nuxt @64robots/nuxt-content-blog
  ```

  </code-block>
</code-group>

**Example**

```json[package.json]
{
  "name": "blog",
  "version": "1.0.0",
  "scripts": {
    "dev": "nuxt",
    "build": "nuxt build",
    "start": "nuxt start",
    "generate": "nuxt generate"
  },
  "dependencies": {
    "@64robots/nuxt-content-blog": "^0.1.12",
    "nuxt": "^2.14.0"
  }
}
```

### `nuxt.config.js`

Import the theme function from `@64robots/nuxt-content-blog`:

```js[nuxt.config.js]
import theme from '@64robots/nuxt-content-blog'

export default theme()
```

The theme exports a function to setup the `nuxt.config.js` and allows you to add / override the default config.

> Check out the documentation of [defu.arrayFn](https://github.com/nuxt-contrib/defu#array-function-merger) to see how the config is merged.

### `tailwind.config.js`

You can override the existing tailwind configuration, check out the [Tailwindcss documentation](https://tailwindcss.com/docs/configuration) for that.

**Example**

```js[tailwind.config.js]
module.exports = {
  theme: {
    extend: {
      colors: {
      }
    }
  }
}
```

### `content/`

This is where you put your markdown content files.

### `static/`

This is where you put your static assets like the logo.

**Example**

```bash
content/
  categories/
    frontend.json
  authors/
    sample-author.json
  posts/
    my-awesome-blog.md
static/
  icon.png
nuxt.config.js
package.json
```

repository: chAhmedRaza/nuxt-content-blog

repo_name: chAhmedRaza/nuxt-content-blog


text:
# Feature Layer Show Attributes
Return all loaded features from a query to show all attributes.

![Feature Layer Show Attributes App](feature-layer-show-attributes.png)

## How to use the sample
Tap on a feature to see its attributes in a callout.

## How it works
The sample creates an instance of `ServiceFeatureTable` and query's features based on user selected feature whereby we explicitly request all attributes to be returned with `ServiceFeatureTable.QueryFeatureFields.LOAD_ALL`. `ArcGISFeature` objects are loadable so we get the `FeatureQueryResult` and iterate through the results creating a `Map` of all available attributes as name value pairs.  We use those name value pairs in a `Callout` for display.

## Relevant API
* Feature
* FeatureLayer
* FeatureQueryResult
* ServiceFeatureTable

#### Tags
Search and Query


text:
### Bug fixes

* [#115](https://github.com/rubocop/rubocop-minitest/issues/115): Fix a false positive for `Minitest/TestMethodName` for when defining test method has an argument, and test method without assertion methods. ([@koic][])

[@koic]: https://github.com/koic

repository: dvandersluis/rubocop-minitest

repo_name: dvandersluis/rubocop-minitest


text:
# Kubernetes CNI Using Wireguard

## Objective
* Implement a CNI plugin (using Wireguard) that securely connects 3 Kubernetes nodes' pods.

## Scope
* Use simple IKEv2 configuration, support of other configurations is not required
* CNI plugin must maintain full-mesh network of kubernetes working nodes
* Create scripts and resources to use Kubernetes “hosted install” method
* Provide a sample Vagrant file script that provisions 3 node cluster with CNI plugin.
* Make sure all the code is properly documented, clean and easy to understand.

## Prerequisites
* VirtualBox (Vagrant provider)
* Vagrant

## Usage
```
TBD
```

## Troubleshooting
```
TBD
```

repository: just-sum-guy/kube-wireguard-cni

repo_name: just-sum-guy/kube-wireguard-cni


text:
# adiesel82/geoservice-laravel

**GeoIP Laravel 5.5 service**

For the current moment SyperGeo service implemented only: https://sypexgeo.net

Plaese follow next steps for install:

**1) add dependence:**
```
composer require adiesel82/geoservice-laravel
```

**2) add next items into *config/app.php***
```
'providers' => [
    ADiesel82\GeoService\GeoServiceProvider::class,
]

'aliases' => [
    'Geo' => ADiesel82\GeoService\GeoServiceFacade::class,
]
```

**3) publish config with artisan:**
```
php artisan vendor:publish
```
Type 0 to publish all or a digit near *ADiesel82\GeoService\GeoServiceProvider*
```
[8 ] Provider: ADiesel82\GeoService\GeoServiceProvider
```
It is *8* in example below and hit enter.

As result you can find *geo.php* in the config folder.

For the current moment SyperGeo service supported only.

**Ready**

### Usage example:
~~~php
$result = \Geo::get(\request()->ip());
dd($result);
~~~
As result:
~~~php
{#129 ▼
  +"city": {#128 ▼
    +"id": 524901
    +"lat": 55.75222
    +"lon": 37.61556
    +"name_ru": "Москва"
    +"name_en": "Moscow"
  }
  +"country": {#130 ▼
    +"id": 185
    +"iso": "RU"
  }
}
~~~

### Auto update database with composer
~~~
"post-install-cmd": [
  "ADiesel82\\GeoService\\ComposerScripts::postInstall"
],
"post-update-cmd": [
  "ADiesel82\\GeoService\\ComposerScripts::postUpdate"
],
~~~


text:
---
title: Getting near to the end of my spreadsheet
layout: post
author: george.dawson
permalink: /getting-near-to-the-end-of-my-spreadsheet/
source-id: 1txbEYv55Uri-iBzM9Q0ME9lPgn558ZlQC9PrYo-GW4k
published: true
---
13/11

Today, I added a shipping option, grand total and made the spreadsheet look better. I did this by doing a similar thing as I did to make the selection of items. I just used data validation to create a list of the shipping options to select and adding a table to see the prices of them. Then I needed to add this to the total by using

'=(the total)+iferror(vlookup(the cells of the chosen delivery option,the top left of the table:the bottom right of the table,2,FALSE),0)'

Then I tidied it up so it would be easier to use.


text:
Chapter 11 - Error Handling
---------------------------

This chapter covers:

- Understanding error handling
- Where and when Camels error handling applies
- The different error handlers in Camel
- Using redelivery policies
- Handling exceptions with onException
- Reusing error handlers in all your routes
- Fine-grained control of error handling

gha_language: Java


text:
# openSenseMap in Docker Compose

This repository contains the `docker-compose.yml` how [opensensemap.org](https://opensensemap.org) is run. It includes a watchtower image which will periodically checks for and deploys updated images.

# What you need

- [Docker](https://docs.docker.com/engine/understanding-docker/) 1.13.0 or above and [Docker Compose](https://docs.docker.com/compose/overview/) 1.11.0 or above
- A server
- a web domain with dns control (you need the subdomains `www`, `api`, `ingress` and optionally `ttn-integration`)

# How to run

Use the script `create-volumes.sh` to create docker volumes. These will be used by the services specified in `docker-compose.yml`.

Create self signed certificates for inter-service communication with [`generateCertificates.sh`](#certificates-for-secure-inter-service-communication).

After you installed the software listed above, created the subdomains and place the `docker-compose.yml` on your server. You may want to configure some values in a `docker-compose.override.yml`. Configuration happens mainly through `environment` keys.

Afterwards you can start everything with `docker-compose up -d`. This repository also contains some bash scripts to deploy updated images.

# Certificates for secure inter-service communication

The `generateCertificates.sh` script wraps [`certstrap`](https://github.com/square/certstrap) to create a self signed certificate authority which can be used to sign server and client certificates.

## Prerequisites

Grab at least version 1.1.1 of `certstrap` ([github.com/square/certstrap/releases](https://github.com/square/certstrap/releases))

## Usage

    ./generateCertificates.sh YOUR-CERTIFICATE-AUTHORITY-NAME SERVICE1[,SERVICE2,...]

Generates a new certficate authority named YOUR-CERTIFICATE-AUTHORITY-NAME and certificates for services named SERVICE1 and SERVICE2. The certificates are valid for hostnames `SERVICE_NAME` and `localhost` and are stored in a new folder called `certificates`.

You can convert the certificate files to \n delimited strings using `sed -z 's/\n/\\n/g' < certificate.crt`.

# Configuration

## Service `web`

| key | comment | optional |
|-----|---------|----------|
| `WEB_DOMAIN` | your domain without protocol. also no `www` |  |
| `API_DOMAIN` | normally `api.yourdomain.tld` |  |
| `INGRESS_DOMAIN` | normally `ingress.yourdomain.tld` |  |
| `ISSUER_ADDRESS` | your email for automatic issuing of a [letsencrypt](https://letsencrypt.org/) tls certificate |  |
| `ADDITIONAL_VHOSTS` | Allows to specify additional vhosts for the caddy web server. | y |
| `USE_STAGING_CA` | if `true` a test-certificate will be issued. Otherwise omit this key | y |

## Service `api`

| key | comment | optional |
|-----|---------|----------|
| `NODE_ENV` | should be set to `production` to enable https checking in the api. | |
| `NODE_CONFIG` | JSON string containing the configuration of the [`openSenseMap-API`](https://github.com/sensebox/openSenseMap-API) service |  |

## Service `mongo`

| key | comment | optional |
|-----|---------|----------|
| `OSEM_dbuser` | the database user to connect to your mongodb, should be the same in services `api`, `mongo`, `ttn-integration` and `mqtt-integration` | y |
| `OSEM_dbuserpass` | the password for the mongodb user, should be the same in services `api`, `mongo`, `ttn-integration` and `mqtt-integration` | y |

## Service `mailer`

| key | comment | optional |
|-----|---------|----------|
| `SENSEBOX_MAILER_CA_CERT` | the certificate of your CA. Server and client should be signed by this CA. See [Certificates for secure inter-service communication](#certificates-for-secure-inter-service-communication) for more information. |  |
| `SENSEBOX_MAILER_SERVER_CERT` | the server certificate |  |
| `SENSEBOX_MAILER_SERVER_KEY` |  the key of the server certificate |  |
| `SENSEBOX_MAILER_SMTP_SERVER` | the smtp server address |  |
| `SENSEBOX_MAILER_SMTP_PORT` | the smtp server port |  |
| `SENSEBOX_MAILER_SMTP_USER` | the smtp server user |  |
| `SENSEBOX_MAILER_SMTP_PASSWORD` | the smtp server password |  |
| `SENSEBOX_MAILER_FROM_DOMAIN` | the domain you are sending from |  |
| `SENSEBOX_MAILER_HONEYBADGER_APIKEY` | api key for honeybadger error reporting | y |

## Service `ttn-integration`

| key | comment | optional |
|-----|---------|----------|
| `ENV` | should be set to `prod` in production. |  |
| `OSEM_dbuser` | the database user to connect to your mongodb, should be the same in services `api`, `mongo` and `ttn-integration` | y |
| `OSEM_dbuserpass` | the password for the mongodb user, should be the same in services `api`, `mongo` and `ttn-integration` | y |
| `OSEM_dbhost` | the hostname or ip of the mongodb instance, should be the same in services `api` and `ttn-integration` | y |
| `OSEM_dbport` | the port of the mongodb instance, should be the same in services `api` and `ttn-integration` | y |
| `OSEM_dbauthsource` | the authSource of the mongodb instance, should be the same in services `api` and `ttn-integration` | y |
| `OSEM_dbdb` | the name of the mongodb database, should be the same in services `api` and `ttn-integration` | y |
| `OSEM_dbconnectionstring` | alternative method to specify the mongodb connection string. If you specify this, `dbuser`,`dbhost` and `dbpass` will be ignored | y |
| `TTN_OSEM_PORT` | the port on which the ttn integration runs | y |
| `TTN_OSEM_loglevel` | loglevel for the ttn integration. `info`, `warn`, `error` | y |

## Service `mqtt-integration`

| key | comment | optional |
|-----|---------|----------|
| `NODE_ENV` | should be set to `production` in production. |  |
| `NODE_CONFIG` | JSON string containing the configuration of the [`mqtt-osem-integration`](https://github.com/sensebox/mqtt-osem-integration) service |  |

## Service `backup`

| key | comment | optional |
|-----|---------|----------|
| `DUPLY_GPG_KEY` | gpg key id or 'disabled' |  |
| `DUPLY_GPG_PW` | gpg password for the key | y |
| `DUPLY_TARGET_URL` | duplicity target url. See [duplicity man page](http://duplicity.nongnu.org/duplicity.1.html) | |
| `DUPLY_TARGET_USER` | user for accessing the target url | y |
| `DUPLY_TARGET_PASS` | password for accessing the target url | y |
| `DUPLY_SOURCE` | source folder for backups | |
| `DUPLY_MAXAGE` | age after duplicity deletes old backups | y |
| `DUPLY_MAXFULLBKPAGE` | age after duplicity creates a new full backup instead of a incremental one | y |
| `DUPLY_ACTION` | duply action. See [http://duply.net/wiki/index.php/Duply-documentation](duply documentation) | y |
| `SCHEDULE` | Cron schedule for running the backup | y |
| `SLACK_HOOK_URL` | Slack webhook url for duply post script | y |
| `DUPLY_PRE` | Complete Duply pre script. Use `$$` to escape single `$`. | y |
| `DUPLY_POST` | Complete Duply post script.  Use `$$` to escape single `$`. | y |

repository: tiefpunkt/OSeM-compose

repo_name: tiefpunkt/OSeM-compose


text:
# Development

---
## Week Zero

 - **4/14/20** *Began app creation.*
    - Saved images for many game elements.
    - Attempted to get the Cinder Block Choreograph.
    - Emailed code mod about errors regarding the build
        - This was resolved with ChoreographConfig.cmake

## Week One

 - **4/21/20** *Finished setup.*
    - Created an image for a game portal.
    - Added all game images and music.
    - Linked Box2D and Choreograph to the project.

 - **4/22/20** *Implemented some basic game functionality.*
    - Randomized the portal location.
    - Coded bird movement in an arc.
        - TO DO:
            - [x] Un-magic the numbers.
            - [x] Restart level after approaching portal.

## Week Two

 - **4/26/20** *Updated project based on feedback.*
    - Changed name from my_app to happy_birds
    - Implemented mouseDown() instead of mouseMove()
    - Replaced char array with std::string for certain constants

 - **4/27/20** *Began working on win condition.*
    - Separated ramp-making from mouseDown.
    - Brings bird to portal when it is close.
        - TO DO:
            - [x] Reset the game when you 'win'
            - [ ] Possibly create a level class
                - Decided that this wasn't necessary
            - [x] Create a start page
            - [x] Create pause and restart buttons
            - [x] Add a random float to the ramp
            so it's more random and fun.

 - **4/28/20** *Began resetting the level.*
    - Added PROPOSAL.md
    - Resets positions and adds a point when you win
    - Added ResetLevel() function to reset level
    - R key now triggers a reset of the level

 - **4/29/20** *Simplified old code.*
    - P key now triggers a pause of the level
    - Streamlined setup() by calling ResetLevel()
    - Removed Box2D from the app
    - Added randomness factor into the ramp
        - TO DO:
            - [x] Show score
            - [x] End game when bird misses

## Week Three

 - **5/3/20** *Began updating project based on feedback.*
    - Created Bird class
    - Added enum class of game states

 - **5/4/20** *Continued updating project based on feedback.*
    - Created a starting and ending screen
    - Added weekly headers to DEVELOPMENT.md
    - Rearranged update() for minimal nesting
    - Changed GetManhattanDistance() to GetEuclideanDistance()
    and made it a standalone function
    - Created a header file for constants
    - Wrote a README file with a GIF
        - TO DO:
            - [x] Finish Bird() class
            - [x] Create different birds
            - [x] Add `q` as a quit button
            - [x] Add `n` as a new game button?

 - **5/5/20** *Made smaller adjustments.*
    - Added a delay before the ending screen
    - Made line comments explaining ending_x_ and ending_y_
    - Made the user's score display during and after the game
        - *Adjust the font size, textbox size, **and** the score
        location if and when adjustments are necessary*
    - Fully implemented the Bird class and integrated it into
    the happy_birds.cc code
    - Wrote and ran simple tests for GetEuclideanDistance()
        - TO DO:
            - [x] Document classes and methods
            - [x] Make sure line comments on code are specific
            - [x] Check spacing
            - [ ] BirdType class?
                - I created bird_type, but there's no BirdType class.
                The file contains an enum and standalone functions.
        - NOTE: While I wrote in my proposal that I was going
        to include a high scores board at the end of the game,
        I decided not to include this, because I don't think
        that this is the kind of game that really necessitates
        keeping track of scores, and because I like the ending
        screen as is.

 - **5/6/20** *Expanded upon the current project.*
    - Added line comments explaining the heavy use of floats.
        - Due to Choreograph functions that only accept floats
        and the heavy use of RandFloat, division, distance, etc.
        It just makes more sense to use floats than to explicitly
        cast every time I use a variable.
    - Created a Species enum and wrote code that changes the bird's
    appearance when prompted by a switch bird key.
    - Added code for each bird to travel in a different way.
        - Some of the birds' special flight patterns are triggered
        by the space bar. This key is saved in config.h.
    - Added final citations and tweaked formatting.


text:
# Feedback-driven fuzzing #

Honggfuzz (since its version 0.5) is capable of performing feedback-driven fuzzing. It utilizes Linux perf subsystem and hardware CPU counters to achieve the best outcomes.

Developers can provide their own initial file (-f flag) which will be gradually improved upon. Alternatively, honggfuzz is capable of starting with just empty buffer, and work its way through, creating a valid fuzzing input in the process.

# Requirements #
  * GNU/Linux OS
  * Relatively modern Linux kernel (v 3.2 should suffice)
  * CPU which is supported by the [perf subsystem](https://perf.wiki.kernel.org/index.php/Main_Page) for hardware-assisted instruction and branch counting
  * CPU supporting [BTS (Branch Trace Store)](https://software.intel.com/en-us/forums/topic/277868?language=es) for hardware assisted unique edge (branch pairs) counting. Currently it's available only in some newer Intel CPUs (unfortunately no AMD support for now)

# Examples #
The main fuzzing strategy is quite simple. It tries to maximize the number of perf events while mangling the file which servers as an input for fuzzing.

## Instruction counting (-Di) ##

```
$ honggfuzz -q -Di -f /usr/share/doc/texlive-doc/latex/ctable/penguin.jpg -- ./djpeg.static ___FILE___
...
[INFO] Launched new process, pid: 21168, (5/5)
[INFO] File size (New/Best): 2789/2789, Perf feedback: Best: 1 / New: 1174343
[INFO] New BEST feedback: New/Old: 2789/2789', Perf feedback counter Curr/High: 1174343/1
[INFO] Launched new process, pid: 21170, (5/5)
[INFO] Launched new process, pid: 21173, (5/5)
[INFO] Launched new process, pid: 21172, (5/5)
[INFO] Launched new process, pid: 21171, (5/5)
[INFO] File size (New/Best): 2789/2789, Perf feedback: Best: 1174343 / New: 20105
[INFO] File size (New/Best): 2789/2789, Perf feedback: Best: 1174343 / New: 1156896
[INFO] File size (New/Best): 2789/2789, Perf feedback: Best: 1174343 / New: 1134940
[INFO] File size (New/Best): 2789/2789, Perf feedback: Best: 1174343 / New: 1134975
[INFO] File size (New/Best): 2789/2789, Perf feedback: Best: 1174343 / New: 1174344
[INFO] New BEST feedback: New/Old: 2789/2789', Perf feedback counter Curr/High: 1174344/1174343
```

It will start with some initial file (or with no file at all), and subsequent fuzzing iterations will try to maximize the number of instructions spent on parsing it.

## Branch counting (-Db) ##

As above, it will try to maximize the number of branches taken by CPU on behalf of the fuzzed process (here: djpeg.static) while performing the fuzzing process.

```
$ honggfuzz -q -Db -f /usr/share/doc/texlive-doc/latex/ctable/penguin.jpg -- ./djpeg.static ___FILE___
...
[INFO] Launched new process, pid: 21391, (5/5)
[INFO] File size (New/Best): 2789/2789, Perf feedback: Best: 1 / New: 115586
[INFO] New BEST feedback: New/Old: 2789/2789', Perf feedback counter Curr/High: 115586/1
[INFO] Launched new process, pid: 21393, (5/5)
[INFO] Launched new process, pid: 21395, (5/5)
[INFO] Launched new process, pid: 21394, (5/5)
[INFO] Launched new process, pid: 21396, (5/5)
[INFO] File size (New/Best): 2789/2789, Perf feedback: Best: 115586 / New: 4326
[INFO] File size (New/Best): 2789/2789, Perf feedback: Best: 115586 / New: 4871
[INFO] File size (New/Best): 2774/2789, Perf feedback: Best: 115586 / New: 104983
[INFO] File size (New/Best): 2789/2789, Perf feedback: Best: 115586 / New: 119456
[INFO] New BEST feedback: New/Old: 2789/2789', Perf feedback counter Curr/High: 119456/115586

```

## Unique branch points counting (-Dp) / Unique branch pair (edges) counting (-De) ##
This is the most powerfull mode of feedback-driven counting that honggfuzz supports. It utilizes Intel's BTS (Branch Trace Store) feature to record all branch events (edges) inside the fuzzed process. Later, honggfuzz will de-duplicate those entries. The resulting number of branch pairs (edges) is good approximation of how much code of a given tool have been actively executed/used (code coverage).

```
$ honggfuzz -q -Dp -f /usr/share/doc/texlive-doc/latex/ctable/penguin.jpg -- ./djpeg.static ___FILE___
...
[INFO] Launched new process, pid: 21715, (5/5)
[INFO] Launched new process, pid: 21719, (5/5)
[INFO] Launched new process, pid: 21717, (5/5)
[INFO] Launched new process, pid: 21718, (5/5)
[INFO] Launched new process, pid: 21716, (5/5)
[INFO] File size (New/Best): 2789/2789, Perf feedback: Best: 1 / New: 887
[INFO] New BEST feedback: New/Old: 2789/2789', Perf feedback counter Curr/High: 887/1
[INFO] Launched new process, pid: 21721, (5/5)
[INFO] File size (New/Best): 2789/2789, Perf feedback: Best: 887 / New: 887
[INFO] New BEST feedback: New/Old: 2789/2789', Perf feedback counter Curr/High: 887/887
[INFO] Launched new process, pid: 21723, (5/5)
[INFO] File size (New/Best): 2789/2789, Perf feedback: Best: 887 / New: 887
[INFO] New BEST feedback: New/Old: 2789/2789', Perf feedback counter Curr/High: 887/887
[INFO] Launched new process, pid: 21725, (5/5)
[INFO] File size (New/Best): 2789/2789, Perf feedback: Best: 887 / New: 887
[INFO] New BEST feedback: New/Old: 2789/2789', Perf feedback counter Curr/High: 887/887
[INFO] File size (New/Best): 2789/2789, Perf feedback: Best: 887 / New: 1606
[INFO] New BEST feedback: New/Old: 2789/2789', Perf feedback counter Curr/High: 1606/887
```

repository: SteveJM/honggfuzz

repo_name: SteveJM/honggfuzz


text:
1
===
Intro.

Messy = practice vs order and communication through documents.

2
===

Lab = "Mangle" - materials, methods, theories, and documents.

Not a computational env in the sense of silicon and transistors

Bring web and computational tools to support science in this environment

3
===

Sara Winchester + House.

Following death of Mr Winchester - Sara visited pyschic medium - travel west and continually build a home - herself and the spirits of people who had died because of winchester rifles.

Sara believed her fortune to be haunted, and so she built this mansion which was under continuous construction day and night for 38 years until her death.

Thus house is famous for it's chaotic layout and complete lack of any master building plan. Sara would hold seances every evening and spirits would guide her in developing the construction plans - which were often written down 'back-of-the-napkin' style.

The house is full of architectural oddities such as doors that lead nowhere, steps down7up11, upsidedown columns, and plethora of different fittings. Trying to understand or navigate the building is difficult, and no one really knows what features of the house were mistakes, whimsy, or deliberate decisions that had to be made for practical reasons or due superstitious beliefs.

4
===

// And so navigating science at the bench is a little like being in Winchester house in its day.

Lab protocols are the written instructions that document the procedures we follow when performing experiments.
However -

	- The knowledge is constantly under construction and remodeling
	- Documents and research objects are relatively unstructured, and are a mix between paper and digital resources.
	- We often need to modify or change things to fit local environments if we're following a procedure that originated in a different lab.
	- And our design decisions tend to be left implicit or opaque - context and details become lost as we continuously build and adapt.
Lab knowledge is messy.
And the way that we manage it impacts the discovery, reuse, and reproducibility of our laboratory science.

5
===

So what i'm interested in, is how we can re-imagine our lab protocols - our documents and written descriptions of laboratoy procedures -
to take advantage of the web and computational tools.
And importantly, do so in a way that actually interfaces with the "messy" practice of bench science.

6
===
So lets consider how we can make protocols 1st class digital objects for science.
How can we make them web addressable documents with structure and metadata...

7
===
One way is incorporate bioOntologies.
Here's a typical statement from a lab procedure -
When this is in digital form we can annotate this text with terms from existing ontologies to assert additional information about entities and their relationships.
The additional knowledge added using ontologies can be leveraged to move beyond keywords and perform automated reasoning, enhanced search, and faceted browsing.

8
===
Another technique we can use is workflow technologies.
Workflows take a process orientated view and allow us to represent the sequence of operations, inputs + outputs in more formal way.
The people orientated execution environment limits some the affordances that formal workflows can offer however.

7
===
Ontologies and workflows can give us structured machine readable specificaitons of the what and how of our lab procedures.
And this is pretty cool - but there's still important information missing that we need to translate our descriptions back into practice across different laboratories. We frequency need to answer questions about the "Why?" as well.

8
===
Every description of a lab procedure is the designed solution to a given problem.
And the solution will always exist and be shaped by the context.
This context forms the background knowledge and lab specific constraints that influence the details of our experimental designs and ways of doing things.
This context is a critical part of the "messy" knowledge of lab science.
As well as describe what and how of an experiment, we can describe the things that influence the what and how - make the context explicit rather than a fuzzy idea.

9
===
So a way to think about context is exemplified by this pic of a milk drop.
We can describe the milk, or the procedure for making drops.
But this milk drop is also a diagram that shows how various forces are at play such as gravity, surface tension and how they are resolved.
There is always a structure around the things we design that influence the form.

But we often ignore it or fail to make it explicit.
When we consider the context around what we design, we can better understand the complex relationship between form, function, and structure. Between process and goal.

10
===
This way of thinking is one of the key insights that Design Patterns can offer us.
Design Patterns were first conceived by architect Christopher Alexander, and have been influential in a number of different domains since.
I dont have time to go into design patterns, here, but one of the things they give us is a vocabulary and shared language to describe the context and aspects of the external environment around our designs that are recurring and generalisable.

11
===
So when we apply design pattern ideas to a laboratory experiment, we realise that there recurring features of the environment that constrain and shape our experimental designs in practice. For example, a live imaging experiment must always balance or resolve the forces of -....

Design patterns capture the 'fuzzy' or implicit context and makes it concrete and usable.

12
===
Once we uncovered and named them, if we incorporate pattern concepts into our descriptions we have a novel and very powerful way to handle lab knowledge. Patterns can give us a way to paramaterise our experimental designs via external constraints, and we can slice or filter our knowledge via more pragmatic contexts - in ways that match the concerns we have in actual practice - "at the bench".

13
===
So putting all this together - i've been making progress in realizing some of these ideas.

14
===
First step is to create design patterns as a vocabulary for laboratory experiments.

15
===
I've developed a knowledge elicitation framework to uncover laboratory patterns and their vocabulary utilising the brains of domain experts.

16
===
Elicitation workshops and design patterns traditionally work best on paper, so next I've created a pattern schema and a web app that utilises lots of forms in order for the community to transfer the knowledge on paper into a structured digital form.

17
===
And finally, I'm specifying a declarative mapping to transform the knowledge that evolves on the pattern web site into a sharable and reusable vocabulary expressed in RDF.

18
===
The second undertaking is to address the authoring and publishing of structured lab procedures.
There's a lot of ways we could proceed here

19
===
Long story short, I've settled on HTML + RDFa as the best container to house our lab protocols.

20
===
The biggest challenge is making it easy for scientist to author structured documents - the solution i've come up with is to modify and join two existing tools.
LabTrove - blog style ELN (uniSoton)
RDFaCE is a WISIWYG RDFa/HTML content editor - based on widely used tinyMCE.
	- allows for easy right click annotation of text in HTML documents.

21
===
So in the near future - we'll have a system for creating design patterns for lab experiments, a pragmatic vocabulary that can add context and complement existing bioontologies, and a system for incorporating machine readable semantics and structured metatdata into lab protocol descriptions.

22
===
In doing all this, we will have achieved a number of things.


text:
# DialogboxAnimation
Hello gyes this is dialogbox animation

Live Sample

Click this link

http://samsetdev.blogspot.in/2016/02/dialogbox-animation.html

Author

Sanjay Singh

Licence

Copyright 2016 Sanjay Singh.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

repository: SamsetDev/DialogboxAnimation

repo_name: SamsetDev/DialogboxAnimation


text:
# File Renamer Class

File Renamer Class is a php class for renaming files in a directory Without changing extensions. (My First Oop project)

## Installation

Clone the [repo](https://github.com/albinvar/File-Renamer-Class.git) and configure your settings in index.php

``` git clone https://github.com/albinvar/File-Renamer-Class.git ```

## Usage

Add the library to you index.php

```php
require 'Renamer.php';
```

Create new object using a prefix & the directory name.

```php
$object = new Renamer('prefix here', 'upload/');
```

Get all files in the directory in the fom of array using getFiles().

```php
$object->getFiles();
```

Launch Renamer Class using launch()

```php
$object->launch();
```

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License
[MIT](https://github.com/albinvar/File-Renamer-Class/blob/main/LICENSE)

repository: albinvar/File-Renamer-Class

repo_name: albinvar/File-Renamer-Class


text:
History Matching for the Lorenz 96 model

[![MIT
license](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/HRMES-MOPGA/L96HistoryMatching/blob/main/LICENSE/)
[![GitHub
contributors](https://img.shields.io/github/contributors/HRMES-MOPGA/L96HistoryMatching)](https://github.com/HRMES-MOPGA/L96HistoryMatching/graphs/contributors)
[![PRs
Welcome](https://img.shields.io/badge/PRs-welcome-yellow.svg)](https://makeapullrequest.com/)
[![DOI](https://zenodo.org/badge/525369211.svg)](https://zenodo.org/badge/latestdoi/525369211)

<!---
[![DOI](http://img.shields.io/badge/DOI-10.1029/2021MS002496-B31B1B.svg)](https://doi.org/10.1029/2021MS002496)
[![GitHub
commits](https://img.shields.io/github/commits-since/HRMES-MOPGA/L96HistoryMatching/0.1.svg?color=orange)](https://GitHub.com/HRMES-MOPGA/L96HistoryMatching/commit/main/) --->

# Semi-automatic tuning of coupled climate models with multiple intrinsic timescales: lessons learned from the Lorenz96 model

[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/HRMES-MOPGA/L96HistoryMatching/HEAD)

This is the source code related to the publication
> Redouane Lguensat, Julie Deshayes, Homer Durand, V. Balaji.
> Semi-automatic tuning of coupled climate models with multiple intrinsic timescales: lessons learned from the Lorenz96 model (2022)
> Pre-print: [https://arxiv.org/abs/2208.06243](https://arxiv.org/abs/2208.06243)

![image info](./HM.gif)

# Important
You need to install two main libraries:
* https://github.com/BayesExeter/ExeterUQ_MOGP/tree/devel (please use devel branch)
* https://github.com/alan-turing-institute/mogp-emulator (code is tested/working with version 0.5.0, mogp_emulator is updated frequently and can introduce breaking changes)

Please read carefully the _instructions.md_ file

# How to use the notebooks
There are four experiments in the paper, each one is the result of two notebooks. One is written in Python and is used for running the L96 model, the other is written in R and is used to perform HM. Any help in making one Python only notebook is more than welcome !

Steps:
* you need to start from the R notebook
* define your initial guess parameter space and run LHS
* save the designpoints then move to the Python notebook
* read the saved data, and run the L96 on the design points, then save the metrics and go back to the R notebook
* run History matching then repeat for subsequent waves !

gha_language: Jupyter Notebook


text:
# Changelog
## [0.3.6] - 2021-07-07
### Fixed
- Allow different return types for `sortBy2`

## [0.3.5] - 2021-05-27
### Fixed
- null child when onClick is null (Android)

## [0.3.4] - 2021-05-27
### Fixed
- Exclude Inkwel from widget three if onClick is null
- Exclude gesture detector from semantics three if onClick is null

## [0.3.3] - 2021-05-25
### Fixed
- Throw from a simple interceptor

## [0.3.2] - 2021-05-19
### Fixed
- Made `BaseProviderWidget` and `BaseThemeProviderWidget` non-abstract to take advantage of dart 2.13's typedef

## [0.3.1] - 2021-04-23
### Fixed
- Fixed issue with release not containing all code

## [0.3.0] - 2021-04-23
### BREAKING
- `logger` is now an extension property on `Object` and will include `[$ClassName] ` as prefix to log messages
- `staticLogger` static getter has replaced `logger` to use in top level functions where we do not have an object to extend from

## [0.2.3] - 2021-04-20
### Added
- replaceWhere
- forEachIndexed

## [0.2.2] - 2021-04-20
### Added
- Disable logger colors on all except android devices

## [0.2.1] - 2021-04-12
### Added
- Extension function on null
- Shared preferences

## [0.2.0] - 2021-04-08
### Added
- Localized error added to get a localization key.
- Connectivity stream to check if the user is connected to wifi or mobile services.  [#35](https://github.com/icapps/flutter-icapps-architecture/issues/35)
### Breaking
- Network error implements now Localized error [#33](https://github.com/icapps/flutter-icapps-architecture/issues/33)

## [0.1.2] - 2021-04-06
### Updated
- Updated dependencies to support desktop too
- Added logging methods to log request and responses
- Added Iterable<Iterable<T>>.flatten extension

## [0.1.1] - 2021-04-02
### Updated
- Updated dependencies to remove test dependency from non-test code

## [0.1.0] - 2021-04-02
### Added
- Initial release

repository: runyaga/flutter-icapps-architecture

repo_name: runyaga/flutter-icapps-architecture


text:
# htdocs-filzball

Website for the Filzball Restaurant in Urdorf.

- Own modules for managing the site.
- Bootstrap (https://getbootstrap.com/examples/navbar, http://getbootstrap.com/examples/justified-nav/)

Todo:

- Lists for menus managed through Google Docs (https://github.com/asimlqt/php-google-spreadsheet-client) or http://codepen.io/ashblue/pen/mCtuA (jquery, lightweight, simple) or http://www.editablegrid.net/en/ (more comprehensive).
- Content managed through some sort of simple Markdown editor.

repository: aoloe/htdocs-filzball

repo_name: aoloe/htdocs-filzball


text:
[![PowerShell Gallery](https://img.shields.io/powershellgallery/v/PSMemory.svg)](https://www.powershellgallery.com/packages/PSMemory)
![powershell version](https://img.shields.io/badge/powershell-v5-blue.svg)
![supported windows versions](https://img.shields.io/badge/supported%20windows%20versions-7%2F8%2F10-yellow.svg)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/7f35ae966821403c9952a277d3e5d19a)](https://www.codacy.com/app/off-world/PSMemory?utm_source=github.com&utm_medium=referral&utm_content=off-world/PSMemory&utm_campaign=Badge_Grade)

___

**PSMemory** is a 64 bit windows memory scanner written in PowerShell hence fully automation capable.

___

## Description

### Cmdlets

#### `Search-Memory`

searches the virtual address space of a process for specific values returning references to the memory they reside in.
Besides the value itself these references contain other related information such as the concrete memory address or the protection of
the page the value was found in. A search can be specified by the `-Values` parameter in the form of a hashtable where the *keys* define
data types and the corresponding *values* define the values of that data type to be searched for as a comma-separated list. Valid data
types to be specified as *keys* for the search table are
-   **Byte** for 8 bit numerical values
-   **Short** for 16 bit numerical values
-   **Int** for 32 bit numerical values
-   **Long** for 64 bit numerical values
-   **String** for ASCII text of arbitrary length
-   **Bytes** for Unicode byte arrays of arbitrary length

**Example**: a search for two 32 bit numerical values *1234* and *5678* as well as the text *Notepad* within the memory of the process *notepad* saving the result in a variable *notepad* for further processing may look like
```Powershell
Get-Process notepad | Search-Memory -Values @{
    Int = 1234, 5678
    String = 'Notepad'
} -OutVariable notepad
```

#### `Compare-Memory`

compares those references' values as present in memory when the reference was created or last updated to the current
in-memory value. With the `-Changed` and `-Unchanged` parameters each reference will be matched whose in-memory value has either
changed in any way or stood the same. For numerical values exclusively there are additionally the `-Increased` and `-Decreased` parameters which track if the in-memory value did either become greater or lower. For everything else there is the `-Filter` parameter where a PowerShell ScriptBlock may be supplied with a custom comparison criteria.

**Example**: given the above search now keep only those references whose in-memory value is either exactly *42* or has increased and update the reference result variable
```Powershell
$notepad | Compare-Memory -Increased -Filter {$_.Value -eq 42} -OutVariable notepad
```

#### `Update-Memory`

updates the current in-memory value referenced by a reference. The new value to be written may be supplied by one of the data type parameters depending on what value of what size to write.

**Example:** after filtering the memory references above now update each remaining referenced in-memory value with a new 32 bit numerical value of *9876*
```Powershell
$notepad | Update-Memory -Int 9876
```
#### `Format-Memory`

formats reference objects as returned by **all** the aforementioned Cmdlets into formatted and human readable output.

**Example:**
```Powershell
Get-Process notepad | Search-Memory -Values @{Int = 42} -OutVariable notepad | Format-Memory
```
or
```Powershell
$notepad | Compare-Memory -Increased -Filter {$_.Value -eq 42} | Format-Memory
```
Alternatively, you can use the alias `fm`.

## Installation

Install from [PowerShell Gallery](https://www.powershellgallery.com/packages/PSMemory)

```Powershell
Install-Module -Name PSMemory
```
or
```Shell
git clone https://github.com/tobiohlala/PSMemory
```

repository: tobiohlala/PSMemory

repo_name: tobiohlala/PSMemory


text:
---
layout: post
title: Easy Dill Pickles
category: food
tag: pickling
excerpt_separator:
---

### Ingredients
* 4 cups water
* 2 cups white vinegar
* 2 tablespoons salt
* 1 teaspoon sugar
* 1 1/2 cucumbers (halved then sliced into spears)
* fresh dill
* 4-5 cloves of garlic (crushed)
* 10 peppercorn kernels

### Instructions
1. In a medium pot, on high, combine water, vinegar, salt and sugar-- dissolve. Bring the brine to a boil, then set aside and let cool to room temperature.
2. In a canning jar, add brine, dill, garlic and peppercorn along with sliced cucumbers then seal.
3. Place in fridge for a week.
4. With patience you will be able to enjoy for up to 5-6 weeks in the fridge (if they can make it that long)!

### Inspired by
This was a really simple recipe to follow. The original recipe used baby canning cucumbers, where I used fully grown cucumbers. Also, my peppercorns were quite old, so I added nearly doubled the amount.

### Closing
I never pickled before, and this was a rather leisurely recipe. Well, any pickling, I suppose is leisurely, after it's prepared at least! It was fun to do, and they tasted great! Another added bonus, that most people do not realize, is that food colouring is added to store bought most often. This recipe, does not have any unnecessary food additives!

Originally, I was trying to use baby cucumbers, but each time I either ate them all or misread the expiration label and they went bad before I could make it. Or the dill went bad, sheesh, I was quite unorganized by this recipe. So when the last batch of baby cucumbers went bad, I just picked up a couple fully grown cucumbers and they worked quite well cut into spears.

 I would like to change it up in the future, such as making it more sweet or moving away from dill and garlic and adding different vegetables to the brine.

 What will you decide to pickle?