text:
# HipChat Notifications Channel for Laravel 5.3 [WIP]

[![Latest Version on Packagist](https://img.shields.io/packagist/v/laravel-notification-channels/hipchat.svg?style=flat-square)](https://packagist.org/packages/laravel-notification-channels/hipchat)
[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](LICENSE.md)
[![Build Status](https://img.shields.io/travis/laravel-notification-channels/hipchat/master.svg?style=flat-square)](https://travis-ci.org/laravel-notification-channels/hipchat)
[![StyleCI](https://styleci.io/repos/65714660/shield)](https://styleci.io/repos/65714660)
[![SensioLabsInsight](https://img.shields.io/sensiolabs/i/1af9cfed-e62d-405a-b06d-9071d2f8bee8.svg?style=flat-square)](https://insight.sensiolabs.com/projects/1af9cfed-e62d-405a-b06d-9071d2f8bee8)
[![Quality Score](https://img.shields.io/scrutinizer/g/laravel-notification-channels/hipchat.svg?style=flat-square)](https://scrutinizer-ci.com/g/laravel-notification-channels/hipchat)
[![Code Coverage](https://img.shields.io/scrutinizer/coverage/g/laravel-notification-channels/hipchat/master.svg?style=flat-square)](https://scrutinizer-ci.com/g/laravel-notification-channels/hipchat/?branch=master)
[![Total Downloads](https://img.shields.io/packagist/dt/laravel-notification-channels/hipchat.svg?style=flat-square)](https://packagist.org/packages/laravel-notification-channels/hipchat)

This package makes it easy to send [HipChat notifications](https://www.hipchat.com) with Laravel 5.3.

## Contents

- [Installation](#installation)
	- [Setting up the HipChat Service](#setting-up-the-hipchat-service)
- [Usage](#usage)
	- [Available Message methods](#available-message-methods)
- [Changelog](#changelog)
- [Testing](#testing)
- [Security](#security)
- [Contributing](#contributing)
- [Credits](#credits)
- [License](#license)

## Installation

You can install the package via composer:

``` bash
composer require laravel-notification-channels/hipchat
```

You must install the service provider:

```php
// config/app.php
'providers' => [
    ...
    NotificationChannels\HipChat\HipChatProvider::class,
];
```
### Setting up the HipChat service

Add your HipChat Account Token and optionally the default room and Hipchat API server's base url to your `config/services.php`:

```php
// config/services.php

    'hipchat' => [
        'token' => env('HIPCHAT_TOKEN'),
        // Default room (optional)
        'room' => 'Notifications',
        // Base URL for Hipchat API server (optional)
        'url' => 'https://api.your.hipchat.server.com',
    ]
```

## Usage

``` php
use NotificationChannels\HipChat\HipChatChannel;
use NotificationChannels\HipChat\HipChatMessage;
use Illuminate\Notifications\Notification;

class UserRegistered extends Notification
{
    public function via($notifiable)
    {
        return [HipChatChannel::class];
    }

    public function toHipChat($notifiable)
    {
        return new HipChatMessage::create("<strong>A new user has registered!</strong>")
            ->room('New Registrations')
            ->sucess()
            ->notify()
            ->html();
    }
}
```

### Available methods

#### HipChatMessage

- `room()`: Specifies the room (id or name) to send the notification to.
- `from()`: Sets the optional label to be shown in addition to the sender's name.
- `content()`: Sets a content of the notification message.
- `text()`: Sets the content format to plain text.
- `html()`: Sets the content format to html. Allowed HTML tags: a, b, i, strong, em, br, img, pre, code, lists, tables.
- `color()`: Sets the color for the message. Allowed values: yellow, green, red, purple, gray, random.
- `notify()`: Specifies if a message should trigger a user notification in a Hipchat client.
- `info()`: Sets notification level to `info` and color to `gray`.
- `success()`: Sets notification level to `success` and color to `green`.
- `error()`: Sets notification level to `info` and color to `red`.

## Testing

``` bash
$ composer test
```

## Security

If you discover any security related issues, please email<EMAIL_ADDRESS>instead of using the issue tracker.

## Changelog

Please see [CHANGELOG](CHANGELOG.md) for more information what has changed recently.

## Contributing

Please see [CONTRIBUTING](CONTRIBUTING.md) for details.

## Credits

- [Peter Matseykanets](https://github.com/pmatseykanets)
- [All Contributors](../../contributors)

## License

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

repository: jjpmann/hipchat

repo_name: jjpmann/hipchat


text:
# JSteroids

[![forthebadge](https://forthebadge.com/images/badges/made-with-javascript.svg)](https://forthebadge.com)

[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/Pejo-306/JSteroids/blob/master/LICENSE) [![GitHub release](https://img.shields.io/badge/release-v1.0.1-brightgreen.svg)](https://github.com/Pejo-306/JSteroids/releases/) [![Phaser 3](https://img.shields.io/badge/Built%20with-Phaser%203-orange.svg)](https://github.com/photonstorm/phaser) [![Heroku](https://img.shields.io/badge/Hosted%20on-Heroku-blueviolet.svg)](https://tranquil-bayou-90414.herokuapp.com/)

JSteroids is a recreation of the classical retro game Asteroids. The project
itself is an HTML5 game created with the help of the open-source game engine
[Phaser 3](https://github.com/photonstorm/phaser) which is based on JavaScript.

## Table of contents

* [Game Description](#game-description)
* [Play the Game](#play-the-game)
* [Getting Started](#getting-started)
  - [Prerequisites](#prerequisites)
  - [Installation](#installation)
  - [Running on a Local Server](#running-on-a-local-server)
  - [Running in a Production Environment](#running-in-a-production-environment)
* [Built with](#built-with)
* [License](#license)

## Game Description

The game is a 2D top-down view shooter. The player controls a spaceship which
may navigate around in space and fire projectiles. The game's main objective
is to destroy asteroids which spawn endlessly in waves. With each wave, the
number of asteroids increases by multiplying the previous wave's asteroid count
with a level multiplier which depends on the player's score. Asteroids come
in several levels with each next level of asteroids being faster and smaller
than the previous.

Saucers are the player's main enemy. They spawn randomly every so often and
shoot in random directions. Like asteroids, saucers also come in a few levels
with each next level of saucers being faster and smaller than the previous
level. Saucers can be destroyed by colliding with either the player or
their projectiles. However, these enemies bounce off asteroids on collision.

Each player-destroyable object (asteroids and saucers) give the player some
amount of score. The objective of the game is to achieve a higher score before
the player loses all of their lives. After the game ends, the player has the
option of returning to the main menu or to directly restart the game.

## Play the Game

This project is currently deployed on Heroku. You may visit the following app
to play JSteroids without performing any setup:

https://tranquil-bayou-90414.herokuapp.com/

## Getting Started

The following instructions will get you a running copy of the game on your
local machine.

### Prerequisites

You must have installed nodejs and npm in order to run this project. The latest
versions used in this project are:

* nodejs v10.15.3
* npm 6.4.1

### Installation

To get a copy of the game, all you need to do is clone this Github repository.

```bash
$ git clone https://github.com/Pejo-306/JSteroids.git
$ cd JSteroids/
```

Then install all npm packages.

```bash
$ npm install
```

### Running on a Local Server

Run webpack's development server.

```bash
$ npm run dev
```

Afterward, open your browser and visit **localhost:8000**.

And you're good to go. Enjoy playing the game :).

### Running in a Production Environment

In order to deploy the game in a production environment, you must start the
provided simple Express.js server. To run the server use the following npm script:

```bash
$ npm start
```

## Built with

* [Phaser 3](https://github.com/photonstorm/phaser)

## License

This project is distributed under the [MIT license](LICENSE).

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

gha_license_id: MIT

license_type: permissive


text:
# Flexi

[![npm version](https://badge.fury.io/js/flexi.svg)](http://badge.fury.io/js/flexi)
[![Ember Observer Score](http://emberobserver.com/badges/flexi.svg)](http://emberobserver.com/addons/flexi)
[![Code Climate](https://codeclimate.com/github/html-next/flexi/badges/gpa.svg)](https://codeclimate.com/github/html-next/flexi)

Flexi is a responsive-design layout framework like Bootstrap and Foundation. Flexi is focused on performance and maintainability, utilizing Ember for greater configuration and convenience than soluions like Bootstrap or Foundation
could offer.

Flexi is also unopinionated about your CSS. You can configure it to utilize your existing CSS, or the CSS of any design
framework.

Flexi does most of it's heavy lifting at `build` time, happily adding very little runtime code and little-to-no CSS to your project.

## Support, Questions, Collaboration

Join the [Ember community on Discord](https://discord.gg/zT3asNS)

## Release Notes

[Changelog](./CHANGELOG.md)

## Contributing

 - Open an Issue for discussion first if you're unsure a feature/fix is wanted.
 - Branch off of `main` (default branch)
 - Use descriptive branch names (e.g. `<type>/<short-description>`)
 - PR against `main` (default branch).

## Thanks

A special thanks goes out to [@ebryn](https://github.com/ebryn) for the
inspiration to pursue a solution for explicit layouts, and [IsleofCode](https://isleofcode.com)
for providing the time to build the original implementation.

repository: html-next/flexi

branch_name: refs/heads/main

repo_name: html-next/flexi


text:
---
title: jResize Plugin, for one window responsive development
author: Todd Motto
layout: post
permalink: /jresize-plugin-for-one-window-responsive-development/
disqus: http://www.toddmotto.com/jresize-plugin-for-one-window-responsive-development
path: 2012-10-28-jresize-plugin-for-one-window-responsive-development.md
tags:
- Library
- jQuery
- JavaScript
---

jResize is a responsive web development tool, built in jQuery to assist the workflow of developers on responsive projects. There are various tools for responsive development, iframes at different widths embedded in the page, and the tedious resizing of the browser. So here’s a different approach which grabs all your HTML, and resizes it inside the browser when you click the width you want. It’s dead simple.

#### Updated! Use jResize in the browser too, without installation: [Browser Development][1]

  Browser Version
  Demo
  Download

Let’s talk you through the plugin.

 [1]: http://www.toddmotto.com/labs/responsive/

### jQuery Options

First we declare our Plugin defaults, to which are some popular viewport widths. Any you specify in the plugin will overwrite these.

{% highlight javascript %}
$.jResize.defaults = {
      viewPortSizes   : ["320px", "480px", "540px", "600px", "768px", "960px", "1024px", "1280px"],
      backgroundColor : '444',
      fontColor       : 'FFF'
}

options = $.extend({}, $.jResize.defaults, options);
{% endhighlight %}

### Variables/Arrays

Here we define some variables for background color, font color and an array for the viewport widths.

‘var resizer’ is our first variable, which as you can see we create an HTML structure from, with some inline styles, so we need nothing more than just pure jQuery and no stylesheets. In here, we create a div which contains an empty unordered list.

{% highlight javascript %}
var resizer = "

" + "

";
{% endhighlight %}

These are our viewport widths (hence the name), which get pulled in from the Plugin’s options. Any width sizes you specify will end up here.

{% highlight javascript %}
var viewPortWidths = options.viewPortSizes;
{% endhighlight %}

This just defines some inline styles for our list elements which we’ll call later.

{% highlight javascript %}
var viewPortList = "display:inline-block;cursor:pointer;text-align:center;width:100px;border-right:1px solid #555;padding:10px 5px;"
{% endhighlight %}

### Wrapping the HTML

To be able to resize the webpage inside the browser, we need to wrap all your HTML inside an empty div. We could piggyback off the body tag, but creating our own markup to resize is better.

Using jQuery’s ‘wrapInner’ and targeting the body tag, this allows us to wrap absolutely everything inside our div tag with an ID of ‘resizer’. Now we’ve got hold of all the HTML inside our newly created tag, this sets us up perfectly.

{% highlight javascript %}
$('body').wrapInner('
');
{% endhighlight %}

### Prepending the Plugin

jQuery’s ‘before’ function allows us to insert content before a targeted element. We don’t want to put our navigation inside our resizer div, as this will resize, so using ‘before’ allows us to inject our navigation after the body tag, but before the resizer content wrap. Here you see we call our ‘resizer’ variable, and use CSS margin, zero auto to center all content.

{% highlight javascript %}
$('#resizer').css({margin: '0 auto'}).before(resizer);
{% endhighlight %}

### Looping the Array and ViewPort widths

Here’s where things get awesome. We loop through our array, which we’ve setup to be a little bit smart. Our specified viewport widths act as a width animator and also a classname, which allows us to have super control with minimal code. Using jQuery’s ‘each’ function (similar to PHP foreach), we then target our unordered list element from our variables above (.viewlist) and append a list item for each variable.

This basically means, if we set 320px as a variable, it will become a class for us to hook onto for clicking, and act as a width that feeds in to automatically make the browser this width.

{% highlight javascript %}
$.each(viewPortWidths, function (go, className) {
    $('.viewlist').append($(''   className   ''));
    $('.'   className   '').click(function () {
        $('#resizer').animate({
            width: ''   className   ''
        }, 300);
    });
});
{% endhighlight %}

### Animated Entrance

We declare a height variable, which gets the outerHeight value from our viewlist, which would equal the height of our plugin. From this we hide the viewports (our navigation) then use the ‘slideDown’ function to show the nav. We then use our height variable, to animate the exact height of the nav, and add a top margin to our resizer div, which holds our content. This allows our plugin to push down the page content and also remain fixed in position.

{% highlight javascript %}
var height = $('.viewlist').outerHeight();
$('.viewports').hide().slideDown('300');
$('#resizer').css({margin: '0 auto'}).animate({marginTop : height});
{% endhighlight %}

### Reset

Also included is a reset button, which drops all widths you’ve manipulated with jResize. We prepend a separate list element for this as it’s not part of our array. This also has a custom class of ‘reset’.

{% highlight javascript %}
$('.viewlist').prepend('
Reset
');
{% endhighlight %}

Using the custom class of ‘reset’, we can then ensure that when the user clicks, it drops all pixel width styling to our resizer. We can’t really remove our width specifically from an inline style, so here we’ll just declare the content to flow to ‘auto’ which drops all styling – allowing or content to go back to normal without refreshing the page.

{% highlight javascript %}
$('.reset').click(function () {
    $('#resizer').css({
        width: 'auto'
    });
});
{% endhighlight %}

### Using and calling jResize

Simply include jresize.js in your page (in the download) and call it like so:

{% highlight html %}

{% endhighlight %}

### Scrollbars

Nothing major, just thinking in terms of scrollbars. Mac OS X (which I use) tends not to have scrollbars that are visible or take up content space, so if you’re using a browser such as FireFox, or a Windows machine where scrollbars are standard, you might wish to widen each width accordingly (probably best to inspect element and get an exact width of the pixels, but usually around 15-20px extra to cater for scrolling).

  Browser Version
  Demo
  Download
  Fork


text:
# Analysis-of-the-Titanic-Data
To perform a full analysis of the survivor or death of the travelers travelling in the Titanic given in the dataset.

To create Hive query Language Files to load the data into the Hive warehouse and perform cleaning operation to remove the null values. In addition to this it shows the analysed Data of Titanic Dataset in train.csv file using Tableau.

license: Unlicense


text:
# SiamMOT

SiamMOT is a region-based Siamese Multi-Object Tracking network that detects and associates object instances simultaneously.

![](readme/SiamMOT.png)

> [**SiamMOT: Siamese Multi-Object Tracking**](https://www.amazon.science/publications/siammot-siamese-multi-object-tracking),
> Bing Shuai, Andrew Berneshawi, Xinyu Li, Davide Modolo, Joseph Tighe,

    @inproceedings{shuai2021siammot,
      title={SiamMOT: Siamese Multi-Object Tracking},
      author={Shuai, Bing and Berneshawi, Andrew and Li, Xinyu and Modolo, Davide and Tighe, Joseph},
      booktitle={CVPR},
      year={2021}
    }

![](readme/ablation.gif)

## Abstract
In this paper, we focus on improving online multi-object tracking (MOT). In particular, we introduce a region-based Siamese Multi-Object Tracking network, which we name SiamMOT. SiamMOT includes a motion model that estimates the instance’s movement between two frames such that detected instances are associated. To explore how the motion modelling affects its tracking capability, we present two variants of Siamese tracker, one that implicitly models motion and one that models it explicitly. We carry out extensive quantitative experiments on three different MOT datasets: MOT17, TAO-person and Caltech Roadside Pedestrians, showing the importance of motion modelling for MOT and the ability of SiamMOT to substantially outperform the state-of-the-art. Finally, SiamMOT also outperforms the winners of ACM MM’20 HiEve Grand Challenge on HiEve dataset. Moreover, SiamMOT is efficient, and it runs at 17 FPS for 720P videos on a single modern GPU.

## Installation

Please refer to [INSTALL.md](readme/INSTALL.md) for installation instructions.

## Try SiamMOT demo
For demo  purposes,  we provide two tracking models -- tracking person (visible part) or jointly tracking person and vehicles (bus, car, truck, motorcycle, etc).
The person tracking model is trained on COCO-17 and CrowdHuman, while the latter model is trained on COCO-17 and VOC12.
Currently, both models used in demos use EMM as its motion model, which performs best among different alternatives.

In order to run the demo, use the following command:
~~~
python3 demos/demo.py --demo-video  PATH_TO_DEMO_VIDE --track-class person --dump-video True
~~~
You can choose `person` or  `person_vehicel` for `track-class` such that person tracking or person/vehicle tracking model is used accordingly.

The model would be automatically downloaded to `demos/models`,
and the visualization of tracking outputs is automatically saved to `demos/demo_vis`

![](readme/demo_volleyball.gif)

![](readme/demo_person_vehicle.gif)

We also provide several pre-trained models in [model_zoos.md](readme/model_zoo.md) that can be used for demo.

## Dataset Evaluation and Training
After [installation](readme/INSTALL.md), follow the instructions in [DATA.md](readme/DATA.md) to setup the datasets.
As a sanity check, the models presented in [model_zoos.md](readme/model_zoo.md) can be used to for benchmark testing.

Use the following command to train a model on an 8-GPU machine:
Before running training / inference, setup the [configuration file](configs) properly
~~~
python3 -m torch.distributed.launch --nproc_per_node=8 tools/train_net.py --config-file configs/dla/DLA_34_FPN.yaml --train-dir PATH_TO_TRAIN_DIR --model-suffix MODEL_SUFFIX
~~~

Use the following command to test a model on a single-GPU machine:
~~~
python3 tools/test_net.py --config-file configs/dla/DLA_34_FPN.yaml --output-dir PATH_TO_OUTPUT_DIR --model-file PATH_TO_MODEL_FILE --test-dataset DATASET_KEY --set val
~~~

**Note:** If you get an error `ModuleNotFoundError: No module named 'siammot'` when running in the git root then make
sure your PYTHONPATH includes the current directory, which you can add by running: `export PYTHONPATH=.:$PYTHONPATH`
or you can explicitly add the project to the path by replacing the '.' in the export command with the absolute path to
the git root.

Multi-gpu testing is going to be supported later.

## Version
This is the preliminary version specifically for [Airbone Object Tracking (AOT) workshop](https://www.aicrowd.com/challenges/airborne-object-tracking-challenge).
The current version only support the motion model being EMM.

* [Update 06/02/2021] Refactor of configuration file
* [Update 06/02/2021] Operator patching for amodal inference (needed in MOT17) and model release of MOT17 model
* [Update 06/02/2021] Support inference based on provided public detection

Stay tuned for more updates

## License

This project is licensed under the Apache-2.0 License.

repository: tiendzung-le/siam-mot

repo_name: tiendzung-le/siam-mot


text:
# BrowserLoader

BrowserLoader is a watir-webdriver based browser loader class. It provides
additional chromium configuration options.

After I re-created this functionality for the 3rd time, I decided to turn it
into a gem so updates could take place in one location rather than multiple
places.

While BrowserLoader provides configuration for Chromium, it can load Firefox
or IE if desired. At this time, default configurations are used when loading
Firefox or IE.

When running on a linux OS, BrowserLoader will start the system's version of
the browser; the executable returned by `which chromium-browser`. When running
on windows, if using Chromium, a path to the Chromium/Chrome executable must
be provided.

Rather than being a nuisance, providing the executable path allows you to use
an older version of chromium for your testing. This becomes valuable if you
consider the breaking changes automatic updates of the browser can cause.

For me, this was especially a problem on windows.

Current versions of Chromium can be found at [http://chromium.woolyss.com](http://chromium.woolyss.com)
and older versions can be downloaded from the `continous` repo maintained by
Google at [https://storage.googleapis.com/chromium-browser-continuous/index.html](https://storage.googleapis.com/chromium-browser-continuous/index.html).

When creating the browser object, BrowserLoader looks for an environment variable
named `BROWSER`. If it exists and is populated with a recognized value, Firefox
or IE will be started. By default, Chromium will be started.

Possible `BROWSER` values:

+ `ie`: Internet Explorer
+ `ff`: Firefox

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'browser_loader'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install browser_loader

## Usage

You can use the BrowserLoader::Factory class directly in your code, or derive/
compose a class from it.

Using it stand-alone:

```ruby
require 'browser_loader'

# Set the user data (profile) directory
BrowserLoader::Factory.user_data_dir = '/tmp/chromium_user_data'

# Override the default timeout period (in seconds)
BrowserLoader::Factory.timeout = 360

# Configure and start the Chromium browser
browser = BrowserLoader::Factory.build

# Do something with browser...

```

Using it through composition:

```ruby
require 'browser_loader'

module MyModule

  def browser
    if @browser.nil?
      # Set the user data (profile) directory
      BrowserLoader::Factory.user_data_dir = '/tmp/chromium_user_data'

      # Override the default timeout period (in seconds)
      BrowserLoader::Factory.timeout = 360

      # Configure and start the Chromium browser
      @browser = BrowserLoader::Factory.build

      # Add an +at_exit+ proc to close the browser when the program exits.
      at_exit do
        @browser.close unless @browser.nil?
      end
    end
  end
end # module

class SomeClass
  include MyModule

  def goto_google
    browser.goto 'http://google.com'
  end
end # class

```

## Contributing

1. Fork it ( https://github.com/[my-github-username]/browser_loader/fork )
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create a new Pull Request


text:
# Notee: A Minimalist Desktop Note Application
Halo this is notee, a minimalist desktop application to create a simple note.

![notee screenshow](https://raw.githubusercontent.com/herdiansc/notee/main/ss.png "screenshot")

## Features
- create simple note
- full screen view

## Get The App
- Open latest release page of this repo here https://github.com/herdiansc/notee/releases/latest
- Download AppImage or build from source.

repository: herdiansc/notee

repo_name: herdiansc/notee


text:
---
layout: post
title: Alaska, All the Way to North (Part 1)
subtitle: Flying all the way to north from Syracuse via Seattle, we finally reach Anchorage, which is the first stop during our one-week-long stay in the northmost state of America, Alaska. Starting from here, we will explore around the city, drive along AK-1 S and State Hwy 9 to Seward looking forward to catching...
date:       2019-05-02 12:00:00
author:     "Helffor"
header-img: "assets/owner/blog/header/post-bg-01.jpg"
thumbnail: /assets/owner/blog/thumbs/thumb01.png
tags: [alaska, travel]
category: [nature]
comments: false
share: false
gallery1:
  - image_path: /assets/owner/blog/galleries/g01/bg1.jpg
    image-caption: Route
    image-copyright: © Helfforich Photography
gallery2:
  - image_path: /assets/owner/blog/galleries/g01/bg2.jpg
    image-caption: Anchorage Airport
    image-copyright: © Helfforich Photography
gallery3:
  - image_path: /assets/owner/blog/galleries/g01/bg3.jpg
    image-caption: Railway
    image-copyright: © Helfforich Photography
gallery4:
  - image_path: /assets/owner/blog/galleries/g01/bg4.jpg
    image-caption: Chugach National Forest
    image-copyright: © Helfforich Photography
---

Flying all the way to the north from Syracuse via Seattle, we finally reach Anchorage, which is the first stop during our one-week-long stay in the northernmost state of America, Alaska. Starting from here, we will explore around the city, drive along AK-1 S and State Hwy 9 to Seward looking forward to catching a glimpse of whales and glaciers in the Resurrection Bay, search the highest peak of North America in Denali National Park, hunt northern lights on the outskirts of Fairbanks, and enjoy the stunning scenery from up above in our flight back to Anchorage.

{%comment%} Gallery {%endcomment%}
{% include subgallery.html id="gallery1" %}

Upon disembarking in Anchorage, I am immediately attracted to the mountains at a distance, ones that are covered with snow even in springtime. Looking through the window at the airport, I'm conviced that I won't get bored in the coming days with views like this. I'm more aware that I NEED to get closer to them and take some fine shots.

{%comment%} Gallery {%endcomment%}
{% include subgallery.html id="gallery2" %}

After renting our jeep, we drive down south towards Seward. The landscape along the highway is unforgettably amazing while we're driving through mountains and lakes. In company with the main road lies a seemingly endless railway. Unfortunately, trains in this season are not so frequent, and it turns out we don't stand a chance of appreciating the gorgeous scenery on a train. In retrospect, we are already planning on going back in the summer and taking the train.

{%comment%} Gallery {%endcomment%}
{% include subgallery.html id="gallery3" %}

On our way I spot a place called Chugach National Forest and I ask my fellows to stop and stare. This is a perfect viewpoint to photograph Kenai Lake and its surroundings. We collect flagstones that were used to pave the railroad and start playing ducks and drakes. Although I cannot retrieve my childhood skill and fail to achieve even a second bounce, this is still a lot of fun.

{%comment%} Gallery {%endcomment%}
{% include subgallery.html id="gallery4" %}

After our brief stop by the lake, we continue to head for Seward, where we will spend four hours cruising around Resurrection Bay in order to look for various kinds of sea animals.


text:
# Mutant Detector
Application to help Magneto find new mutants based on DNA sequence. Each DNA Sequence is represented in a string array like the example below:

`var dna = ["CTGCCA", "CAGTGC", "TTATGT", "AGAAGG", "CTCCTA", "TCACTG"];`

The array can be also interpreted as a char matrix. There are only four possible chars, A, T, G and C (each one represnt a nitrgenous base). Mutant DNAs have more than one sequence of 4 identical chars, as shown in the image below:

Mutant:

![Mutant DNA](/images/mutant.png)

Human:

![Human DNA](/images/human.png)

## Application Components
* HTTPServer
* MutantDetector
* Database

### Component communication
![Component Communication](/images/componentCommunication.png)

### HTTPServer
Provides an API to run tests against the MutantDetector. This is the only starting point to any client. There are two available endpoints:

|Method|URL|Description|
|------|---|-----------|
|POST|/mutant|Scan a DNA sequence passed in the body of the request. A 200-OK response means the DNA is mutant, 403-Forbidden means it's human. If the data sent is not an array of strings, the application will return 400-BadRequest.|
|GET|/stats|Get scan statistics.|

Default port is 3001, but it can be changed by setting environment variable `PORT` or `HTTP_PORT` with the new desired port.

### MutantDetector
This component contains the logic to detect whether a DNA is mutant or not.
A function `isMutant(dna)` is implemented inside the module and returns `true` when the passed DNA is mutant and `false` when it's human.

### Database
This module is intended to provide a seamless interatction between the HTTPServer and a database. This module is implemented to work with two database engines:

* **SQLite3** - For local and development use. This is the default engine.
* **BigQuery** - To use in an environment suitable to handle many API calls in a short period of time.

## How to run the application
To run the application in local mode (with a local SQLite DB), simply run the following commands:

```
git clone https://github.com/martin919191/mutants.git
cd mutants
npm install
npm start
```

To run the application using BigQuery engine instead, run the following commands:

```
git clone https://github.com/martin919191/mutants.git
cd mutants
npm install
export DBTYPE=BIGQUERY
npm start
```
To run with BigQuery engine, it is required to be in a Google Cloud environment, and to set up a dataset named `mutant_data`.

To test a local instante, run the following commands (change the port in URL in case it was changed before running the application):

```
# Get application stats
curl -X GET https://localhost:3001/stats

# Test application with a mutant DNA
curl -X POST \
    -d '{"dna": ["ATGCGA","CAGTGC","TTATGT","AGAAGG","CTCCTA","TCACTG"]}' \
    -H 'Content-Type: application/json' \
    https://localhost:3001/mutant

# Test application with a human DNA
curl -X POST \
    -d '{"dna": ["CTGCCA", "CAGTGC", "TTATGT", "AGAAGG", "CTCCTA", "TCACTG"]}' \
    -H 'Content-Type: application/json' \
    https://localhost:3001/mutant
```

### Deploy application to Google AppEngine
This application is ready to be deployed to an AppEngine environment. To do that, run the following command (Google Cloud CLI must be configured in the environment):

`gcloud app deploy`

## Live instance
An instance of the application is already deployed and is accessible on the following URL: [https://project-mutants.uc.r.appspot.com/](https://project-mutants.uc.r.appspot.com/)

Run the following commands to interact with the deployed application:

```
# Get application stats
curl -X GET https://project-mutants.uc.r.appspot.com/stats

# Test application with a mutant DNA
curl -X POST \
    -d '{"dna": ["ATGCGA","CAGTGC","TTATGT","AGAAGG","CTCCTA","TCACTG"]}' \
    -H 'Content-Type: application/json' \
    https://project-mutants.uc.r.appspot.com/mutant

# Test application with a human DNA
curl -X POST \
    -d '{"dna": ["CTGCCA", "CAGTGC", "TTATGT", "AGAAGG", "CTCCTA", "TCACTG"]}' \
    -H 'Content-Type: application/json' \
    https://project-mutants.uc.r.appspot.com/mutant
```


text:
# A simple web component library

This project is under construction and it includes several samples of component that using LitElement with JavaScript.

## How to setup

Install the necessary dependencies.

```
npm i
```

## How to start Dev Server

This sample uses open-wc's [es-dev-server](https://github.com/open-wc/open-wc/tree/master/packages/es-dev-server) for previewing the project without additional build steps. ES dev server handles resolving Node-style "bare" import specifiers, which aren't supported in browsers. It also automatically transpiles JavaScript and adds polyfills to support older browsers.

To run the dev server and open the project in a new browser tab:

```bash
npm run serve
```

There is a development HTML file located at `/dist/index.html` that you can view at http://localhost:8000/dist/index.html.

## How to run Test

This sample uses Karma, Chai, Mocha, and the open-wc test helpers for testing. See the [open-wc testing documentation](https://open-wc.org/testing/testing.html) for more information.

Tests can be run with the `test` script:

```bash
npm run test
```

## How to Bundeling

This is how you bundeling the web components JavaScriptfile into the dist library

```bash
npm run bundle
```
This starter project doesn't include any build-time optimizations like bundling or minification. We recommend publishing components as unoptimized JavaScript modules, and performing build-time optimizations at the application level. This gives build tools the best chance to deduplicate code, remove dead code, and so on.

For information on building application projects that include LitElement components, see [Build for production](https://lit-element.polymer-project.org/guide/build) on the LitElement site.


text:
# [TensorBoard Empty Scalar Hider](https://chrome.google.com/webstore/detail/tensorboard-empty-scalar/ejhcppphehbibgdnmjelljfeconkljmk)

![demo](assets/demo.gif)

Chrome Extension of hiding empty scalar/panes in TensorBoard.

Inspired by [issue#40](https://github.com/tensorflow/tensorboard/issues/40) of tensorboard.

## Installation

Install at chrome web store stroe [here](https://chrome.google.com/webstore/detail/tensorboard-empty-scalar/ejhcppphehbibgdnmjelljfeconkljmk).

## TODO

* [ ] Auto detect tensorboard page
* [x] Click any action to trigger hider script
* [x] Hide empty category pane
* [x] Option page
* [x] Option of if hiden empty category pane (only hide scalar card defaultly)
* [ ] Right click menu button to run script

repository: Jasonnor/tensorboard-empty-scalar-hider

repo_name: Jasonnor/tensorboard-empty-scalar-hider


text:
# gemini-cbt
Plugin for starting up a [Cross Browser Testing](https://crossbrowsertesting.com) tunnel when running tests with Gemini

[![Build Status](https://travis-ci.org/sanghviharshit/gemini-cbt.svg?branch=master)](https://travis-ci.org/sanghviharshit/gemini-cbt)

> Based on original source code from https://github.com/Saulis/gemini-browserstack

## Requirements
Works with [gemini](https://github.com/gemini-testing/gemini) [v1.0.0](https://github.com/gemini-testing/gemini/releases/tag/v1.0.0) or later.

## Installation
`npm install gemini-cbt`

## Configuration
- All parameters supported by cbt_tunnels (https://www.npmjs.com/package/cbt_tunnels)
  - __username__ (optional) sets the username for CBT. Defaults to environmental variable CBT_USERNAME
  - __authkey__ (optional) sets the authkey for CBT. Defaults to environmental variable CBT_ACCESS_KEY

Example configuration for your `.gemini.yml`

```yml
rootUrl: http://localhost:8080/home
gridUrl: http://this.address.is.ignored/so-anything-goes

system:
  plugins:
    cbt:
      username: foo
      authkey: bar
      quiet: true
      tunnelname: foobar

browsers:
  win10_edge17:
    desiredCapabilities:
      browserName: 'MicrosoftEdge'
      version: '17'
      platform: 'Windows 10'
      screenResolution: '1366x768'
      record_video: 'true'
      record_network: 'true'

  macos10_safari11:
    desiredCapabilities:
      browserName: 'Safari'
      version: '11'
      platform: 'Mac OSX 10.13'
      screenResolution: '1366x768'
```

## Environment variables
You can provide the following environment variables to override the default configs
- `CBT_USERNAME` - username for crossbrosertesting.com account
- `CBT_AUTHKEY` - authentication key for crossbrosertesting.com account
- `CBT_ID` - Add an id to test name
- `CBT_QUIET` - start tunnel in quiet mode
- `CBT_BUILD` - to associate the tests with a specific build in crossbrowsertesting.com
- `CBT_TUNNEL_NAME` - to create a named tunnel
- `CBT_MAX_DURATION` - max duration for the test
- `CBT_RECORD_VIDEO` - record video for tests
- `CBT_RECORD_NETWORK` - record network data for tests

### Example
Here is an example `npm run update` command for updating screenshots
```
<EMAIL_ADDRESS>CBT_AUTHKEY=abcd123xyz CBT_BUILD="`git log --pretty=format:'%h' -n 1` - `date +%r`" npm run update
```

repository: sanghviharshit/gemini-cbt

repo_name: sanghviharshit/gemini-cbt


text:
# RPinterestBot
Bot for Pinterest

## Setup
1. Create Pinterest application
2. Rename conf.pinterest.app.sample.js to conf.pinterest.app.js
3. Fill the file with **name** , **consumer_key** , **consumer_secret** , **access_token** (**callback_url** and **scope** is for user authentification)
4. Create your job in folder jobs

## Example
Once your pinterest application created you can run job.
```
node job me
```

## How to write job
1. Create a file in jobs folder, the filename is the job name
2. In job get a Pinterest app by using ```getPinterestApp(name, endpoints)```
  * if you provide no arguments the first Pinterest app is returned
  * name (string or undefined - optionnal) : using a specific Pinterest app
  * endpoints (array - optionnal) : return an available Pinterest app which can use thoses endpoints (rate limit)

## PID watcher and killer
Jobs'list running (pid + job + options)
```
node pid
```
Kill a job
```
node pid kill {pidId}
```
Kill all jobs
```
node pid kill all
```

## JOBS
* example -> do nothing
* me -> return authenticated user information
* my_boards -> return authenticated user’s public boards
* get_pins_in_board -> returns list of Pins on the board
* valid_board -> check if argument provided is a valid board
* valid_user -> check if argument provided is a valid_user

## Pinterest User Authentification
Getting access token for external user with an app.
```
node save_oauth "myapp"
```
*(if app name argument is not provided the first one in conf is picked)*
A server will be up at <IP_ADDRESS> on port 3000.
When callback is done a file is created in oauth_access_cache like this: screen_name.tok
It will contain the app name, access token and access token secret.

## Optionnal arguments
```
// user to use (require getting access token)
-u OR --user "myuser"
// pinterest app to use
-a OR --app "myapp"
// file to upload
-f OR --file "/path/to/file"
```
**for user argument use in lower case the screen name of the account**

## Documentation Pinterest API
List of endpoints (GET / POST / PATCH / DELETE)
```
node doc
```
List of endpoints (GET only)
```
node doc get
```
List of endpoints (POST only)
```
node doc post
```
List of endpoints (PATCH only)
```
node doc patch
```
List of endpoints (DELETE only)
```
node doc delete
```
Endpoint details
```
node doc "/v1/me/"
```
List of parameters
```
node doc parameters
```
Test endpoint (GET and POST)
```
node doc test "/v1/me/"
```

## LIMITS
Sandbox: 200 calls / 60 minutes / token
Live: 1000 calls / 60 minutes / token

Url images in 60x60 in sandbox

Can't see private board (will be never support by pinterest team)

List of Scopes
* read_public : Use GET method on a user’s Pins, boards and likes.
* write_public : Use PATCH, POST and DELETE methods on a user’s Pins and boards.
* read_relationships : Use GET method on a user’s follows and followers (on boards, users and interests).
* write_relationships : Use PATCH, POST and DELETE methods on a user’s follows and followers (on boards, users and interests).

## TODO
* add explanations for all
* refactor doc.js (add search more powerful)
* refactor classes and add folders
* save_oauth add port + scope

repository: rancoud/RPinterestBot

repo_name: rancoud/RPinterestBot


text:
# Troubleshooting Guide

Reverse-engineering Android apps can be a messy process. `apk-mitm` greatly simplifies a part of it by automating a series of steps that would have to be performed manually otherwise. However, it can't guarantee that this always works, so that's why this troubleshooting guide exists.

## Types of issues

There's three main types of issues that can occur with `apk-mitm`:

- [**Patching an APK fails**](./patching-fails.md)

_You're seeing errors in your terminal while running `apk-mitm`._

- **A patched APK can't be installed**

_Trying to install the APK on your device produces an error message._

- **An installed patched APK is broken**

_The patched app is either not working at all or you're unable to look at its traffic._

repository: shroudedcode/apk-mitm

gha_language: TypeScript

repo_name: shroudedcode/apk-mitm


text:
### PACE protocol implementation ###

PACE(.py) protocol [BSI TR3110] implementation for PCD by [Tobias Senger](https://github.com/tsenger/pypace) implementing PACE-ECDH-GM-AES-CBC-CMAC-128 with elliptic curve static domain parameters Brainpool P-256-r1.
- key exchange: ECDH on [Brainpool P-256-r1](https://tools.ietf.org/html/rfc5639#section-3.4)
- mapping: generic (generic group operations)
- symmetric cipher: AES-CBC 128Bit key length
- authentication token T: AES-CMAC 128Bit key length

![PACE protocol messages](PACE.svg)

See [BSI TR3110] part2 3.2.1 for cryptographic overview and [BSI TR3110] part3 B.1, B.11 for message exchange overview.

Other implementations of the PACE Protocol supporting more variants are [JMRTD](https://static.javadoc.io/org.jmrtd/jmrtd/0.6.4/org/jmrtd/protocol/PACEProtocol.html) in Java or [OpenPACE](https://github.com/frankmorgner/openpace) in C.

[BSI TR3110]: https://www.bsi.bund.de/EN/Publications/TechnicalGuidelines/TR03110/BSITR03110-eIDAS_Token_Specification.html

| parameter | description  |
|-----------|--------------|
| pace_oid | PACE-ECDH-GM-AES-CBC-CMAC-128 algorithm identifier |
| CHAT | the Certificate Holder Authorization Template (CHAT) to denote role and read/write access rights |
| pw_ref | contains the password type {1:MRZ,2:CAN,3:PIN,4:PUK}|
| car   |  Certification Authority Reference  |
| T_other   | T_PCD for ICC and T_ICC for PCD   |

```
https://sequencediagram.org source:
title PACE-ECDH-GM-AES-CBC-CMAC-128
PCD->ICC:manage security environment (MSE)\nset authentication for mutual authentication (Set AT)\n(pace_oid,CHAT,pw_ref)
#box over ICC,PCD: pace_oid~domain parameters D\n-key exchange ECDH, EC domain parameters: Brainpool P-256-r1\n-mapping: generic (group operation)\n-symmetric cipher: AES-CBC 128Bit key length\n-authentication token T: AES-CMAC 128Bit key length
PCD->ICC:general authenticate (GA) start\n(command: 0x7C 0x00 ~Dynamic Authentication Data)
ICC->PCD:encrypted nonce
box right of PCD:decrypt(AES-CBC,encrypted nonce,password)=nonce
group Map Nonce EC Diffie-Hellmann key exchange (p256r1)=shared key P
PCD->ICC:PCD public key
ICC->PCD:ICC public key
end
box over ICC,PCD:(p256r1,nonce,P)=D_Mapped
group EC Diffie-Hellmann key exchange (p256r1, D_Mapped)=shared key K
PCD->ICC:PCD public key 2
ICC->PCD:ICC public key 2
end
box over ICC,PCD:(K)=K_enc,K_mac
PCD->ICC:(AES-CMAC,K_mac,ICC public key 2)=T_PCD
ICC->PCD:(AES-CMAC,K_mac,PCD public key 2)=T_ICC (,car1,car2)
box over ICC,PCD:verifyToken(AES-CMAC,K_mac,T_other,other public key 2)
```


text:
# Counting Sort

In computer science, counting sort is an algorithm for sorting a collection of objects according to keys that are small integers; that is, it is an integer sorting algorithm. It operates by counting the number of objects that have each distinct key value, and using arithmetic on those counts to determine the positions of each key value in the output sequence. Its running time is linear in the number of items and the difference between the maximum and minimum key values, so it is only suitable for direct use in situations where the variation in keys is not significantly greater than the number of items. However, it is often used as a subroutine in another sorting algorithm, radix sort, that can handle larger keys more efficiently.

[Algorithm Visualization](https://www.cs.usfca.edu/~galles/visualization/CountingSort.html)

Time complexity

| Best     |  Average   | Worst    |
| -------- | --------   | ------   |
| Ω(n + k) |  Θ(n + k)  | O(n + k) |

Space Complexity

|        Worst        |
|---------------------|
|        O(k)         |

## References

* [Wikipedia](https://en.wikipedia.org/wiki/Counting_sort)
* [YouTube](https://youtu.be/TTnvXY82dtM)
* [MIT YouTube Video](https://youtu.be/Nz1KZXbghj8)

## Books

* **Introduction to Algorithms** by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein

## Articles

* [Counting Linearly With Counting Sort](https://medium.com/basecs/counting-linearly-with-counting-sort-cd8516ae09b3)

## Implementations

* [Implementation in C++](https://www.geeksforgeeks.org/counting-sort/)
* [Implementation in Java](https://www.geeksforgeeks.org/counting-sort/)
* [Implementation in Python](https://www.geeksforgeeks.org/counting-sort/)
* [Implementation in C#](https://www.geeksforgeeks.org/counting-sort/)
* [Implementation in JavaScript](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/counting-sort)
* [Implementation of counting sort in many languages](https://rosettacode.org/wiki/Sorting_algorithms/Counting_sort)

repository: yrenelapin/awesome-algorithms

repo_name: yrenelapin/awesome-algorithms


text:
# USA mass murders map using d3js

Built on top of [Jenna Xu’s code](https://gist.github.com/xujenna/25db2af0bf59950d7390ceeba187df42), using [Mother Jones Mass Shooting Data](https://www.motherjones.com/politics/2012/07/mass-shootings-map/).

View it here: [labs.letemps.ch/interactive/2019/…](https://labs.letemps.ch/interactive/2019/_is-embed-somewhere/tueries-masse-etats-unis/)

Edit `index-without-template.html` instead of `index.html.twig` to avoid being annoyed by our templating system.


text:
---
title: Hugo Syntax Highlighting
description: Syntax Highlighting example test article that shows how to creating and highlighting code blocks in Hugo-generated site
date: 2018-04-15
categories:
  - "Development"
tags:
  - "Chroma"
  - "Hugo"
  - "Syntax Highlighting"
  - "HTML"
  - "Markdown"
---

You can have code snippets highlighted so that they are easier to read on your site using Chroma, Hugo's default syntax highlighter. It is built in Go lang and is really, really fast – and for the most important parts compatible with Pygments. Chroma takes source code and other structured text and converts it into syntax highlighted HTML, ANSI-coloured text, etc.

The example below shows a simple HTML code snippet highlighted with the Hugo [highlight](https://gohugo.io/content-management/shortcodes/#highlight) built-in shortcode:

{{< highlight html >}}
<!DOCTYPE html>

  <meta charset="UTF-8">
  <title>Example HTML5 Document</title>

Test

{{< /highlight >}}

The following code snippet was used to achieve that result:

```
{{</* highlight html */>}}
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Example HTML5 Document</title>
</head>
<body>
  <p>Test</p>
</body>
</html>
{{</* /highlight */>}}
```

For more information, see "[Hugo Syntax Highlighting](https://gohugo.io/content-management/syntax-highlighting)" from official Hugo docs.

repository: Vimux/Binario

gha_language: HTML

repo_name: Vimux/Binario


text:
# Presentations about Python Extension Patterns

PyCon UK 2015: [https://www.youtube.com/watch?v=ViRIYqiU128](https://www.youtube.com/watch?v=ViRIYqiU128)

PyCon US 2016: [https://www.youtube.com/watch?v=Yq__HtUIH5Y](https://www.youtube.com/watch?v=Yq__HtUIH5Y)

repository: paulross/PythonExtensionPatterns

gha_language: C

repo_name: paulross/PythonExtensionPatterns


text:
# Terminating Gateways in Consul Connect

## Goals
- Represent two backend services (`hello-server` and `world-server`) with a terminating gateway
- Use intentions to allow connection from a client in the mesh to backend services outside the mesh
- Migrate `world-server` to the service mesh with traffic splitting
- Upgrade `hello-server` to require mTLS and re-configure terminating-gateway with certificates

## Prerequisites
- consul git repo
- envoy in PATH

## Instructions
### Setup
* Build `consul` from master then start a Consul server in dev mode with Connect enabled.

`$ make dev` (and ensure binary is in PATH)

`$ consul agent -dev -log-level trace`

* Register and start the gateway proxy

`$ curl -X PUT -d @consul.d/services/my-gateway.json \
    "http://localhost:8500/v1/agent/service/register"`

`$ consul connect envoy -gateway=terminating -admin-bind=localhost:19001 -- -l trace`

**Note**: We register the gateway separately in order to add a tag to it. For traffic splitting to work the tags/meta must be present on the gateway itself rather than the linked service. I'm thining of a solution for this, but don't have one ready yet. Also, the CLI does support auto-registration, as with Mesh Gateways.

* Configure the gateway

`$ consul config write consul.d/config-entries/my-gateway.hcl`

* Create default deny intention

`$ consul intention create -deny "*" "*"`

* Register the services.

`$ curl -X PUT -d @consul.d/services/hello-server.json \
    "http://localhost:8500/v1/agent/service/register"`

`$ curl -X PUT -d @consul.d/services/world-server-legacy.json \
    "http://localhost:8500/v1/agent/service/register"`

`$ curl -X PUT -d @consul.d/services/client.json \
    "http://localhost:8500/v1/agent/service/register"`

or

`./register-services.sh`

* Start the Envoy sidecar for the client.

`$ consul connect envoy -sidecar-for hello-client -- -l trace`

* Build then start the servers.

`$ make`

`$ hello-server/bin/hello`

`$ world-server-legacy/bin/world`

* Run the client

`$ hello-world-client/bin/client -loop=false`

There should be an error, due to the lack of intentions allowing the connection.

* Create intentions that allow the connection:

`$ consul intention create hello-client hello-server`

`$ consul intention create hello-client world-server`

Expected output is: `Hello ...world`

Traffic flows through client's sidecar and terminating gateway to both backing services.

### L7 Routing: Traffic splitting for world-server

* Set up http service default and service resolver

`$ consul config write consul.d/config-entries/world-defaults.hcl`

`$ consul config write consul.d/config-entries/world-resolver.hcl`

* Register then start cloud version of `world-server`:

`$ curl -X PUT -d @consul.d/services/world-server.json \
    "http://localhost:8500/v1/agent/service/register"`

`$ world-server/bin/world`

`$ consul connect envoy -sidecar-for world-server-v1 -admin-bind localhost:19002 -- -l trace`

* Enable traffic splitting

`$ consul config write consul.d/config-entries/world-splitter.hcl`

Expected output is split between: `Hello ...world` and `Hello World`

Traffic is split between terminating gateway and cloud world-server's sidecar.

* Dial split up to 100/0

`$ consul config write consul.d/config-entries/world-splitter-100.hcl`

Expected output is: `Hello World`

### TLS Origination for hello-server

* Re-register the service with the new port (8443):

`$ curl -X PUT -d @consul.d/services/hello-server-tls.json \
    "http://localhost:8500/v1/agent/service/register"`

* Restart `hello-server` with mTLS enabled:

`$ hello-server/bin/hello -mtls -addr="localhost:8443"`

* Add full TLS config to the gateway

`$ consul config write consul.d/config-entries/my-gateway-mtls.hcl`

Running the client app should work as expected.

Note that the client makes HTTP requests and Envoy upgrades them to HTTPS.

repository: freddygv/terminating-gateways-demo

repo_name: freddygv/terminating-gateways-demo


text:
# Blogger: Neighborhood Blog Site

This project demonstrates a blogging application constructed in MEAN

Completed for Code Louisville's Spring 2017 session

## Web site features
- Track bloggers and their postings
- Individual blog postings have their own publishable URL
- Angular client application uses a RESTful API service
- All CRUDL operations demonstrated
- Responsive to large, medium and small media
- Small initial database can be re-seeded
- MongoDB server authentication can be demonstrated

## Packages and frameworks
- MongoDB 3.4.2, Mongoose 4.8.2
- Express 4.14.1
- Angular 1.6.1
- Node.js 6.9.4
- Zurb Foundation for Sites 6.3.1

## To see it in action:
- Install the application and its runtime environment
    - Install Node.js
    - Install and prepare MongoDB
        - MongoDB can serve from "localhost" or from another network address
        - Determine where your MongoDB datastore will reside
        - Set up MongoDB administration user and database, if needed
        - Set up the application user and database
        - Set up scripts to assist server and client shell startup
        - For prepared examples, refer to ./notes/MongoDB-notes.txt
        - Refer to the MongoDB documentation for installation advice
    - Download the application into a preferred folder
        - Use Git clone, or download and unpack the ZIP file
    - Retrieve npm modules and libraries
        - Open a command window in the application root
        - Issue the command "npm install" in the application folder
- Start the application
    - Start the MongoDB server
        - MongoDB can be run in its own command window, or as a background service
        - To demonstrate MongoDB authentication, use the --auth startup option
        - Configure "mongoUsesAuth" in ./server/config.js to agree with the authentication option
        - MongoDB authentication is not required to run the application
    - Start a MongoDB client shell, if desired
    - Start the Blogger application
        - Open a command window in the application root
        - Issue "node index -c mongoip -u username -p password -r seed"
            - "mongoip" is the network address of your MongoDB server, most likely "localhost"
            - If MongoDB requires authentication, application startup will require a username and password
            - Use (optionally) "-r empty" or "-r seed" to reset the database
            - Use "node index --help" to see all options.
    - Start a web browser and point it to "localhost:8080/Home"
- Application highlights
    - Errors and route requests are logged to the Node.js console
    - If you alter the Angular app, re-minimize it with "npm run build"
    - The AngularJS library is unminimized to allow for clearer error reporting

## Comments are welcome! Send to: Calvin Miracle<EMAIL_ADDRESS>


text:
# Udacity Front-end Web Developer Nanodegree
This repo contains my projects for udacity front-end web developer nanodegree
## Covered Topics and Tools Used for Projects
- Responsive Web Design
- Object-Oriented Javascript
- Javascript Design Patterns
- ES6
- Knockout JS
- Google Maps API
- Foursquare API
- Jasmine Testing Suite
- Tape Testing Framework
- Yarn
- Webpack Module Bundler
- Surge Static Web Publishing
- & More ...

## Projects List
- [x] P1 Mockup to Article
- [x] P2 Animal Trading Cards
- [x] P3 Personal Portfolio
- [x] P4 Pixel Art Maker
- [x] P5 Pokemon Memory Game
- [x] P6 Arcade Game
- [x] P7 RSS Feed Reader Testing
- [x] P8 Neighborhood Map

<img src='https://i.imgur.com/8jPnhEW.png'/>


text:
# Description

Please include a summary of the change and include relevant motivation and context.

...

## Checklist:

- [ ] The `make build` command has been run successfully for the changed image without any error or warning.
- [ ] Any new code follows the style guidelines of this project.
- [ ] The code changes have been self-reviewed.
- [ ] Corresponding changes to the documentation have been made.
- [ ] The version has been updated in the VERSION file.

## Type of change:

- [ ] Bug fix (non-breaking change which fixes an issue) → The patch number in the VERSION file has been increased.
- [ ] New feature (non-breaking change which adds functionality) → The minor number in the VERSION file has been increased.
- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected) → This requires a major version release.
- [ ] Automation.
- [ ] Documentation.
- [ ] Example.
- [ ] Testing.

repository: tecnickcom/alldev

repo_name: tecnickcom/alldev


text:
数据库乱码

- jdbc:mysql://<IP_ADDRESS>:3306/ifex?characterEncoding=UTF-8
- 数据库编码格式
- 具体到一张表的一个字段，指定编码
- If you have MySQL 5.5 or later you can change the column encoding from utf8 to utf8mb4. This encoding allows storage of characters that occupy 4 bytes in UTF-8.
- `ALTER TABLE database.table MODIFY COLUMN col VARCHAR(255)  CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL;`

[Incorrect string value” when trying to insert UTF-8 into MySQL via JDBC?](http://stackoverflow.com/questions/10957238/incorrect-string-value-when-trying-to-insert-utf-8-into-mysql-via-jdbc)

filename: 数据库乱码解决方案.md


text:
# Heroku buildpack: sh
A [Heroku buildpack](http://devcenter.heroku.com/articles/buildpacks)
that runs shell scripts during deploy process.

## Usage
This buildpack works best with another buildpack for your app.

First, [set the buildpack for your app](https://devcenter.heroku.com/articles/using-multiple-buildpacks-for-an-app#setting-a-buildpack), e.g.:

```
$  heroku buildpacks:set heroku/ruby
```

then, [add this buildpack](https://devcenter.heroku.com/articles/using-multiple-buildpacks-for-an-app#adding-a-buildpack) to run a script while building your app::

```
$ heroku buildpacks:add --index 1 https://github.com/zunda/heroku-buildpack-sh.git
```

Place shell scripts to be run during deploy into the directory `./.buildpack-sh`
and add execute flag: `chmod +x` to them.
This buildpack runs `run-parts -v .buildpack-sh` to detect and execute them.

### Example
```
$ heroku buildpacks:set heroku/ruby
$ heroku buildpacks:add --index 1 https://github.com/zunda/heroku-buildpack-sh.git
$ heroku buildpacks:add --index 1 https://github.com/heroku/heroku-buildpack-apt.git
Buildpack added. Next release on this-app will use:
  1. https://github.com/heroku/heroku-buildpack-apt.git
  2. https://github.com/zunda/heroku-buildpack-sh.git
  3. heroku/ruby
Run git push heroku master to create a new release using these buildpacks.
$ ls -l .buildpack-sh/source_version
-rwxrwxr-x 1 zunda zunda 48 May 22 19:58 .buildpack-sh/source_version
$ cat .buildpack-sh/source_version
#!/bin/sh

echo SOURCE_VERSION: $SOURCE_VERSION
```

## License
[MIT](LICENSE)

repository: zunda/heroku-buildpack-sh

repo_name: zunda/heroku-buildpack-sh


text:
# 0.8.0 Migration Guide

## Domain Management

You can now set global and app domains via `domains:set` and `domains:set-global`. See the [domains documentation](/docs/configuration/domains.md) for more details.

## Plugin Uninstallation

A new `uninstall` plugin trigger was introduced. This functionality may be in use for newer plugins, so be aware that older Dokku versions may require manual cleanup.

See the [uninstall trigger documentation](/docs/development/plugin-triggers.md#uninstall) for implementation instructions.

## Deployment Tasks

Should a pre or post deployment task fail, we now fail the entire deploy.

## Nginx HTTP2 Support

Due to bugs in Nginx, the minimum version for HTTP2 is now 1.11.5.

repository: dokku/dokku

gha_language: Shell

repo_name: dokku/dokku


text:
# readme generator

[![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)

### Table Of Contents
* [Installation](#installation)
* [Usage](#usage)
* [Credits](#credits)
* [License](#license)

## Installation
npm install

## Usage

### Description
A node-powered app that creates a quality readme from the CL

### Languages
JavaScript,ES6,Node

### Questions
##### GitHub
[carrington13](https://github.com/carrington13)
##### Email
<EMAIL_ADDRESS>

## Credits
Casey Arrington, Trilogy Education Services

## License
Copyright 2021 Casey Arrington

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

[Read More About BSD 3 Here](https://opensource.org/licenses/BSD-3-Clause)


text:
---
layout: post
title: Week 2 Day 3
---

## Topics for Today
* [Splats](https://github.com/tiy-lv-python-2015-10/class-notes/blob/master/week2/07-Splats.ipynb)
* Testing Classes
  * [Code](https://github.com/tiy-lv-python-2015-10/class-notes/blob/master/week2/class_based_tests.py)
  * [Tests](https://github.com/tiy-lv-python-2015-10/class-notes/blob/master/week2/test_cheetah.py)
* [Exercise](https://github.com/tiy-lv-python-2015-10/class-notes/blob/master/week2/exercise_pig.py)

## Homework
* [Blackjack](https://github.com/tiy-lv-python-2015-10/blackjack)


text:
# droid-jump
Sample game showcasing how to use Play Games Services in a game.

## Setup
 1. Create your project in the Google Play Developer Console.
 2. Link your app to the game configuration.
 3. Set the applicationId in build.gradle to the package name configured in the Google Play Developer Console.
 4. Copy the APP ID from the console into app/src/main/res/values/ids.xml.
 5. Copy your leaderboards and achievements data from the console into `app/src/main/res/values/ids.xml`

## Examples
1. **Sign In** Allows to sign-in the user. You can find it in MainActivity.java and there are few methods for its integration:
	- `signInSilently` - for auto sign in.
	- `startSignInIntent` - for starting sign in process on button click.
2. **Achievements** Allows players to see their locked and unlocked achievements. Files that contain achievements integration:
	- `AchievementsFragment` - for showing a custom UI with a list of achievements.
	- `AchievementDetailsFragment` - for showing a custom UI with information about a specific achievement.
	- AchievementsManager - for managing achievements data.
3. **Leaderboards** Allows players to see their score and compare it with other players. Files that contain leaderboards integration:
	- `LeaderboardsFragment` - for showing a custom UI with a list of leaderboards.
	- `LeaderboardScoresFragment` - for showing a custom UI with scores of the leaderboard.
	- `ScoresManager` - for managing an achievements data.
4. **Friends** Allows players to find their friends and compare game activity using in-game profile popup. The file that contains friends integration:
	- `FriendsFragment` - for showing a custom UI with a list of friends where the user can see all their friends and remove any person from the friend list.
5. **Video Recording** Helps easily add video recording to your game and lets users share their videos with friends on YouTube. Go to ``MainActivity`` and find method:
	- `showVideoOverlay` - displays video recording overlay.

repository: googleinterns/droid-jump

gha_language: Java

repo_name: googleinterns/droid-jump


text:
# Disclaimer

This is just a quick example. If you use this example to build your system,
than be prepared to do your own securty settings. Feel free to change any parts
to make your life easier, this version only solves the purpose to get you started.

# About

This is an example of how to use the official docker images.
For this example to use you will need licenses for the JChem Microservices
Modules (downloaded to this folder as `license.cxl`) and __docker__ and
__docker-compose__ installed on your system.

# How to run

execute `docker-compose up`

# What is happening in this example?

The docker-compose file has a description of the JChem Microservices system
whit a central license server. The license server is a module we build during
__UP__ command, and it is based on [Nginx](https://hub.docker.com/_/nginx) image.

# How to access the system?

In the end the port 8080 will be open and forwared towards the outer world.

# What could be on volumes?

* `/app/jws/jws-db/data` folder contains all the data you upload to JMS DB.
* `/app/jws/jws-config/common-config` folder contains all the configurations for the services
* `/app/jws/logs/` folder contains all the log files

These folders in a production environment could be on volumes depending on your
needs, but this is only a kick-starter example, it does not aim to teach docker
basics. If you want to restructure the conatiners, feel free. If you would like
to save more persistent data, than it is up to you.

repository: ChemAxon/jchem-microservices-examples

repo_name: ChemAxon/jchem-microservices-examples


text:
# Topic

> 影響你最深的一句話是什麼？(Best Advice You've Received | 0-100)

> I think a lot of people don't realize how many opportunities they're given on a daily basis, and to really go after those things.

> 我覺得很多人都沒有發現自己每天都有好多機會，也沒有好好把握它們。

[![Image](https://cdn.voicetube.com/assets/thumbnails/ZfsyrNKhNTE.jpg)](https://www.youtube.com/embed/ZfsyrNKhNTE?rel=0&showinfo=0&cc_load_policy=0&controls=1&autoplay=1&iv_load_policy=3&playsinline=1&wmode=transparent&start=66&end=73&enablejsapi=1&origin=https://tw.voicetube.com&widgetid=1)

Host: Ingrid

Today issue: Don't worry, be happy!!!

[Host record](https://cdn.voicetube.com/tmp/everyday_records/ingrid.wang_vt_50297/3389.mp3)

## learning points
1. _
	* realize [ˋrɪə͵laɪz] (v.) 明白；認識到；意識到
		- After waiting outside the bathroom for 15 minutes I realized there was no one inside.
			+ 在浴室外等了15分鐘後，我意識到裡面沒有人。
		- He later found out that the milk he drank earlier was camel milk his face Twisted in disgust as he came to the realization of what he drank.
			+ 他後來發現，他早些時候喝的牛奶是駱駝奶，他的臉因厭惡而扭曲，因為他意識到自己喝了什麼。

2. _
	* opportunity [͵ɑpɚˋtjunətɪ] (n.) 機遇；時機；機會；可能性
		- My girlfriend is going on a business trip this Friday I decided to take this opportunity to shop for an engagement ring while she is away.
			+ 我的女朋友本週五正在出差，我決定藉此機會在她不在的時候購買訂婚戒指。

3. _
	* basis [ˋbesɪs] (n.) 基礎；根據；行動（或進程）的方式
		- Steve works out at a gym on a regular basis that is why he's so fit.
			+ 史蒂夫定期在健身房工作，這就是他如此健康的原因。

		- The robber grabbed my wallet and ran I'd have gone after him but I was in a state of shock.
			+ 強盜搶了我的錢包然後跑了，我應該追逐他，但是我處於一種震驚的狀態。


text:
# Welcome to frads documentation

Date: 2023-08-14

Version: 1.0.0

`frads` project is an open source, BSD-licensed library providing easy-to-use wrapper for Radiance rendering engine.

## Table Of Contents
The documentation consists of three parts:

1. [How-To Guides](how-to/index.md): Scenario-based how-to guides
2. [CLI Manual](manual/index.md): Manual pages for all the command-line-interfaces.
3. [Reference](ref/config.md): Code API documentation

## Installation
You can find installation instructions on our [README](https://github.com/LBNL-ETA/frads#installation).

## Project Overview

::: frads
    options:
      show_root_heading: false
      show_root_toc_entry: false
      members: None

## Acknowledgements

This work was supported by the Assistant Secretary for Energy Efficiency and Renewable Energy, Building Technologies Program, of the U.S. Department of Energy, under Contract No. DE-AC02-05CH11231.

repository: LBNL-ETA/frads

gha_language: Python

gha_license_id: NOASSERTION

repo_name: LBNL-ETA/frads


text:
# Butternut Squash and Goat Cheese Ravioli With Browned Butter Oregano Bread Crumbs

## Overview

- Yield: 6 servings
- Prep Time: 30 mins
- Cook Time: 1 hr
- Total Time: 1 hr 30 mins

## Ingredients

#### Butternut Squash Ravioli:

- 1 medium butternut squash peeled, seeded + cubed (about 4 cups)

- 1 tablespoon olive

- salt + pepper to taste

- 5 ounces drunken goat cheese or fresh goat cheese crumbled*

- 2 ounces gorgonzola cheese crumbled*

- 1/2 cup freshly grated parmesan

- 1 egg

- 1/4 teaspoon nutmeg

- 1 pound fresh pasta dough

- 12-16 fresh figs sliced

#### Browned Butter Oregano Bread Crumbs:

- 3 cups day old sourdough bread finely torn or pulsed to chunky crumbs in a food processor

- 2 tablespoons olive oil

- 1 tablespoon fresh chopped oregano

- salt + pepper toast

- 6 tablespoons unsalted butter

- 1/2 cup fresh oregano

- 2 ounces prosciutto finely diced

## Method

1. Preheat oven to 400 degrees F.
---
2. Peel the squash and cut into cubes and placing them on a baking sheet. Coat them with olive oil, salt & pepper. Roast the squash at 400 degrees for 45 minutes until tender. Allow to cool for 15 minutes or so.
---
3. Transfer the squash to a food processor and add the goat cheese, parmesan cheese, egg and nutmeg. Puree until smooth. Taste and season with salt and pepper.
---
4. Roll your pasta dough into lasagna sheets. I like to roll my pasta to the 5th setting, but all pasta machines vary. Heavily flour your ravioli mold or counter. Seriously, do not be afraid of the flour. Flour is your friend and without it your ravioli will stick to the mold (or your counter)!
---
5. Lay one sheet of pasta on the mold, making sure the entire mold is covered. Now, if you have one, grab an egg and fit it into each well. This helps form a space for the filling to go. Remove the egg, now take a tablespoon of the butternut squash filling and place it into each well. Spritz the pasta sheet with a little water or use your fingers and dab some water along all of the ravioli edges. Lay the second sheet on top and run a rolling pin over to seal. Turn the mold over to release the ravioli. They will not be fully separated. Use a pizza cutter or sharp knife to cut them fully apart. Lay the ravioli on a parchment lined baking sheet and continue making ravioli until you've used all the cheese filling. Make sure to cover the ravioli with a damp towel as you work. At this point you can freeze the ravioli for later if desired, or continue on with the recipe.
---

#### Browned Butter Oregano Bread Crumbs:

1. Heat a large skillet over medium heat and add the olive oil. Once hot, add the bread crumbs, oregano, salt + pepper and cook, stirring for 4-5 minutes or until toasted and golden. Remove the bread crumbs from the pan to a plate.
---
2. Bring a large pot of salted water to a boil.
---
3. Place the butter, remaining 1/2 cup oregano leaves and prosciutto in the skillet and cook over medium heat until the butter is browned and the prosciutto crisp. Remove from the heat.
---
4. Boil the ravioli for 1-2 minutes or until they float. Carefully remove the ravioli from the water and gently stir the ravioli into the butter sauce. Divide the ravioli among plates and top with the breadcrumbs and figs. Serve immediately with goat cheese.
---

## References and Acknowledgments

[Butternut Squash and Goat Cheese Ravioli With Browned Butter Oregano Bread Crumbs](http://www.halfbakedharvest.com/butternut-squash-and-goat-cheese-ravioli-with-browned-butter-oregano-bread-crumbs-video/)

repository: troyerta/recipes

repo_name: troyerta/recipes


text:
# Final-Year-Project-Applied-Diss
4th year Software Development Final Year Project

## Contents
* [Project Details](#details)
* [Introduction](#intro)
* [Video Demo](#demo)
* [Dissertation](#dissertation)
* [Architecture](#arc)
* [Features](#features)
* [App Preview](#preview)
* [Deployment](#deploy)

# Project Details

| Project Details   |     |
| --- | --- |
| **Course** | BSc (Hons) in Software Development  |
| **Module** |  Applied Project and Minor Dissertation |
| **College** | [GMIT](http://www.gmit.ie/) Galway |
| **Students** | [Derrick Conway](https://www.linkedin.com/in/derrick-conway-12b81113a/) G00328406
 [Gary Mannion](https://www.linkedin.com/in/gary-mannion-56236713a/) G00319609|
| **Project Supervisor** | Patrick Mannion |
| **Module Supervisor** | John Healy |
| **Project Title** | Farm At Ease |

[Top](#contents)

# Introduction
For our final year project, we decided to create a Farming App called Farm At Ease, specifically for young farmers. Currently there is a farming crisis across Ireland and we felt an App like ours was badly needed.  Working as a team and following an agile methodology we developed an App that allows users to view to keep track of animals dosing, AI, calf Tagging and be able to measure how much feed you have for the stock for the winter months ahead.  Adding these specific features will help young farmer in everyday life to reduce stress and depression that young farmer face in every day.  We created a 3-tier application, using Mongo Db and CouchDB as the our Data Tier, NodeJS for our Logic Tier and Ionic 3 for our Presentation Tier which we used FireBase Authentication for our login/register section.

[Top](#contents)

# Video Demo

###### Quick 2 minute video

[![IMAGE ALT TEXT HERE](Images/video.png)](https://www.youtube.com/watch?v=0lMA6Trt_xg)

###### More in depth video with detailed description

[![IMAGE ALT TEXT HERE](Images/video.png)](https://www.youtube.com/watch?v=v1VYPLz4iYU)

[Top](#contents)

# Dissertation
Click below to view our Dissertation PDF or click [here](https://github.com/Gazza1996/Final-Year-Project-Applied-Diss/tree/master/Dissertation) to view the latex files used to create it.

[](https://github.com/Gazza1996/Final-Year-Project-Applied-Diss/blob/master/Dissertation.pdf)

[Top](#contents)

# Architecture
The following is an overview of the Technologies/Architecture used creating Farm At Ease.

### Presentation Tier

* [Ionic 3 Framework](https://ionicframework.com/docs/)
* [Angular 4 Framework](https://angular.io/)
* [Firebase Authentication](https://firebase.google.com/)

### Logic Tier
* [NodeJS](https://nodejs.org/en/)

### Data Tier
* [MongoDB](https://www.mongodb.com/company) Database
* [CouchDB](http://couchdb.apache.org/) Database

[Top](#contents)

# Features
The following are the main features of our project:
* Users can create their own Account
* Users can Log into their Account
* Users can reset their password if they have forgotten theirs
* Users has option for six areas AI, Medicines, Tagging, Feed, Scanner, Reports.
* Users can update and delete but only in certain parts of a section.
* Users can search medicines and tags.
* Logged in users can enter and delete new heard tags.
* Logged in users can calaulate the amount silage feed needed for the winter and spring mounts.
* Logged in users can record animals in calf in AI section.
* Logged in users can scan medicine bottles for information on withdraw period for meat and milk.
* Logged in users can record heard animales reciving medicine.
* Logged in users can record heard reports in the reports section.

[Top](#contents)

# App Preview
The following images are previews of various pages in our application.

* Login Page

| IOS  |
| :-------------: |
|  |

[Top](#contents)

* Register Page

| IOS  |
| :-------------: |
|  |

[Top](#contents)

* Reset Password

| IOS  |
| :-------------: |
|  |

[Top](#contents)

* Side Menu

| IOS  |
| :-------------: |
|  |

[Top](#contents)

* Scanner

| IOS  |
| :-------------: |
|  |

[Top](#contents)

* Report Page

| IOS  |
| :-------------: |
|  |

[Top](#contents)

* Add Pages

| IOS  | IOS | IOS |
| :-------------: | :-------------: | :-------------: |
|  |  |  |

[Top](#contents)

* Pages

| IOS  | IOS | IOS |
| :-------------: | :-------------: | :-------------: |
|  |  |  |

[Top](#contents)

* Feed Page

| IOS  | IOS | IOS | IOS |
| :-------------: | :-------------: | :-------------: | :-------------: |
|  |  |  |  |

[Top](#contents)

# Deployment
### Deploy on Android Device
* This repository contains our [FarmWithEase.apk](https://github.com/Gazza1996/Final-Year-Project-Applied-Diss/blob/master/FarmWithEase/FarmWithEase.apk) file.
* Download this apk and install it on your android device.

### Hosting
* Our app is being hosted online using the firebase hosting service. It can be accessed [here](https://farming-26588.firebaseapp.com/?fbclid=IwAR2r17Ii8gp7nfq41e5yE5JKVo52AhHzU4Iq_odxpmAJrQNhnJIwdG7xDmQ)

## Deploy Locally

Prerequisites
* Mongo Installed - Click [here](https://www.mongodb.com/download-center?jmp=tutorials&_ga=2.180285351.2088142531.1523826631-1629278295.1507240892#community) for instructions.
* NodeJS, Ionic, Cordova - Click [here](https://ionicframework.com/docs/intro/installation/) and follow the instructions.

### Deploy Back-End
1. Clone or Download this repository.
2. Start MongoDB. You should be able to do this by pressing the windows key and searching for the following command then running it.
```bash
mongo
```
If this fails you can start mongo running by executing the following command from the bin folder of your installation of Mongo.
```bash
mongod
```
3. In your terminal or CMD, navigate to the FarmWithEase back-end folder which in this project is called 'server'. First make sure that mongo is running in its own terminal. Complete the following commands to get the server running.

```bash
npm install
node server.js
```

The back-end should now be running locally on your machine.

### Deploy Front End
1. Clone or Download this repository.
2. In your terminal navigate into the folder.
3. Run the following command to install the project dependencies.

```bash
npm install
```
4. Once complete run this command to view the application running in development mode.

```bash
ionic serve
```
5. The application should now open up in your browser.

[Top](#contents)

gha_language: TeX


text:
# udacity-term2-p1
Environment: Win7+Docker;

1) Code must compile without errors with cmake and make.
2) RMSE px&py<0.11 and vx&vy<0.52
  a) laser + radar sensor: dataset1 & dataset2
  ![Image text](https://github.com/Genzaiwuxian/udacity-term2-p1/blob/master/figure/radar%26laser_dataset1.png)
  ![Image text](https://github.com/Genzaiwuxian/udacity-term2-p1/blob/master/figure/radar%26laser_dataset2.png)

  b) laser sensor open: dataset1 & dataset2
  ![Image text](https://github.com/Genzaiwuxian/udacity-term2-p1/blob/master/figure/laser_dataset1.png)
  ![Image text](https://github.com/Genzaiwuxian/udacity-term2-p1/blob/master/figure/laser_dataset2.png)

  c) radar sensor open: dataset1 & dataset2
  ![Image text](https://github.com/Genzaiwuxian/udacity-term2-p1/blob/master/figure/radar_dataset1.png)
  ![Image text](https://github.com/Genzaiwuxian/udacity-term2-p1/blob/master/figure/radar_dataset2.png)

3) Follows the Correct Algorithm
  tools: calculate the jacbian matrix and RMSE;
  Kalmanfilter: prediction and update(for laser)&updateEKF(for radar)
  FusionEKF: initialise like R, H, timesamp, first x_ value, etc. then call prediction, and Update/UpdateKF function based on differnt sensor.

4) remarks:
  a) Laser+Radar is better than sigle sensor;
  b) between laser and radar, laser have good performance than radar in prediction of px and py;
  c) for vx and vy, laser and radar have no big differnce, it seems that radar have better result in vx, and laser better in vy.


text:
# Protect Generic NAS Mountpoints using PowerShell

Warning: this code is provided on a best effort basis and is not in any way officially supported or sanctioned by Cohesity. The code is intentionally kept simple to retain value as example code. The code in this repository is provided as-is and the author accepts no liability for damages resulting from its use.

This PowerShell script creates a new protection job for NAS volumes.

## Download the script

Run these commands from PowerShell to download the script(s) into your current directory

```powershell
# Download Commands
$scriptName = 'protectGenericNas'
$repoURL = 'https://raw.githubusercontent.com/bseltz-cohesity/scripts/master/powershell'
(Invoke-WebRequest -UseBasicParsing -Uri "$repoUrl/$scriptName/$scriptName.ps1").content | Out-File "$scriptName.ps1"; (Get-Content "$scriptName.ps1") | Set-Content "$scriptName.ps1"
(Invoke-WebRequest -UseBasicParsing -Uri "$repoUrl/cohesity-api/cohesity-api.ps1").content | Out-File cohesity-api.ps1; (Get-Content cohesity-api.ps1) | Set-Content cohesity-api.ps1
# End Download Commands
```

## Components

* protectGenericNas.ps1: the main PowerShell script
* cohesity-api.ps1: the Cohesity REST API helper module

Place all files in a folder together. And run the script like so:

```powershell
# example
./protectGenericNas.ps1 -vip mycluster `
                    -username myuser `
                    -domain mydomain.net `
                    -policyName 'My Policy' `
                    -jobName 'My New Job' `
                    -timeZone 'America/New_York' `
                    -enableIndexing `
                    -mountPath \\myserver\myshare `
                    -cloudArchiveDirect
# end example
```

## Parameters

* -vip: name or IP of Cohesity cluster
* -username: name of user to connect to Cohesity
* -domain: your AD domain (defaults to local)
* -policyName: name of the protection policy to use
* -jobName: name of protection job

## Optional Prameters

* -startTime: (optional) e.g. '18:30' (defaults to 8PM)
* -mountPath: (optional) one or more volumes to protect (comma separated, default is all volumes)
* -mountList: (optional) text file list of volumes to protect
* -inclusions: (optional) one or more inclusion paths (comma separated)
* -inclusionList: (optional) text file list of paths to include
* -exclusions: (optional) one or more exclusion paths (comma separated)
* -exclusionList: (optional) text file list of exclusion paths
* -timeZone: (optional) e.g. 'America/New_York' (default is 'America/Los_Angeles')
* -incrementalProtectionSlaTimeMins: (optional) default 60
* -fullProtectionSlaTimeMins: (optional) default is 120
* -enableIndexing: (optional) default is disabled
* -cloudArchiveDirect: (optional) default is false
* -storageDomainName: (optional) default is 'DefaultStorageDomain' (or 'Direct_Archive_Viewbox' for cloud archive direct jobs)

repository: bseltz-cohesity/scripts

gha_language: PowerShell

repo_name: bseltz-cohesity/scripts


text:
---
title: Product Rule
layout: page
exclude: true
---

<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS_CHTML"></script>

The **product rule** states that the derivative of two functions that are multiplied together is the **first function multipled by the derivative of the second function, plus the derivative of the first function multiple by the second function**. This can be remembered with the nemonic:

> right d left plus left d right

The derivative is therefore given by:

\\[ g(x)h(x)' = g(x)\frac{dh}{dx} + h(x)\frac{dg}{dx} \\]

or

\\[ u'v + v'u \\]

Examples:

\\[ (4t^{2} - t)(t^3 - 8t^2 + 12)' = \\]
\\[ (4t^{2} - t)(3t^2 - 16t) + (t^3 - 8t^2 + 12)(8t - 1) = \\]
\\[ 20t^4 - 132t^3 + 24t^2 + 96t - 12 \\]

## Proof

You can prove that \\( (uv)' = u'v + v'u \\) by using the multiplication of these functions with the \\( \frac{dy}{dx} \\) formula. In the example below I use the functions \\( f \\) and \\( g \\). First we substitute into the change in \\( x \\) formula with the two functions multiplied together.

\\[ \frac{f(x + \Delta x)g(x + \Delta x) - f(x)g(x)}{\Delta x} \\]

We then add by \\( f(x + \Delta x)g(x) \\) and \\( -f(x + \Delta x)g(x) \\) which equals \\( 0 \\) but allows us to group terms together. This results in:

\\[ \frac{f(x + \Delta x)g(x + \Delta x) -f(x + \Delta x)g(x) + f(x + \Delta x)g(x) - f(x)g(x)}{\Delta x} \\]

Next, factorise the resulting terms.

\\[ \frac{f(x + \Delta x)(g(x + \Delta x) - g(x))}{\Delta x} + \frac{ g(x)(f(x + \Delta x) - f(x))}{\Delta x} \\]

Bring the first term of each fraction outside of the divisor to separate them.

\\[ f(x + \Delta x)\frac{g(x + \Delta x) - g(x)}{\Delta x} + g(x)\frac{ f(x + \Delta x) - f(x)}{\Delta x} \\]

We now have the derivative defined in four distinct units: \\( f(x + \Delta x) \\), \\( \frac{(g(x + \Delta x) - g(x))}{\Delta x} \\), \\( g(x) \\) and \\( \frac{f(x + \Delta x) - f(x)}{\Delta x} \\). This format is starting to look suspiciously like \\( u'v + v'u \\). The last piece of puzzle is to define individuals limits for each part of this expression and use the limit sum rule to combine them.

\\[ \lim_{x \to 0} f(x + \Delta x) = f(x) \\]

\\[ \lim_{x \to 0} \frac{(g(x + \Delta x) - g(x))}{\Delta x} = g'(x) \\]

\\[ \lim_{x \to 0} g(x) = g(x) \\]

\\[ \lim_{x \to 0} \frac{f(x + \Delta x) - f(x)}{\Delta x} = f'(x) \\]

So therefore, if we place the limits into the original long form expression

\\[ \lim_{x \to 0} f(x + \Delta x) \lim_{x \to 0} \frac{g(x + \Delta x) - g(x)}{\Delta x} + \lim_{x \to 0} g(x) \lim_{x \to 0} \frac{ f(x + \Delta x) - f(x)}{\Delta x} \\]

By substituting for equivalent expressions defined above we can see that

\\[ = f(x)g'(x) + g(x)f'(x) \\]

Which is the same as \\( (f(x)g(x))' \\) thus proving the product rule.

## Multiple Products

This **generalises further to finding the derivate of expressions with more than two functions multipled together** so that you take the derivate of each individual function multiplied by the other functions and added together for each combination of functions, in the form:

\\[ g(x)h(x)f(x)' = g(x)'h(x)f(x) + g(x)h(x)'f(x) + g(x)h(x)f(x)' \\]

### Visualising the Product Rule

You can **visualise the product rule** using simple geometric shapes. For example, in the case of two functions being multiplied together you can imagine this as a rectangle who's length is given by the first function and who's width is given by the second function. The example below shows a box, the length of which is given by the function `sin(x)` and the height of which is given by `x^2`.

```
┏━━sin(x)━━┓
┏━━━━━━━━━━┓ ┓
┃          ┃ ┃
┃          ┃ x^2
┃          ┃ ┃
┗━━━━━━━━━━┛ ┛
```

If you were to increase `x` slightly you would get 3 new pieces of area: `A`, `B` and `C`.

```
┏━━━━━━━━━━┓ ┏━┓
┃          ┃ ┃ ┃
┃          ┃ ┃A┃
┃          ┃ ┃ ┃
┗━━━━━━━━━━┛ ┗━┛
┏━━━━━━━━━━┓ ┏━┓
┃     B    ┃ ┃C┃
┗━━━━━━━━━━┛ ┗━┛
```

The areas of these different sections are:

\\[ A = \Delta sin(x)x^2 \\]

\\[ B = sin(x)\Delta x^2 \\]

\\[ C = \Delta sin(x) \Delta x^2 \\]

We can ignore `C` because the change of a `Δ` value raised to a power is negligible. That means the whole change of this expression over a tiny `Δx` is the area of `A` plus the area of `B` which is the same as product rule outlined above. So the solution would be:

\\[ cos(x)x^2 + sin(x)2x \\]

This geometric intuition can be **generalised to three dimensions** to implicate what happens with a higher number of functions. In that case you would end up with *three* cuboids that describe the derivative of the function.


text:
# Custom HTML Tags

You might know that you can create custom HTML tags using JS frameworks like Vue.js or React. This library allows you to do this in php as well and to turn your custom HTML into something else.

**This library is NOT ready for production! Work in progress!**

## Simple Example

This will just rename a tag:

```php
$html = '<div><my-funky-tag class="test" /></div>'

$parser = new Phauthentic\CustomHtml\Parser();
$parser->addTag('my-funky-tag', \Phauthentic\CustomHtml\RenameTag::create('other-tag'));

echo $parser->parse();
```

The above should output:

```html
<div><other-tag class="test" /></div>
```

You can add whatever transformation you want by adding a callable via `Parser::add`.

## License & Copyright

Copyright Florian Krämer

[MIT](license.txt)

repository: burzum/custom-html-parser

repo_name: burzum/custom-html-parser


text:
# GuerillaMail
A Laravel wrapper for the GuerillaMail API.

Strongly inspired from this [python wrapper](https://github.com/ncjones/python-guerrillamail/) by **ncjones**.

## Guide

The `GuerillaMail` facade has the following methods: `getEmailAddress`, `getEmailList`, `getEmail`, `setEmailAddress`. For more details, have a look at the `GuerillaMailClient` class.

The methods `getEmailList` and `getEmail` return instances of the `Mail` class which has the following proporties:
- `$from`
- `$timestamp`
- `$date`
- `$replyTo`
- `$read`
- `$subject`
- `$excerpt`
- `$body`
- `$contentType`
- `$id`
- `$recipient`
- `$size`

repository: JhumanJ/GuerillaMail

repo_name: JhumanJ/GuerillaMail


text:
# ⚠ UPDATE: Jan 2021 - THIS IS NO LONGER MAINTAINED

This repository tried to support adding a comment. There is a much better support from GitHub in https://github.com/actions/github-script.

You can use the `github-script` with Comvent (https://github.com/rytswd/comvent) to provide ChatBot like support.

Comvent is still being supported.

---

# Respost - Response Post

## **WHAT**: Send Response from GitHub Actions

Simple HTTP POST to write to the Issue and PR.

## **HOW**: Example - Issue Creation + Bot-like Response

![Issue Creation, with Comvent](docs/respost_issue_example.gif)

> **WARNING**: I have edited the above recording, it was originally around 90 sec.
> **NOTE**: [`comvent`](http://github.com/rytswd/comvent) is used to provide bot-like comment parsing.

## **HOW**: Example - Above, with YAML

```yaml
name: Respost - Write comment to new Issue event
on: issues

jobs:
  comment:
    runs-on: ubuntu-latest
    steps:
      - uses<EMAIL_ADDRESS>        with:
          title: Respost Custom Title from step 1, for Issue
          body: "Hello, World! Respost is here, making your GitHub Actions workflow even easier!"
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
```

This is all you need to automatically drop a comment when a new issue is created.

You can find more examples in this repo's [`.github/workflows/`](.github/workflows/).

## **WHY**: Simple and Cheap

GitHub Actions can be defined either in JavaScript or Docker container.

Docker container allows full segregation and secure setup, but it takes about ~10sec to build and start up.
When you wish to use GitHub Actions on frequently used events such as PR and Issue Comments, this can easily add up.

TypeScript can work seamlessly with JSON object, and [axios](github.com/axios/axios) provides easy HTTP POST handling.

repository: rytswd/respost

repo_name: rytswd/respost


text:
# folea.Serilog.Enrichers.HttpHeaders
Simple to use Serilog Enricher that allows developers to select the headers they want to log and the name of the properties that will be used

## Installation
To install download from Nugget

## Demo

Just call it from Main inside Program.cs in your asp.net core project as follows

```c#
Log.Logger = new LoggerConfiguration()
                .ReadFrom.Configuration(_config).WriteTo.Console(new JsonFormatter())
                .Enrich.WithHttpHeaders(new Tuple<string, string>[2] { new Tuple<string, string>("request-id", "requestId"),
                                                                        new Tuple<string, string>("event-id", "eventId"),
                                                                        new Typle<string, string>("another-header", "another-property") })
                .CreateLogger();
```


text:
# mysql-honeypotd

[![Build Status](https://travis-ci.org/sjinks/mysql-honeypotd.svg?branch=master)](https://travis-ci.org/sjinks/mysql-honeypotd)
[![Coverity Scan Build Status](https://scan.coverity.com/projects/14112/badge.svg)](https://scan.coverity.com/projects/14112)

Low interaction MySQL honeypot written in C

## Dependencies

[libev](http://software.schmorp.de/pkg/libev.html)

## Usage

`mysql-honeypotd [options]...`

Mandatory arguments to long options are mandatory for short options too.

  * `-b`, `--address ADDRESS` the IP address to bind to (default: <IP_ADDRESS>)
  * `-p`, `--port PORT`       the port to bind to (default: 3306)
  * `-P`, `--pid FILE`        the PID file (default: `/run/mysql-honeypotd/mysql-honeypotd.pid`)
  * `-n`, `--name NAME`       the name of the daemon for syslog (default: `mysql-honeypotd`)
  * `-u`, `--user USER`       drop privileges and switch to this `USER` (default: `daemon` or `nobody`)
  * `-g`, `--group GROUP`     drop privileges and switch to this `GROUP` (default: `daemon` or `nogroup`)
  * `-c`, `--chroot DIR`      chroot() into the specified `DIR`
  * `-s`, `--setver VER`      set MySQL server version to `VER` (default: 5.7.19)
  * `-f`, `--foreground`      do not daemonize
  * `-h`, `--help`            display this help and exit
  * `-v`, `--version`         output version information and exit

**Notes:**
  1. `--user`, `--group`, and `--chroot` options are honored only if mysql-honeypotd is run as `root`
  2. PID file can be outside of chroot
  3. When using `--name` and/or `--group`, please make sure that the PID file can be deleted by the target user

## Sample output

```
Oct 20 22:06:45 server mysql-honeypotd[22363]: Access denied for user 'root' from <IP_ADDRESS>:4240 to x.x.x.146:3306 (using password: YES)
Oct 20 22:06:45 server mysql-honeypotd[22363]: Access denied for user 'root' from <IP_ADDRESS>:4281 to x.x.x.135:3306 (using password: YES)
Oct 20 22:06:46 server mysql-honeypotd[22363]: Access denied for user 'root' from <IP_ADDRESS>:4570 to x.x.x.146:3306 (using password: YES)
Oct 20 22:06:46 server mysql-honeypotd[22363]: Access denied for user 'root' from <IP_ADDRESS>:4644 to x.x.x.135:3306 (using password: YES)
Oct 20 22:06:46 server mysql-honeypotd[22363]: Access denied for user 'root' from <IP_ADDRESS>:4949 to x.x.x.146:3306 (using password: YES)
Oct 20 22:06:47 server mysql-honeypotd[22363]: Access denied for user 'root' from <IP_ADDRESS>:4998 to x.x.x.135:3306 (using password: YES)
Oct 20 22:06:47 server mysql-honeypotd[22363]: Access denied for user 'root' from <IP_ADDRESS>:1238 to x.x.x.146:3306 (using password: YES)
Oct 20 22:06:47 server mysql-honeypotd[22363]: Access denied for user 'root' from <IP_ADDRESS>:1264 to x.x.x.135:3306 (using password: YES)
Oct 20 22:06:48 server mysql-honeypotd[22363]: Access denied for user 'root' from <IP_ADDRESS>:1537 to x.x.x.135:3306 (using password: YES)
Oct 20 22:06:49 server mysql-honeypotd[22363]: Access denied for user 'root' from <IP_ADDRESS>:2370 to x.x.x.135:3306 (using password: YES)
```