text:
# Damage state transitions

This output collects the number of buildings that go from one
damage state to another one according to the event for which we
get the intensity file and the fragility functions.

You can think of it as a table:

| taxonomy | from_damage_state | to_damage_state | n_buildings | replacement_costs_usd_bdg |
|----------|-------------------|-----------------|-------------|---------------------------|
| RC1      |                 0 |               1 |         100 |                   12000.0 |
| RC1      |                 0 |               2 |          50 |                   12000.0 |
| RC1      |                 0 |               3 |          25 |                       ... |
| RC1      |                 0 |               4 |          10 |                       ... |
| ...      |               ... |             ... |         ... |                       ... |
| RC1      |                 1 |               2 |           3 |                       ... |
| RC1      |                 1 |               3 |           2 |                       ... |
| ...      |               ... |             ... |         ... |                       ... |
| RC2      |                 0 |               1 |          20 |                     11000 |
| ...      |               ... |             ... |         ... |                       ... |

This kind of table fill be filled for every geo cell in the exposure model, so that we
can compute the overall loss for each of the cells later.

repository: gfzriesgos/deus

gha_language: Python

repo_name: gfzriesgos/deus


text:
# Disallow dynamic import (no-dynamic-import)

Lighting Locker vNext may prohibit [dynamic import](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#Dynamic_Imports). To prevent code from breaking, use [script injection](https://developer.mozilla.org/en-US/docs/Web/API/HTMLScriptElement#Dynamically_importing_scripts) instead.

## Rule details

Example of **incorrect** code:

```js
import('./a.js');
```

Example of **correct** code:

```js
const newScript = document.createElement('script');
document.head.appendChild(newScript);
newScript.src = './a.js';
```

license: MIT

repository: apoblock/eslint-plugin-lwc

branch_name: refs/heads/master

extension: md

gha_license_id: MIT

license_type: permissive

repo_name: apoblock/eslint-plugin-lwc


text:
---
title: Grandma Shelby's Brownies
author: Jacob Dahleen
date: 2020-06-08 20:28:00 -0500
categories: [Dessert, Bars]
tags: [dessert, brownies, chocolate]
toc: true
---

A simple brownie recipe that is delicious. They have received great reviews for birthday treats at multiple workplaces.

# Ingredients
- 2 sticks of butter (or margarine)
- 2 cups sugar
- 4 eggs
- 4 squares (4 oz) Baker's Brand unsweetened chocolate, melted
- 1 ⅓ cups flour
- 1 tsp baking powder
- ½ tsp salt
- 1 tsp vanilla
- powdered sugar

# Steps
1. Preheat oven to 350° F
1. Melt the butter and chocolate together in a small saucepan on low heat, stiring occasionally
1. While the butter and chocolate are melting beat eggs and sugar with a hand mixer until thick and golden
1. Beat in the butter and chocolate
1. Stir in the flour, baking powder and salt
1. Stir in the vanilla
1. Pour into a greased 13'x9' pan
1. Bake at 350° F for 20-25 min
1. Sift powdered sugar on top
1. Cool then cut


text:
---
layout: post
title:  "Dropout - A simple way to improve Neural Network ?"
date:   2016-02-10 11:42:36
categories: ml
tags: ml
crosspost_to_medium: true
image: /assets/article_images/desktop.jpg
---

Dropout technique by [Hinton](https://www.cs.toronto.edu/~hinton/) is among recent pioneers in the field of neural network. The main objective
behind using Dropout is to tackle the problem of [overfitting](https://en.wikipedia.org/wiki/Overfitting). Dropout achieves this by selectively
turning off (dropping out) some of the activations in a layer during forward propagation and backpropagating through all activations turned on.

### Further readings

+ [Dropout: A Simple Way to Prevent Neural Networks from Overfitting][paper-link]
+ [How do you implement a dropout in neural network][quora-link]
+ [Udacity Deep Learning - Dropout][udacity-link]

[quora-link]: https://www.quora.com/How-do-you-implement-a-dropout-in-deep-neural-networks
[paper-link]: https://www.cs.toronto.edu/~hinton/absps/JMLRdropout.pdf
[udacity-link]: https://www.udacity.com/course/viewer#!/c-ud730/l-6379031992/m-6392358586

repository: daxlab/blog

branch_name: HEAD

repo_name: daxlab/blog


text:
https://developer.rackspace.com/blog/postgresql-plus-wal-e-plus-cloudfiles-equals-awesome/
https://github.com/abevoelker/docker-postgres
https://github.com/wal-e/wal-e
https://gist.github.com/ruckus/2293434
https://blog.heroku.com/archives/2013/9/26/wal_e_and_continuous_protection_with_heroku_postgres
https://postgres.heroku.com/follow
https://gist.github.com/elithrar/8682235

docker exec 372b3c2bc266 su postgres -c "envdir /etc/wal-e.d/env wal-e backup-push /var/lib/postgresql/9.3/main"

# Postgres Dockerfile

Docker image for Postgres 9.3 + WAL-E + PL/Python and PL/V8 languages

## Basic usage

```
$ docker run -p 5432:5432 abevoelker/postgres
2014-07-31 06:11:07 UTC LOG:  database system was shut down at 2014-07-31 05:52:53 UTC
2014-07-31 06:11:07 UTC LOG:  database system is ready to accept connections
2014-07-31 06:11:07 UTC LOG:  autovacuum launcher started
```

## WAL-E usage

This image comes with [WAL-E][wal-e] for performing continuous archiving of PostgreSQL WAL files and base backups.  To use WAL-E, you need to do a few things:

1. Create a directory with your secret environment variables (e.g. your AWS secret keys) in [envdir][envdir] format (one variable per file) and mount it as a volume overwriting `/etc/wal-e.d/env` when calling `docker run`.

2. Edit your `postgresql.conf` archive settings to use WAL-E. Changes should look something like this:

  ```
  wal_level = archive # hot_standby is also acceptable (will log more)
  archive_mode = on
  archive_command = 'envdir /etc/wal-e.d/env wal-e wal-push %p'
  archive_timeout = 60
  ```

3. Mount a volume to `/etc/cron.d` with a crontab for running your periodic WAL-E tasks (e.g. full backups, deleting old backups).  Here's an example that does a full backup daily at 2AM and deletes old backups (retaining 7 previous backups) at 3AM:

  ```
  PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
  0 2 * * * postgres envdir /etc/wal-e.d/env wal-e backup-push /var/lib/postgresql/9.3/main
  0 3 * * * postgres envdir /etc/wal-e.d/env wal-e delete --confirm retain 7
  ```

4. Run the container with `/sbin/my_init` instead of the default command.  This is necessary to start cron, syslog, and Postgres.  In this mode, [runit][runit] manages the cron and Postgres processes and will restart them automatically if they crash.

Example `docker run` that covers basic WAL-E usage:

```
$ ls -1 /tmp/env
AWS_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY
WALE_S3_PREFIX
$ ls -1 /tmp/cron
wal-e
$ cat /tmp/cron/wal-e
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
0 2 * * * postgres envdir /etc/wal-e.d/env wal-e backup-push /var/lib/postgresql/9.3/main
0 3 * * * postgres envdir /etc/wal-e.d/env wal-e delete --confirm retain 7
$ docker run -v /tmp/env:/etc/wal-e.d/env -v /tmp/cron:/etc/cron.d abevoelker/postgres /sbin/my_init
*** Running /etc/rc.local...
*** Booting runit daemon...
*** Runit started as PID 13
2014-07-31 06:11:07 UTC LOG:  database system was shut down at 2014-07-31 05:52:53 UTC
2014-07-31 06:11:07 UTC LOG:  database system is ready to accept connections
2014-07-31 06:11:07 UTC LOG:  autovacuum launcher started
```

## License

MIT license.

[wal-e]:  https://github.com/wal-e/wal-e
[envdir]: https://pypi.python.org/pypi/envdir
[runit]:  http://smarden.org/runit/

repository: AnalogJ/docker-postgres

gha_language: Shell

repo_name: AnalogJ/docker-postgres


text:
# Test typescript 2, express server and node

This is based on [Brian Love's article](http://brianflove.com/2016/11/08/typescript-2-express-node/)
but I'll be trying it on my linux machine and using `yarn`.

Below are the step by step procedures, to use this repo directly:
```
git clone https://github.com/winksaville/test-typescript-2-express-node.git
cd test-typescript-2-express-node.git
yarn install
yarn run grunt
yarn start
```
And then in a browser access `localhost:8080' something like:
```
chromium http://localhost:8080
```
##Create directory and the initial package.json
```
mkdir test-typescript-2-express-node
cd test-typescript-2-express-node
yarn init
```
I then edited package.json as Brian suggested:
```
$ cat package.json
{
  "name": "test-typescript-2-express-node",
  "version": "0.1.0",
  "description": "Test typescript 2, express server and node js",
  "main": "index.js",
  "repository": "https://github.com/winksaville/test-typescript-2-express-node",
  "author": "Wink Saville",
  "license": "Unlicense",
  "scripts": {
    "dev": "NODE_ENV=development nodemon ./win/www",
    "grunt": "grunt",
    "start": "node ./bin/www"
  }
}
```
## Installed express
```
yarn add express

```
## Add start script, see Brian's article for more info.
```
mkdir bin
vi bin/www
$ cat bin/www
#!/usr/bin/env node
"use strict";

//module dependencies
var server = require("../dist/server");
var debug = require("debug")("express:server");
var http = require("http");

//create http server
var httpPort = normalizePort(process.env.PORT || 8080);
var app = server.Server.bootstrap().app;
app.set("port", httpPort);
var httpServer = http.createServer(app);

//listen on provided ports
httpServer.listen(httpPort);

//add error handler
httpServer.on("error", onError);

//start listening on port
httpServer.on("listening", onListening);

/**
 * Normalize a port into a number, string, or false.
 */
function normalizePort(val) {
  var port = parseInt(val, 10);

  if (isNaN(port)) {
    // named pipe
    return val;
  }

  if (port >= 0) {
    // port number
    return port;
  }

  return false;
}

/**
 * Event listener for HTTP server "error" event.
 */
function onError(error) {
  if (error.syscall !== "listen") {
    throw error;
  }

  var bind = typeof port === "string"
    ? "Pipe " + port
    : "Port " + port;

  // handle specific listen errors with friendly messages
  switch (error.code) {
    case "EACCES":
      console.error(bind + " requires elevated privileges");
      process.exit(1);
      break;
    case "EADDRINUSE":
      console.error(bind + " is already in use");
      process.exit(1);
      break;
    default:
      throw error;
  }
}

/**
 * Event listener for HTTP server "listening" event.
 */
function onListening() {
  var addr = httpServer.address();
  var bind = typeof addr === "string"
    ? "pipe " + addr
    : "port " + addr.port;
  debug("Listening on " + bind);
}
```
## Install Typescript and Grunt and grun task runners
```
yarn add typescript --dev
yarn add grunt --dev
yarn add grunt-contrib-copy grunt-ts grunt-contrib-watch --dev
```
## Add the gruntfile.js and again, see Brian's article for explanation
```
$ cat gruntfile.js
module.exports = function(grunt) {
  "use strict";

  grunt.initConfig({
    copy: {
      build: {
        files: [
          {
            expand: true,
            cwd: "./public",
            src: ["**"],
            dest: "./dist/public"
          },
          {
            expand: true,
            cwd: "./views",
            src: ["**"],
            dest: "./dist/views"
          }
        ]
      }
    },
    ts: {
      app: {
        files: [{
          src: ["src/\*\*/\*.ts", "!src/.baseDir.ts"],
          dest: "./dist"
        }],
        options: {
          module: "commonjs",
          target: "es6",
          sourceMap: false
        }
      }
    },
    watch: {
      ts: {
        files: ["src/\*\*/\*.ts"],
        tasks: ["ts"]
      },
      views: {
        files: ["views/**/*.pug"],
        tasks: ["copy"]
      }
    }
  });

  grunt.loadNpmTasks("grunt-contrib-copy");
  grunt.loadNpmTasks("grunt-contrib-watch");
  grunt.loadNpmTasks("grunt-ts");

  grunt.registerTask("default", [
    "copy",
    "ts"
  ]);

};
```
## I then ran `yarn run grunt` and as expected saw 'No files to compile':
```
$ yarn run grunt
yarn run v0.20.0
$ grunt
Running "copy:build" (copy) task

Running "ts:app" (ts) task
No files to compile

Done.
Done in 0.73s.
```
## Install middleware:
```
yarn add body-parser cookie-parser morgan errorhandler method-override
```
And yarn said:
```
yarn add v0.20.0
[1/4] Resolving packages...
[2/4] Fetching packages...
warning<EMAIL_ADDRESS>The platform "linux" is incompatible with this module.
info<EMAIL_ADDRESS>is an optional dependency and failed compatibility check. Excluding it from installation.
[3/4] Linking dependencies...
[4/4] Building fresh packages...
success Saved lockfile.
success Saved 10 new dependencies.
├─<EMAIL_ADDRESS>├─<EMAIL_ADDRESS>├─<EMAIL_ADDRESS>├─<EMAIL_ADDRESS>├─<EMAIL_ADDRESS>├─<EMAIL_ADDRESS>├─<EMAIL_ADDRESS>├─<EMAIL_ADDRESS>├─<EMAIL_ADDRESS>└─<EMAIL_ADDRESS>Done in 1.92s.
```
## Install @types

These added to devDependencies because types are only used durning
compiliation
```
yarn add @types/body-parser @types/cookie-parser @types/morgan @types/errorhandler @types/method-override --dev
```
And yarn said:
```
yarn add v0.20.0
[1/4] Resolving packages...
[2/4] Fetching packages...
warning<EMAIL_ADDRESS>The platform "linux" is incompatible with this module.
info<EMAIL_ADDRESS>is an optional dependency and failed compatibility check. Excluding it from installation.
[3/4] Linking dependencies...
[4/4] Building fresh packages...
success Saved lockfile.
success Saved 10 new dependencies.
├─<EMAIL_ADDRESS>├─<EMAIL_ADDRESS>├─<EMAIL_ADDRESS>├─<EMAIL_ADDRESS>├─<EMAIL_ADDRESS>├─<EMAIL_ADDRESS>├─<EMAIL_ADDRESS>├─<EMAIL_ADDRESS>├─<EMAIL_ADDRESS>└─<EMAIL_ADDRESS>Done in 2.30s.
```
## Create `Server` Class

As before Brian has a nice explanation of the class.
```
mkdir src
vi server.ts
```
And server.ts is
```
import * as bodyParser from "body-parser";
import * as cookieParser from "cookie-parser";
import * as express from "express";
import * as logger from "morgan";
import * as path from "path";
import errorHandler = require("errorhandler");
import methodOverride = require("method-override");

/**
 * The server.
 *
 * @class Server
 */
export class Server {

  public app: express.Application;

  /**
   * Bootstrap the application.
   *
   * @class Server
   * @method bootstrap
   * @static
   * @return {ng.auto.IInjectorService} Returns the newly created injector for this app.
   */
  public static bootstrap(): Server {
    return new Server();
  }

  /**
   * Constructor.
   *
   * @class Server
   * @constructor
   */
  constructor() {
    //create expressjs application
    this.app = express();

    //configure application
    this.config();

    //add routes
    this.routes();

    //add api
    this.api();
  }

  /**
   * Create REST API routes
   *
   * @class Server
   * @method api
   */
  public api() {
    //empty for now
  }

  /**
   * Configure application
   *
   * @class Server
   * @method config
   */
  public config() {
    //empty for now
  }

  /**
   * Create router
   *
   * @class Server
   * @method api
   */
  public routes() {
    //empty for now
  }
}
```
I then ran grunt to build what we have so far:
```
$ yarn run grunt
yarn run v0.20.0
$ grunt
Running "copy:build" (copy) task

Running "ts:app" (ts) task
Compiling...
Using tsc v2.1.5

TypeScript compilation complete: 1.35s for 2 TypeScript files.

Done.
Done in 2.08s.
```
## Add Server.config code:
```
/**
  * Configure application
  *
  * @class Server
  * @method config
  */
public config() {
  //add static paths
  this.app.use(express.static(path.join(__dirname, "public")));

  //configure pug
  this.app.set("views", path.join(__dirname, "views"));
  this.app.set("view engine", "pug");

  //use logger middlware
  this.app.use(logger("dev"));

  //use json form parser middlware
  this.app.use(bodyParser.json());

  //use query string parser middlware
  this.app.use(bodyParser.urlencoded({
    extended: true
  }));

  //use cookie parker middleware middlware
  this.app.use(cookieParser("SECRET_GOES_HERE"));

  //use override middlware
  this.app.use(methodOverride());

  //catch 404 and forward to error handler
  this.app.use(function(err: any, req: express.Request, res: express.Response, next: express.NextFunction) {
      err.status = 404;
      next(err);
  });

  //error handling
  this.app.use(errorHandler());
}
```
## Add pug and create public and views directories
```
yarn add pug
mkdir public
mkdir views
```
And here is what the directory structure is now:
```
$ tree -I node_modules
.
├── bin
│   └── www
├── dist
│   └── server.js
├── gruntfile.js
├── package.json
├── public
├── README.md
├── src
│   └── server.ts
├── UNLICENSE
├── views
└── yarn.lock

5 directories, 8 files
```
## We can now compile the server
```
$ yarn run grunt
yarn run v0.20.0
$ grunt
Running "copy:build" (copy) task

Running "ts:app" (ts) task
Compiling...
Cleared fast compile cache for target: app
Using tsc v2.1.5

TypeScript compilation complete: 1.45s for 2 TypeScript files.

Done.
Done in 2.17s.
```
Run the server:
```
$ yarn start
yarn start v0.20.0
$ node ./bin/www
```
And if we access a client the server from a chromium browser we
get the result `Cannot GET /`:
```
$ chromium http://localhost:8080
```
The server outputs a 404:
```
GET / 404 0.718 ms - 13
```

## To solve the 404 we'll create routes

./src/routes/route.ts and ./src/routes/indes.ts:
```
$ cat src/routes/route.ts
import { NextFunction, Request, Response } from "express";

/**
 * Constructor
 *
 * @class BaseRoute
 */
export class BaseRoute {

  protected title: string;

  private scripts: string[];

  /**
   * Constructor
   *
   * @class BaseRoute
   * @constructor
   */
  constructor() {
    //initialize variables
    this.title = "Tour of Heros";
    this.scripts = [];
  }

  /**
   * Add a JS external file to the request.
   *
   * @class BaseRoute
   * @method addScript
   * @param src {string} The src to the external JS file.
   * @return {BaseRoute} Self for chaining
   */
  public addScript(src: string): BaseRoute {
    this.scripts.push(src);
    return this;
  }

  /**
   * Render a page.
   *
   * @class BaseRoute
   * @method render
   * @param req {Request} The request object.
   * @param res {Response} The response object.
   * @param view {String} The view to render.
   * @param options {Object} Additional options to append to the view's local scope.
   * @return void
   */
  public render(req: Request, res: Response, view: string, options?: Object) {
    //add constants
    res.locals.BASE_URL = "/";

    //add scripts
    res.locals.scripts = this.scripts;

    //add title
    res.locals.title = this.title;

    //render view
    res.render(view, options);
  }
}
```
```
$ cat src/routes/index.ts
import { NextFunction, Request, Response, Router } from "express";
import { BaseRoute } from "./route";

/**
 * / route
 *
 * @class User
 */
export class IndexRoute extends BaseRoute {

  /**
   * Create the routes.
   *
   * @class IndexRoute
   * @method create
   * @static
   */
  public static create(router: Router) {
    //log
    console.log("[IndexRoute::create] Creating index route.");

    //add home page route
    router.get("/", (req: Request, res: Response, next: NextFunction) => {
      new IndexRoute().index(req, res, next);
    });
  }

  /**
   * Constructor
   *
   * @class IndexRoute
   * @constructor
   */
  constructor() {
    super();
  }

  /**
   * The home page route.
   *
   * @class IndexRoute
   * @method index
   * @param req {Request} The express Request object.
   * @param res {Response} The express Response object.
   * @next {NextFunction} Execute the next method.
   */
  public index(req: Request, res: Response, next: NextFunction) {
    //set custom title
    this.title = "Home | Testing typescript 2, express, node";

    //set options
    let options: Object = {
      "message": "Welcome to testing typescript 2, express, node!!"
    };

    //render template
    this.render(req, res, "index", options);
  }
}
```
And add index.pug to the views directory
```
$ cat views/index.pug
html
  head
    title= title
  body
    h1= message
```

## Finally we can compile and start the server
```
$ yarn run grunt
yarn run v0.20.0
$ grunt
Running "copy:build" (copy) task
Copied 1 file

Running "ts:app" (ts) task
Compiling...
Cleared fast compile cache for target: app
Using tsc v2.1.5

TypeScript compilation complete: 1.38s for 4 TypeScript files.

Done.
Done in 2.10s.

$ yarn start
yarn start v0.20.0
$ node ./bin/www
[IndexRoute::create] Creating index route.
```
And run client in the browser:
```
$ chromium http://localhost:8080
Created new window in existing browser session.
```
And we see the result in the Window:
```
Welcome to testing typescript 2, express, node!!
```

And in the server we see the access:
```
GET / 200 187.977 ms - 153
```

## The last thing Brian says is to install node monitor:
```
yarn add nodemon
```
And then you can run `dev`:
```
yarn run dev
```
Although, at the moment it doesn't seem to be doing the recompiling when I
change code.

license: Unlicense


text:
+++
# Project title.
title = "Woningnet"

# Date this page was created.
date = 2019-03-01T00:00:00

# Project summary to display on homepage.
summary = "A great interface to view houses! Click for gif"

# Tags: can be used for filtering projects.
# Example: `tags = ["machine-learning", "deep-learning"]`
tags = ["woningnet"]

# Optional external URL for project (replaces project detail page).
external_link = ""

# Featured image
# To use, add an image named `featured.jpg/png` to your project's folder.
[image]
  # Caption (optional)
  caption = ""

  # Focal point (optional)
  # Options: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight
  focal_point = "Smart"
+++
I got tired of clicking on woningnet so I made this viewer that puts the houses
on a map! It offers a nice interface which allows you to reduce time spent on woningnet.
See gif for small example.
![test](featured.gif)

repository: cvanelteren/academic-start

repo_name: cvanelteren/academic-start


text:
# Spring Url Generator (surlgen)

## **⚠ THIS PROJECT IS NOW UNMAINTED AND IN READ-ONLY MODE ⚠**

## Usage

### Create Service-Classes for Spring-RequestMapping Annotation

To generate Spring Services for every [@RequestMapping](http://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/bind/annotation/RequestMapping.html)
add following to your pom.xml in the build/plugins section.

```XML
<plugin>
    <groupId>com.mysema.maven</groupId>
    <artifactId>apt-maven-plugin</artifactId>
    <version>1.1.3</version>
    <executions>
        <execution>
            <goals>
                <goal>process</goal>
            </goals>
            <configuration>
                <processor>de.neofonie.surlgen.processor.spring.UrlFactoryServiceGenerator</processor>
            </configuration>
        </execution>
    </executions>
</plugin>
```

This will generate for each Controller methods to generate (compiler-safe) methods for url-construction.
These are based on [MvcUriComponentsBuilder](http://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/servlet/mvc/method/annotation/MvcUriComponentsBuilder.html).

### Create Static-Accessors/TLD for Url-Factory class

Adding the UrlFunctionGenerator as processor will generate a UrlFunction-Class. Applying a additional tld-filename, a TLD-File will also be generated.

```XML
<processors>
    <processor>de.neofonie.surlgen.processor.spring.UrlFactoryServiceGenerator</processor>
    <processor>de.neofonie.surlgen.processor.spring.UrlFunctionGenerator</processor>
</processors>
<options>
    <tld.file>${project.build.directory}/${project.build.finalName}/WEB-INF/tld/urls.tld</tld.file>
</options>
```

repository: Neofonie/surlgen

gha_language: Java

repo_name: Neofonie/surlgen


text:
---
layout: post
title: When in Rome Writeup
---

10 points, cryptography

When in Rome is the first challengeof the 2016 sctf and at 10 points it is the perfect
starting challenge. To begin you are given the string

"Nvctfdv kf jTKW! Nv yfgv pfl veafp kyv gifscvdj nv yrmv nizkkve wfi kyv wzijk hlrikvi fw 2016. Yviv zj pfli wzijk fw (yfgvwlccp) drep wcrxj! jtkw{ny3e_1e_tkw_u0_r5_tkw3i5_u0}"

Judging by the name and my basic understanding of crypto I figured this was a Rot probelm.

Now you can do this by hand but I decide to go to [planetcalc](http://www.planetcalc.com/1434)

This website allows you to enter a string and it figures out all the ROTs for you.
After going through all the possiblities it is really easy to see that ROT9 is what we are looking for.


text:
FlickrTweet
-----

This is a simple app that searches the public Twitter and Flickr streams
for keywords and displays the first results it finds. It's an experiment for
me to learn how to do AngularJS development.

You can see the live app at http://flickrtweet.bphogan.com

Sharing this code to get ideas.

This uses CoffeeScript and Sass, and doesn't have tests yet. I will rewrite
this TDD-style shortly.  Consider it an experiment, not something you should
copy or emulate.

Building
------

I used `qedproject` to generate this project, so it uses Guard to watch for
changes to the files and put things in the right folders.

If you already have Ruby 1.9.x installed just clone this and run

~~~
$ bundle install
$ bundle exec guard
~~~

That'll get everything you need.

Use

~~~
qedproject --server
~~~

to run the http server on port 1337.

License
======

MIT license.

repository: napcs/flickrtweet

repo_name: napcs/flickrtweet


text:
# Status Update Week 8

## Last Week's Accomplishments

> Made a decent amount of progress with my issue pertaining to creating a petition and storing it into the data base with Grace's help

## This Week's Plan

> Finish implementing creation and storage of new petition instances.

> Use a class view style instead of current style where get and post are two separate functions

> Class style allows for get and post to be methods

## Anything Blocking?

> Have to use a class view style for the views so that after the creation of a petition /create/ can be used for getting the new petition page and posting a new petition to the database

## Notes

> N/A

repository: poulor/rcos-status-updates

repo_name: poulor/rcos-status-updates


text:
The following query is used to create the `user_story_line` table in KARTE Datahub that is the basis for the `user_story_line` view in this Looker Block.

```
{% set period_of_days = "60"%}
{%set  target_event = "_chat_open" %}
# edit target_event

with data as (
  SELECT user_id,session_id,sync_date,event_name
    ,if(event_name = "view"
      ,json_extract_scalar(values,"$.view.access.uri.url")
      ,"-") as url
    ,if(event_name = "message_open"
      ,json_extract_scalar(values,"$.message_open.message.campaign_id")
      ,if(event_name = "message_click"
        ,json_extract_scalar(values,"$.message_click.message.campaign_id")
      ,"-"
      )) as campaign_id
  FROM {{ karte_event("FORMAT_DATE('%Y%m%d', DATE_ADD(CURRENT_DATE, INTERVAL -" + period_of_days + " DAY))", "FORMAT_DATE('%Y%m%d', CURRENT_DATE)") }}
  where (
    event_name = "identify"
    or event_name = "view"
    or event_name = "message_open"
    or event_name = "message_click"
    or event_name = "{{target_event}}"
    )
  ),

target_event as (
  SELECT user_id,session_id,min(sync_date) as event_start
  FROM data
  where event_name = "{{target_event}}"
  group by user_id,session_id

  )

SELECT data.user_id,data.session_id,sync_date,event_name,url,campaign_id,event_start
  ,row_number() over(partition by data.session_id order by data.sync_date) as _no
from data
inner join target_event as t on data.user_id = t.user_id and data.session_id = t.session_id
where sync_date < event_start or (sync_date = event_start and event_name = "{{target_event}}")

order by user_id,sync_date
```


text:
### Design Choices

Primary purpose of Hyper (`application/vnd.hyper+json`) is to be used by
developers as the hypermedia type that they actually code against. As such,
simplicity and developer experience are very important in its design. Hyper
stays as close as possible to plain JSON and avoids being verbose or bloated
in its syntax.

Simplicity comes from an intentionally small set of additional constraints that
Hyper introduces on top of "plain old JSON". The Hyper spec is essentially as
short as the following three principles:

1. Hyper is a JSON document of arbitrary shape. Any JSON is a valid Hyper as
   long as it doesn't violate the other two rules (which most JSON documents,
   do not).
1. Keys of JSON objects in a Hyper document (referred to as 'attributes' in the
   rest of this spec, for brevity) MAY be URIs. In Hyper, attributes that are
   valid URIs indicate extra semantics and processing rules that MAY be provided
   by a resource at the other end of the URI. URIs do not have to be
   dereferenceable, however. They are just a namespace, and the meaning of a
   namespace CAN be provided by any convenient means (e.g. publishing an RFC,
   Swagger document or a nicely printed book). These URIs can also be Compact
   URIs - [CURIEs](https://www.w3.org/TR/2010/NOTE-curie-20101216/). Namespacing
   attributes by providing them as URIs is a primary way of introducing
   additional semantic and processing rules - foundation of extensibility in
   Hyper.
1. Applications producing and consuming Hyper messages acknowledge the implicit
   existence of a core set of extensions ('core vocabulary'), that is documented
   at a set of URIs, the root of which is <http://hyperjson.io/props/>.

Hyper allows gradual introduction of Hypermedia controls in the form of mixins.
As opposed to many other hypermedia formats, there is no required object shape
in Hyper. Most valid JSON documents are also valid Hyper documents. Additional
functionality is introduced through [extensions](#extensions). Extensions, in
Hyper, add functionality via mixins, rather than inheritance-style
implementation of a parent, abstract Hyper document. It is entirely up to
individual API developers to decide "how much" hypermedia they want to add to
their JSON payloads.

#### Default Mixin - Core Vocabulary

In Hyper, core vocabulary is mixed-in via the default extension. The default
extension is `{"prefix" : "h", "uri" : "http://hyperjson.io/props/"}` that is
always present and cannot be removed or overriden. Capabilities in the default
extension form a small but powerful vocabulary selected based on the guidelines
outlined in the [Hypermedia Project
Charter](https://github.com/the-hypermedia-project/charter/blob/master/reference/hypermedia-elements.md).

Hyper is a web standard, based on existing specifications, such as: URI
Template [[RFC6570](http://tools.ietf.org/html/rfc6570)],
[CURIEs](https://www.w3.org/TR/2010/NOTE-curie-20101216/) and [IANA-registered
Link Relation
Types](http://www.iana.org/assignments/link-relations/link-relations.xhtml).

#### CURIEs and URI Templates

CURIEs and URI Templates are used extensively in Hyper. If you are unfamiliar
with them, it is worth spending a minute explaining them.

CURIEs are just a standard way of abbreviating long URIs by assigning prefix to
the common part of the URI, similar to how namespaces are used in XML. If you
are using the same base URI repeatedly in your API, using CURIES can
significantly clean-up the payload and make it much more readable. Being a
hypermedia format, we use URIs extensively in Hyper so keeping things clean and
manageable is very useful.

Case in point: let's assume that we need to refer to a lot
of URIs that all start with "<http://hyperjson.io/props/>". We can CURIE this URL
by defining a prefix such as: `{"h" : "http://hyperjson.io/props/"}` and then
long URIs like <http://hyperjson.io/props/ref> and
<http://hyperjson.io/props/link> become much simpler `h:ref` and `h:link`.
You can read more about CURIE standard at:
<https://www.w3.org/TR/2010/NOTE-curie-20101216/>

URI Template is a web standard that allows describing a range of Uniform
Resource Identifiers (URIs) through variable expansion. For instance
`http://api.example.com/users{user-id}/photo` can describe a template for how
a photo URI of any user may look in some API. You can read more about
URI templates in [RFC6570](http://tools.ietf.org/html/rfc6570)

repository: inadarei/hyper

gha_language: CSS

repo_name: inadarei/hyper


text:
# cloudflup

Cloudflup is another Cloudflare dynamic DNS update client for A and AAAA records. That's pretty much it. By default, it will attempt to do both. If you don't care about AAAA, just comment out the call to its update method at the bottom.

### Usage
```$ ./cloudflup.rb```

### Configuration

Prior to running, make sure options.yaml is filled out. All parameters are required. You can get your API key from within your Cloudflare account.

License
---
MIT

repository: meanjollies/cloudflup

repo_name: meanjollies/cloudflup


text:
# CoqFJ

Featherweight Java is a minimimum core calculus for Java formalized in [this paper](https://www.cis.upenn.edu/~bcpierce/papers/fj-toplas.pdf)

CoqFJ is a mechanization of the standard theorems for type safety, i.e. progress and preservation, using coq.

To compile the code, simply run ```make``` at the root folder.

You can also generate the makefile from scratch running ```coq_makefile -f _CoqProject -o makefile```

If you use CoqIDE, make sure to enable Project File options at ```Edit -> Preferences -> Project Project file options are "append to arguments"```.

And ```Default name for project file _CoqProject```

repository: hephaestus-pl/coqfj

repo_name: hephaestus-pl/coqfj


text:
# trans.form [![Build Status](https://travis-ci.org/nperez0111/trans.form.svg?branch=master)](https://travis-ci.org/nperez0111/trans.form)

> A Wrapper around [object-manip](https://github.com/nperez0111/object-manip) to be used on any object to allow transformations.

To see why this is _safe or not safe_ refer to [my library](https://github.com/nperez0111/objExtension#is-this-even-safe)

## Install

```
$ npm install --save trans.form
```

## Usage

```js
const transform = require('trans.form');
let x = {
	a: 2
}
x[ transform ]( {
	a: function(x){
    	return x + 2;
    }
} )
//=> { a: 4 }
```

## API

### transForm

Returns the key to be able to manipulate the object.

#### Methods available to all `Object`s

### transform( transformerObject )

#### input
Type: `Object`
Must conform to the formatting specified by [object-manip](https://github.com/nperez0111/object-manip#usage)

Returns a new object after all the values of the current object have been transformed.

### transform.save( transformerObject )

#### This is a mutable method!
This if the exact same as above but saves all changes into the object.

## License

MIT © [Nick The Sick](http://nickthesick.com)


text:
---
layout: "github"
page_title: "GitHub: github_rest_api"
description: |-
  Get information on a GitHub resource with a custom GET request to GitHub REST API.
---

# github_rest_api

Use this data source to retrieve information about a GitHub resource through REST API.

## Example Usage

```hcl
data "github_rest_api" "example" {
  endpoint = "repos/example_repo/git/refs/heads/main"
}
```

## Argument Reference

 * `endpoint` - (Required) REST API endpoint to send the GET request to.

## Attributes Reference

 * `code`     - A response status code.
 * `status`   - A response status string.
 * `headers`  - A map of response headers.
 * `body`     - A map of response body.

repository: integrations/terraform-provider-github

branch_name: refs/heads/main

extension: markdown

gha_language: Go

repo_name: integrations/terraform-provider-github


text:
# Observability

## Metrics and Tracing

Tracing and metrics are provided by Jaeger's implementation of the OpenTracing project and Prometheus.
Every component has been integrated with the above library and produces traces and metrics.
Metrics are can be scraped via the default HTTP component at the `/metrics` route for Prometheus.
Traces will be sent to a Jaeger agent, which can be setup through environment variables mentioned in the config section.
Sane defaults are applied for making the use easy.
The `component` and `client` packages implement capturing and propagating of metrics and traces.

## Prometheus Exemplars

[OpenTracing](https://opentracing.io) compatible tracing systems such as [Grafana Tempo](https://grafana.com/oss/tempo/)
can work with [Prometheus Exemplars](https://grafana.com/docs/grafana/latest/basics/exemplars/).

Below are prerequisites for enabling exemplars:

- Use Prometheus Go client library version 1.4.0 or above.
- Use the new `ExemplarObserver` for `Histogram` or `ExemplarAdder` for `Counter`
  because the original interfaces has not been changed for the backward compatibility.
- Use `ObserveWithExemplar` or `AddWithExemplar` methods noting the `TraceID` key — it is needed later to configure
  Grafana, so that it knows which label to use to retrieve the `TraceID`

An example of enabling exemplars in an already instrumented Go application can be found [here](../../trace/metric.go)
where exemplars are enabled for `Histogram` and `Counter` metrics.

The result of the above steps is attached trace IDs to metrics via exemplars.
When querying `/metrics` endpoint `curl -H "Accept: application/openmetrics-text"  <endpoint>:<port>/metrics`
exemplars will be present in metrics entry after `#` in [Open Metrics](https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#exemplars-1) format.

repository: beatlabs/patron

repo_name: beatlabs/patron


text:
---
published: true
title: The Equilibrium Index problem in Objective C
layout: post
---
One of the demo challenges at __Codility.com__ is the [Equilibrium Index](https://codility.com/demo/take-sample-test/) problem. Since I noticed in the solution feedback that there were few complaints about the Objective-C online compiler not working I decided to give it a try myself.

The _equilibrium index_ of a sequence is an index such that the sum of elements at lower indexes is equal to the sum of elements at higher indexes. For example, in a sequence A:

> A[0]=-7 A[1]=1 A[2]=5 A[3]=2 A[4]=-4 A[5]=3 A[6]=0

3 is an equilibrium index, because:

> A[0]+A[1]+A[2]=A[4]+A[5]+A[6]

6 is also an equilibrium index, because:

> A[0]+A[1]+A[2]+A[3]+A[4]+A[5]=0

(The sum of zero elements is zero) so 7 is not an equilibrium index because it is not a valid index of sequence A.

Your challenge is to write a function __int equilibrium(int A[])__ that, given a sequence, returns its equilibrium index (any) or -1 if no equilibrium index exists. Assume that the sequence may be very long. The problem can be solved by using various approaches, the most common being simply to follow the equilibrium definition. Create an empty project and use the __main.m__ file to run the code:

{% highlight objective-c %}
int equilibrium(NSMutableArray *A) {
    int i, j, equi = -1;
    for (i=0; i<A.count; ++i) {
        int lsum = 0, rsum = 0;
        for (j=0; j<i; ++j) {
            lsum += [A[j] integerValue];
        }
        for (j=i+1; j<A.count; ++j) {
            rsum += [A[j] integerValue];
        }
        if (lsum == rsum) {
            equi = i;
            NSLog(@"%d ", equi);
        }
    }
    return equi;
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSMutableArray *array = [[NSMutableArray alloc]
            initWithArray:@[@-1, @3, @-4, @5, @1, @-6, @2, @1]];
        NSLog(@"Equilibrium points:");
        equilibrium(array);
    }
    return 0;
}
{% endhighlight %}

Here is the score I got using this approach:
![alt text](https://github.com/mhorga/mhorga.github.io/raw/master/images/equi_bad.png "Bad score")

It seems this approach was not efficient for two reasons:

- it takes way too long to process large input data sets because time complexity is quadratic or O(n^2)

- it fails on large input values (outside the __int__ min/max limits) due to the arithmetic overflows

We can improve our algorithm by updating the left/right sums in O(1) constant time instead of recomputing them both at each iteration. To handle larger input values we should use a proper data-type such as __long long__ instead of __int__. Here is a better solution:

{% highlight objective-c %}
int equilibrium(NSMutableArray *A) {
    long long sum = 0;
    int i, equi = -1;
    for(i=0; i<A.count; i++) {
        sum += (long long)[A[i] integerValue];
    }
    long long lsum = 0;
    for(i=0;i<A.count;i++) {
        long long rsum = sum - lsum - (long long)[A[i] integerValue];
        if (lsum == rsum) {
            equi = i;
            NSLog(@"%d", i);
        }
        lsum += (long long)[A[i] integerValue];
    }
    return equi;
}
{% endhighlight %}

Using this solution I got the perfect score:
![alt text](https://github.com/mhorga/mhorga.github.io/raw/master/images/equi_good.png "Good score")

Until next time!


text:
# FF2 Damage Tracker (Rework)

- This is a rework of the [really old ff2 damage tracker plugin](https://forums.alliedmods.net/showthread.php?t=196861) made originally by [MasterOfTheXP](https://forums.alliedmods.net/member.php?u=152150).
## How to install.
- Download this repository (right top green button), and copy `damagetracker.smx` on your plugins folder.

## New stuff added to this plugin:
- cvar: `sm_dmgtrck_color_r`: change the R (of the RGBA) Color of the tracker ( 0 to 255 ).
- cvar: `sm_dmgtrck_color_g`: change the G (of the RGBA) Color of the tracker ( 0 to 255 ).
- cvar: `sm_dmgtrck_color_b`: change the B (of the RGBA) Color of the tracker ( 0 to 255 ).
- cvar: `sm_dmgtrck_color_a`: change the A (of the RGBA) Opacity (transparency) of the tracker ( 0 to 255 ).
- cvar: `sm_dmgtrck_def_enabled`: Enable ff2 damage tracker by default ( 0 to 1, being 0 disabled, and 1 enabled. ).

You can use [this page](https://www.rapidtables.com/web/color/RGB_Color.html) to select the colors.

## Fixes from the original version:
- Tracker no longer disappears after a few minutes.

## Current known bugs:
- none.

## This plugin is not fully tested, if you find any issues, report it to [ISSUES](https://github.com/Frenzoid/FF2DamageTracker/issues) or [send me a private message via Steam](https://steamcommunity.com/id/MrFren/).


text:
# GPII Universal

The package contains cross-platform core components of the GPII personalization infrastructure. This repository should
not be used directly, but in conjunction with one of the top-level GPII architecture-specific repositories.
Additional documentation is available [on our wiki](http://wiki.gpii.net/w/Architecture).

## Installation

In production, this repository should be installed using one of the top-level GPII architecture-specific repositories:

* [windows](https://github.com/GPII/windows)
* [linux](https://github.com/GPII/linux)
* [android](https://github.com/GPII/android)

For development purposes this repository can also be cloned directly.

## Quick Start

To verify the basic installation of GPII universal, you can start the core framework with

`npm start`

If all is well, you will see a message like

    01:51:07.289:  Kettle Server 2us8uqry-22 is listening on port 8081

Note that this installation will not include any OS-specific features, but can be used to verify system function with
basic preference sets which only start solutions which require filesystem-based configuration (XML, JSON or .INI files).

## Environment Variables

Through the use of Kettle
[resolvers](https://github.com/fluid-project/kettle/blob/master/docs/ConfigsAndApplications.md#referring-to-external-data-via-resolvers),
some pre-defined configuration files offer the ability to read environment variables to change commonly used settings.

### Preferences Server

The Preferences Server with the `gpii.config.cloudBased.flowManager.production` configuration uses the following
variables:

* `GPII_PREFERENCESSERVER_LISTEN_PORT`: TCP port to listen on (default: `8081`)
* `GPII_DATASOURCE_HOSTNAME`: The host name of CouchDB (default: `http://localhost`)
* `GPII_DATASOURCE_PORT`: The port of CouchDB (default: `5984`)

Example:

```snippet
GPII_PREFERENCESSERVER_LISTEN_PORT=9081 \
GPII_DATASOURCE_HOSTNAME=https://localhost \
GPII_DATASOURCE_PORT=5984 \
NODE_ENV=gpii.config.cloudBased.flowManager.production \
npm start
```

### Flow Manager

The Flow Manager with the `gpii.config.cloudBased.flowManager.production` configuration uses the following variables:

* `GPII_FLOWMANAGER_LISTEN_PORT`: TCP port to listen on (default: 8081)
* `GPII_FLOWMANAGER_TO_PREFERENCESSERVER_URL`: The preferences server URL used by the cloud based flow manager to
 communicate with the preferences server
 preferences (default: `http://localhost:8081`)
* `GPII_DATASOURCE_HOSTNAME`: The host name of CouchDB (default: `http://localhost`)
* `GPII_DATASOURCE_PORT`: The port of CouchDB (default: 5984)
* `GPII_CLOUD_URL`: The URL to GPII Cloud (default: `http://localhost:8084`). Used by an untrusted local flow manager
 to communicate with GPII Cloud.

#### Example:

```snippet
GPII_FLOWMANAGER_LISTEN_PORT=9091 \
GPII_FLOWMANAGER_TO_PREFERENCESSERVER_URL=http://localhost:8081 \
GPII_DATASOURCE_HOSTNAME=https://localhost \
GPII_DATASOURCE_PORT=5984 \
NODE_ENV=gpii.config.cloudBased.flowManager.production \
npm start
```

## Recovering From System Corruption Using the Journal

Either when operating the live GPII system or running test cases, you may end up corrupting your desktop settings in the
case there is a system crash. In this case, you can navigate to

    http://localhost:8081/journal/journals.html

to browse a set of journal recovery snapshots. Clicking on the first link on this page will restore your system
to the state it was in prior to the most recent GPII login.

## Testing

There are currently 3 different sets of tests:

* Tests that run in the browser
* Tests that run in node.js
* Production tests, that run in node.js, but which interact with external services.

The `npm test` command will run the browser and Node based tests.  Please note, the node tests may behave oddly if you
have set the `NODE_ENV` variable. The last two types of tests require you to have either Docker or Vagrant installed
and available on your path, or else have a local instance of CouchDB listening on port 25984.
If you are using Vagrant, you'll need to set the `GPII_TEST_COUCH_USE_VAGRANT` environment
variable to `true`, or if you wish to bind tests against a local CouchDB on port 25984, you can
set the `GPII_TEST_COUCH_USE_EXTERNAL` environment variable to `true`. See [the documentation for the
gpii-couchdb-test-harness package](https://github.com/GPII/gpii-couchdb-test-harness) for more details.

### Convert Preferences Data

GPII has two sets of source preferences JSON5 data files, located at `%gpii-universal/testData/preferences` and
`%gpii-universal/tests/data/preferences/`.  These are converted and used in various configurations.

The preferences files in `%gpii-universaluniversal/testData/preferences/` are converted into both `snapset` and
`user` preferences:

* `%gpii-universal/build/dbData/snapset/gpiiKeys.json`
* `%gpii-universal/build/dbData/snapset/prefsSafes.json`
* `%gpii-universal/build/dbData/user/gpiiKeys.json`
* `%gpii-universal/build/dbData/user/prefsSafes.json`

The above `snapset` preferences safes and GPII keys are:

1. loaded into production and staging CouchDB instances in cloud environments.
2. loaded into a local CouchDB instance when GPII runs locally, regardless of which configuration is used.

The above `user` preferences are loaded into the local CouchDB for running GPII integration tests.

The preferences in `%gpii-universal/tests/data/preferences/` are converted into `user` preferences:

* `%gpii-universal/build/tests/dbData/user/gpiiKeys.json`
* `%gpii-universal/build/tests/dbData/user/prefsSafes.json`

These `user` preferences and the above `snapset` preferences are used with CouchDB when GPII runs in a development configuration.

When any preferences file in either one of the two source directories (`%gpii-universaluniversal/testData/preferences/`
or `%gpii-universal/tests/data/preferences/`) are modified, running `npm run postinstall` will generate
gpiiKeys.json and prefsSafes.json files, whose contents are structured for loading into CouchDB.
This step is needed for any preferences modifications that are to be applied to GPII.

### Running browser tests

You can run the browser tests in this package with a range of browsers using [Testem](https://github.com/testem/testem),
and the configuration file `tests/testem.js`, which will ensure that code coverage information is collected.  From the
root of the `universal` folder, run the following command:

`npm run test:browser`

Please note, when running the browser tests locally using this command, the tests will fail on some browsers
(notably Firefox, Safari, and Opera) unless the browser has focus.  You can manually click the browser when it launches
to give it focus.  You should not give another window focus until the tests complete.  This is not a problem when
running the browser tests in Vagrant (see below).  It's also not a problem when running the tests in Chrome, which you
can do using a command like:

`npm run test:browser -- --launch Chrome`

You can also run (and debug) the tests manually from the root of the repository using a command like:

`node node_modules/testem/testem.js --file tests/testem.js`

The required test fixtures and Testem will start, and Testem will provide a URL you can open in a browser.

If you would like to debug individual tests or view the test summary in a browser without using Testem, you can:

1. Host the working directory, for example, using a command like the following from the root of the repository:
   `python -m SimpleHTTPServer 4103`
2. Open the "rollup" file `tests/all-tests.html` that runs all tests in a browser.  Continuing the above example, you
   would load the URL `http://localhost:4103/tests/web/html/all-tests.html`.

Please note, when hosting the tests yourself, you may see multiple 404 errors related to the `/testem.js` and
`/coverage/client/coverageSender.js` files which are provided by Testem and the `gpii.testem` harness respectively.
These 404 errors will not cause any tests to fail and can be safely ignored.

### Running node-based tests

From the root of the `universal` folder, run the following command:

`npm run test:node`

Please note, the node tests may behave oddly if you have set the `NODE_ENV` variable.

### Running tests using a VM

A VM can be automatically created using tools provided by the
[Prosperity4All Quality Infrastructure](https://github.com/GPII/qi-development-environments/). Please ensure the
[requirements](https://github.com/GPII/qi-development-environments/#requirements) have been met. The `vagrant up`
command can then be used to provision a new VM.

Within the VM, the application will be installed in the directory specified by the `nodejs_app_install_dir` variable,
which is defined in `provisioning/vagrant-vars.yml` configuration file in this repository. By default the installation
 directory is set to `/home/vagrant/sync/universal`.

Following the provisioning phase, tests can be run in the VM directly from the host system, without the need to log
into the VM or interact with its console.

From your project's top-level directory (where the `Vagrantfile` and `package.json` files reside), run:

* Node and browser tests: `npm run test:vagrant`
* Node tests only: `npm run test:vagrantNode`
* browser tests only: `npm run test:vagrantBrowser`
* production tests: `npm run test:vagrantProduction`

The `test:vagrantProduction` target uses the `vagrantCloudBasedContainers.sh` script to spin up docker container-based
GPII components inside the VM.

**WARNING:** There is also a `test:productionConfig` npm script but do not run it
directly.  It is used to execute the production tests *within* the docker container-based GPII components
created by `vagrantCloudBasedContainers.sh`.  It is executed as the last step of
`vagrantCloudBasedContainers.sh`.

You can also run `vagrant ssh` to connect to the VM (or open the VirtualBox console and interface with the desktop
environment) and run the tests manually if you wish.

## Usage

To use any of the gpii components or functionality in Node.js, use the
following statements to get access to fluid and/or gpii objects.

```javascript
var fluid = require("infusion"),
    gpii = fluid.registerNamespace("gpii");

fluid.require("%gpii-universal");
// Now you will have access to both fluid and gpii namespaces.
```

### Running node-based production tests

The purpose of these tests are to test production config setups of the system. This involves using the cloud based flow
manager when fetching or updating user settings, so there are extended requirements for these tests.

These tests are a supplement to the `all-tests.js` (and hence not part of that test suite) and should be run separately
when testing the system and having the below requirements available.

The tests are run in one of two ways, using the following commands:

1. From a host machine running a guest VM: `npm run test:vagrantProduction`
2. From within the VM: `./scripts/vagrantCloudBasedContainers.sh`

### Coverage Reporting

The preferred way to consistently generate a code coverage report is to use Vagrant as described above.  When you start
a VM using `vagrant up` and run `npm run test:vagrant`, the full test suite will run in the VM, and at then end of
the run:

1. A summary of the report will be displayed to the console.
2. A coverage report will be saved to the `reports` directory (open the `index.html` file in that directory in a browser
   to see the full details).

The report displays the code coverage for:

1. Code reached from the tests run directly in Node.
2. Code reached within a browser when running the tests in Testem.
3. Server fixtures exercised by browser requests when running the Testem tests.

A code coverage report will also be generated when you run the `npm test` command on your local machine, but you will
need to ensure that browsers receive focus when they are launched (see above).

The `npm test` command has [two additional associated scripts](https://docs.npmjs.com/misc/scripts).  The `pretest`
script runs before the command defined for the `test` script.  The `posttest` script runs after.  In our case
we use a `pretest` script to clean up previous coverage data before we run the tests, and a `posttest` script to
compile the actual report.  Both the `pretest` and `posttest` steps must run in order to generate the report.  If you
only care about the test results, you should not need to run either of these scripts.

## Docker Containers

The provided Dockerfile can be used to run GPII Universal directly.

### Build image

#### Method 1: Via the universal VM

Start the universal VM by running `vagrant up` in the universal root directory.

Inside the universal VM, run:

```snippet
cd sync/universal
./scripts/vagrantCloudBasedContainers.sh
docker images
```

Running `docker images` will show the universal docker image named `vagrant-universal` has been built.

Running `./scripts/vagrantCloudBasedContainers.sh`:

1. Starts the preferences server in the production mode on the port 9081 inside the VM. To test it, open a browser and
   access the URL: `http://localhost:9081/preferences/carla`. The preferences for `carla` should be returned.
2. Starts the flow manager in the production mode on the port 9082 inside the VM. To test it, open a terminal and run:

    ```snippet
    curl -H "Content-Type: application/x-www-form-urlencoded" -X POST
     -d "username=li&password=dummy&client_id=pilot-computer&client_secret=pilot-computer-secret&grant_type=password"
     -X POST http://localhost:9082/access_token
    ```

   An access token should be returned. An example:

   ``` snippet
    {
        "access_token": "19199532c97ed2e0f0d360df6679f058",
        "expiresIn":3600,
        "token_type":"Bearer"
    }
    ```

3. The CouchDB data can be accessed via the URL: `http://localhost:5984/_utils/`

**Note**:

1. All 3 ports are forwarded from the VM to the host machine. Running the same test URLs on the host machine should
   return the same result.
2. In the case that you would like to start these 3 servers without rebuilding the universal docker image, run the
   script with `--no-rebuild` option: `./scripts/vagrantCloudBasedContainers.sh --no-rebuild`

#### Method 2: On a host machine that has docker installed

To build a Docker image simply run: `docker build -t my-universal .`

The following command can be used to build an image locally as long as it is run relative to the repository's
`Dockerfile`:

`docker build --rm -t gpii/universal:$(git rev-parse --short HEAD) .`

That will use the Git repository's current abbreviated commit hash as a
[Docker tag](https://docs.docker.com/reference/commandline/cli/#tag). If you would like to download the latest public
Universal image you can use this command:

`docker pull gpii/universal`

Or use the following command to download a particular image identified using a Git commit hash:

`docker pull gpii/universal:<first seven characters of a git commit hash>`

repository: GPII/universal

gha_language: JavaScript

gha_license_id: NOASSERTION

repo_name: GPII/universal


text:
# ROS-Repo

Collection of ROS code and examples

> Working on Windows WSL Ubuntu 16.04

Install ROS on Windows by following [this guide](https://janbernloehr.de/2017/06/10/ros-windows)


text:
---
title: "RENCI-SILS CI-BER project cited in White House “Big Data” announcement"
slug: renci-sils-ci-ber-project
spotlight: false
publish_date: 2012-04-02
author: subers
featuredImage: null
groups:
    -
projects:
    -
people:
    -
teams:
    -
collaborations:
    -
tags:
    - []
---

CHAPEL HILL, NC - On March 29, 2012, the White House announced the "Big Data Research and Development Initiative."

According Tom Kalil, deputy director for Policy at the Office of Science and Technology Policy, six federal departments and agencies will share more than $200 million in new commitments that, together, promise to greatly improve the tools and techniques needed to access, organize and glean discoveries from huge volumes of digital data.

The Cyberinfrastructure for Billions of Electronic Records (CI-BER) project was included in the White House fact sheet titled, "Big Data Across the Federal Government," which was distributed in conjunction with the announcement. CI-BER was listed as one of the leading projects in the country "that address the challenges of, and tap the opportunities afforded by, the big data revolution."

The research and the underlying infrastructure of CI-BER are sponsored by multiple agencies of the federal government. The fact sheet also noted that the test bed will evaluate technologies and approaches to support sustainable access to ultra-large data collections.

The CI-BER project is led by principal investigator, Richard Marciano, professor at the University of North Carolina at Chapel Hill's School of Information and Library Science (SILS). It aims to further the understanding of infrastructure that scales and provides insights into the management of "big data" in general. Researchers associated with the project look at ultra-high scale collections and visual analytics techniques in order to enhance the value of government records that can lead to generalizable infrastructure and technology.

The CI-BER project is a collaboration between the National Archives and Records Administration (NARA) and UNC Chapel Hill. Some 17 student interns working in NARA's Applied Research Lab in Rocket Center, WV, under the leadership of Mark Conrad, archives specialist, have assembled a collection of almost 100 million unique files containing electronic records of the federal government. Marciano and students at UNC Chapel Hill have built a stand-alone collection RENCI, which is federated with the Rocket Center holdings. The UNC students working on the project include Chien-Yi Hou, doctoral student, and Pamella Lach, master's student at SILS.  Both are also members of the College of Arts and Sciences Digital Innovation Lab (DIL).

CI-BER demonstrates the interplay between the sciences and the humanities and the potential educational impact of big data collaboratives.

In addition to Marciano, UNC CI-BER members include: Stan Ahalt, co-PI and director of RENCI; Leesa Brieger and Jeff Heard, RENCI senior research software developers; Joe Hope, RENCI interface developer Web programmer; Erik Scott, RENCI project engineer; and SILS students Chien-Yi Hou and Pamella Lach.

More Information:

White House Fact Sheet

Office of Science and Technology Policy blog

White House Press Release

UNC School of Information and Library Science

New York Times story

repository: stephsuber/renci-website

repo_name: stephsuber/renci-website


text:
# Testimonials | General

In the context of an application, product or business, testimonials are formal statements from customers declaring the benefits or sharing their successful experience with a
product or service.

Testimonials can be presented as quotes, videos, audio and other formats. Their objective is to help establish trust and encourage potential customers to acquire products and
services.

### Never create or use fake testimonials.

As testimonials are used to buld trust and establish credibility, fabricated testimonials can severely damage a brand's reputation. It is too much of a risky.

todo: complement

### Display the person's name and photo in the testimonial if possible.

Using the person's name and their photo gives more credibility to the testimonials.

todo: complement

### Use only the customer's first name if the industry, field or information is sensitive.

todo: complement

### Consider using video testimonials for increased credibility.

todo: add description

Ádditional Tags: Video

### Keep the length of video testimonials under 60 seconds.

todo: add description

Ádditional Tags: Video


text:
## 2. Setting Up Sign-In Method

After creating your Firebase project.

Click `Authentication` on the left menu and enable Email/Password sign-in method.

![Sign method](https://github.com/TugayYaldiz/vue-comment-grid/blob/master/docs/img/setting-sign-methods/sign-method.gif?raw=true)

---
[Previous Step](https://github.com/TugayYaldiz/vue-comment-grid/blob/master/docs/creating-database.md) • [Next Step](https://github.com/TugayYaldiz/vue-comment-grid/blob/master/docs/get-base-url-api-key.md)


text:
# engnr-docs
Engnr team live documentation suite.

**Note.** All scripts are intended to be executed from the root of this repo.

1. Build Docker image by running `./docs image`.

1. Create initial documentation set by running `./docs init`.

   This script will create `docs` folder one level above relative to your local clone of this
   repo. Such behaviour enables linking this repo as a Git submodule into several projects at
   the same time.

1. Once you have documentation set configured just run `./docs watch`.

   This script listens to filesystem change events and automatically generates its output into
   `build-docs` folder.

1. Now edit documentation sources using your favourite text editor.

   Use browser of your choice to access `localhost:4000`. Hint: there are various browser
   plugins which can reload page automatically for your further convenience.

1. Use `./docs build` to power up your CI system with documentation publishing
   to GitHub/GitLab pages, etc.

**Note.** Run `./docs` without any arguments or pass `--help` to see help message.
Each subcommand has its additional help message.

repository: engnr/engnr-docs

repo_name: engnr/engnr-docs


text:
# Psalm 060 General Notes
## Type of psalm

Psalm 60 is a psalm of war.

## Special concepts in this chapter

### Protection
God has preserved the land of Israel, and now he will give them victory over the countries of Moab and Edom.

repository: mandolyte/uw-obsidian

repo_name: mandolyte/uw-obsidian


text:
## Notes

1. Added a small update to `kick` to consider also `.gohtml` extensions.

   Going to `$GOPATH/src/go.isomorphicgo.org/go/kick/`, in `kick.go` file I updated first line of `InitializeWatcher` function as such:
   ```go
   func initializeWatcher(shouldRestart chan bool, dirList []string) {

        supportedExtensions := map[string]int{".go": 1, ".html": 1, ".tmpl": 1, ".gohtml": 1}
   ```
   Then just ran `go install` to have it in `$GOPATH/bin`, which is part of my `PATH` env var, so I can use it anywhere.

   _Optional:_ In my (OCS tendency) case, I added a new line (`\n`) marker to the line that logs the reloading action, as such: `Instant KickStart Applied ....\n`

repository: dxps/goings

repo_name: dxps/goings


text:
# BusinessApplications

```text
aws-q2-2023/Category/BusinessApplications
```

```text
include('aws-q2-2023/Category/BusinessApplications')
```

| Illustration | BusinessApplications | BusinessApplicationsCard | BusinessApplicationsGroup |
| :---: | :---: | :---: | :---: |
| ![illustration for Illustration](../../aws-q2-2023/Category/BusinessApplications.png) | ![illustration for BusinessApplications](../../aws-q2-2023/Category/BusinessApplications.Local.png) | ![illustration for BusinessApplicationsCard](../../aws-q2-2023/Category/BusinessApplicationsCard.Local.png) | ![illustration for BusinessApplicationsGroup](../../aws-q2-2023/Category/BusinessApplicationsGroup.Local.png) |

## Sprites
The item provides the following sriptes:

- `<$BusinessApplicationsXs>`
- `<$BusinessApplicationsSm>`
- `<$BusinessApplicationsMd>`
- `<$BusinessApplicationsLg>`

## BusinessApplications

### Load remotely
```plantuml
@startuml
' configures the library
!global $LIB_BASE_LOCATION="https://raw.githubusercontent.com/tmorin/plantuml-libs/master/distribution"

' loads the library's bootstrap
!include $LIB_BASE_LOCATION/bootstrap.puml

' loads the package bootstrap
include('aws-q2-2023/bootstrap')

' loads the Item which embeds the element BusinessApplications
include('aws-q2-2023/Category/BusinessApplications')

' renders the element
BusinessApplications('BusinessApplications', 'Business Applications', 'an optional tech label', 'an optional description')
@enduml
```

### Load locally
```plantuml
@startuml
' configures the library
!global $INCLUSION_MODE="local"
!global $LIB_BASE_LOCATION="../.."

' loads the library's bootstrap
!include $LIB_BASE_LOCATION/bootstrap.puml

' loads the package bootstrap
include('aws-q2-2023/bootstrap')

' loads the Item which embeds the element BusinessApplications
include('aws-q2-2023/Category/BusinessApplications')

' renders the element
BusinessApplications('BusinessApplications', 'Business Applications', 'an optional tech label', 'an optional description')
@enduml
```

## BusinessApplicationsCard

### Load remotely
```plantuml
@startuml
' configures the library
!global $LIB_BASE_LOCATION="https://raw.githubusercontent.com/tmorin/plantuml-libs/master/distribution"

' loads the library's bootstrap
!include $LIB_BASE_LOCATION/bootstrap.puml

' loads the package bootstrap
include('aws-q2-2023/bootstrap')

' loads the Item which embeds the element BusinessApplicationsCard
include('aws-q2-2023/Category/BusinessApplications')

' renders the element
BusinessApplicationsCard('BusinessApplicationsCard', 'Business Applications Card', 'an optional description')
@enduml
```

### Load locally
```plantuml
@startuml
' configures the library
!global $INCLUSION_MODE="local"
!global $LIB_BASE_LOCATION="../.."

' loads the library's bootstrap
!include $LIB_BASE_LOCATION/bootstrap.puml

' loads the package bootstrap
include('aws-q2-2023/bootstrap')

' loads the Item which embeds the element BusinessApplicationsCard
include('aws-q2-2023/Category/BusinessApplications')

' renders the element
BusinessApplicationsCard('BusinessApplicationsCard', 'Business Applications Card', 'an optional description')
@enduml
```

## BusinessApplicationsGroup

### Load remotely
```plantuml
@startuml
' configures the library
!global $LIB_BASE_LOCATION="https://raw.githubusercontent.com/tmorin/plantuml-libs/master/distribution"

' loads the library's bootstrap
!include $LIB_BASE_LOCATION/bootstrap.puml

' loads the package bootstrap
include('aws-q2-2023/bootstrap')

' loads the Item which embeds the element BusinessApplicationsGroup
include('aws-q2-2023/Category/BusinessApplications')

' renders the element
BusinessApplicationsGroup('BusinessApplicationsGroup', 'Business Applications Group', 'an optional tech label') {
    note as note
        the content of the group
    end note
}
@enduml
```

### Load locally
```plantuml
@startuml
' configures the library
!global $INCLUSION_MODE="local"
!global $LIB_BASE_LOCATION="../.."

' loads the library's bootstrap
!include $LIB_BASE_LOCATION/bootstrap.puml

' loads the package bootstrap
include('aws-q2-2023/bootstrap')

' loads the Item which embeds the element BusinessApplicationsGroup
include('aws-q2-2023/Category/BusinessApplications')

' renders the element
BusinessApplicationsGroup('BusinessApplicationsGroup', 'Business Applications Group', 'an optional tech label') {
    note as note
        the content of the group
    end note
}
@enduml
```

repository: tmorin/plantuml-libs

gha_language: TypeScript

repo_name: tmorin/plantuml-libs


text:
# Go code for RabbitMQ tutorials

Here you can find Go code examples from [RabbitMQ tutorials](https://www.rabbitmq.com/getstarted.html).

## Requirements

These examples use the [`rabbitmq/amqp091-go`](https://github.com/rabbitmq/amqp091-go) client library.

repository: rabbitmq/rabbitmq-tutorials

repo_name: rabbitmq/rabbitmq-tutorials


text:
# SeisDownload.jl

[![Stable](https://img.shields.io/badge/docs-stable-blue.svg)](https://kura-okubo.github.io/SeisDownload.jl/stable)
[![Dev](https://img.shields.io/badge/docs-dev-blue.svg)](https://kura-okubo.github.io/SeisDownload.jl/dev)
[![Build Status](https://travis-ci.com/kura-okubo/SeisDownload.jl.svg?branch=master)](https://travis-ci.com/kura-okubo/SeisDownload.jl)
[![Codecov](https://codecov.io/gh/kura-okubo/SeisDownload.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/kura-okubo/SeisDownload.jl)

**Download seismic waveform from data server.**

- Download from earthquake data center with multiple processors
- All data (metadata, waveform, fft, ...) is saved in the form of [SeisData](https://seisio.readthedocs.io/en/latest/src/working_with_data.html) structure with [SeisIO.jl®](https://github.com/jpjones76/SeisIO.jl).

## Installation

Then from the Julia command prompt:

1. Press ] to enter pkg.
2. Type or copy: `add https://github.com/kura-okubo/SeisDownload.jl`
3. Press backspace to exit pkg.
4. Type or copy: `using Pkg; Pkg.build("SeisDownload"); using SeisDownload`

## Example
You can download data using `seisdownload`:
to run the example script:

  1. cp `~/.julia/packages/SeisDownload/(versionID)/EXAMPLE/` somewhere and cd `EXAMPLE/Noise_BP`
  2. type `julia -p 3 exec.jl`

- `-p` is num of **additional** processes (= np - 1 parallelizes your processes with your all processors).

More information; see `EXAMPLE` directory.

## Installation Q&A
- Please run with obspy enviroment.
Anaconda environment is useful; see [link](https://github.com/obspy/obspy/wiki/Installation-via-Anaconda). This package is stable with python 3.7.3.

gha_language: Julia


text:
    GoMarketplace

  Buy anything with your smartphone!

  Technologies   |
  How To Use   |
  License

## :rocket: Technologies

Project developed to improve React Native concepts during the [GoStack BootCamp](https://rocketseat.com.br/bootcamp), using the following technologies:

-  [React Native](https://reactnative.dev/)
-  [React Navigation](https://reactnavigation.org/)
-  [styled-components](https://www.styled-components.com/)
-  [VSCode][vc] with [EditorConfig][vceditconfig] and [ESLint][vceslint]

## :information_source: How To Use

To clone and run this application, you'll need [Git](https://git-scm.com), [Node.js v12][nodejs] or higher + [Yarn v1.22][yarn] or higher, [React Native v0.62][reactnative] or higher and a emulator Android/IOS installed on your computer. From your command line:

```bash
# Clone this repository
$ git clone https://github.com/Jhordy9/gomarketplace.git

# Go into the repository
$ cd gomarketplace

# Install dependencies
$ yarn install

# Initiate a emulator Android/IOS

# Run the app
$ yarn android/ios
```

## :memo: License
This project is under the MIT license. See the [LICENSE](https://github.com/Jhordy9/gomarketplace/blob/master/LICENSE) for more information.

---

Codding by Jhordy Isensee 👨💻 [ConnectWithMe!](https://www.linkedin.com/in/jhordyisensee/)

[nodejs]: https://nodejs.org/
[yarn]: https://yarnpkg.com/
[vc]: https://code.visualstudio.com/
[vceditconfig]: https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig
[vceslint]: https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint
[reactnative]: https://reactnative.dev/


text:
# TeamViewer Group Per User Sync

The script moves device entries from a common group to a shared group per
user. If such group doesn't exist, it will attempt to create the group.
Then it moves the device into that group and shares it with the respective
user. If the device is already present in the group or the group is already
shared with the user, the entry is skipped without doing any changes.

The caller needs to provider mapping data that maps a device to a user.
The data needs to be in CSV format and must have the following columns:

- `email`: The email of the user to map the device to.
- `device`: The alias of the device.
- `teamviewerid`: The TeamViewer ID of the device.

To resolve a certain device, the script prefers the TeamViewer ID over the
alias. The TeamViewer ID can also be left blank, so the script will only
try to resolve via the given device alias.

The created groups are named using the following pattern:
`Devices of<EMAIL_ADDRESS>(using the user's email address).

By default, this script writes log data to a file in the current working
directory using the following filename pattern:
`TeamViewerGroupPerUserSync.2020-03-11_17:00:00.log`
(using the date/time of the script invocation)

## Example Usages

```
.\Invoke-TeamViewerGroupPerUserSync -ApiToken 'MyApiToken' -MappingFilePath 'MyMappings.csv' -SourceGroupName 'My Computers'
```

```
.\Invoke-TeamViewerGroupPerUserSync -ApiToken 'MyApiToken' -MappingFilePath 'MyMappings.csv' -IgnoreSourceGroup
```

## Script Parameters

### `-ApiToken`

The TeamViewer API token to use.
Must be a user access token.
The token requires the following access permissions:

- *User management* : `View users`
- *Group management* : `View, create, delete, edit and share groups`
- *Computer & Contacts* : `View, add, edit and delete entries`

![ApiTokenPermissions](ApiTokenPermissions.png)

### `-MappingFilePath`

Path to the file that holds the mappings between users (email) and devices.
The file needs to be in CSV format (using "," comma delimiter) and must
provide the columns described above: email, device

### `-SourceGroupName`

The name of the group, where all devices are currently located.
If this parameter is set, only devices from that group are considered for
the sync.
Devices will be moved out of this group into the respective per-user groups.
Cannot be used in combination with the `IgnoreSourceGroup` parameter.

### `-IgnoreSourceGroup`

If set, there will be no restriction/filtering done on the current group of
devices. All devices of the account associated with the API token are
considered, regardless of their current group.

### `-NoLogFile`

Optionally, suppresses outputting log data to a file.

repository: teamviewer/api-example-scripts

gha_language: PowerShell

repo_name: teamviewer/api-example-scripts


text:
scrapy-intro
============

Introduction to Scrapy presentation for CharPy meetup Sep. 25, 2013

### To run the demo:

#### 1. Download and install these packages

* Virtual Box, http://www.virtualbox.org/
* Vagrant, http://www.vagrantup.com/

#### 2. Fire up the virtual machine and log in

    git clone https://github.com/dmkoch/scrapy-intro
    cd scrapy-intro
    vagrant up
    vagrant ssh

#### 3. Install PyPI requirements

    pip install -r /vagrant/requirements.txt

#### 4. Run the spider

    cd /vagrant/newsbot
    scrapy crawl cnn -o articles.json

### To build the presentation:

    cd /vagrant
    make
    # presentation is created here: build/presentation.html

repository: dmkoch/scrapy-intro

repo_name: dmkoch/scrapy-intro


text:
# Terminal::Print

## History

At first I thought I might try writing a NativeCall wrapper around ncurses. Then I realized that there is absolutely no reason to fight a C library which has mostly bolted on Unicode when I can do it in Pure Perl 6, with native Unicode goodness.

## Usage

Right now it only provides a grid with some nice access semantics.

````
  my $screen = Terminal::Print.new;

  $screen[9][23] = "%";         # prints the escape sequence to put '%' on line 9 column 23
  $screen[9][23];               # returns "%"
  $screen[9][23].print-cell     # prints "%" on the 23rd column of the 9th row

  $screen(9,23,"%");            # another way, designed for golfing or simpler expression
````

(Please note that these are are still subject to change as the library develops further).

Terminal::Print intends to provide the essential underpinnings of command-line printing, to be the fuel for the fire, so to speak, for libraries which might aim towards 'command-line user interfaces' (CUI), asynchronous monitoring, rogue-like adventures, screensavers, video art, etc.

Check out some animations:
````
perl6 -Ilib examples/show-love.p6
perl6 -Ilib examples/zig-zag.p6
perl6 -Ilib examples/matrix-ish.p6
perl6 -Ilib
````

By default the `Terminal::Print` object will use ANSI escape sequences for it's cursor drawing, but you can tell it to use `universal` if you would prefer to use the cursor movement commands as provided by `tput`. (You should only really need this if you are having trouble with the default).

```
    my $t = Terminal::Print(move-cursor-profile => 'universal')
```

Additionally, we have `debug`. This will be used to generate and run the test suite.

# It dies immediately complaining about my TERM env setting

In order to make the shelling out to `tput` safer, I have opted to use a whitelist of
valid terminals. The list is quite short at the moment, so my apologies if you trigger
this error. Everything should work smoothly once you have added it to the lookup hash
in `Terminal::Print::Commands`. Please consider sending it in as a PR, or filing a bug
report!

# STATUS: BETA

This module is currently a bit under nourished. It hungers for a proper test suite and documentation.

Copyright 2015-2016, John Haltiwanger. Released under the Artistic License 2.0.


text:
# ECMulator
Copyright (c) 2017 Po Huit

There is a lot of confusion about how to calculate jam
probabilities for EVE Online ECM modules. This program
caculates single-cycle jam probabilities for any combination
of ECM modules and drones.

## Usage

Run `python3 ecmulator.py` with appropriate arguments.

* The `--jam` (`-j`) argument specifies a jam module or
  drone, including a repeat count for convenience.  Multiple
  `--jam` arguments may be given. All jams are applied to a
  single target.

  The module or drone is specified in the format

  > *<base-type><variant>\[*`x`*<count>]\[H]*

  The *count* defaults to 1 if omitted.

  The `H` indicates that the jam should be overheated (overloaded).

  The *base types* are as follows:

  * D: A drone. The *variant* must be one of:

      * 3: EC-300
      * 6: EC-600
      * 9: EC-900

  * M: A multispectral jammer. The *variant* must be one of:

      * 1: T1
      * M: Meta 1
      * 2: T2
      * L: Legion
      * G: Dread Guristas
      * K: Kaikka's
      * T: Thon's
      * V: Vaipas' *[sic]*
      * E: Estamel's

  * R or X: a "matched" or "mismatched" racial jammer,
    respectively. The "matched" case (R) applies the jammer
    to a hull whose sensor type matches the jammer's; the
    "mismatched" case (X) applies the jammer to a hull of
    some other sensor type. The *variant* must be one of:

      * 1: T1
      * M: Meta 1
      * 2: T2
      * S: Storyline *[named]*
      * L: Legion

  * B: A Burst Jammer. These have a 30 second cycle time
    instead of 20, which is not taken into account here in
    any way. The *variant* must be one of:

      * 1: T1
      * M: Meta
      * 2: T2
      * G: 'Ghost'
      * S: Sentient
      * D: Unit D-34343's Modified
      * F: Unit F-435454's Modified
      * P: Unit P-343554's Modified
      * W: Unit W-634's Modified

  For example, if you have 1 matched racial meta jammer and 4
  mismatched racial meta jammers fitted, say

      --j RM --j XMx4

* The `--resist` (`-r`) argument specifies the sensor
  strength of the target hull. The default of 20 represents
  an "average" T1 Cruiser hull.

* The `--skill` (`-s`) argument specifies the Signal
  Dispersion skill level of the pilot. Jammer effectiveness
  increases by 5% per level. The default of 5 is what a good
  pilot should have.

* The `--hull` (`-H` — don't ask about the uppercase)
  argument specifies the hull bonus percentage (for example,
  `30` for 30%) for jammers. The default of 0 reflects an
  unbonused ship. Hull bonuses must be calculated manually:
  there's too many cases to be specified to make a
  programmatic calculation useful.

* The `--fitting` (`-f`) argument specifies a rig or module
  that gives an ECM strength bonus. See the description of
  `--jam` for general syntax. Stacking penalties are
  applied.

  The *base types* are as follows:

  * S: A Signal Distortion Amplifier module. The *variant*
    must be one of:

      * 1: T1
      * i: Initiated  *[ugh lowercase]*
      * I: Induced
      * C: Compulsive
      * H: 'Hypnos'
      * 2: T2

  * P: A Particle Dispersion Augmentor rig. The *variant*
    must be one of:

      * 1: T1
      * 2: T2

## Frequently Asked Questions

Q: *Why doesn't this tool also deal with ECM ranges?*

A: Your fitting tool calculates the ranges great. There
should be an option to provide percent-of-falloff for
joint probability calculation, though.

-----

Q: *Why not just copy jam strengths from my fitting tool?*

A: What a pain.

-----

Q: *What about implants?*

A: As far as I know, there are not any that specifically
affect ECM strength.

-----

Q: *Why is the syntax for specifying jams and fittings so
gross?*

A: It was designed for brevity and scripting rather than
for readability. Patches welcome.

-----

Q: *Can you do pretty graphs?*

A: Not yet. You can script something with a plotting tool
if you want to make your own.

## Thanks

Props to [PyFA](http://github.com/pyfa-org/Pyfa) and the EVE
University [wiki](http://wiki.eveuniversity.org) for making
development and checking of this tool much, much easier.

## License

This program is licensed under the "MIT License". Please see
the file `COPYING` in the source distribution of this software
for license terms.

repository: PoHuit/ecmulator

repo_name: PoHuit/ecmulator


text:
How to configure Kaya?
==============

Kaya retrieve information from profiles file called cucumber.yml allocated on project root folder.
You have to have this file into your project to work with Kaya.

Kaya will show only those suites marked as runnable as test suites. To do this you only have to add a flag to each cucumber profile you want to expose as follows:
Supose you have a profile called regression on cucumber.yml file

	#cucumber.yml
	regression: -t @regression runnable=true

The flag `runnable=true` indicates to Kaya to expose the profile to be executed as a test suite.

repository: despegar/cars-kaya

repo_name: despegar/cars-kaya


text:
---
date: 2016-12-11T00:00:00
draft: false
title: "Channel Operator Tools"
type: "post"
---

## Channel Verification Process
We developed a new tool that channels can enable. When enabled, new users joining a channel will need to verify via the web in order to earn voice status (able to speak in a +m moderated channel) .
This will hinder ban evaders and gives staff new options to work with to help deter and stop abusive users.
It can be used in event channels with large amounts of users, or used as a tool to force people to make an effort to chat in the channel. The inner workings behind the engine will be explained in detail to the #optalk crew before making it public to all channels as a service on Snoonet.

# How it works
- User joins channel
- User is sent a link to a secure website to prove they are a real person
- Magic happens on our backend
- After visiting the URL sent to them, mode +v is applied to their nickname

You may currently request this verification process on your channel by asking in #snoonet or #optalk.

repository: snoonetIRC/website

gha_language: SCSS

repo_name: snoonetIRC/website


text:
# About the Foundation for Public Code

[Our mission](organization/mission.md) is:

> [...] to enable public-purpose software and policy that is open and collaborative.

This repository is meant to reflect the concept of the Foundation for Public Code and hold all information about it.
It's `main` branch is the official ['source of truth'](GOVERNANCE.md) and central repository for all information about the Foundation for Public Code.

## Contributing

We are looking for people like you to [contribute](CONTRIBUTING.md) to this project by suggesting improvements and helping develop the Foundation for Public Code. 😊 Get started by reading our [Contributors Guide](CONTRIBUTING.md).

Please note that this project is released with a [Contributor Code of Conduct](CODE_OF_CONDUCT.md). By participating in this project you agree to abide by its terms. Please be lovely to all other community members.

## Preview, build and deploy

The repository builds to a static site deployed at [about.publiccode.net](https://about.publiccode.net/). It is built with [GitHub pages](https://pages.github.com) and [Jekyll](https://jekyllrb.com/).

Releasing and deploying [is done with a release branch](activities/documentation/merge-develop-into-main.md).

We aim to deploy every Monday.

You can use the scripts:

* `./script/serve.sh` to serve the site locally with livereload
* `./script/test.sh` to run the tests including markdownlint and htmlproofer

### Branches and Travis CI build status

All branches are tested with every change for broken links, so if some site we link to on the internet goes down the 'Build Status' down here will go red.

| Branch | Build Status | |
|----|----|----|
| `develop` | [![Build Status](https://travis-ci.com/publiccodenet/about.svg?branch=develop)](https://travis-ci.com/publiccodenet/about/branches) | Version from which we work |
| `main` | [![Build Status](https://travis-ci.com/publiccodenet/about.svg?branch=main)](https://travis-ci.com/publiccodenet/about/branches) | Deployed to <https://about.publiccode.net>, once a week |

## License

[![CC0](https://licensebuttons.net/p/zero/1.0/88x31.png)](https://creativecommons.org/publicdomain/zero/1.0/)

To the extent possible under law, the Foundation for Public Code has waived all copyright and related or neighboring rights to the content in this repository. It is [licensed CC0](https://creativecommons.org/publicdomain/zero/1.0/), which basically means that anyone can do anything with it. This does not apply to trademarks or logos of the Foundation for Public Code.

Contributors to this repository agree that their contributions also fall under this license and that they have the power and authority to grant this licence.

repository: brandmuse/about

repo_name: brandmuse/about