text:
### 5.4.0
- Updated Fomantic-UI to 2.8.8
- Fixed and improved resource management
- Updated to Aardvark.Rendering 5.4

### 5.4.0-prerelease0007
- updated to rendering 5.4 prerelease

### 5.4.0-prerelease0006
- updated to rendering 5.3 prerelease

### 5.4.0-prerelease0005
- extend dropdown modes (icon / clearable / nonclearable)

### 5.4.0-prerelease0004
- extend dropdownConfig on event (allow open menu by hover or click)

### 5.4.0-prerelease0003
- prevent dropdown to fire init message

### 5.4.0-prerelease0002
- prevent dropdowns onChange messages (not set be GUI)

### 5.4.0-prerelease0001
- Updated Fomantic-UI to 2.8.8
- Fixed and improved resource management

### 5.3.6
- Fixed memory leak in event handler management
- Updated to Xilium.CefGlue 0.4.0

### 5.3.5
- Fixed assembly version of packages due to missing Aardvark.Build reference (was <IP_ADDRESS>)
- Fixed CEF packages

### 5.3.4
- Updated to Aardvark.Rendering 5.3

### 5.3.3
- exception handling for screenshots

### 5.3.2
- Fixed CEF processes nuget packages
- [Screenshot] Save image with alpha when using PNG

### 5.3.1
- OrbitState: exposed view : CameraView as extension

### 5.3.0
- OrbitState now private, better functions for converting between freefly/orbit modes.

### 5.3.0-prerelease0007
- temporarily reactivate simple media-specific render commands

### 5.3.0-prerelease0006
- proper shutdown for giraffe app binding

### 5.3.0-prerelease0005
- proper shutdown for giraffe app binding

### 5.3.0-prerelease0004
- proper shutdown for giraffe app binding

### 5.3.0-prerelease0003
- added giraffe backend nupkg

### 5.3.0-prerelease0002
- experimental giraffe backend

### 5.2.1
- added Mac/ARM64 turbojpeg

### 5.2.0
https://github.com/aardvark-platform/aardvark.docs/wiki/Aardvark-5.2-changelog

### 5.2.0-prerelease0008
- update rendering

### 5.2.0-prerelease0007
- Initial prerelease for 5.2

### 5.1.14
- [SimplePrimitives.fs] added textarea; js typo fix

### 5.1.13
- added orbit camera controller helpers

### 5.1.12
- switched to f# 5.0 (version bump for base/fshade/suave)

### 5.1.11
- fixed arcball problem on mac

### 5.1.10
- fixed arcball problem on mac

### 5.1.9
- fixed DPI scaling for CEF control
- Remove PBOs and read to host memory directly instead for compatibility

### 5.1.8
- workaround for blocking startup caused by slow network drives (#39)

### 5.1.7
- added animateForwardAndLocation to deprecated animation code (used in Dibit and PRo3D) with corrected final interation. All other deprecated animations do not reach their target.

### 5.1.6
- fixed cursor change problem on netcoreapp

### 5.1.5
- color picker can optionally save previous picks

### 5.1.4
- added Adaptify.Core to paket.template of aardvark.ui to fix missing references in applications

### 5.1.3
- updated dependencies

### 5.1.2
- updated Aardvark.Base
- updated Aardvark.Rendering (breaking changes)

### 5.1.1
- updated packages

### 5.1.0
- updated to FSharp.Data.Adaptive 1.1 and base 5.1 track

gha_language: F#


text:
# GCStats
[![Build Status](https://travis-ci.org/dainis/node-gcstats.svg?branch=master)](https://travis-ci.org/dainis/node-gcstats) [![Build status](https://ci.appveyor.com/api/projects/status/oeu171tgxbsac88q/branch/master?svg=true)](https://ci.appveyor.com/project/dainis/node-gcstats/branch/master)

Exposes stats about V8 GC after it has been executed.

# Usage

Create a new instance of the module and subscribe to `stats`-events from that:

    var gc = (require('gc-stats'))();

    gc.on('stats', function (stats) {
        console.log('GC happened', stats);
    });

This will print blobs like this whenever a GC happened:

    GC happened {
      startTime:<PHONE_NUMBER>976,
      endTime:<PHONE_NUMBER>390,
      pause: 1921414,
      pauseMS: 1,
      gctype: 1,
      before: {
         totalHeapSize: 11354112,
         totalHeapExecutableSize: 3670016,
         usedHeapSize: 7457184,
         heapSizeLimit:<PHONE_NUMBER>,
         totalPhysicalSize: 9725880,
         totalAvailableSize:<PHONE_NUMBER>,
         mallocedMemory: 8192,
         peakMallocedMemory: 1186040
      },
      after: {
         totalHeapSize: 12402688,
         totalHeapExecutableSize: 3670016,
         usedHeapSize: 6485792,
         heapSizeLimit:<PHONE_NUMBER>,
         totalPhysicalSize: 10166144,
         totalAvailableSize:<PHONE_NUMBER>,
         mallocedMemory: 8192,
         peakMallocedMemory: 1186040
      },
      diff: {
         totalHeapSize: 1048576,
         totalHeapExecutableSize: 0,
         usedHeapSize: -971392,
         heapSizeLimit: 0,
         totalPhysicalSize: 440264,
         totalAvailableSize: 953984,
         mallocedMemory: 0,
         peakMallocedMemory: 0
      }
    }

## Property insights
* totalHeapSize: Number of bytes V8 has allocated for the heap. This can grow if usedHeap needs more.
* usedHeapSize: Number of bytes in use by application data
* total HeapExecutableSize: Number of bytes for compiled bytecode and JITed code
* heapSizeLimit: The absolute limit the heap cannot exceed
* totalPhysicalSize: Committed size (node 0.11+)
* totalAvailableSize: Available heap size(node 4+)
* startTime: Nanoseconds for start, using hrtime()
* endTime: Nanoseconds for end, using hrtime()
* pause: Nanoseconds from start to end of GC using hrtime()
* pauseMS: pause expressed in milliseconds
* mallocedMemory
* peakMallocedMemory
* numberOfNativeContexts
* numberOfDetachedContexts
* gctype can have the following values([v8 source](https://github.com/nodejs/node/blob/554fa24916c5c6d052b51c5cee9556b76489b3f7/deps/v8/include/v8.h#L6137-L6144)):
  * 1: Scavenge (minor GC)
  * 2: Mark/Sweep/Compact (major GC)
  * 4: Incremental marking
  * 8: Weak/Phantom callback processing
  * 15: All

# Installation

    npm install gc-stats

# Node version support
node-gcstats depends on C++ extensions which are compiled when the *gc-stats* module is installed. Compatibility information can be inspected via the [Travis-CI build jobs](https://travis-ci.org/dainis/node-gcstats/).

license: Unlicense,MIT

repository: healthHyperledger/SmartMED

branch_name: refs/heads/master

detected_licenses: Unlicense MIT

extension: md

gha_language: Shell

gha_license_id: MIT

license_type: permissive

repo_name: healthHyperledger/SmartMED


text:
# Kohana Module

Kohana Backwards Module is enabled by default since v4.0. You can disable it by setting `KO7::$compatibility` to `TRUE`.

This Module ensures that deprecated Class calling (`Kohana_*`) will still be available after updating to Koseven 4.0+

repository: uBizzy/koseven

branch_name: refs/heads/devel

gha_language: PHP

gha_license_id: NOASSERTION

repo_name: uBizzy/koseven


text:
# YordanDecentralizedCoin
Yordan Decentralized Coin Is Project Work for the construction of places of worship and social programs

YordanDecentralizedToken
Yordan Decentralized Token Is Project Work for the construction of places of worship and social programs REMIX EXAMPLE PROJECT

Remix example project is present when Remix loads very first time or there are no files existing in the File Explorer. It contains 3 directories:

'contracts': Holds three contracts with different complexity level, denoted with number prefix in file name.
'scripts': Holds two scripts to deploy a contract. It is explained below.
'tests': Contains one test file for 'Ballot' contract with unit tests in Solidity.
SCRIPTS

The 'scripts' folder contains example async/await scripts for deploying the 'Storage' contract. For the deployment of any other contract, 'contractName' and 'constructorArgs' should be updated (along with other code if required). Scripts have full access to the web3.js and ethers.js libraries.

To run a script, right click on file name in the file explorer and click 'Run'. Remember, Solidity file must already be compiled.

Output from script will appear in remix terminal.

license: MIT

branch_name: refs/heads/main


text:
---
layout: post
title:  "CryptDB"
date:   2015-10-19 20:30
permalink: cryptdb
---

The problem CryptDB solves is how to get useful functionality out of database
that's not trusted.  This became a compelling problem relatively recently due
to two trends.  First the internet has dramatically increased the attack
surface of most applications increasing the importance of security -- one must
not only worry about dishonest employees but also sophisticated global
cybercrime organizations.  Second, is the advent of cloud.  For the first time,
users are compelled to store large amounts of data off premise on hardware
owned and operated by third parties.  To the extent they can achieve provable
security guarantees that don't rely on trusting large corporations (who are
legally compelled to comply with untrustworthy governments), trust in and
adoption of the cloud should increase dramatically.

There is, of course, a difficult trade-off here between functionality of the
database and data leakage.  The more sophisticated queries an application
needs, the less secure an encryption scheme can be used for the data, reducing
overall security of the system as argued by [Naveed et al.](http://research.microsoft.com/en-us/um/people/senyk/pubs/edb.pdf)
What's most worrying about this potential trade-off is how unintuitive the risk
is.  It seems to me that users are quite unlikely to have sufficient experience
to work out the trade-offs involved meaning they'll likely make significant errors.
That said, overall I do believe this paper is valuable.  I suspect in the long
term it will be used in conjunction with other security practices (firewalls,
physical security, etc) to provide a "defense in depth" approach that we're
lacking in modern systems.


text:
---
title: "Apply"
lesson: 4
chapter: 1
cover: ""
date: "13/03/2018"
---

Apply the changes described by the Terraform plan means let Automium creates or destroys resources on Enter Cloud Suite.

To have an idea of what can be done with 2 clicks in Automium, consider to add the following Terraform file:

```yaml
# Create ssh firewall policy
module "myserver_ssh_sg" {
  source = "github.com/entercloudsuite/terraform-modules//security?ref=2.6"
  name = "myserver_ssh_sg"
  region = "${var.region}"
  protocol = "tcp"
  port_range_min = 22
  port_range_max = 22
  allow_remote = "<IP_ADDRESS>/0"
}

# Create instance
module "myserver" {
  source = "github.com/entercloudsuite/terraform-modules//instance?ref=2.6"
  name = "myserver"
  region = "${var.region}"
  flavor = "e3standard.x1"
  network_name = "${var.network_name}"
  keypair = "${var.keyname}"
  sec_group = ["${module.myserver_ssh_sg.sg_id}"
  tags = {
    "server_group" = "MYSERVER"
  }
}
```

Run a **Plan** to check the resources that we are going to create on Enter Cloud Suite, a new instance with the related: floating IP, network port and security group in order to login via SSH.

**Apply** the plan to confirm the creation tasks.

**Destroy** the created resources is as simple as deleting the Terraform file.

repository: entercloudsuite/automium-docs

repo_name: entercloudsuite/automium-docs


text:
oolib.js is a tiny JavaScript library that provides an original solution to the age-old problem of JavaScript OOP encapsulation.

You can find the documentation here: http://idya.github.com/oolib/.

#Files
Several variants are provided, for use in various environments:

* **oolib.js** simply creates a global namespace variable named *oo*; **oolib-min.js** is the minified version
* **oolib-amd.js** is an A(synchronous) M(odule) D(efinition) module (RequireJS, curl.js, etc.); **oolib-amd-min.js** is the minified version
* **oolib-cjs** is a CommonJS module (typically for server-side environments); **oolib-cjs-min.js** is the minified version

repository: thinkanyforever/oolib

repo_name: thinkanyforever/oolib


text:
base128
=======

In many protocols or formats like JSON or early WebSocket, it requires String in UTF-8 representation, so we can not store raw binary data into String without encoding like Base64.

However, Base64 encodes binary into only 6 bits spece but we can actually use one more bit in valid UTF-8 string from U+0000 to U+007F, so using Base128 is better than Base64 (~ 16% more information we can store in the same space.)

This base128 module provides simple encode, decode interfaces between Buffer and String on Node.js which are implemented in C++.

Usage
-----

Use `npm` to grab a package then load by `require()`.

    $ npm install base128
    $ node
    > var base128 = require('base128')

Examples
--------

To Encode,

     var base128 = require('base128')
     var binary = new Buffer([0xFF, 0x01])
     var string = base128.encode(binary)
     console.log(string) #=> '\u007F\u0003\u0000' (These cahracters are invisible, though.)

To Decode,

     var base128 = require('base128')
     var string = '\u007F\u0003\u0000'
     var binary = base128.decode(string)
     console.log(binary) #=> '<Buffer ff 01>'


text:
# Permissions

To perform actions, users need permissions that allow them to do so.

Squirrel has some default permissions for all models:

* `view`
* `add`
* `change`
* `delete`

Those permissions apply to the frontend and the [API](03-api.md) as well.

## Orders

Orders have a second set of permissions that allow for specific actions to be performed for **all teams**.

Those are:

* `view_all_teams`
* `add_all_teams`
* `change_all_teams`
* `delete_all_teams`

This enables us to allow users to e.g. place orders for all teams without belonging to it which is a typical
helpdesk scenario.

**Those permissions do not implicitly grant the base permission.** If you want someone to be able to delete
orders for all teams, grant them the `delete` and the `delete_all_teams` permission. This was a carefully made decision
that follows the principle that *explicit is better than implicit.*

gha_language: Python


text:
---
layout: note
title: 0x400 Notes
---

# TCP Flags Stored in Header
* URG
    - Urgent
    - Identifies important data
* ACK
    - Acknowledgement
    - Acknowledges a packet; it is turned on for the majority of the connection
* PSH
    - Push
    - Tells receiver to push the data through instead of buffering it
* RST
    - Reset
    - Resets a connection
* SYN
    - Synchronize
    - Synchronizes sequence numbers at the beginning of a connection
* FIN
    - Finish
    - Gracefully closes a connection when both sides say goodbye

# TCP Connection

* Sequence number and acknowledgment number are used to maintain state
* SYN and ACK flags are used to open connections in a 3 step handshake
    - Client sends packet with SYN flag on and ACK flag off
    - Then Server responds with a packet with both flags on
    - Finally Client sends back a packet with SYN flag off but ACK on
    - After this every packet will hace the ACK flag on and SYN off
* Sequence numbers all TCP to put unordered packets back into order
    - Helps determine whether packets are missing
    - Also helps aboiding mix ups
* TCP is great for applications where reliability and bidirectional communication are needed

# UDP is a faster but less reliable than TCP
* UDP like the IP protocol is connectionless and unreliable
    - Expects application to deal with its connectionless
# Unswitched Netowrk
* Packets pass through every device on the network
* Each device is expected to only look at packets addressed to them
* It is very easy to go into **Promiscuous Mode** which causes it to look at all packets
* **Sniffing** is the act of capturing packets that aren't necessarily meant for public view

# Switched Network
* Only sent to the port they are assigned
* Requires more intelligent hardware
* One techniqure is to spoof **Source Address**
* When an ARP reply comes in with an IP that exists, the receiver will overwrite MAC
* ARP keeps no state information
* With theses details an **ARP Redirection** can be execute
* The act of changing entries in the ARP Cache is called **ARP Cache Poisoning**

# TCP/IP Hijacking is a clever technique that uses spoofed packets to take over a connection
* Attacker must be on the same network
* Very usefule for one-time passworks

## RST Hijacking
* Form of TCP/IP hijacking
    - Involves  injecting an authentic looking reset packet
    - If  Source is spoofed an ACK number is correct receiving side will believe it should restart transmission


text:
# Changelog

All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## Unreleased

## v1.3.1 - 2022-03-26

### Fixed

- Fix bug where banners would stay invisible or partially visible when mouse
  leaves the window. [#774](https://github.com/dotboris/prod-guard/issues/774)

### Changed

- Rename the `master` branch to `main`. This should have 0 impact on end users
  but it's worth mentioning.

## v1.3.0 - 2022-03-02

### Added

- Top and bottom banners now automatically hide themselves when the mouse gets
  close. This allows you to see what's underneath a banner and to click or
  interact with the parts of the page that would be under the banner.

### Changed

- Change internal IDs from temporary integers to permanent UUIDs. This is an
  internal change that should not have any effect on users. This change is in
  preparation for adding an import/export feature.

## v1.2.0 - 2021-05-22

### Added

- It is now possible to change the text for the "Top Banner" and "Bottom Banner"
  style warnings.
- It is now possible to change the colors of all warnings.

### Changed

- Migrate the whole build process to Webpack 5. This should have no impact on
  end users but it's worth mentioning.
- Migrate tests to Jest. This should have no impact on end users but it's worth
  mentioning.
- Migrate codebase from Vue.js to React. This should have no impact on end users
  but it's worth mentioning.

## v1.1.1 - 2020-08-18

### Fixed

- Fixed major bug where loading, adding, removing, changing warnings did not
  work at all but only on the published version of the extension. It works in
  dev but it falls flat when it's published for real.

## v1.1.0 - 2020-08-16

### Added

- Added support for Chrome & Chromium

## v1.0.0 - 2020-08-16

### Added

- Ability to add warning to websites based regular expressions.
- Top Banner style warning.
- Bottom Banner style warning.
- Border style warning.
- Interface for managing warnings.

repository: dotboris/prod-guard

gha_language: TypeScript

repo_name: dotboris/prod-guard


text:
---
slug: csumb-awarded-8-million-innovation-grants
title: "CSUMB awarded $8 million innovation grants"
date: January 01 2020
---

Published on March 20, 2015

  The innovative work being done by CSU Monterey Bay was recognized by the state
  through its Awards for Innovation in Higher Education.

  CSIT-in-3, a program that allows students to earn a computer science degree in
  three years, was ranked among the top five applications and was awarded $5
  million. CSIT-in-3 is a collaboration between Hartnell College and CSUMB that
  started in 2013.

  It is one of two CSUMB programs that received funding. A developmental math
  course was awarded $3 million.

  The fund, proposed by Gov. Jerry Brown and included in last year’s budget, was
  doled out to colleges and universities for devising creative and
  cost-effective ways to get more students to earn degrees in less time.

  A total of 58 proposals were submitted by 52 colleges and universities.
  Fourteen of them were funded; a committee chaired by the governor’s finance
  director decided how to allocate the money.

  The CSIT-in-3 program represents a new model for bachelor’s degree completion
  as well as for improving enrollment, retention, transfer and graduation for
  underrepresented students in technology. It’s cohort-based, meaning students
  who start the program together take all classes, participate in
  extra-curricular activities and graduate together. Students benefit from
  workshops, field trips and guest speakers.

  “We believe that CSIT-in-3 is the only program of its kind in the country,”
  said Hartnell President Willard Lewallen. “It’s the most innovative program
  I’ve been involved with in my 36 years in education.” Lewallen went on to say
  that the program involves an unprecedented level of collaboration between the
  two schools.

  Math@CSUMB is designed to increase the success of students who are required to
  take developmental math in their freshman year.

  Nationwide, half of all college students need remedial math, and only 50
  percent of them pass the class the first time they take it. Math@CSUMB has
  increased the success rate to approximately 90 percent, and has contributed to
  a dramatic increase in student retention at CSUMB.

  The classes are built around activities and student work rather than
  traditional lecture formats. They use tutoring, supplemental instruction and a
  high-tech environment that provides immediate feedback. And university faculty
  members work with community college and K-12 teachers to implement similar
  strategies at their schools.

repository: csumb-archives/news-gatsby

gha_language: JavaScript

repo_name: csumb-archives/news-gatsby


text:
angularjs-form-validation
=========================

I'm going to follow the following tutorial: [AngularAgility][url-repo-aa]. And as you can read in Angular Agility repo, it is also interesting to check out their [first outline in Plunker][url-first-plunker].

I first knew about Angular Agility repo in this page: http://www.tweetganic.com/a/24180

[url-repo-aa]: https://github.com/AngularAgility/AngularAgility
[url-first-plunker]: http://plnkr.co/edit/PS0sNo?p=preview

license: Unlicense

repository: joaquindev/angularjs-form-validation

repo_name: joaquindev/angularjs-form-validation


text:
# Relativity - Closed Loop Robot Control

## How to Setup Environment

Clone this repository onto a Linux system (Ubuntu). Enter the closed_loop_robot_sim directory.

```sh
cd path/to/cloned/directory/closed_loop_robot_sim
```

Robot simulation can be run in docker container. First, the user must install docker, or verify it is installed on your machine. To install execute the `docker.sh` script with the argument `install`. After the installation concludes log out of and into your user account to be able to use docker as a non-sudo user.

```sh
# To install docker
./docker.sh install

# To check if installed
docker --version
# Should output 'Docker version X.X.X, build XXX' if installed
```

Then, you can create the docker image that will be used to run the simulation. To do so, run the below command:

```sh
# To build image, run script with argument install
./docker.sh build
```

NOTE: The first time you run this, it will take ~10 min to build the container. After the image is built is on your system, you can check for it by running the command:

```sh
docker images
# You should see output like:
# REPOSITORY            TAG     IMAGE ID    CREATED             SIZE
# relativity/cl_robot   0.1    ...         A few seconds ago   1.13 GB
```

You can remove this docker image from your computer with the command: `./docker.sh remove`
You can run the docker container to an interactive terminal with the command `./docker.sh bash`
You can attach to the running docker container by opening a new terminal window/tab with the command: `./docker.sh another`

## How to Run

Open Grafana interface in Firefox or similar browser at `http://localhost:3000/`. It make take several refreshes to open.
Robot sim will be running in the docker container, and information being sent to your local browser.

Log into Grafana with username `admin` and password `admin`.
Open the dashboard "Sensor Dashboard". Once logged in,this option should be available on the home page under 'Recently viewed dashboards'.

```sh
cd path/to/cloned/directory
./docker.sh bash

# In docker container
./run.sh
```

## Testing

I did not unit test (lack of time), but I did write some pytest files to verify basic functionality of components and do integration testing for pub/sub.

All tests can be run in docker bash (`./docker.sh bash`) with the `pytest` command.

```sh
pytest test/infra/test_mqtt_wrappers.py     # Test test_mqtt_wrappers.py script
pytest -s test/infra/test_mqtt_wrappers.py  # Test test_mqtt_wrappers.py script with log output display
pytest -v test/infra/test_mqtt_wrappers.py  # Test test_mqtt_wrappers.py script with test summary output display
```

## To Do/Current Status

See docs/remaining_work.md

## Software Design diagram

Software design diagram - explains communication and modules

![software design diagram](https://github.com/alisonbelow/closed_loop_robot_sim/blob/master/docs/resources/software_design_diagram.png)

## Troubleshooting

To check if Grafana server is running, execute command `sudo service grafana-server status` in docker terminal.

To check if InfluxDB server is running, execute command `sudo service influxdb status` in docker terminal.
Can also check server is active with command `curl -sl -I localhost:8086/ping`.

To check if Grafana server is running, execute command `sudo service mosquitto status` in docker terminal.

To see all statuses, execute command `sudo service --status-all` in docker terminal.


text:
+++
title = "Amazon Elastic Load Balancing"
chapter = false
weight = 20
+++

## Introduction to Amazon Elastic Load Balancer (ELB)

### What to expect

This workshop shows some of the basic networking aspects of sharing a Load Balanced Application internally and externally.

Within your own AWS account, you can explore how to provision a logically isolated section of the AWS Cloud where you can launch AWS resources in a virtual network that you define.

![End-to-end Apps](/images/r53-diagram.png)

You will use the following services:

- **AWS Network Load Balancers** for a scalable application
- **AWS Privatelink** and **Transit Gateway** for cross VPC communication
- **Amazon Route 53** for DNS and directing clients to the correct resource

repository: geseib/awselbworkshop

repo_name: geseib/awselbworkshop


text:
Release Notes
-------------------

WildFly-Camel 11.0.0 provides Camel-3.0.0 integration with WildFly-18.0.1

This is a major update release.

Component upgrades include

* WildFly-18.0.1
* Camel-3.0.0
* Hawtio-2.8.0

Here some highlights that come with the Camel3 update

* Remove support for @ContextName
* Remove support for SerializationDataFormat

* Remove support for camel-mongodb
* Remove support for camel-script
* Remove support for camel-chronicle
* Remove support for camel-rmi
* Remove support for camel-jibx
* Remove support for camel-boon
* Remove support for camel-ejb
* Remove support for camel-mqtt
* Remove support for camel-linkedin

* Rename camel-mina2 to camel-mina
* Rename camel-mongodb3 to camel-mongodb
* Rename camel-netty4 to camel-netty
* Rename camel-quartz2 to camel-quartz
* Rename camel-rxjava2 to camel-rxjava
* Rename camel-hdfs2 to camel-hdfs

In addition to that, we also resolved a number of other [tasks and bugs](https://github.com/wildfly-extras/wildfly-camel/blob/master/docs/Changelog.md).

For details please see the [11.0.0 Milestone](https://github.com/wildfly-extras/wildfly-camel/issues?q=milestone%3A11.0.0).

Enjoy

repository: baranowb/wildfly-camel

repo_name: baranowb/wildfly-camel


text:
# Homepage

Welcome to the documentation. On your left will be a list of the different services that Zoho provides. Clicking on one of them will show you a breakdown on the different areas within that service which are covered in this documentation.

Feel free to visit the [Contributing section](./contributing) if there's something missing which you have knowledge of, or if there's something as simple as a spelling mistake which needs fixing.

repository: zakarybk/my-zoho-doc

repo_name: zakarybk/my-zoho-doc


text:
# Install Seldon-Core

## Pre-requisites:
* Kubernetes cluster version equal or higher than 1.12
    * For Openshift it requires version 4.2 or higher
* Installer method
    * Helm version equal or higher than 3.0
    * Kustomize version equal or higher than 0.1.0
* Ingress
    * Istio ( sample installation using Istio 1.5 can be found at https://github.com/SeldonIO/seldon-core/tree/master/examples/auth )
    * Ambassador

### Running older versions of Seldon Core?

Make sure you read the ["Upgrading Seldon Core Guide"](../reference/upgrading.md)

* **Seldon Core will stop supporting versions prior to 1.0 so make sure you upgrade.**
* If you are running an older version of Seldon Core, and will be upgading it please make sure you read the [Upgrading Seldon Core docs](../reference/upgrading.md) to understand breaking changes and best practices for upgrading.
* Please see [Migrating from Helm v2 to Helm v3](https://helm.sh/blog/migrate-from-helm-v2-to-helm-v3/) if you are already running Seldon Core using Helm v2 and wish to upgrade.

## Install Seldon Core with Helm

First [install Helm 3.x](https://docs.helm.sh/docs/intro/install/). When helm is installed you can deploy the seldon controller to manage your Seldon Deployment graphs.

If you want to provide advanced parameters with your installation you can check the full [Seldon Core Helm Chart Reference](../reference/helm.html).

The namespace `seldon-system` is preferred, so we can create it:

```bash
kubectl create namespace seldon-system
```

Now we can install Seldon Core in the `seldon-system` namespace.

```bash
helm install seldon-core seldon-core-operator \
    --repo https://storage.googleapis.com/seldon-charts \
    --set usageMetrics.enabled=true \
    --namespace seldon-system
```

Make sure you install it with the relevant ingress (`ambassador.enabled` or `istio.enabled`) so you are able to send requests (instructions below).

### Install a specific version

In order to install a specific version you can do so by running the same command above with the `--version` flag, followed by the version you want to run.

### Install a SNAPSHOT version

Whenever a new PR was merged to master, we have set up our CI to build a "SNAPSHOT" version, which would contain the Docker images for that specific development / master-branch code. Whilst the images are pushed under SNAPSHOT, they also create a new "dated" SNAPSHOT version entry, which pushes images with the tag `"<next-version>-SNAPSHOT_<timestamp>"`. A new branch is also created with the name `"v<next-version>-SNAPSHOT_<timestamp>"`, which contains the respective helm charts, and allows for the specific version (as outlined by the version in `version.txt`) to be installed.

This means that you can try out a dev version of master if you want to try a specific feature before it's released.

For this you would be able to clone the repository, and then checkout the relevant SNAPSHOT branch.

Once you have done that you can install seldon-core using the following command:

```bash
helm install helm-charts/seldon-core-operator seldon-core-operator
```

In this case `helm-charts/seldon-core-operator` is the folder within the repository that contains the charts.

### Install with cert-manager

You can follow [the cert manager documentation to install it](https://cert-manager.io/docs/installation/kubernetes/).

You can then install seldon-core with:

```bash
helm install seldon-core seldon-core-operator \
    --repo https://storage.googleapis.com/seldon-charts \
    --set usageMetrics.enabled=true \
    --namespace seldon-system \
    --set certManager.enabled=true
```

## Ingress Support

For particular ingresses that we support, you can inform the controller it should activate processing for them.

 * Ambassador
   * add `--set ambassador.enabled=true` : The controller will add annotations to services it creates so Ambassador can pick them up and wire an endpoint for your deployments.
   * For full instructions on installation with Ambassador read the [Ingress with Ambassador](../ingress/ambassador.md) page.
 * Istio Gateway
   * add `--set istio.enabled=true` : The controller will create virtual services and destination rules to wire up endpoints in your istio ingress gateway.
   * For full instructions on installation with Istio read the [Ingress with Istio](../ingress/istio.md) page.

## Seldon Core Kustomize Install

The [Kustomize](https://github.com/kubernetes-sigs/kustomize) installation can be found in the `/operator/config` folder of the repo. You should copy this template to your own kustomize location for editing.

To use the template directly, there is a Makefile which has a set of useful commands:

For kubernetes clusters of version higher than 1.15, make sure you [comment the patch_object_selector here](https://github.com/SeldonIO/seldon-core/blob/master/operator/config/webhook/kustomization.yaml#L8).

Install cert-manager

```bash
make install-cert-manager
```

Install Seldon using cert-manager to provide certificates.

```bash
make deploy
```

Install Seldon with provided certificates in `config/cert/`

```bash
make deploy-cert
```

## Other Options

### Install Production Integrations

Now that you have Seldon Core installed, you can set it up with:

#### Install with Kubeflow

  * [Install Seldon as part of Kubeflow.](https://www.kubeflow.org/docs/guides/components/seldon/#seldon-serving)

#### GCP MarketPlace

If you have a Google Cloud Platform account you can install via the [GCP Marketplace](https://console.cloud.google.com/marketplace/details/seldon-portal/seldon-core).

#### OpenShift

You can install Seldon Core via OperatorHub on the OpenShift console UI.

#### OperatorHub

You can install Seldon Core from [Operator Hub](https://operatorhub.io/operator/seldon-operator).

## Upgrading from Previous Versions

See our [upgrading notes](../reference/upgrading.md)

## Advanced Usage

### Install Seldon Core in a single namespace (version >=1.0)

**You will need a k8s cluster >= 1.15**

#### Helm

You can install the Seldon Core Operator so it only manages resources in its namespace. An example to install in a namespace `seldon-ns1` is shown below:

```bash
kubectl create namespace seldon-ns1
kubectl label namespace seldon-ns1 seldon.io/controller-id=seldon-ns1
```

We label the namespace with `seldon.io/controller-id=<namespace>` to ensure if there is a clusterwide Seldon Core Operator that it should ignore resources for this namespace.

Install the Operator into the namespace:

```bash
helm install seldon-namespaced seldon-core-operator  --repo https://storage.googleapis.com/seldon-charts  \
    --set singleNamespace=true \
    --set image.pullPolicy=IfNotPresent \
    --set usageMetrics.enabled=false \
    --set crd.create=true \
    --namespace seldon-ns1
```

We set `crd.create=true` to create the CRD. If you are installing a Seldon Core Operator after you have installed a previous Seldon Core Operator on the same cluster you will need to set `crd.create=false`.

#### Kustomize

An example install is provided in the Makefile in the Operator folder:

```bash
make deploy-namespaced1
```

See the [multiple server example notebook](../examples/multiple_operators.html).

### Label focused Seldon Core Operator (version >=1.0)

**You will need a k8s cluster >= 1.15**

You can install the Seldon Core Operator so it manages only SeldonDeployments with the label `seldon.io/controller-id` where the value of the label matches the controller-id of the running operator. An example for a namespace `seldon-id1` is shown below:

#### Helm

```bash
kubectl create namespace seldon-id1
```

To install the Operator run:

```bash
helm install seldon-controllerid seldon-core-operator  --repo https://storage.googleapis.com/seldon-charts  \
    --set singleNamespace=false \
    --set image.pullPolicy=IfNotPresent \
    --set usageMetrics.enabled=false \
    --set crd.create=true \
    --set controllerId=seldon-id1 \
    --namespace seldon-id1
```

We set `crd.create=true` to create the CRD. If you are installing a Seldon Core Operator after you have installed a previous Seldon Core Operator on the same cluster you will need to set `crd.create=false`.

For kustomize you will need to [uncomment the patch_object_selector here](https://github.com/SeldonIO/seldon-core/blob/master/operator/config/webhook/kustomization.yaml)

#### Kustomize

An example install is provided in the Makefile in the Operator folder:

```bash
make deploy-controllerid
```

See the [multiple server example notebook](../examples/multiple_operators.html).

repository: Giphy/seldon-core

gha_language: Jupyter Notebook

repo_name: Giphy/seldon-core


text:
# Geo-Inferencing in Twitter [Soft-Boiled]

Documentation: http://soft-boiled.readthedocs.org/en/latest/

## General
The usage examples below assume that you have created a zip file containing the top level directory of the repo called soft-boiled.zip. Example IPython notebooks demonstrating the functionality of these algorithms can also be found in the notebooks directory of this repository.

## Spatial Label Propagation [slp.py]:

### Usage:
```python
sc.addPyFile ('/path/to/zip/soft-boiled.zip') # Can be an hdfs path
from src.algorithms import slp

# Create dataframe from parquet data
tweets = sqlCtx.read.parquet('hdfs:///post_etl_datasets/twitter')
tweets.registerTempTable('my_tweets')

# Get Known Locations
locs_known = slp.get_known_locs(sqlCtx, 'my_tweets', min_locs=3, dispersion_threshold=50, num_partitions=30)

# Get at mention network, bi-directional at mentions
edge_list = slp.get_edge_list(sqlCtx, 'my_tweets')

# Run spaital label propagation with 5 iterations
estimated_locs = slp.train_slp(filtered_locs_known, edge_list, 5, dispersion_threshold=100)

# prepare the input functions to the evaluate function. In this case, we create a holdout function
# that filter approximately 10% of the data for testing, and we also have a closure that prepopulates
# some of the parameters to the train_slp function
holdout_10pct = lambda (src_id): src_id[-1] != '9'
train_f = lambda locs, edges : slp.train_slp(locs, edges, 4, neighbor_threshold=4, dispersion_threshold=150)

# Test results
test_results = slp.evaluate(locs_known, edge_list, holdout_10pct, train_f)

```

### Options:
##### Related to calculating the median point amongst a collection of points:
***dispersion_threshold***: This is the maximum median distance in km a point can be from the remaining points and still estimate a location

***min_locs***:  Number of geotagged posts that a user must have to be included in ground truth.

##### Related to the actual label propagation:
***num_iters***: This controls the number of iterations of label propagation performed

## Gaussian Mixture Model [gmm.py]
### Usage:
```python
sc.addPyFile ('/path/to/zip/soft-boiled.zip') # Can be an hdfs path
from src.algorithms import gmm

# Create dataframe from parquet data
tweets = sqlCtx.read.parquet('hdfs:///post_etl_datasets/twitter')
tweets.registerTempTable('my_tweets')

# Train GMM model
gmm_model = gmm.train_gmm(sqlCtx, 'my_tweets', ['user.location', 'text'], min_occurrences=10, max_num_components=12)

# Test GMM model
test_results = gmm.run_gmm_test(sc, sqlCtx, 'my_tweets', ['user.location', 'text'], gmm_model)
print test_results

# Use GMM model to predict tweets
other_tweets = sqlCtx.read.parquet('hdfs:///post_etl_datasets/twitter')
estimated_locs = gmm.predict_user_gmm(sc, other_tweets, ['user.location'], gmm_model, radius=100, predict_lower_bound=0.2)

# Save model for future prediction use
gmm.save_model(gmm_model, '/local/path/to/model_file.csv.gz')

# Load a model, produces the same output as train
gmm_model = gmm.load_model('/local/path/to/model_file.csv.gz')
```
### Options
##### Related to GMM :
***fields***: A set of fields to use to train/test the GMM model. Currently only user.location and text are supported

***min_occurrences***: Number of times that a token must appear with a known location in the text to be estimated

***max_num_components***: Limit on the number of GMM components that can be used

#### Predict User Options

***radius***: Predict the probability that the user is within this distance of most likely point, used with predict_lower_bound

***predict_lower_bound***: Used with radius to filter user location estimates with probability lower than threshold

repository: jonathanrudich/soft-boiled

repo_name: jonathanrudich/soft-boiled


text:
This is an open-source, MIT-licensed implementation of Uber's Schemaless
(immutable BigTable-style sharded MySQL/Postgres).

All code is in Go.

DATABASE SUPPORT

For learning or other:

	* SQLite

	* Badger (experimental, local storage only)

For more serious testing and usage:

	* MySQL

	* Postgres

SETTING UP FOR DEVELOPMENT AND RUNNING TESTS

1. Install MySQL and Postgres

2. Setup users on MySQL and Postgres

3. Run both shell scripts inside tools/create_shard_schemas, one at a time,
loading the generated sql file into Postgres and MySQL locally.

4. Now, you can run tests a bit more easily. For me, this looks like:

~/go-src/src/github.com/rbastic/go-schemaless$ MYSQLUSER=user MYSQLPASS=pass PGUSER=user PGPASS=pass SQLHOST=localhost make test

Having replaced the user and pass with the appropriate usernames and passwords
for MySQL and Postgres, this should pass all tests.

Any test cases should be idempotent - they should not result in errors on
subsequent runs, for example, due to hard-coded row keys.

DISCLAIMER

I do not work for Uber Technologies.

VIDEOS

"Taking Storage for a Ride With Uber", https://www.youtube.com/watch?v=Dg76cNaeB4s (30 mins)

"GOTO 2016 • Taking Storage for a Ride", https://www.youtube.com/watch?v=kq4gp90QUcs (1 hour)

ARTICLES

"Designing Schemaless, Uber Engineering’s Scalable Datastore Using MySQL"

"Part One", https://eng.uber.com/schemaless-part-one/

"Part Two", https://eng.uber.com/schemaless-part-two/

"Part Three", https://eng.uber.com/schemaless-part-three/

"Code Migration in Production: Rewriting the Sharding Layer of Uber’s Schemaless Datastore"
https://eng.uber.com/schemaless-rewrite/

Most of the underlying implementation is derived from https://github.com/dgryski/go-shardedkv.

OTHER RESOURCES

FriendFeed: https://backchannel.org/blog/friendfeed-schemaless-mysql

Pinterest: https://engineering.pinterest.com/blog/sharding-pinterest-how-we-scaled-our-mysql-fleet

Martin Fowler's slides on Schemaless Data Structures: https://martinfowler.com/articles/schemaless/

OTHER OPEN-SOURCE IMPLEMENTATIONS

https://github.com/hoteltonight/shameless - Schemaless in Ruby

THANKS

To Damian Gryski for releasing https://github.com/dgryski/go-shardedkv.

To Booking.com for allowing the release of https://github.com/photosrv/photosrv.

To Uber Technologies for releasing numerous materials on the design and
implementation of Mezzanine, their Schemaless store.

And to many others :)

repository: isgasho/go-schemaless

repo_name: isgasho/go-schemaless


text:
# Digit Classification
Digit Classification drawing tool using tkinter. CNN model trained on MNIST data
## Code of Conduct
Check the Code of conduct [here] (https://github.com/shubhdeeprajput/MNIST_keras/blob/master/CODE_OF_CONDUCT.md)


text:
### Jeet grid package for Meteor (especially for [Scotty](https://github.com/juliancwirko/scotty) boilerplate)

only Stylus, because it is awesome ;) (no Scss)

### Usage

You don't need to install Meteor Stylus package it is absorbed by s-jeet.
If you have it installed just uninstall it and install only s-jeet package.

You can use it without Scotty boilerplate. Just install it:

````meteor add juliancwirko:s-jeet````

and import jeet and rupture .styl files (you can also add nib):

````
@import 'nib'
@import 'jeet'
@import 'rupture'
````
nib works well with Autoprefixer.
Autoprefixer removes unused prefixes generated by nib and nib itself is sometimes helpful with its mixins and features.

See Scotty main .styl file here: [https://github.com/juliancwirko/scotty/blob/master/client/style/style.styl](https://github.com/juliancwirko/scotty/blob/master/client/style/style.styl)

### Blog post about working with Jeet in Meteor:

[Meteor.js without Bootstrap](http://julian.io/meteor-js-without-bootstrap/)

### Awesome deps!

- [Stylus](http://learnboost.github.io/stylus/) 0.49.3
- [nib](http://visionmedia.github.io/nib/) 1.0.4
- [autoprefixer-stylus](https://github.com/jenius/autoprefixer-stylus) 0.4.0
- [Jeet](https://github.com/mojotech/jeet) 6.1.2
- [Rupture](https://github.com/jenius/rupture) 0.6.1

### Autoprefixer

"Parse CSS and add vendor prefixes to rules by Can I Use" - [caniuse.com](http://caniuse.com)

Demo:
````
.test
    transform translateX(20%)
````

Which compiles to:
````
.test {
    -webkit-transform: translateX(20%);
    -ms-transform: translateX(20%);
    transform: translateX(20%);
}
````

Always actual, based on Caniuse.com!

### Changelog

- 0.2.6 Autoprefixer and Rupture versions bump
- 0.2.5 Stylus version bump
- 0.2.4 Autoprefixer version bump
- 0.2.3 Stylus and Nib versions bump
- 0.2.2 Jeet version bump
- 0.2.1 Jeet 6 on board
- 0.2.0 now with Autoprefixer
- 0.1.0 better approach with compile plugin (based on the [Meteor Stylus package](https://github.com/meteor/meteor/tree/devel/packages/stylus))
- 0.0.5 init


text:
# Boletus nigripes With., 1796 SPECIES

#### Status
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Arr. Brit. Pl. (London), Edn 3 4: 316 (1796)

#### Original name
Boletus nigripes With., 1796

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Polyporales/Polyporaceae/Polyporus/Polyporus leptocephalus/ Syn. Boletus nigripes/README.md

repo_name: mdoering/backbone


text:
# Debug-RPG

In this incremental game, you are the lead developer for a tiny and new startup, HipsterTech.
 Officially, while your job is to write code, you only get paid when you debug something. You are paid 2$ per bug solved.
Further, the codebase is absolutely terrible. It's constantly generating bugs, the larger it becomes, the more bugs it generates. The CEO is also constantly watching. If you ever have more than 500 unsolved bugs, you will fired immediately.

Eventually, you decide you've had enough, so you tell Carol in HR that you are quitting in 30 days. You want to make as much cash as possible before leaving, but you aren't motivated to do much for HipsterTech. Maybe you can outsource?

![Action-packed Gameplay!](http://nigelmnz.com/images/debug-rpg.png)

## Installation

    npm install -g debug-rpg

repository: Nigelmnz/debug-rpg

repo_name: Nigelmnz/debug-rpg


text:
# CRUD APP

The following crud-app is able to perform inventory management from a csv file contained in the ./data/ directory.
It is able to:
- List the available items in inventory
- Update the inventory
- Delete items from inventory
- Add items to the inventory
- Everything is saved to the csv file

## Installation

Download the source code:

```shell
git clone https://github.com/MarcBarakat/nyu-python-marcbarkat.git
cd ./nyu-python-marcbarkat/
```

Finally, download the [example `products.csv` file](https://raw.githubusercontent.com/prof-rossetti/nyu-info-2335-70-201706/master/projects/crud-app/products.csv) and save it as `data/products.csv`.

## Usage

```shell
Run the command:
cd app
python products_app.py
Follow the instructions provided by the prompt
```

repository: MarcBarakat/nyu-python-marcbarkat

repo_name: MarcBarakat/nyu-python-marcbarkat


text:
# Examples

## Instructions

1. Build Augury Labs workspace (from the repository root)

- `yarn`
- `yarn build` or `yarn build:watch`

2. Serve specific demo project (from the specific demo directory)

- `yarn`
- `yarn start:augury` or `yarn start`

## Configuration Patterns

### These are not part of the Augury Labs yarn workspace.

This is because, while all Augury Labs packages needs to interoperate and share dependencies, examples
have particular individual needs that may clash with each other and cause various complications.
Some Examples:

- Examples might want to showcase Augury's compatibility with particular versions of Angular.
- Projects built using the standard `@angular/cli` do not play nice with lerna/yarn workspaces.

As such, they have their dependencies installed separately. Dependencies are kept in the demo's own
`node_modules` folder.

### Examples do not declare `@augury/*` packages in their package.json

Since they are installed independently, in order for the examples to use the `@augury/*` modules
directly from `packages/*`, they do not declare these dependencies, as doing so would result in
the `@augury/*` packages being fetched from the npm registry.

To accomplish this, the demo projects rely on the workspace to have been built a priori. The
undeclared packages are then found by the node module resolver in the `node_modules` folder at
the repository root.

This allows us to run watchers on the workspace as well as individual demo projects, triggering
reloads on changes to either workspace or demo code.

repository: doytsujin/augury-labs

repo_name: doytsujin/augury-labs


text:
# Pull Request Branch Name

A github action that retrieves the pull request branch name and sets it in the output for other actions to use.

# Usage

```yaml
- uses: mdecoleman/pr-branch-name2.0.0
  id: vars
  with:
    repo-token: ${{ secrets.GITHUB_TOKEN }}
- run: echo ${{ steps.vars.outputs.branch }}
```

# License

The scripts and documentation in this project are released under the [MIT License](LICENSE)

repository: mdecoleman/pr-branch-name

repo_name: mdecoleman/pr-branch-name


text:
[Home](./index.md) > [@firebase/firestore](./firestore.md) > [/](./firestore_.md) > [addDoc](./firestore_.adddoc.md)

## addDoc() function

Add a new document to specified `CollectionReference` with the given data, assigning it a document ID automatically.

Signature:

```typescript
export declare function addDoc<T>(reference: CollectionReference<T>, data: T): Promise<DocumentReference<T>>;
```

## Parameters

|  Parameter | Type | Description |
|  --- | --- | --- |
|  reference | [CollectionReference](./firestore_.collectionreference.md)<T> | A reference to the collection to add this document to. |
|  data | T | An Object containing the data for the new document. |

Returns:

Promise<[DocumentReference](./firestore_.documentreference.md)<T>>

A Promise resolved with a `DocumentReference` pointing to the newly created document after it has been written to the backend (Note that it won't resolve while you're offline).

repository: ChaseKnowlden/firebase-js-sdk

repo_name: ChaseKnowlden/firebase-js-sdk


text:
# Magic the Gathering for Node.js
Version 0.3.0

## About
MTG Node is a personal experiment with node.js and socket.io. My intention is to create a simple web application enabling you to play Magic the Gathering with friends through a web browser. My goal is not to enforce the rules of the game whatsoever but just to provide a digital interface that could be played the same way you would with real cards.

The application is still pretty ugly and basic but does the job.

## Warning
You should use a modern web browser (Chrome, Firefox and Safari would do the trick - forget right away about Internet Explorer you fool). You should also use a quite modern computer since the game makes use of 3D rotations and since a old computer will not render the game correctly otherwise. I will develop fallbacks later on.

Also, note that this application is not secured in any way and should not be used to launch a server on the
Internet. I recommend its use through LAN only.

## Installation
To start the server on which every one will connect, you need to install [node.js](http://nodejs.org/).

Once this is done, you'll have to install some npm packages.

```
# Use sudo if you run into access rights errors
npm install -g grunt-cli grunt bower
```

Finally clone this repository and install the dependencies likewise.
```
git clone git@github.com:Yomguithereal/mtgnode.git
cd mtgnode
npm install
bower install
```

## Usage
To launch the server. Enter the proper directory and launch the following command.

```
node app
```

By default, the application will be available on `localhost:3000` (url to type in your browser).

To create your first user, connect to the server on your web browser and type the following url.

```
localhost:3000/user/create?username=YOUR-USERNAME
```

Then, access the login page through `localhost:3000` and click on the relevant button to log in.

If you want other people to connect to your server (on a LAN, typically), just give them your local IP address
and let them type it on their browser with port 3000.

```bash
#  Example
<IP_ADDRESS>:3000
```

## Pages
Once connected, you have access to four differents locations.

* A main lobby displaying hosted games and serving as a hub for other pages.
* A deck-builder enabling you to search cards and create decks for your user.
* A game debugging zone (basically, you will play against yourself in a mirrored fashion).

## Game Controls
You are always the bottom player on your screen.

To draw a card, click the deck. Then drag the card where you want.

You also have access to some contextual actions with your right click.

## Database
This application runs without a database server and keeps a json file of its user and decks data. So, if you want to save or transfer the data from one of your instances to another one, the file is located at `database/mtgnode.db`.

## Card display driver
This application does not provide the cards images so it can stay lightweight. In order to display card, it uses what is called a `driver` which will fetch the required images on some remote site hosting them.

### Available drivers
* mtgimage (default)
* magiccards.info
* gatherers

### Changing the driver
To change the display driver, go to `config/mtgnode.js` and change for the wanted driver.

## Thanks
This app runs on [mtgjson](http://mtgjson.com/)'s data.

repository: AngelODeath/mtgnode

repo_name: AngelODeath/mtgnode


text:
# Universal-node

## Build and Run

To install the dependencies run:

```bash
npm install
```

To run the API server do:

```bash
node server.js
```

repository: coletiv/universal-node

repo_name: coletiv/universal-node


text:
# XBOX-Live-Code-Generator
The Xbox Live Gold and Gift Card Code Generator allows you to create unlimited codes. This script is an easy way to find new Xbox card codes online without the hassle of surveys or risk of viruses from downloading a code-gen program. A lot of Xbox Gift Card card codes have already been used so keep on trying.

CLICK HERE >>> https://www.reapinfo.org/xboxlive


text:
# PDF To Text
This depends upon pdftotext (v0.14.5) from  poppler-utils ( http://poppler.freedesktop.org).
Please install poppler-utils before testing.

This has been tested on a Linux box. But you should be able to run it
on a MINGW32 shell/bash Windows environment as well (but you will need
to make adjustments for CRLF on Windows environment when making outputs).

Alternatively, simply echo to terminal.

![demo](Parsed.png "Demo")

repository: pkjmesra/ParserTools

repo_name: pkjmesra/ParserTools


text:
---
title: about
layout: about.njk
---

Hello there and thanks for coming to check out my about page!

I suppose you’re here to read all about the fascinating explanation of who I am, what I do, and why I have a website dedicated to it. Imagine the possibilities! It could be a legend filled with adventure, intrigue, long lost love, and treasure!  Or perhaps the story begins on a dark and stormy night where the first full moon of spring hangs lifeless in the sky, and a newly turned werewolf howls in the far away distance. Or better yet, what if the tale starts just as a young boy receives an unexpected letter? One that promises an introduction to a world filled with magic, wizards, and dangerous dragons?

Unfortunately, the truth is not quite that exciting.

I’m just a full-time developer that works at a large corporation by day, and by night, well... I mostly just sleep. However I do have a keen interest in indie game development and most recently, teaching myself to create vector art.

To that end I’ve set aside some of my spare time in order to teach myself a few tricks to do with game development, creating game art assets, and other indie dev related activities. So the truth is, this site is just a collection of my thoughts and attempts at creating interesting side projects for myself (and celebrations of when I actually manage to complete one).

Enjoy!

![Mini RPG Vector Characters](/images/banner.png "Mini rpg vector characters that I created")


text:
---
id: circuits
title: Circuits
sidebar_label: Circuits
---

An electronic circuit is a closed path or interconnection of different electronic components and two terminals (positive and negative/ground) of a power source.
There should always be an *uninterrupted path between the two ends of the power source*, otherwise the circuit will be incomplete and the components will not work.

![Simple electornic circuit](assets/img/simple-cell-circuit.png)

The Arduino board can also act as a power source and we establish the connections similar to the circuit above by using the **3.3v or 5v as the positive terminal** and the **GND pin as the negative terminal**.

![Simple Arduino circuit](assets/img/simple-arduino-circuit.png)

## Sensors and actuators
Other than the Arduino as a power source, there are a variety of other components we generally use in our circuits. They can broadly be categorized into the following groups:

- **Sensors:** Components that capture some information from the environment and transfer it to the Arduino board in an electronic format.

    **Example:** A button, a temperature sensor, a distance sensor, a humidity sensor

- **Actuators:** Components that display, demonstrate or represent some information from the Arduino on the environment.

    **Example:** LED, motors, buzzer

> Other than *sensors* and *actuators*, the circuits we will build will also include other components like a resistor. These don't fit in either category and are used as part of the circuit to enable both sensors and actuators to work.

## Analog and Digital signals
Electronic signals, the way data is represented electronically, can take two forms:

- **Digital:** Signals that can only have two possible states or values: *High or Low*, *On or Off*, *True or False*. These are also called binary.

- **Analog:** Signals that can have a continuous range of states or values: *0 to 255* and *0 to 1023* which are the ranges we can write to actuators and read from sensors, respectively.

It is important to determine and be mindful of the type of signal in our circuit since both **sensors and actuators can be of both types**. So, when manipulating them (receiving or sending data) we need to do so according to the appropriate signal.

## The breadboard
When creating our circuits, we can simply connect wires between our components or use a device that facilitates the organization of these connections.

Suppose we need to power two LEDs using the Arduino board. To do so, we can simply establish the necessary connections using wires.

![Arduino circuit with two LEDs](assets/img/arduino-two-leds.png)

However, these connections can quickly become difficult to manage and to understand with an increase in the number of components in our circuit. To avoid the confusion or better manage the connections, we can use **breadboards**.

![Arduino powering a breadboard](assets/img/arduino-breadboard-simple.png)

In a breadboard, we have **rows and columns of interconnected points**. In the image above, each point in the last row (in red) will be connected to the 3.3v pin from the Arduino board. Similarly, each point on the row before the last (in black) will be connected to the GND pin.

In the middle of the board, the interconnections change orientation. We have two sets of interconnected points forming distinct columns **a to e** and **f to j**.

This way, to connect our two LEDs, we just need to place them on the breadboard with each terminal in a different column. Next, we connect the column with the negative terminal of the LED to the row connected to GND. We do the same for the positive terminal and repeat for the other LED.

![Arduino powering a breadboard](assets/img/arduino-breadboard-with-leds.png)

> Seems confusing? Don't worry. You will understand it better with practice

repository: ivanruby/ruby-coders

repo_name: ivanruby/ruby-coders


text:
---
layout: default
---

# 1993-09-18 - Check out "EFFector Online 6.1"

## Header Data

From<EMAIL_ADDRESS>(Timothy C. May)

To<EMAIL_ADDRESS>Message Hash: ede1083d7011dbfe44b06a7bf21b7d47b275405b83bd81a9b9c268ac278285fb

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1993-09-18 04:19:33 UTC

Raw Date: Fri, 17 Sep 93 21:19:33 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Timothy C. May)
Date: Fri, 17 Sep 93 21:19:33 PDT
To<EMAIL_ADDRESS>Subject: Check out "EFFector Online 6.1"
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

The latest "EFFector Online," available in the usual places, is
oriented toward crypto, having a lengthy summary of the
Skipjack/Capstone issue (more legalese about escrow than crypto) and a
nice Barlow piece on crypto (updating his piece a year ago in CACM).

Barlow even mentions "unless you're a real cypherpunk," so we're
entering the language.

I'd post the whole thing here, except that it's 1100+ lines.

Definitely check it out!

-Tim

--
..........................................................................
Timothy C. May         | Crypto Anarchy: encryption, digital money,
<EMAIL_ADDRESS>     | anonymous networks, digital pseudonyms, zero
408-688-5409           | knowledge, reputations, information markets,
W.A.S.T.E.: Aptos, CA  | black markets, collapse of governments.
Higher Power: 2^756839 | Public Key: PGP and MailSafe available.
Note: I put time and money into writing this posting. I hope you enjoy it.

{% endraw %}
```

## Thread

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

+ Return to<EMAIL_ADDRESS>(Timothy C. May)](/authors/tcmay_at_netcom_com_timothy_c_may_)"

+ 1993-09-18 (Fri, 17 Sep 93 21:19:33 PDT) - Check out "EFFector Online 6.1" -<EMAIL_ADDRESS>(Timothy C. May)_


text:
### [CVE-2015-9126](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2015-9126)
![](https://img.shields.io/static/v1?label=Product&message=Snapdragon%20Mobile%2C%20Snapdragon%20Wear&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=Integer%20overflow%20when%20processing%201X%20circuit%20service%20message&color=brighgreen)

### Description

In Android before 2018-04-05 or earlier security patch level on Qualcomm Snapdragon Mobile and Snapdragon Wear MDM9607, MDM9635M, MDM9640, MDM9645, MDM9650, MDM9655, MSM8909W, SD 210/SD 212/SD 205, SD 425, SD 430, SD 450, SD 617, SD 625, SD 650/52, SD 808, SD 810, SD 820, SD 835, SD 845, SD 850, and SDX20, possible buffer overflow when processing 1X circuit service message.

### POC

#### Reference
- http://www.securityfocus.com/bid/103671

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

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
Human Activity Recognition Using Smartphones
===================

Repo for Getting and Cleaning Data project on Coursera.

### Project Info

The aim of this project is to collect and clean data from ``UCI HAR Dataset.zip``.

### Before you start...

* Script ``run_analysis.R`` should be placed in the same directory as ``UCI HAR Dataset.zip`` archive containg raw data.
* R library ``reshape2`` should be installed on your machine.

### How script works

1. Merges the training and the test sets to create one data set.
2. Extracts only the measurements on the mean and standard deviation for each measurement.
3. Uses descriptive activity names to name the activities in the data set
4. Appropriately labels the data set with descriptive variable names.
5. From the data set in step 4, creates a second, independent tidy data set with the average of each variable for each activity and each subject.

### Where I can find details?

There are comments in code that describe step by step what script does.

### What can I do?

You can simply run script in R environment by entering command: ``source(run_analysis.R)``.
At the end you will get two data sets in environment:

1. ``final_data`` described by Code Book in ``CodeBook.md`` file.
2. ``tidy_data`` with the same attributes (``CodeBook.md``), but instead of raw values, averages for each activity and each subject are given.

repository: kkutt/datasciencecoursera

repo_name: kkutt/datasciencecoursera


text:
---
title: TranscriptConversationDetailSearchRequest
---
## ININ.PureCloudApi.Model.TranscriptConversationDetailSearchRequest

## Properties

|Name | Type | Description | Notes|
|------------ | ------------- | ------------- | -------------|
| **SortOrder** | **string** | The sort order for results | [optional] |
| **SortBy** | **string** | The field in the resource that you want to sort the results by | [optional] |
| **PageSize** | **int?** | The number of results per page | [optional] |
| **PageNumber** | **int?** | The page of resources you want to retrieve | [optional] |
| **Sort** | [**List<SearchSort>**](SearchSort.html) | Multi-value sort order, list of multiple sort values | [optional] |
| **Types** | **List<string>** | Resource domain type to search | |
| **Query** | [**List<TranscriptConversationDetailSearchCriteria>**](TranscriptConversationDetailSearchCriteria.html) | The search criteria | [optional] |
{: class="table table-striped"}

repository: MyPureCloud/platform-client-sdk-dotnet

gha_language: C#

repo_name: MyPureCloud/platform-client-sdk-dotnet


text:
# Vehicle Detection Project

The goals / steps of this project are the following:

- Perform a Histogram of Oriented Gradients (HOG) feature extraction on a labeled training set of images and train a classifier Linear SVM classifier
- Optionally, you can also apply a color transform and append binned color features, as well as histograms of color, to your HOG feature vector.
- Note: for those first two steps don't forget to normalize your features and randomize a selection for training and testing.
- Implement a sliding-window technique and use your trained classifier to search for vehicles in images.
- Run your pipeline on a video stream (start with the test_video.mp4 and later implement on full project_video.mp4) and create a heat map of recurring detections frame by frame to reject outliers and follow detected vehicles.
- Estimate a bounding box for vehicles detected.

Video link

https://www.youtube.com/watch?v=cX3WrvpVXp0&feature=youtu.be

## Data exploration
You can find the code in the **Block 1** in attached IPython notebook

Before starting the project I did a quick data exploration just to touch with my end the images. It was very useful because I discovered that all images are in PNG format so I have to pay attenction how to read them.

For the rest of the project I'll opening all images with OpenCV library that give me that BGR images with channel color range from 0 ... 255

Here you can find the stats about dataset:

    Your function returned a count of 8792  cars and 8968  non-cars
    of size:  (64, 64, 3)  and data type: uint8

Also all the data are normalized with the range [0 , 1] and the type are converted from uint8 --> float32

Here an example of the dataset:

## Color, spatial and Hog features extraction
**Explain how (and identify where in your code) you extracted HOG features from the training images. Explain how you settled on your final choice of HOG parameters**

This one is a big point, you can find the code in following blocks:
- **Block 2** Color and spacial bin features
- **Block 3** Hog features
- **Block 4** Features extraction and scaler
- **Block 5** Save result for the future usage

### Color and spacial bin  (Block 2)
The tricky part was to choose the right color space and to scale the images before the computation. The images scaled are very important in order to have a better performance on the classification task (variance 1)

I scaled all images in a range [0...1] and change the histogram range from (0,256) -> (0.0,1.0)

With the experience from the lessons, exercises and various trials, I decided to map my images with the color space **YCrCb**

For the spacial bin I choose a resolution 32x32 px because it is good to identify a car at low resolution.

I tried with 16x16 px but seems have a worse performace.

In the end I used the sklearn.StandardScaler() to scale the data in order to normalize the features weight

Here an example of the results:

### Hog features (Block 3)
The HOG detaction it was a very nice technics that use the magnedute of the gradient to discover the real direction of the gradient it self.

The parameters chosen are:

**orient** = 9
**pix_per_cell** = 8
**cell_per_block** = 2
After some trial this parameter are good trade off between performance / number of feauture extracted for the SVM model

I tried also the gamma correction on the hog extraction to avoid false positive in the darker zone on the video but it seems not work well so I decided to remove it and to use some others technics

Here an example of the hog extraction:

### Features extraction and scaler (Block 4)
At the last block you'll find the mesh of the all technics discuss before. Just to recap here all the parameters:

    color_space = 'YCrCb' # Can be RGB, HSV, LUV, HLS, YUV, YCrCb
    orient = 9  # HOG orientations
    pix_per_cell = 8 # HOG pixels per cell
    cell_per_block = 2 # HOG cells per block
    hog_channel = "ALL" # Can be 0, 1, 2, or "ALL"
    spatial_size = (32, 32) # Spatial binning dimensions
    hist_bins = 32    # Number of histogram bins
    hist_range = (0.0, 1.0)  # Range for a normalized img
    spatial_feat = True # Spatial features on or off
    hist_feat = True # Histogram features on or off
    hog_feat = True # HOG features on or off
    gamma_correction = False

And here the result on the entire dataset:

    104.1 Seconds to extract features from hog, spatial and color...
    (17760, 8460)

In the end I saved the result in a pickle file just to re use it

## Linear SVM Classifier
**Describe how (and identify where in your code) you trained a classifier using your selected HOG features (and color features if you used them)**

You'll find the code in the **Block 6**

I choose the Support Vector machine for two reasons:
 - First one it is the first time that I used it :)
 - Second one for this type of problem, dataset dimension and number of features I guess it was an optimal choice

Before run the classifier I did some data preparition:
 - Features extration discussed above (HOG, COLOR, SPATIAL)
 - I scaled all data with the sklearn.StandardScaler() to normalize the weights
 - I create the target variable with 1 for "car" and 0 for "not car"
 - I shuffled the data with sklearn.utils.shuffle to prevent some ordering in the data, in fact we talked about data recorded from a car so a lot of frames should be similar
 - I created the test set with a 20% of data from train set with the sklearn.model_selection.train_test_split
 - Finally I ran my linear SVM classifier with the follow results:

        Using: 9 orientations 8 pixels per cell and 2 cells per block
        Feature vector length: 8460
        6.8 Seconds to train SVC...
        Test Accuracy of SVC =  0.9904

## Sliding Window Search
**Describe how (and identify where in your code) you implemented a sliding window search.

This point is divided into following part:
 - Sliding windows (only graphic)
 - Multiscale sliding windows (with the classifier)
 - Improve performance of the sliding windows (parameters for the pipeline)
 - Heatmap to reduce false positive e multiple detection

### Sliding windows
This was also a tricky part to choose a good parameters for good sliding windows

First I started with a very simple version of the sliding windows with only graphic component, you can find the implementation in the **Block 7**.
After from the suggestion in the lessons I reduce the region of interest of the sliding windows with follow coordinates:

H = (400,680)
W = (0,1280)

### Multiscale sliding windows
After I bind my classifier to sliding windows with a function named:

    search_windows()

You can find the code in the **Block 8**

I used different scale of sliding windows in order to match tree class of objects:
 - NEAR (96,96)
 - MID  (64,64)
 - FAR  (32,32)

Here you can find a simple schema to resume the technics:

Here you can find the result of multi scaled sliding technics:

### Improve performance
Anyway this type of implementation is **inefficient** in fact I have to extract all features (hog, color, spatial). So the best is to extract the features array once and then sub-sampling it in the n-chunk and predict the result on it.

I defined a function named:

    find_cars()

You can find the base code in **Block 9** and in **Block 11** I modify it with new paraments for the pipeline:
 - Sliding windows size - to run the function thoght different size
 - Histogram range size - to pass the correct range for the normalized data

The result of this improvement are fantastic

Normal version **Block 8**

    8.27 Time to extract features...

Improved version:  **Block 9**

    1.04 Time to extract features...  better!

### Heatmap
You'll find the code in the **Block 10**

In order to avoid false positive or multiple detection I used a trick lerned during lessons, to add some "heat" to the detected car windows.
With the *temperature* of the windows we can avoid:
 - to draw multiple detection and draw a single box around
 - false positive detection because we can choose a **thereshold** to decide how many overlapped windows are needed to have a real car detection

After various trials I choose a **Threshold** = 2

Here a result image:

## Try the pipeline on test images
**Show some examples of test images to demonstrate how your pipeline is working. How did you optimize the performance of your classifier?**

You'll find the code in the **Block 11**

Finally I'll tried my entire pipeline on the tests images inside the folder **test_images** attached in the project
The function name is:

    process_image()

Here the result:

I take some time to optimize the pipeline because I have problem with detection and false positive. Following I'll report the step and thinking:
 - First at all I used in the first part of the project the RGB space for the detection but the YCrCb seems better in fact in the I gain 2 % in the test set accurancy
 - For the false positive first I played around with the threshold of the heat map but the winner strategy is to drop the MID slinding windows, so in the final pipeline I used only the FAR and NEAR windows.
 - For the performance in the first version I had a big problem in fact to convert entire video take around 2 hours (on my laptop) so after developing the sub-sampling my life become more easy, take only 12 minutes

## Video implementation
**Provide a link to your final video output. Your pipeline should perform reasonably well on the entire project video (somewhat wobbly or unstable bounding boxes are ok as long as you are identifying the vehicles most of the time with minimal false positives.)**

Here the link to the final video

       https://www.youtube.com/watch?v=cX3WrvpVXp0&feature=youtu.be

You'll find the code in **Block 12**

**Describe how (and identify where in your code) you implemented some kind of filter for false positives and some method for combining overlapping bounding boxes.**

As discussed before to prevent the false positive I used:
- overlapped boxes with *tempature* technics
- drop the intermediate slinding windows

## Discussion
**Discussion includes some consideration of problems/issues faced, what could be improved about their algorithm/pipeline, and what hypothetical cases would cause their pipeline to fail.**

- We can have false positive when we have guardrail plus three (See image below)
- To improve the pipeline we can add some features like more color space or output of SOBEL operator
- The pipeline may fail in the long darker zone because there aren't gamma consideration
- The pipeline consider only the normal car like Berlina or City car so if we found a big truck the detection maybe not work properly. I'll have to try.
- If we use BIRD'S EYE view in this project we can create a dinamyc region of interst for the detection.
- With some prospective trick we can calculate the distance from the others car

## Thanks for reading
### Diego Paladini

repository: diegopaladini/CarND-Vehicle-tracking

repo_name: diegopaladini/CarND-Vehicle-tracking


text:
In the examples so far we have used the `busybox` container image. This image is convenient for demonstrations because it is small, but for real world applications it isn't really suitable.

For real world applications you will want to choose a more complete base image built from one of the more popular Linux distributions.

Popular choices for base images are:

* [Fedora](https://hub.docker.com/_/fedora)
* [CentOS](https://hub.docker.com/_/centos)
* [Debian](https://hub.docker.com/_/debian)
* [Ubuntu](https://hub.docker.com/_/ubuntu)
* [Alpine](https://hub.docker.com/_/alpine)

For the remainder of this workshop we will be using a Fedora base image.

Delete the `greeting` image created from the `busybox` image.

```execute
docker rmi greeting
```

Change location to the `~/greeting-v2` sub directory.

```execute
cd ~/exercises/greeting-v2
```

View the contents of the `Dockerfile` by running:

```execute
cat Dockerfile
```

This time you should see:

```
FROM fedora:30

COPY hello goodbye /

CMD [ "/hello" ]
```

Only the `FROM` instruction has been changed. This time the `fedora:30` base image is referenced instead of the `busybox` image.

Build the image by running:

```execute
docker build -t greeting .
````

The build may take a little bit longer as the `fedora` base image needs to be pulled down and it is somewhat larger than the more minimal `busybox` base image.

When the build has completed check that the container image runs:

```execute
docker run --rm greeting
```

Run the image again but this time create an interactive shell.

```execute
docker run -it --rm greeting /bin/bash
```

From the interactive shell, you can dig around inside the container image. You will see that it contains a complete base Fedora operating system environment.

When you are finished, shutdown the container by running:

```execute
exit
```


text:
# Perfect Deck

This project provides a set of tools for optimizing a [Magic: The Gathering](https://magic.wizards.com) deck.

## Usage

Clone the repository, install Maven, Java, and run:

```bash
mvn clean package -DskipTests
```

Then start the tool by running:

```bash
java -jar target/perfect-deck-1.0.0-SNAPSHOT.jar
```

Once in the tool shell, you can use the following:

```bash
# global help
help

# help on commands
help mulligans
help goldfish

# exit shell
exit
```

You can run the mulligans simulator with a predefined deck and rules with:

```bash
mulligans -D src/main/resources/reanimator-deck2.txt -R src/main/resources/reanimator-rules.txt -I 50000
```

You can run the goldfish simulator with a predefined deck and rules with:

```bash
goldfish -D src/main/resources/reanimator-deck2.txt -P org.mtgpeasant.decks.reanimator.ReanimatorDeckPilot -I 50000
```

You can run and follow 5 goldfish games with a predefined deck and rules with:

```bash
goldfish -D src/main/resources/reanimator-deck2.txt -P org.mtgpeasant.decks.reanimator.ReanimatorDeckPilot -I 5 -n -v
```

## Deck format

This tools supports MWS, Apprentice and [Cockatrice](https://github.com/Cockatrice/Cockatrice/wiki/Deck-List-Import-Formats) deck file formats.

Here is an example of a deck file:

```
// discard
4 Faithless Looting
4 Putrid Imp

// reanimation
4 Animate Dead
4 Exhume

// steaks
4 Hand of Emrakul
2 Greater Sandwurm
1 Pathrazer of Ulamog
4 Ulamog's Crusher

// mana
3 Dark Ritual
4 Lotus Petal
1 Crumbling Vestige
7 Mountain
10 Swamp

// others
3 Dragon Breath
3 Gitaxian Probe
2 Shred Memory

// Sideboard:
SB: 3 Apostle's Blessing
SB: 4 Duress
SB: 2 Electrickery
SB: 2 Mind Rake
SB: 2 Pyroblast
SB: 2 Shenanigans
```

Syntax is quite straightforward:

* an empty line is ignored
* a line starting with `#` or `//` is ignored (_comment_)
* a line starting with `SB: ` is considered as a card from sideboard
* a card can be defined as:
    * `{number} {name}` (ex: `3 Swamp`)
    * `{number}x {name}` (ex: `3x Swamp`)
    * `{name}` (ex: `Swamp`); counts only one card

## Rules definition

Here is an example of rules:

```
// ============
// === Matchers
// ============
<B>: [Swamp] | [Lotus Petal] | [Crumbling Vestige]
<R>: [Mountain] | [Lotus Petal] | [Crumbling Vestige] | [Simian Spirit Guide]
<X>: [Swamp] | [Mountain] | [Lotus Petal] | [Crumbling Vestige] | [Simian Spirit Guide]
<+1>: [Lotus Petal] | [Dark Ritual] | [Simian Spirit Guide]
<creature>: [Hand of Emrakul] | [Greater Sandwurm] | [Pathrazer of Ulamog] | [Ulamog's Crusher]
<rea>: [Exhume] | [Animate Dead] | [Reanimate]
<cantrip>: [Gitaxian Probe]

// ======================
// === Hand keeping rules
// ======================
// I can reanimate turn 1
<<turn 1 imp>>: <B> & [Dark Ritual] & [Putrid Imp] & <creature> & <rea>

// I can reanimate turn 2
<<turn 2 imp>>: <B> & <X> & [Putrid Imp] & <creature> & <rea>
<<turn 2 looting>>: <B> & <R> & [Faithless Looting] & <creature> & <rea>

// I can reanimate turn 2 by discarding a creature on 1st turn with a hand of 7 (OTD)
<<turn 2 OTD>>: <B> & <+1> & <creature> & <rea>

// I can reanimate turn 3 by discarding a creature on 1st turn with a hand of 7 (OTD)
<<turn 3 OTD>>: <B> & <X> & <creature> & <rea>

// one element of the combo is missing but I can play Faithless Looting turn 1
<<looting to find last element>>: <R> & [Faithless Looting] & @atleast(2)( <B> <creature> <rea> )

// I miss 1 mana source but I have a gitaxian probe: if I'm OTD, I have 4 draws to find my 2nd mana source
<<probe to find mana source>>: <X> & <cantrip> & <creature> & <rea>
```

This files defines matchers (pretty similar to [Regular expressions](https://en.wikipedia.org/wiki/Regular_expression)).

* an empty line is ignored
* a line starting with `#` is ignored (_comment_)
* a line starting with `<{name}>: {matcher}` declares a **named** matcher (that can be reused in other matchers or hand keeping rules)
* a line starting with `<<{name}>>: {matcher}` is considered to declare a hand keeping rule

Syntactically, a matcher and a rule are exactly the same. The only difference is that the tool will perform simulations
against **hand keeping rules only**. Atomic matchers are just useful internally to simplify complex rules writing.

A `{matcher}` can be of the following types:

* `[{name}]`: basic card matcher; matches if the card is available in hand
* `<{name}>`: references a declared named matcher or rule
* `({matcher 1} & {matcher 2} & ...)`: compound matcher that matches if **all** matchers match
* `({matcher 1} | {matcher 2} | ...)`: compound matcher that matches if **at least one** matcher matches
* `@atleast({nb})({matcher 1} {matcher 2} ...)`: compound matcher that matches if **at least** `{nb}` of the matchers match

## License

This code is under [Apache-2.0 License](LICENSE.txt)

repository: privarola/perfect-deck

gha_language: Java

repo_name: privarola/perfect-deck


text:
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

#
 **E-Commerce_Backend**

---

---

## **Table Of Contents**

---

1. [Description](#description)
2. [Installation](#installation)
3. [Usage](#usage)
4. [Contributing](#contributing)
5. [Tests](#tests)
6. [Review and Contribute](#github)
---

##
  **Description**

---

This is a backend application to create, read, update, and delete products from a database.  This database holds products in a table along side other tables that organize tags for these products, and even a table of categories which aline with the products as well.

---

##
  **Installation**

---

To install, first download the dependencies with ```npm i``` .  Next run npm run seed in order to seed the database with the test data.  Now start the server with npm start.

---

##
  **Usage**

---

There is no front end built out for this project so to use full c.r.u.d. you will need to use Postman to test the routes.

---

##
  **Contributing**

---

github is listed in the bottom of the readme along with licence information at the top.

---

##
  **Tests**

---

no tests run, there is a short video with a demo and tests included here.
If the embed isnt working here is a link to the demo video.

(https://drive.google.com/file/d/1MK5d-fF256-TndGCEVZylfIwdsZdyh3Q/view)

---

##
  **Github and Email**

---

##
 **Review and contribute here**

### _Github:_ [cmgson/E-Commerce_Backend](https://github.com/cmgson/E-Commerce_Backend)

### _Email:_<EMAIL_ADDRESS>
---


text:
# Dispatcher, the Bot

Hi y'all, I am Dispatcher and I am here to help you out with basic information that will help you during your flight preparation.

## Getting Started

First of all, you need to invite me to you Discord server (must have admin powers for this one). Then, you will only need to give me some commands and I will be at your disposal.

### Prerequisites

- Must have a Discord server or be Admin in one;
- Grant me the permission to join the serve;
- All set!

### Installing

Please, go to: [Discord Application page](https://discordapp.com/oauth2/authorize?client_id=490642659426304011&permissions=8&scope=bot) and authorize me to join you.

You should see me in your server after this step. Look for Dispatcher on the online list.

![Screenshot of Discord](https://i.imgur.com/0SpiYhf.png)

## Running the bot

Here you will find the list of all the commands that you can run with Dispatcher.

```
WIP
```

## Built With

* [Axios](https://github.com/axios/axios) - Promise based HTTP client for the browser and node.js
* [Aviation Weather REST API](https://avwx.rest) - Getting METAR/TAF from airports
* [Discord.js](https://discord.js.org/#/) - discord.js is a powerful node.js module that allows you to interact with the Discord API very easily

## Author

* **Joao Braganca** - [JvBraganca](https://github.com/jvbraganca)

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

repository: jvbraganca/dispatcher-bot

repo_name: jvbraganca/dispatcher-bot


text:
# cspace-ui-plugin-profile-anthro

[![npm package](https://img.shields.io/npm/v/cspace-ui-plugin-profile-anthro.svg)](https://www.npmjs.com/package/cspace-ui-plugin-profile-anthro)
[![continuous integration](https://github.com/collectionspace/cspace-ui-plugin-profile-anthro.js/actions/workflows/ci-js.yml/badge.svg?branch=master&event=push)](https://github.com/collectionspace/cspace-ui-plugin-profile-anthro.js/actions/workflows/ci-js.yml)

Anthropology profile plugin for the CollectionSpace UI.

## Installation

### For developers

Follow these instructions to download and install the source code of the plugin.

Using git:

```
$ git clone https://github.com/collectionspace/cspace-ui-plugin-profile-anthro.js.git
$ cd cspace-ui-plugin-profile-anthro.js
$ npm install
```

To run the cspace-ui application configured with this plugin:

```
$ npm run devserver
```

Then open a browser to http://localhost:8080.

By default, the application served from the dev server will use the CollectionSpace services API
located at http://localhost:8180.

To run the application against CollectionSpace services located on a different host, edit
index.html, and change the `serverUrl` configuration property. For example, to use a server running
on nightly.collectionspace.org, port 8180, use the settings:

```
cspaceUI({
  serverUrl: 'http://nightly.collectionspace.org:8180',
  // ...
});
```


text:
### hyperparameter

Go back to the [[AI Glossary]]

The "knobs" that you tweak during successive runs of training a model. For example, learning rate is a hyperparameter.

Contrast with parameter.

url: https://raw.githubusercontent.com/KGBicheno/KGB_Agora/70ea95c9d38ab2f31abbd510691bb4c050a6cb3b/Artificial Intelligence/Introduction to AI/Week 3 - Introduction/Definitions/Hyperparameter.md


text:
# IoT Dashboard
Dashboard designed in React JS using StyledComponents for IoT applications.

## :computer: Preview

![alt text](/assets/screenshot.png "Dashboard")

## :rocket: Link

Access the dashboard using this [link](https://thales-iot.netlify.app/).

repository: thales-iot/dashboard

repo_name: thales-iot/dashboard


text:
This bot lets you refer to a google sheet and gain an embed in a Discord channel.

[Extended support server](https://discord.gg/83KyR23Jtm)

[Click here to invite me to your server!](https://discord.com/api/oauth2/authorize?client_id=794175938728296469&permissions=67584&scope=bot)

`>prefix [new_prefix] [channel|guild]`
**Default Prefix** `>`

Lets you customize what prefix calls the lookup bot. You can specify it for the entire guild, or the channel the command is used in (default).

`>import [url] [channel|guild]`

Lets you provide the bot with a google sheets url to import into its database. You can specify if it is for the channel the command is used in (default), or if it is the default url for the entire guild.

Feel free to make a copy of [this template](https://docs.google.com/spreadsheets/d/1yletu44kejejacfNpgU4o3PiirpVO4rSCv2W8p22oOc/edit?usp=sharing) to save yourself some time!

You can make a sheet named `discord_config` and customize entities with templates, and colors. The `discord_config` sheet needs a required column named `name`, an optional one named `template`, and an optional one named `color` that will color the embed.

Using a template relays only the name and formatted template to the embed.

If an entity has a column named `image`, it will relay that image to the embed. `thumbnail` will similarly do the same thing. `url` will relay the url to the embed in the url spot. `color` will override the default color from the discord_config.

`>refresh`

Reruns the import command for the channel or guild's associated spreadsheet.

The bot currently expects all tabs in a spreadsheet to have a row of column headers, and a column header of `name`.
The spreadsheet must be publicly visible to work with the bot. There is currently nothing that confirms this visibility in the bot.

`>[entity_type] [entity_name]`

Searches the spreadsheet for the entity type and name. First it looks for the worksheet of the same name as `entity_title` then finds the first row with the name `entity_name`. After that, it uses all the columns in that row to create an embed and send it to the chat.

`entity_name` and `entity_type` do not currently support spaces.

The bot currently expects all tabs in a spreadsheet to have a row of column headers, and a column header of `name`. The bot ignores any tabs that start with an `_`.

repository: kinostl/custbot

repo_name: kinostl/custbot


text:
# Porter's CDN Setup

Porter uses a variety of services to distribute its CLI, mixin and plugin binaries.

## Azure Storage

Binaries are uploaded to [Azure Blob Storage](https://azure.microsoft.com/en-us/services/storage/blobs/) upon relevant events in our GitHub repositories, such as merges to the "main" branch (producing `canary` artifacts) and official releases (producing `latest` and semver-tagged artifacts).

Although it is possible to provide URLs directly to the stored resources, we'd be tightly coupled to a particular storage account and layout, not to mention ungainly URLs.  Therefore, we utilize the services below to achieve flexibility and control over asset links.

## DNS for porter.sh

DNS entries for the `porter.sh` domain are managed via a [Netlify](https://www.netlify.com/) account.  A `cdn` CNAME record exists in this configuration such that `cdn.porter.sh` can represent the hostname for all artifact URLs.

## Azure Front Door

We use [Azure Front Door](https://azure.microsoft.com/en-us/services/frontdoor/) to route incoming requests involving the `https://cdn.porter.sh` hostname to their corresponding assets in storage.  This is where TLS certificate material for our custom domain is managed, along with routing rules corresponding to various classes of assets (mixins, plugins, etc.)

## Azure Web Application Firewall

As a first stop for all incoming traffic, we use [Azure Web Application Firewall](https://docs.microsoft.com/en-us/azure/web-application-firewall/) to filter out requests involving invalid URIs.  This ensures that most of the traffic actually reaching Azure Front Door corresponds to actual assets.

repository: simongdavies/porter

gha_language: Go

repo_name: simongdavies/porter


text:
---
layout: post
title: "Techniques for Automated Machine Learning"
date: 2019-07-21 04:03:36
categories: arXiv_AI
tags: arXiv_AI Review Reinforcement_Learning Optimization Deep_Learning
author: Yi-Wei Chen, Qingquan Song, Xia Hu
mathjax: true
---

* content
{:toc}

##### Abstract
Automated machine learning (AutoML) aims to find optimal machine learning solutions automatically given a machine learning problem. It could release the burden of data scientists from the multifarious manual tuning process and enable the access of domain experts to the off-the-shelf machine learning solutions without extensive experience. In this paper, we review the current developments of AutoML in terms of three categories, automated feature engineering (AutoFE), automated model and hyperparameter learning (AutoMHL), and automated deep learning (AutoDL). State-of-the-art techniques adopted in the three categories are presented, including Bayesian optimization, reinforcement learning, evolutionary algorithm, and gradient-based approaches. We summarize popular AutoML frameworks and conclude with current open challenges of AutoML.

##### Abstract (translated by Google)

##### URL
[http://arxiv.org/abs/1907.08908](http://arxiv.org/abs/1907.08908)

##### PDF
[http://arxiv.org/pdf/1907.08908](http://arxiv.org/pdf/1907.08908)


text:
---
permalink: /docs/installation/
layout: splash
title: "Tutorial: Installation"
date: 2018-06-15 22:31:13 +0200
redirect_from:
  - /theme-setup/
---

# Tutorial: Installation

## Requirements

This library requires Spark 2.0+ (not tested for earlier version). The
library is tested with Scala 2.11 & 2.12. If you want to use
another version, feel free to contact us.

## Including spark-fits in your project

You can link spark-fits to your project (either `spark-shell` or `spark-submit`) by specifying the coordinates:

```bash
# Scala 2.11
toto:~$ spark-submit --packages "com.github.astrolabsoftware:spark-fits_2.11:1.0.0" <...>

# Scala 2.12
toto:~$ spark-submit --packages "com.github.astrolabsoftware:spark-fits_2.12:1.0.0" <...>
```

It might not contain the latest features though (see *Building from source*).
You can check the latest available version at the root of the project (see the maven central badge)

## Building from source

If you want to contribute to the project, or have access to the latest features, you can fork and clone the project, and build it from source.
This library is easily built with SBT (see the `build.sbt` script provided). To
build a JAR file simply run

```bash
toto:~$ sbt ++${SCALA_VERSION} package
```

from the project root. The build configuration includes support for
Scala 2.11. In addition you can build the doc using SBT:

```bash
toto:~$ sbt ++${SCALA_VERSION} doc
toto:~$ open target/scala_${SCALA_VERSION}/api/index.html
```

## Running the test suite

To launch the test suite, just execute:

```bash
toto:~$ sbt ++${SCALA_VERSION} coverage test coverageReport
```

We also provide a script (test.sh) that you can execute. You should get the
result on the screen, plus details of the coverage at
`target/scala_${SCALA_VERSION}/scoverage-report/index.html`.

## Using with spark-shell, pyspark or jupyter notebook

Follow the [dedicated]({{ site.baseurl }}{% link 03_interactive.md %}) tutorial!

## Batch mode and provided examples

Follow the [dedicated]({{ site.baseurl }}{% link 04_batch.md %}) tutorial!

We also include [examples](https://github.com/astrolabsoftware/spark-fits/tree/master/examples) and runners (`run_*.sh`) in the root folder of the repo.
You might have to modify those scripts with your environment.

repository: astrolabsoftware/spark-fits

gha_language: Scala

repo_name: astrolabsoftware/spark-fits


text:
# AppiumReplJava

## Build project with mvn

mvn clean install

Navigate to target folder and execute

java -jar appiumrepljava-1.0-SNAPSHOT.jar

Follow the instructions on the repl console

Start appium server on different terminal

Sample android caps:
```
{
  "deviceName": "android",
  "app": "/Users/XXXX/Documents/workspace/PagePatternAppium/build/wordpress.apk",
  "platformName": "android",
  "newCommandTimeout": "700000",
  "appPackage": "org.wordpress.android",
  "appActivity": "org.wordpress.android.ui.WPLaunchActivity"
}
```
Sample iOS caps:
```
{
"platformName":"ios"
"deviceName":"iPhone 6"
"platformVersion":"8.3"
"app":"/Users/XXXXX/git/VodQa_MobileAutomationWorkShop/VodQA_WorkShop/build/ios.app"
}
```

repository: iamPHD/AppiumReplJava

repo_name: iamPHD/AppiumReplJava