text:
# Real-Time Web @cmda-minor-web · 2019-2020

During this course you will learn how to build a **meaningful** real-time application. You will learn techniques to setup an open connection between the client and the server. This will enable you to send data in real-time both ways, at the same time.

## Goals
- _Deal with real-time complexity_
- _Handle real-time client-server interaction_
- _Handle real-time data management_
- _Handle multi-user support_

[Rubric][rubric]

## Program

### Week 1
Goal: Build and deploy a unique barebone real-time app

[Exercises](https://github.com/cmda-minor-web/real-time-web-1920/blob/master/course/week-1.md)
[Slides](https://docs.google.com/presentation/d/1Q_2EpEnW53G-DiRYtfp1VRYHdLJYJ7bjoLxAWhGbW-0/edit?usp=sharing)

#### Monday 6 April
9.30 - Laurens, Guido
* start with barebone product (chat)
* start with main product if you are skilled enough

11.00 - Robin, Maikel
* Start working on your product
Ask Robin and Maikel for help if needed

16.00 - Guido, Laurens, Maikel, Robin
Stand-up

#### Tuesday 7 April
9.30 - Guido, Laurens
* API creating explained
* What is socket.io?
* Data management
* Questions

10.30 - Robin, Maikel
* Continue working on product
Ask Robin and Maikel for help if needed

16.00 - Guido, Laurens, Maikel, Robin
Stand-up

#### Friday 10 April (goede vrijdag)
10.30 - Guido, Laurens
* Check up talk, (10 min)

### Week 2
Goal: Store, manipulate and share data between server-client

[Exercises](https://github.com/cmda-minor-web/real-time-web-1920/blob/master/course/week-2.md)
[Slides](https://docs.google.com/presentation/d/1p_P-rciWJQ2BMgveOYNTcwEJHh1yxB1-HqKZhiD8kkk/edit?usp=sharing)

#### Tuesday 14 April
9.30 - Laurens, Guido
* Feedback of last week
* How does the rubric work?
* Create a data flow in couples
* Data management explained
* Questions

11:00 - Robin, Maikel
* Continue working on product
Ask Robin and Maikel for help if needed

16:00 - Laurens, Guido, Maikel Robin
Stand-up

#### Friday 17 April
9.30 - Guido

* Live coding
* Data management explained
* Socket broadcast functions

10.30 - Laurens, Guido
* Progress talk, (10 min)

### Week 3
Goal: Handle data sharing and multi-user support

[Exercises](https://github.com/cmda-minor-web/real-time-web-1920/blob/master/course/week-3.md)
[Slides](https://drive.google.com/open?id=19GE6r1jha3gX-uhQI0NIv09klTT45BihuELqZSEa2_8)

#### Monday 20 April
9.30 - Guido
* Storing data
* Caching
* Security (OAuth)
* Sessions

#### Tuesday 21 April
9.30 - Laurens, Guido
* Events
* Peer reviews

### Week 4

#### Wednesday 6 May
* Privacy discussion

Robin, Maikel
* Optional code review

#### Thursday 7 May
• assessments

#### Friday 8 May
• assessments

## Schema

| Laurens  |   |             |          |   |           |          |   |          |
|----------|---|-------------|----------|---|-----------|----------|---|----------|
| Groep 1  | 1 | Joan        | Groep 2  | 1 | Nick      | Groep 3  | 1 | Bas      |
|          | 2 | Leroy       |          | 2 | Marjolein |          | 2 | Wouter   |
|          | 3 | Reinier     |          | 3 | Michel    |          | 3 | Nathan   |
|          | 4 | Stefan      |          | 4 | Sjors     |          | 4 | Mohammad |
|          |   |             |          |   |           |          |   |          |
| Guido    |   |             |          |   |           |          |   |          |
| Groep 4  | 1 | Kris        | Groep 5  | 1 | Lennart   | Groep 6  | 1 | Tabish   |
|          | 2 | Daniel      |          | 2 | Mees      |          | 2 | Robin F  |
|          | 3 | Marissa     |          | 3 | Thijs S   |          | 3 | Max      |
|          | 4 | Roy         |          | 4 | Kevin C   |          | 4 | Robert   |
|          |   |             |          |   |           |          |   |          |
| Maikel   |   |             |          |   |           |          |   |          |
| Groep 7  | 1 | Deanna      | Groep 8  | 1 | Heralt    | Groep 9  | 1 | Marten   |
|          | 2 | Lars        |          | 2 | Stan      |          | 2 | Damian   |
|          | 3 | Ramon       |          | 3 | Kyle      |          | 3 | Manouk   |
|          | 4 | Jennifer    |          | 4 | Gijs      |          | 4 | Coen     |
|          |   |             |          |   |           |          |   |          |
| Robin    |   |             |          |   |           |          |   |          |
| Groep 10 | 1 | Tomas       | Groep 11 | 1 | Giovanni  | Groep 12 | 1 | May      |
|          | 2 | Peppe-Quint |          | 2 | Wessel    |          | 2 | Lien     |
|          | 3 | Kevin K     |          | 3 | Tim       |          | 3 | Rick     |
|          | 4 | Simone      |          | 4 | Randy     |          | 4 | Monika   |
|          |   |             |          |   |           |          |   |          |

<!-- Add a link to your live demo in Github Pages 🌐-->

<!-- ☝ replace this description with a description of your own work -->

<!-- replace the code in the /docs folder with your own, so you can showcase your work with GitHub Pages 🌍 -->

<!-- Add a nice image here at the end of the week, showing off your shiny frontend 📸 -->

<!-- Maybe a table of contents here? 📚 -->

<!-- How about a section that describes how to install this project? 🤓 -->

<!-- ...but how does one use this project? What are its features 🤔 -->

<!-- What external data source is featured in your project and what are its properties 🌠 -->

<!-- This would be a good place for your data life cycle ♻-->

<!-- Maybe a checklist of done stuff and stuff still on your wishlist? ✅ -->

<!-- How about a license here? 📜  -->

[rubric]: https://docs.google.com/spreadsheets/d/e/2PACX-1vSd1I4ma8R5mtVMyrbp6PA2qEInWiOialK9Fr2orD3afUBqOyvTg_JaQZ6-P4YGURI-eA7PoHT8TRge/pubhtml


text:
A library of arbitrarily large integers
=======================================

As you know, C provides fixed-size integers.  You can use a variety
of sizes (e.g., `short`, `int`, `long`), but you don't necessarily
know how big those sizes are.  There are usually some associated
libraries that let you choose the sizes of your integers (e.g.,
`int8`, `int16`, `int32`, `int64`), but those are still fixed size.
C's `double` and `long double` type provide a wider range of values,
but sacrifice accuracy.

In contrast, some other languages, like Scheme, provide arbitrarily
large integers.  Why?  Because programmers can't always predict
what size they will need.  (There is an apocraphal story of a Scheme
program for automated trading doing really well on a day that the
market changed significantly because it was the only one that
adjusted on the fly.)

This library provides ...

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: C

license_type: permissive


text:
---
layout: layout.hbs
---

# Features

## Feature: Add epoch

``` gherkin
Feature: Add to timeline
  Epochs and events should be described by a single phrase
  Scenes must have a question and answer
  Only 6 epochs may exist
  Epochs may have 0+ scenes
  Scenes may have 0+ events

  Scenario: Create epoch
    Given there is not an epoch already created in the space
    And I have clicked on the epoch box
    And I have entered a phrase in the text box
    And I have chosen a color for the epoch
    When I press the submit button
    Then the epoch is added to the database
    And the box displays the phrase and color

  Scenario: Create event
    Given there is an epoch in the epoch space
    And I have clicked on the 'Add Event' button for that epoch
    And I have added a phrase to the text box
    And I have chosen a color for the event
    When I press the submit button
    Then the description of the event is added as a child to the epoch in the database
    And an event box appears under the epoch
    And the box contains the event description and color

  Scenario: Create scene question
    Given that I have clicked on the event box
    And I have added a question to the initial form
    When I click on the 'Begin Scene' button
    Then the 'Edit Scene' box appears
    And the first player is asked to create a character

  Scenario: Create character for scene
    Given that a scene has been started
    And it is my turn
    And I have added a character name to the 'Name' box
    And I have added a description to the 'Description' box
    When I click on the 'Add character' button
    Then the character is added to the list
    And the next player is given the lens

  Scenario: Roleplay scene
    Given that a scene has been started
    And everyone has a character
    And it is my turn
    When I type my actions into the scene roleplay box
    Then everyone can see what I type

  Scenario: Answer scene question
    Given that a scene roleplay has finished
    And I am the user who created the scene
    And I have written a short phrase to answer the initial question in the text box
    When I click 'Submit'
    Then the answer is added to the database
    And the scene dialogue closes
    And the lens passes to the next player

```

## Feature: Begin game/end game

``` gherkin
Feature: Begin game/end game
  Users should be able to join an existing game
  Users should be able to start their own game
  Users should be able to leave the game

  Scenario: Join existing game with password
    Given that I have entered my name in the 'Name' field
    And I have entered a valid password in the password field
    When I click on the 'Begin Game' button
    Then I am taken to the initial screen of the game
    And my name is added to the list of players in that game

  Scenario: Attempt to join existing game without password
    Given that I have entered my name in the 'Name' field
    And I have entered an incorrect password in the password field
    When I click on the 'Begin Game' button
    Then an error message appears to tell me that no such game exists
    And I am asked if I want to start a new game or re-enter the password

  Scenario: Create game
    Given that I have entered my name in the 'Name' field
    When I click on the 'Create Game' button
    Then a message appears to tell me what the password for my game is
    And there is a button to begin the game
    And the game is added to the list of active games

  Scenario: Leave game
    Given that I am part of a current game
    When I click the 'Leave Game' button
    Then I am removed from the list of players for that game
    And the page returns to the intro page

```

repository: EmberRandall/book

repo_name: EmberRandall/book


text:
# Structural parsing #

Goal: correctly break input into tokens and hierarchical forms, but don't
worry about verifying that tokens have the correctly internal structure.
Just make sure the right amount of text is matched for each token.

# Token parsing #

Goal: determine the internal structure of the number, ident,
char, string, and regex tokens

# Static token constraints #

### String ###

octal escape

 - value must be less than `8r400`

### Regex ###

 - uses `java.util.regex.Pattern.compile` for definition of accepted input

### Ratio ###

denominator != 0

### Integer ###

custom base: radix must be <= 36, digits must be within range of radix

### Float ###

big decimal overflow/underflow: exponent limited to Java Integer range:
see http://docs.oracle.com/javase/7/docs/api/java/math/BigDecimal.html#BigDecimal(java.lang.String)

### Symbol ###

### Keyword, auto-keyword ###

### Reserved ###

### Char ###

octal escape

 - <= 255

unicode escape: value can *not* be between u+D800 and u+DFFF

    \uDFFF              ; -> error
    (first "\uDFFF")    ; -> not an error -- it's okay in strings

# Further constraints #

## Var ##

 - must be a symbol -- [ref](http://clojure.org/special_forms#var)

## Metadata ##

in `^ {} {}`:

 - metadata must be symbol, keyword, auto keyword, string, or map
 - value must implement IMeta

invalid:

 - `^ 3 {}`
 - `^ {} 3`

doesn't implement IMeta:

 - number
 - string
 - reserved
 - regex
 - char

does implement IMeta:

 - symbol
 - set
 - function
 - table
 - list
 - vector

# Linting #

## Definitely ##

 - repeated name usage in function or let parameter lists

        (defn f [x x] x)
        (fn [x x] x)
        (let [x 1 x 2] x)

 - no nested shorthand functions

        #(map #(+ 1 %1) %1)

 - `%...` variables names inside shorthand functions

 - eval reader -- `#=xyz` -- permits only a symbol or a non-empty list

## Not sure ##

  - variables defined, used, used but not defined, defined but not used
  - formatting -- consistent indentation
  - ?shadowing?
  - known special forms and functions: correct syntax used
  - maximum number of function parameters, maximum nesting level
  - operator position is treated specially with respect to special forms:

        (let [def 1] def)        ; ==> okay

        ((fn [def] (def 2 3)) +) ; ==> error

## Potential warnings ##

Breaking these isn't illegal, but may indicate an error even if the syntax is okay,
or may cause an undetected error which confusingly doesn't show up until later:

  - string, regex, number, ident, char followed by whitespace

repository: mattfenwick/clolint-js

repo_name: mattfenwick/clolint-js


text:
# fitness_tracker

## Installation
Simply visit [fitness_tracker](https://aqueous-lowlands-63673.herokuapp.com/?id=5e514089c41d790017f05df4) and get started.

## Purpose
This application helps the user log their workout based on type of workout, Resistance or Cardio. The user can then input the workout details and have them logged into the fitness tracker. The ui then displays the user’s fitness statistic

## Functionality
Using MongoDB, and mLab, the user's input is logged and tracked so they can view their workout statistics over time.

## Contributing Resources
* Other Contributors: UNCC Tas and Boot Camp Students

## Links
* Deployed Application:  https://aqueous-lowlands-63673.herokuapp.com/?id=5e514089c41d790017f05df4

* Github Repo:  https://github.com/cmarshman/fitness_tracker

## Images

![Opening-Page](public/images/opening-page.png)
![Add-Workout](public/images/add-workout.png)
![Logged-Stats](public/images/logged-stats.png)

## License
MIT License

Copyright (c) [2020] [Cory_Marshman]

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

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

gha_language: JavaScript

gha_license_id: MIT


text:
---
hrs_structure:
  division: '2'
  volume: '10'
  title: '25'
  chapter: '441'
  section: 441-42
type: hrs_section
tags:
  - Business
menu:
  hrs:
    identifier: HRS_0441-0042
    parent: HRS0441
    name: 441-42 Trustee's compensation
weight: 28275
title: Trustee's compensation
full_title: 441-42 Trustee's compensation
---
**§441-42 Trustee's compensation.** The trustee shall be entitled to the same compensation as provided by law for trust companies in the management of fiduciary accounts, but in no event shall any sum in excess of five per cent of the income derived from the fund or pre-need trust in any year be paid as compensation to the trustee for its services in the administration of the fund or trust. [L 1967, c 199, pt of §1; [HRS §441-42](/title-25/chapter-441/section-441-42/); am L 1985, c 101, §22]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
> https://leetcode.com/problems/flower-planting-with-no-adjacent/

You have n gardens, labeled from 1 to n, and an array paths where paths[i] = [x^i^, y^i^] describes a bidirectional path between garden x^i^ to garden y^i^. In each garden, you want to plant one of 4 types of flowers.

All gardens have **at most 3** paths coming into or leaving it.

Your task is to choose a flower type for each garden such that, for any two gardens connected by a path, they have different types of flowers.

Return **any** such a choice as an array answer, where answer[i] is the type of flower planted in the (i+1)th garden. The flower types are denoted 1, 2, 3, or 4. It is guaranteed an answer exists.

## Example 1:

```X
Input: n = 3, paths = [[1,2],[2,3],[3,1]]
Output: [1,2,3]
Explanation:
Gardens 1 and 2 have different types.
Gardens 2 and 3 have different types.
Gardens 3 and 1 have different types.
Hence, [1,2,3] is a valid answer. Other valid answers include [1,2,4], [1,4,2], and [3,2,1].
```

## Example 2:

```
Input: n = 4, paths = [[1,2],[3,4]]
Output: [1,2,1,2]
```

## Example 3:

```
Input: n = 4, paths = [[1,2],[2,3],[3,4],[4,1],[1,3],[2,4]]
Output: [1,2,3,4]
```

## Constraints:

- `1 <= n <= 104`
- `0 <= paths.length <= 2 \* 104`
- `paths[i].length == 2`
- 1 <= x^i^, y^i^ <= n
- x^i^ != y^i^
- Every garden has **at most 3** paths coming into or leaving it.

license: Unlicense

repository: atelier-algorithm/weekly-algos

branch_name: refs/heads/main

gha_license_id: Unlicense

repo_name: atelier-algorithm/weekly-algos


text:
# ALREC
Lottery Picker - Uses Higher Math (Fourier Analysis,etc) To Pick and Wheel Numbers

This project is starting life as my Jenkins/Docker/Android CI and Testing Project.
As time goes by, the project will consist of both an android tree and a Java desktop tree.

Some initial code will likely be Octave, MatLab, Maxima, and SciLab Code.
There may be other scripts as well, since I now use Sage with all of it's component CAS elements.

For now, this is a small 5 and 10 week frequency counting/compare app that downloads a file
from a url to update the list of numbers. Later I'll use OLG's xml page and an xml pull parser
to update the app. A working sync adapter and parser are available from another app but time flys...

As the CI project progresses some of the gotchas and  steps will be posted on the wiki for this repository.

repository: doswellf/alrec

repo_name: doswellf/alrec


text:
# Roles Based Access Control

## Understanding Subjects, Resources and Operations

![Subjects Resources Operations](./images/RBAC-items.jpeg)

## Understanding Roles

![RBAC Roles](./images/RBAC-Role.jpeg)

## Understanding Role Bindings

![RBAC RoleBindings](./images/RBAC-RoleBinding.jpeg)

## Configuring Role and RoleBinding Manifests

![Configuring Role and RoleBinding Manifests](./images/roles-bindings.png)

## Review the Certificate Creation Process

![Certificate Creation Process](./images/rbac-process.jpeg)

## Creating the Certificates

**Step 1:** Declare the name of the Kubernetes user we're going to support by setting it to an environment
variable

`export MAGIC_USER=dicktracy`

**Step 2:** Generate the public ssl key

`openssl genrsa -out ${MAGIC_USER}.key 2048`

**Step 3:** Make a `private key` and a `certificate signing request` that applies to the user we created and the groups, `devs`
and `tech-leads`

`openssl req -new -key ${MAGIC_USER}.key -out ${MAGIC_USER}.csr -subj "/CN=${MAGIC_USER}/O=devs/O=tech-leads"`

------

Now we'll put on an "System Adminstrator Hat" and create the `public certificate`

------

**Step 4:** Create the public certificate

`openssl x509 -req -in ${MAGIC_USER}.csr -CA ~/.minikube/ca.crt -CAkey ~/.minikube/ca.key -CAcreateserial -out ~/.minikube/${MAGIC_USER}.crt -days 500`

**Step 5:** Set the certificate as credential a key, replace `myname` with your home directory name

`kubectl config set-credentials ${MAGIC_USER}@minikube --client-certificate=/home/nyname/.minikube/${MAGIC_USER}.crt --client-key=${MAGIC_USER}.key --embed-certs=true`

**Step 6:** Create a new Kubernetes context

`kubectl config set-context ${MAGIC_USER}@minikube --cluster=minikube --user=${MAGIC_USER}@minikube`

## Create the Required Namespaces

**Step 1:** Execute the manifest that contains declarations for the namespaces, `devs` and `test`

`kubectl apply -f namespaces.yaml`

 **Step 2:** Check that the namespaces have been created

 `kubectl get ns`

## Create Roles and RoleBindings for a User

**Step 1:** Create the `pod-access` role that allows only using `kubectl get`

`kubectl apply -f pod-reader.yaml`

**Step 2:** Create the rolebinding, `user-pod-reader` that allows the user, `dicktracy` to assume the
role, `pod-reader`.

`kubectl apply -f user-pod-reader-rolebinding.yaml`

## Verifying RBAC

**Step 1:**  Move into the context that supports `dicktracy`

`kubectl config use-context ${MAGIC_USER}@minikube`

**Step 2:** Try to create a pod in the namespace, `test`

`kubectl run --generator=run-pod/v1 pinger-dk --image=reselbob/pinger:v2.1 -n test`

You'll fail.

**Step 3:** You'll fail, so let's go back to being the admin in `minikube`.

 `kubectl config use-context minikube`

**Step 4:** Try to create a pod again

`kubectl run --generator=run-pod/v1 pinger-dk --image=reselbob/pinger:v2.1 -n test`

**Step 5:** As the `minikube` admin, take a look to see that the pod is in the namespace, `test`

`kubectl get pods -n test`

**Step 6:** Now, switch back to be `dicktracy`

`kubectl config use-context ${MAGIC_USER}@minikube`

**Step 7:** As the user `dicktracy`, take a look to see that the pod is in the
namespace, `test`

`kubectl get pods -n test`

**Step 8:** Try to get a list of pods in all the namespaces

`kubectl get pods --all-namespaces`

**SUPRISE! You can't do it. Dick Tracy does not have permission to list pods at the cluster scope.**

## Create Roles and RoleBindings for Groups

**Step 1:** Switch back to being the admin in `minikube`.

 `kubectl config use-context minikube

**Step 2:** Create the `simple-pod-developer` role that allows creating and listing pods

`kubectl apply -f simple-dev-role.yaml`

**Step 3:** Create the rolebinding, `simple-pod-developers` that allows the group, `devs` to assume the
role, `simple-pod-developer`.

`kubectl apply -f simple-dev-rolebinding.yaml`

**Step 4:** Now, switch back to be `dicktracy`

`kubectl config use-context ${MAGIC_USER}@minikube`

Run this command:

`kubectl run --generator=run-pod/v1 pinger-dk --image=reselbob/pinger:v2.1 -n devs`


text:
restify
=======

>An Erlang Library For REST Interfaces

[![Build Status](https://travis-ci.org/tjchaplin/restify.png?branch=master)](https://travis-ci.org/tjchaplin/restify)

# Get Going

```erlang
%Specify routes:[{Method:atom(),Route:string(),Handler:fun()}]
Routes=[{'GET',
		 "/awesomeoRoute",
		 fun(Req) -> Req:ok({"plain/text","Received Request to awesomeoRoute"}) end
		}].

%Specify mochiweb server options
Options = [{ip,"<IP_ADDRESS>"},{port,8888}].

%Start Listening and responding to requests
restify_server:start(Options,Routes).
```

# Purpose

A library to make the creation of rest interfaces easier in erlang.  To allow developers to focus on the implementation of the API, not the details of setting up the webserver.

# Building

##Windows

1. Get the [restify](https://github.com/tjchaplin/restify) source from GitHub
2. Open the command prompt
3. Cd into the directory
4. Ensure [rebar](https://github.com/rebar/rebar) is in your Path so that you can execute commands
5. Execute rebar command

```
$ rebar get-deps compile
```

##Unix

1. Get the [restify](https://github.com/tjchaplin/restify) source from GitHub
2. Cd into the directory
3. Make it

```
$ make
```

# Usages

To use this library in an OTP application it needs to be added to the supervision tree.  The best way to do this is as follows

* Add As Rebar Dependency

In your **rebar.config** file:

```
{deps, [{restify,
			".*",
			{git, "https://github.com/tjchaplin/restify.git"}}
]}.
```

* Create a module that will setup the rest server

rest_server.erl
```erlang
-module(rest_server).

-export ([start_link/0]).

start_link() ->
	%Specify routes:[{Method:atom(),Route:string(),Handler:fun()}]
	Routes=[{'GET',
			 "/awesomeoRoute",
			 fun(Req) -> Req:ok({"plain/text","Received Request to awesomeoRoute"}) end
			}],

	%Specify mochiweb server options
	Options = [{ip,"<IP_ADDRESS>"},{port,8888}],

	%Start Listening for requests.
	%Note: this will return a PID for the supervisior to monitor
	restify_server:start(Options,Routes).
```

* Add the *rest_server* as a worker to the appliction supervisor

myapp_sup.erl

```erlang
-module(myapp_sup).
-behaviour(supervisor).
-export([start_link/0]).
-export([init/1]).

start_link() ->
    supervisor:start_link({local, ?MODULE}, ?MODULE, []).

init([]) ->
    RestServer={rest_server,
    				{rest_server, start_link, []},
    				permanent, 5000, worker, dynamic},
	SupervisorChildren =[RestServer],
    {ok, { {one_for_one, 5, 10}, SupervisorChildren} }.
```

* Now when your OTP application is started the rest_server(restify) will be monitored

# Dependencies

The library uses [mochiweb](https://github.com/mochi/mochiweb) as its lightweight webserver.

repository: tjchaplin/restify

repo_name: tjchaplin/restify


text:
A **computer vision library for omnidirectional(360°) cameras**. This package is divided into two parts:
* **Basic functions** for inter-conversion of different types of mappings associated with omni directional cameras, virtual reality and 360° videos, like cubemap, spherical projections, perspective projection and equirectangular projection.
* **Software applications** like **360° video viewer**, **fisheye image generator** with variable intrinsic properties, GUI to determine **fisheye camera paraeters**.

##### Objectives of the OmniCV library
This library has been developed with the following obectives:
* **Quick and easy** to use API to encourage and enhance the research in areas using omni directional cameras.
* To support **real time** applications.
* Provide extensions in **python** as well as **C++** as they are the languages used by researchers.
* Provide **ROS package** to use in robotics research.

[*Click here to know more about omni directional cameras*](omnidir-cameras.md)

## Highlights
* Detailed [examples](Examples/README.md) and [application notes](applications/README.md) to understand how to use the package.
* Installation guide for
  * Python version
  * C++ version
  * ROS packge
* [**Detailed documentation**](https://kaustubh-sadekar.github.io/OmniCV-Lib/).

## Output Gallery

Some interesting 360° video effects

Arround the world effect             |  Hollow world effect
:-------------------------:|:-------------------------:
![](gifs/eqrect2FisheyeFet2.gif)  |  ![](gifs/eqrect2FisheyeFet1.gif)

Creating custom fisheye images

Equirect2Fisheye             |  Custom image using GUI
:-------------------------:|:-------------------------:
![](gifs/eqrect2fisheye.gif)  |  ![](gifs/eqrect2Fisheye.gif)

GUI to determine fisheye camera parameters

GUI to get radius        |  GUI to get fisheye params
:-------------------------:|:-------------------------:
![](gifs/getRadius.gif)  |  ![](gifs/FisheyeParams.gif)

Horizontal and vertical orientation viewing mode support

360° viewer mode 1        |  360° viewer mode 2
:-------------------------:|:-------------------------:
![](gifs/360Viewer2.gif)  |  ![](gifs/360Viewer3.gif)

## Index to theory, examples and application notes
* [Types of omni directional cameras](omnidir-cameras.md)
* [Examples](Examples/README.md)
  * Equirectangular image to fisheye or pinhole camera image.
  * Fisheye image to equirectangular image.
  * Equirectangular image to cube map image (horizontal or dice format)
  * Convert cube map image (horizontal or dice format) to equirectangular image.
  * Convert equirectangular image to perspective image with desired field of view and viewing angles.
  * Convert cubemap image to perspective image with desired field of view and viewing angles.
* [Application notes](applications/README.md)
  * GUI to control focus, distortion and view orientation to generate different kinds of distortion effects and get images with different properties.
  * GUI to determine fisheye camera parameters like aperture and fisheye radius for further conversions.
  * GUI to view an equirectangular image in 360° format with control trackbars to change FOV(Field Of View) and viewing angles. (You can download any 360° video **from youtube** and view it using the GUI and **enjoy the 360° viewing experience**).

## Installation guide
A custom make file has been written which provides quick and easy options for installing and testing the library.

```shell

    git clone https://github.com/kaustubh-sadekar/OmniCV-Lib
    cd OmniCV-Lib/omnicv/
    # To build c++ as well as python files
    make build-all
    # To build only python files
    make build-python
    # To build only c++ files
    make build-cpp
 ```

Installing OmniCV in a virtual environment using pipenv. Pipfile and Pipfile.lock files have been provided. Copy both the files to the present working directory. Then simply run the following commands to setup OmniCV in a local environment.

```shell

    pipenv install
    pipenv shell
```

## Running Tests

```shell

    cd OmniCV-Lib/omnicv/
    # To test only python extension of the project
    make test-py
    # To test only c++ extension of the project
    make test-cpp
    # To test python as well as c++ extension of the project
    make test-all
```

##### ROS Nodes
To build the ROS nodes follow these steps:
* Create a folder named omnicv in your ros workspace where you have your other ros packages

```shell
roscd src/
mkdir omnicv
```
* Add the contents present inside ros_files folder to the omnicv folder created in the previous step.
* Build the workspace.

```shell
cp OmniCV/ros_files/ [PATH TO ROS WORKSPACE]/src/omnicv/
roscd
catkin_make
```
```

repository: mfkiwl/OmniCV-Lib

repo_name: mfkiwl/OmniCV-Lib


text:
---
title: How to Remove the Vertical Grid Scrollbar
description: How to hide the vertical scrollbar of the Grid and TreeList with CSS, if scrolling is not used.
type: how-to
page_title: How to Hide the Vertical Grid Scrollbar
slug: grid-hide-vertical-scrollbar
position:
tags: grid, treelist, scroll, scrollbar, scrolling
ticketid: 1541813, 1541728
res_type: kb
---

## Environment

			Product
			Grid for Blazor, TreeList for Blazor

## Description

How do I hide the Grid vertical scrollbar? I don't set the Grid `Height`, so I prefer to completely remove the disabled vertical scrollbar with CSS.

## Solution

There are three required CSS styles to disable vertical scrolling and ensure proper cell alignment between the header, data and footer area of the Grid/TreeList:

1. Remove the vertical scrollbar, which is visible by default.
1. Remove the empty space above and below the vertical scrollbar. These empty spaces are in the header and footer area.
1. Remove two right borders in the header and footer area, which are no longer necessary. These borders normally separate the empty spaces from the header and footer cells.

### Notes

* Do not set the component `Height` attribute. Do not apply `height` style to the component `<div>`. Doing so may show the vertical scrollbar back and cause misalignment between the header cells and data cells.
* Versions **2.26** and older require `!important` for the `padding` style.
* The exact same classes and styles will work for the **TreeList** as well.

>caption Hide the Grid/TreeList vertical scrollbar

````CSHTML
@* Hide the vertical scrollbar of the Grid *@

<TelerikGrid Data="@GridData" Class="grid-no-scroll">
    <GridColumns>
        <GridColumn Field=@nameof(Product.Name) Title="Product Name">
            <FooterTemplate>
                footer
            </FooterTemplate>
        </GridColumn>
    </GridColumns>
</TelerikGrid>

<style>
    .grid-no-scroll .k-grid-content {
        overflow-y: auto;
    }

    .grid-no-scroll .k-grid-header,
    .grid-no-scroll .k-grid-footer {
        padding-right: 0; /* version 2.26 and older requires !important here */
    }

    .grid-no-scroll .k-grid-header-wrap,
    .grid-no-scroll .k-grid-footer-wrap {
        border-right-width: 0;
    }

</style>

@code {
    List<Product> GridData { get; set; }

    protected override void OnInitialized()
    {
        GridData = new List<Product>();
        for (int i = 1; i <= 5; i++)
        {

            GridData.Add(new Product()
            {
                ID = i,
                Name = "Product " + i.ToString()
            });
        }
    }

    public class Product
    {
        public int ID { get; set; }
        public string Name { get; set; }
    }
}
````

repository: telerik/blazor-docs

repo_name: telerik/blazor-docs


text:
# How to use the compute engine to create your own API for the flask server

## Cloud Console
1. Go to [Google Cloud Platform Console](https://console.cloud.google.com/)
2. Go to Compute Engine and choose VM instances.
3. Create your own instance by clicking on `+ create instance` button.
4. Configure the settings, default is OK.
5. Go to the instances tab, you will see your new instance appear.
6. Make an SSH connection by hovering to the most - right column and click on `ssh`

## Linux Terminal
Now that you are connected with the server, perform the following commands below to install the correct dependencies:
1. `sudo apt-get update`
2. `sudo apt-get install libgl1-mesa-glx libegl1-mesa libxrandr2 libxrandr2 libxss1 libxcursor1 libxcomposite1 libasound2 libxi6 libxtst6`
3. `sudo apt-get install wget`
4. `wget https://repo.anaconda.com/archive/Anaconda3-2021.05-Linux-x86_64.sh`
5. `bash Anaconda3-2021.05-Linux-x86_64.sh`
6. `rm Anaconda3-2021.05-Linux-x86_64.sh`
7. `source .bashrc`
8. To verify installation, run these commands
* `python --version`
*  `which python`
*  `which conda`
*  `conda list conda$`
9. Now create a new directory, you can name it anything, e.g `mkdir my_project` and then go to the directory by using `cd my_project`
10. Now its time to run Jupyterlab by running these commands
* `jupyter lab --ip <IP_ADDRESS> --port 8888 --no-browser`
*  After running that, you will be able to receive a token to open Jupyterlab on your browser. Now you can go to browser and use this URL:
`<External IP>:8888/lab?token=<token>`

You can find the External IP on your Google Cloud Console in the VM Instances of the Compute Engine

## Jupyterlab
1. After successfully opening the Jupyterlab on your browser, move either `classification.py` or `ner.py` to the Jupyterlab directory.
2. Now rename the Python script as `app.py`
3. Move the `requirements.txt` also to the Jupyterlab directory.
4. Open the Jupyterlab terminal by clicking on `File -> New Terminal`
5. Run this command: `pip install requirements.txt`
6. Then you're set! Now run the server by doing this command `flask run -h <IP_ADDRESS>`

## You need to repeat again to create another virtual machine to run the other model. Repeat from the top!

## Extras
- To stop the flask server click `CTRL + C`
- To use the API run with this URL on the browser:
`<External IP>:5000/?input=<YOUR_INPUT_TO_THE_MODEL_HERE>`
- To give your more context, these are example JSON outputs with the input: `Kebakaran di Jakarta`

For the Named Entity Recognition, you will get this JSON output:
```
{
"DESCRIPTION": [
"kebakaran"
],
"LOCATION": [
"jakarta"
],
"PERSON": [],
"WEAPON": []
}
```

For the Classification Model, you will get this JSON output:
```
{
"label": "Fire"
}
```

repository: briancatraguna/SixPackTeamApp

gha_language: Kotlin

repo_name: briancatraguna/SixPackTeamApp


text:
# nyc-subway-finder
Text-based interface for finding real-time data about New York City subway train
arrivals on the 1, 2, 3, 4, 5, 6, and S lines

# Requirements:
cImage module

google.transit module - can be installed using pip:

> pip install --upgrade gtfs-realtime-bindings

# Description:
Subway Finder is a program that takes real-time information from the Metro
Transit Authority (MTA) of New York City and converts it into a user-friendly
format. The MTA uses the GTFS-realtime protocol to transmit data on train times
and stops. To launch the program, run the nyc-subway-finder.py file.

# Features:
- Allows you to search in real time for New York City subway trains on the
1, 2, 3, 4, 5, 6, and S lines
- Simple prompts to help the user find which train they are looking for
- When the user input matches more than one station, the user can pick from a
list of possible stations
- Provides the option to search again or quit after each search

# Detailed program breakdown:
Our program is based on the Model-View-Controller system. Our model, contained
mostly in train.py, is the back end of our program, and contains a class called
Train that has all the properties we want the "trains" to have: direction,
stops, and arrival time. Each of those abilites is contained inside a method of
the class.

Our controller is the function that calls our other programs and holds the
information until it is displayed to the user. The controller is the program
that accesses the real-time feed, passes it onto the model, and coordinates the
exchange of information between the model and the view program. The controller
contains the functions that allow user input to be non-specific, using regular
expression methods to match user inputs to official station names.

Finally, our view is the interfaces.py program that puts all of the information
out there for the user to see. It consists of a TextInterface class, which
contains code that aks for and receives user input and passes it back to the
controller. This class also has methods for  asking the user whether they want
to do another search or exit the program.

repository: simonbilskyrollins/nyc-subway-finder

repo_name: simonbilskyrollins/nyc-subway-finder


text:
# Kataw parser test case

> Auto-generated tests to validate error recovery
>

### Cases

> `````js
> super = x
> `````

> `````js
> y = super
> `````

> `````js
> f(super)
> `````

> `````js
> new super
> `````

> `````js
> new super()
> `````

> `````js
> new super(12, 45)
> `````

> `````js
> new new super
> `````

> `````js
> new new super()
> `````

> `````js
> new new super()()
> `````

### Templates

#### class-method body

`````js
class C { m() { #; }
`````

#### class-method body assignment

`````js
class C { m() { k = #; } }
`````

#### class-method

`````js
class C { m() { foo(#); } }
`````

license: ISC

repository: axefrog/kataw

repo_name: axefrog/kataw


text:
# svcNALshow

Prints out the position and type of all NAL units in a raw h.264/SVC bitstream.

## Requirements

 - premake4
 - g++
 - libboost-system-dev
 - libboost-program-options-dev

## Compile

Use premake4 to create the makefiles and compile the application:

```bash
git clone git@github.com:csieber/svcNALshow.git
cd svcNALshow/

premake4 gmake
```

Build the application:

```bash
cd build/
make
```

## Usage

```
Options:
  --help                Help
  -F [ --file ] arg     SVC stream
```

Check the vagrant [here](vagrant/README.md) for an example how to use the application.

## Citing

Please cite the following publication if you use this application:

```
@inproceedings{sieber2013implementation,
  title={Implementation and User-centric Comparison of a Novel Adaptation Logic for DASH with SVC},
  author={Sieber, Christian and Ho{\ss}feld, Tobias and Zinner, Thomas and Tran-Gia, Phuoc and Timmerer, Christian},
  booktitle={2013 IFIP/IEEE International Symposium on Integrated Network Management (IM 2013)},
  pages={1318--1323},
  year={2013},
  organization={IEEE}
}
```

repository: csieber/svcNALshow

repo_name: csieber/svcNALshow


text:
# [Job Search PWA - Built with Stencil](https://jobsearch.pwatoday.com/)

There comes a time in every software engineers life when he has to go out looking for jobs. When this happened to me, I created this app to open source my job search so my friends and family can stay up to date on the process, and provide me with valuable feedback on jobs that I have applied / interviewed for.

If you want to use this tool, feel free to fork this repo. I have created a sample database file (sample-jobs.json) that you can import into your firebase instance.

Hopefully this will bring you as much luck as it has brought me!

![Job Search Preview](job-search-preview.png?raw=true "Job Search")

## Ionic PWA Tookit

I used the Ionic PWA Toolkit as a starter for this project. The Ionic PWA Toolkit is the recommended way to build production ready Progressive Web Apps (PWAs) with Ionic. This toolkit gets you started with [Stencil](https://stenciljs.com/) and an early release of Ionic (4.x+). This combination of tools gives you the ability to build a fast, efficient PWA with zero config needed and best practices out of the box.

## Features Included in the Job Search PWA

- Stencil for easily building and loading standardized Web Components
- Ionic Framework
- Firebase Hosting
- Firebase Authentication
- [Firebase Realtime Database Integration](https://www.pwatoday.com/post/integrating-firebase-with-a-stencil-built-pwa)
- [Global Sass Variables](https://www.pwatoday.com/post/global-css-sass-variables-with-stencil)
- Push Notifications setup (In Development)
- Showing a toast when a new version of the PWA is available (In Development)
- Unit Tests
- Everything needed for an add to homescreen PWA (service worker, web manifest and iOS meta tags)

## Getting Started

fork this repo, downlod it locally and run:

```bash
npm install
npm start
```

You will need to add your own firebase configuration file. the file should be ```src/helpers/config.ts``` and look something like this.

```js
export var firebaseConfig = {
    apiKey: <api-key>,
    authDomain: <auth-domain>,
    databaseURL: <database-url>,
    projectId: <project-id>,
    storageBucket: <storage-bucket>,
    messagingSenderId: <messaging-sender-id>
}
```

## Production

To build your PWA for production, run:

```bash
npm run build
```
The build is preconfigured for --es5 options, to enable support for iOS 10.x devices

## Service Workers

For info on how Service Workers work in Stencil check out the stencil service workers blog. In ours, we have service workers doing push notifications in the background. [Service Worker docs](https://stenciljs.com/docs/service-workers).

## Unit Tests

To run the unit tests once, run:

```
npm test
```

To run the unit tests and watch for file changes during development, run:

```
npm run test.watch
```

repository: sghome/job-search

repo_name: sghome/job-search


text:
# CONTRIBUTING

Thank you for your interest in contributing to the Factom Asset Tokens Daemon
project. There is [plenty of
work](https://github.com/Factom-Asset-Tokens/fatd/projects/2) to do and we
welcome your contribution.

### Ways to contribute
- Open an issue:
    - Report a bug
    - Request a feature
    - Suggesting an improvement
- Debug an open issue:
    - Reproduce and confirm it
    - Identify the issue in code
    - Suggest a fix
- Open a pull request:
    - Implement a bug fix
    - Implement an approved feature,
    - Update documentation or code not conforming to [policy](./CODE_POLICY.md)

## Getting started

Aside from getting your build environment set up, which is described in the
[README](./README.md), please take the time to read through this and the [Code
Policy](./CODE_POLICY.md). These documents are going to evolve over time, so
please take special note of any changes to these files when you pull.

Check out the [project
board](https://github.com/Factom-Asset-Tokens/fatd/projects/2) to get an idea
about what is currently being worked on.

## Reporting Issues

**!!!DO NOT REPORT SECURITY ISSUES IN THE PUBLIC ISSUE TRACKER!!!**

Security related issues should be emailed directly to
[adam@canonical-ledgers.com](mailto:adam@canonical-ledgers.com).

**!!!DO NOT REPORT SECURITY ISSUES IN THE PUBLIC ISSUE TRACKER!!!**

When reporting issues, please try to use the templates provided by the GitHub
Issue tracker, which can also be found in `.github/ISSUE_TEMPLATE/` on the
`master` branch.

Please do not use the issue tracker for support. Use the [Factom Asset Tokens
Discord](https://discord.gg/wGqT8VB) server instead. We'll be happy to help.

## Opening Pull Requests

**!!!DO NOT DISCLOSE SECURITY ISSUES OR SUBMIT PATCHES HERE!!!**

Please do not submit PRs that address unpublished security issues. If the issue
is security related, copy this template and email the issue or patch to
[adam@canonical-ledgers.com](mailto:adam@canonical-ledgers.com).

**!!!DO NOT DISCLOSE SECURITY ISSUES OR SUBMIT PATCHES HERE!!!**

It is highly recommended to wait for confirmation from @AdamSLevy before
proceeding with a major code change. However, if the change is small and is
clearly in line with an open issue or corrects something, by all means please
go ahead and open a PR.

repository: kompendium-ano/fatd

gha_language: Go

repo_name: kompendium-ano/fatd


text:
# csc290-connectfour
by Simran, Andi, Onimisi, Maria and James

## Game Description

This game is a python implementation of the popular board game
connect four.

Connect four is a 2 player game, and the rules are very straight forward. You each take turns placing disks and whoever gets 4 disks either vertically, diagonally, or horizontally wins. Keep in mind that whenever a player places a disk, the disk is placed at the lowest possible row, and the disks stack on top of eachother.

## Installation guide
***
  ### Software needed:
  * [Pygame](https://www.pygame.org/download.shtml)
  * A Python IDE of your choice, we recommend [PyCharm](https://www.jetbrains.com/pycharm/download/?utm_source=product&utm_medium=link&utm_campaign=PC&utm_content=2018.3#section=windows)

  ### How to install
   * Git clone the repo into a local directory of your choice.
   * Open PyCharm and create a project from the directory you cloned into.
   * Start the game by running `menu.py` in the IDE.

## Game controls

When you start the game, click the play button to advance to the game screen. There are two players, so you each take turns placing one disk, player 1 is red, and player 2 is yellow. Place disks by clicking on the column you want to drop the disk in.

## How to Play:
* The first turn is taken by Player 1.
* Keep taking turns and placing disks until a winner is declared.
* A winner is declared if a player has four consecutive disks in
either of the directions vertical, horizontal, or diagonal.

## Game Screenshots
***

## Documentation
***
Documentation about our project and directory structure can be found at the [wiki page](https://github.com/AFYY/csc290-connectfour/wiki) for our repo.

## Contributions
***
  ### Onimisi Ayira, github username: ayira-onimisi:
   * I implemented about 95% of `board_view.py` with the gameplay, I wasn't responsible for adding a check for a winning move. I also
    implemented about 50% the class `board.py`, all the methods apart from the `check_winner()` method and the functions that  `check_winner()` uses. I also created `colors.py`. In the readme I wrote the Installation guide, the Documentation page([the wiki page](https://github.com/AFYY/csc290-connectfour/wiki)), I added screenshots to the readme and I also selected the license used for our project.

  ### Simranjeet Bilkhu, GitHub username: simran-sb:
   * I wrote the check_winner, check_verticle, check_horizontal methods in board.py. I also wrote the menu.py module, win_screen.py mode and the button.py module and edited the others so that they work together properly.
     In the readme, I wrote the game controls and description sections

  ### Maria Abdul Karim, GitHub username: mariaakarim:
  * I implemented method check diagonal in board.py. I also fixed few bugs in the existing code in board.py, board_view.py, and menu.py.
  I was also responsible to completing the docstrings in all of our game files. Moreover, I also wrote the "How to Play" section in README.md.

  ### Andi Fan, Github username: Andi Fan
  * Added circles to the gamescreen in boardview.

## License

This project was built by Simran, Andi, Onimisi, Maria and James under the MIT license.

The License can be found [here](license.txt)

repository: mariaakarim/Connect-Four

repo_name: mariaakarim/Connect-Four


text:
---
layout: default
title:  Android configuration
permalink: /android-config/
parent: Configure
nav_order: 4
---

# Android configuration

## Configure Keystore

Create a `signing-android.properties` file in `.config` and fulfill with your company signing data.

```properties
storeFile=/path/to/your/keystore/keystore.jks
keyAlias=my_alias
keyAliasPassword=XXXXXXXXXX
storePassword=XXXXXXXXX
```

## Create a firebase Android app

In the firebase settings, create a new Android application with `com.leroymerlin.pandalab` as package name and download the `google-services.json`.

![image](../assets/firebase/firebase-config-web-create.png)

Set the path to the `google-services.json` in `.config/config.json` with the key **googlePlayServicesPath**.

```json
{
  "googlePlayServicesPath":".config/google-services.json"
}
```

repository: adeo/panda-lab

gha_language: TypeScript

repo_name: adeo/panda-lab


text:
# Filter9

```text
material-4/Image/Filter9
```

```text
include('material-4/Image/Filter9')
```

| Illustration | Filter9 |
| :---: | :---: |
| ![illustration for Illustration](../../material-4/Image/Filter9.png) | ![illustration for Filter9](../../material-4/Image/Filter9.Local.png) |

## Sprites
The item provides the following sriptes:

- `<$Filter9Xs>`
- `<$Filter9Sm>`
- `<$Filter9Md>`
- `<$Filter9Lg>`

## Filter9

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

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

' loads the package bootstrap
include('material-4/bootstrap')

' loads the Item which embeds the element Filter9
include('material-4/Image/Filter9')

' renders the element
Filter9('Filter9', 'Filter9', 'an optional tech label', 'an optional description')
@enduml
```

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

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

' loads the package bootstrap
include('material-4/bootstrap')

' loads the Item which embeds the element Filter9
include('material-4/Image/Filter9')

' renders the element
Filter9('Filter9', 'Filter9', 'an optional tech label', 'an optional description')
@enduml
```

repository: tmorin/plantuml-libs

repo_name: tmorin/plantuml-libs


text:
---
title: "A write up of the W3C TPAC 2019"
date: 2019-10-28
author: Rachel Andrew
categories:
  - W3C
---
This year the W3C Technical Plenary and Advisory Committee Meeting (TPAC) was held in Fukuoka, Japan. As part of my work representing Fronteers in the W3C I attended the two Advisory Committee (AC) meetings held at TPAC, along with the CSS Working Group meeting days. In this post I will highlight some of the things that might be of interest to Fronteers members. I hope this gives a good overview of the breadth of things discussed.

This year TPAC was held in Fukuoka, Japan. As part of my work representing Fronteers in the W3C I attended the two Advisory Committee (AC) meetings held at TPAC, along with the CSS Working Group meeting days. In this post I will highlight some of the things that might be of interest to Fronteers members. I hope this goves a good overview of the breadth of things discussed.

Two public documents that give an great overview of the recent work of the W3C are the [W3C Factsheet](https://www.w3.org/2019/09/factsheet.html), and the [W3C Strategic Highlights](https://www.w3.org/2019/09/w3c-highlights/) document. These documents give a good picture of what is happening at the W3C in a straightforward manner.

In addition to these documents a financial report was shared which is _member-only_. If any Fronteers member wishes to view any member-only document, or have further details of anything discussed here, please let me know, I'll be happy to share those with you.

The Tuesday meeting began with an update from the CEO Jeff Jaffe. This introduced some of the topics that would be discussed later in the meeting and reminded us of the fact that in May this year the W3C and the WHATWG succesfully completed the negotiation of a Memorandum of Understanding rooted in the mutual belief that that having two distinct specifications claiming to be normative is generally harmful for the Web community.

We then moved onto discussion of the W3C becoming a legal entity, and the various legal and administrative matters that this would entail.

The second half of the meeting moved into shorter updates about various areas of the W3C and lightning talks.

# Update on Web of Things

There are two groups dealing with WoT in the W3C, an [Interest Group](https://www.w3.org/WoT/IG/) which is open to anyone, and a [Working Group](https://www.w3.org/WoT/WG/) open only to W3C Members and Invited Experts, in common with all Working Groups.

In June this year a WoT workshop was held in Munich, and the [Architecture](https://www.w3.org/TR/2019/CR-wot-architecture-20190516/) and [Thing Description](https://www.w3.org/TR/2019/CR-wot-thing-description-20190516/) were published as Candidate Recommendations on 16 May 2019.

# Globalization and Inclusion

In this session we heard about the work to make the W3C more inclusive and global. This work falls into categories of Diversity and Inclusion, Facilitation and Culture, and Tools. There are efforts in place across these areas which are owned by members of the Advisory Board (AB).

The area of Diversity and Inclusion achieved the sponsorship of seven people from diverse backgrounds to come to TPAC this year. Funds for this were raised from 10 W3C members and one individual sponsor.

As a CSS Working Group member I experience one change made in the area of Facilitation and Culture in that one CSS Working Group meeting per month has moved to a timezone more friendly to people in the Asia and Pacific region. This aims to include more people in the meetings than would otherwise be able to participate.

In the area of Tools, one area under development is the facilitation of translation for meetings to enable people to participate in their own language, rather than needing to be an English speaker. Other subjects in this area are the use of online tools such as Google Docs which are not accessible in all areas of the world, this is a good reminder to those of us in countries where we can easily access these things that not everyone can.

# Code of Ethics and Professional Conduct

As a follow-on from the discussion on globalization and inclusion was a session on the Code of Ethics and Professional Conduct (CEPC) being discussed by the Positive Work Environment Community Group.

The group are working to update the CEPC following feedback and referencing other best practices for Codes of Conduct. In addition to producing a document, the group is helping to train people as ombuds who will help in situations where the code has been broken, or when someone has a concern.

The group are keen to receive feedback on the draft, which you can find [here](https://w3c.github.io/PWETF/).

# Incubation

Fronteers members might be familiar with the Web Incubation Community Group (WICG), which is a place where new web platform ideas can be proposed and discussed outside of a Working Group. In general new platform features should start life here, so this is likely to be the initial place to post if you have an idea which isn't an edit to an existing spec for example.

Chris Wilson gave a presentation about the [WICG](https://github.com/wicg/) and other places for incubation, and explained the incubation process for new web platform ideas.

1. here’s a problem space to solve” → (public!)
2. WICG post →
3. Work with community, prototype solutions →
4. "Minimum Viable Design" - get web developers to try it out
5. Community-building, iteration, graduation, →
6. WG (horizontal review, iterate, lock down, implementations) →
7. W3C Recommendation

As anyone who has seen one of my talks knows, I am very keen to encourage web designers and developers to get involved with web platform features. So do take a look at [the threads in the WICG discussions](https://discourse.wicg.io/), and see if there are features you have use cases for.

# Lightning talks

The session finished with the following lightning talks, designed to highlight different areas of work across the W3C:

* SVG - Amelia Bellamy-Rhoyds, Invited Expert
* VR and AR on the Web - Ada Rose Cannon, Samsung
* Web beyond the browser - Hyojin Song, LG
* Second Screen on the Web - Mark Foltz, Google

# Continuous Standards Development

THe first session of the Thursday meeting was on proposed updates to the process by which specifications on the Recommendation track are worked on, in particular what happens when specifcations in Candidate Recommendation (CR) status need an edit. The current workflow is cumbersome and often means that the spec in CR is quite outdated when compared to the latest Editor's Draft.

There are a range of proposals to help improve this process, which should ultimately help in making the published documents more useful to refer to.

# Mini App standardization and next steps

While we in the West tend to hear a lot about PWAs, in China hybrid web and mobile apps are popular, these use web technologies within a native wrapper. The [Chinese Web Interest Group](https://www.w3.org/2018/chinese-web-ig/) are working to standarize this technology. This is a fairly new group, and this session was an update on their activities.

# PWAs and Project Fugu

The aim of Project Fugu is:

> "Enable web apps to do anything native apps can, by exposing the capabilities of native platforms to the web platform, while maintaining user security, privacy, trust, and other core tenets of the web."

There are various APIs being developed to meet this aim, their progress can be tracked on the [Capabilities Landing Page](https://developers.google.com/web/updates/capabilities) or the [Fugu API Tracker](bit.ly/fugu-api-tracker ).

How the world pays online - an update on the Web Payments Community Group

The [Web Payments Community Group](https://www.w3.org/community/webpayments/) work on a family of specifications. You might be familiar with the [Payment Request API](https://www.w3.org/TR/payment-request/), which is the most mature of these specifications and is an API to allow a payment request to be invoked in the browser.

The Group are working on moving Payment Request to Proposed Recommendation, and trying to encourage wider use of these specifications.

# CSS Working Group Meetings

We also had two days of CSS Working Group meetings at TPAC, although I had to miss some of the Tuesday afternoon to attend the AC meeting.

A highlight for me was to get a resolution on an outstanding issue meaning that I could publish a new Working Draft of the [Multiple-column Layout specification](https://www.w3.org/TR/css-multicol-1/). This WD includes the edits I made after the specification reading workshop that Fronteers members took part in earlier this year.

In addition it was resolved that the [CSS Writing Modes](https://www.w3.org/TR/css-writing-modes-3/) specification could go to Proposed Recommendation (PR) Status. This is the last step before it becomes a W3C Recommendation. It was especially nice that it went to PR while we were in Japan, given that Writing Modes is key to being able to set vertical modes such as Japanese.

If any Fronteers member wants to know more about any of the above, please get in touch with me, It's part of my role to pass on any relevant information, or put you in touch with the right people to help.

Members of Fronteers are encouraged to seek access to a members-only channel on our Slack space. If you haven't joined it yet, you can [sign up for our Slack automatically](https://fronteers-slack.herokuapp.com/). To join the members-only channel, send a private message to Anneke Sinnema (@anneke).

repository: fronteers/website

gha_language: Liquid

repo_name: fronteers/website


text:
Pebble MTG Life Counter
===================
A Magic: The Gathering life counter and round timer for the Pebble smart watch. Tracks two players life totals, the last two life total changes per player, and round time.

![alt tag](https://raw.github.com/crankeye/pebble-mtg-life-counter/master/screenshots/usage.png)
How to Use
----------
**Up**: Me +/- 1

**Up Long**: Me +/- 5

**Select**: Toggle +/-

**Select Long**: Reset Life Counter / Reset Round Timer

**Down**: You +/- 1

**Down Long**: You +/- 5

Change Log
----------
### v1.1
- Added round timer.
- Increased history update delay to 2 seconds
- Fixed bug when pressing select during the reset prompt.

### v1.0
- Released

Donate
------
**Bitcoin**: `1Exq7Tf6djX5Mkn1APnExbFoAV2n5h2p7A`
**Litecoin**: `LggR9F33ZYhEp2KXmC43rpVmBZZXNfAN3C`

License
-------
This project is licensed under the MIT license. Please see the LICENSE file for more details.

repository: crankeye/pebble-mtg-life-counter

repo_name: crankeye/pebble-mtg-life-counter


text:
# Settings

Settings is simply a place to put data about the script.

## `description`

If present will be displayed before the script runs.

## `when`

Will be interpolated before the script runs and if `false` the script will not run

repository: jlyonsmith/shovel

repo_name: jlyonsmith/shovel


text:
# risk_dash [Dash](https://plot.ly/dash/) application documentation

## Overview

The included [Dash][dash] application is purely to demonstrate a use case for the risk_dash package. There is minimal css provided through using [Bootstrap](https://getbootstrap.com/docs/4.0/getting-started/introduction/)

## Getting Started


text:
# Encrypted Root Device Volumes & Snapshots (Lab)

#### What is an AMI
##### Amazon Machine Image

#### Snapshots of Root Device Volumes
* To create a snapshot of Amazon EBS volumes that serve as root devices, you should stop the instance before taking the snapshot.

#### Volumes versus Snapshots - Security
* Snapshots of encrypted volumes are encrypted automatically
* Volumes restored from encrypted snapshots are encrypted automatically
* You can share snapshots, but only if they are **unencrypted**.
    * These snapshots can be shared with other AWS accounts made public.

repository: enterloper/aws-certified-solutions

repo_name: enterloper/aws-certified-solutions


text:
---
layout: post
title: Voice VLAN
category: Layer 2
tag: knowledge
---
On Cisco switch’s, you can configure a particular VLAN known as the voice VLAN. It is a special VLAN that Cisco developed that is meant to lead from the switch the the 3 port switch on the back of an IP Phone. The traffic from the computer will be sent untagged, regardless of whether the access VLAN for that port is the default VLAN. All traffic from the phone gets tagged to its assigned voice VLAN. It behaves in many way like a trunk, but from an operational perspective it is still a port in access mode. The configuration looks like this:
```
SW1(config)# interface GigabitEthernet0/1
SW1(config-if)# switchport mode access
SW1(config-if)# switchport access vlan 100
SW1(config-if)# switchport voice vlan 101
```
If you you show commands, you will not find the interface to be in trunk operational mode, but remember it works like a rudimentary trunk.

As soon as you apply the `switchport voice vlan` command, Portfast is enabled on the interface, though you will not see it in the running-config.


text:
---
id: 2508
title: Whoever said life is about adventure and risk-taking never had typhoid shots
date: 2010-03-15T19:10:53+00:00
author: Vicki
layout: post
guid: https://vkblog.github.io/?p=2508
permalink: /2010/03/whoever-said-life-is-about-adventure-and-risk-taking-never-had-typhoid-shots/
categories:
  - Uncategorized
tags:
  - cheap
  - death
  - family
  - home
  - Indiatrip
  - Mr. B
  - shanking
---
_UPDATED:  [Just found out our malaria pills](http://tenfoldindia.blogspot.com/2007/01/shots-vaccines-and-violent-nightmares.html) can give violent nightmares!  Wheee!_

Following on the heels of [our previous India excitement](https://vkblog.github.io/2010/03/08/a-conversation-with-my-parents-about-india/), Mr. B and I took a trip to the [doctor’s office](http://travelclinicmd.com/) on Friday to get prepped for our trip to India with [some shots](http://www.youtube.com/watch?v=XNtTEibFvlQ).  The visit started out fairly innocently; over the phone, they’d told me that we would need probably two shots and a malaria pill.  We waited in a very cool, adventure-themed room while the doctor came:

[](https://raw.githubusercontent.com/vkblog/vkblog.github.io/master/public/img/2010/03/504529610_1775222331_0.jpeg.jpg)

which had the following image in it:

[](https://raw.githubusercontent.com/vkblog/vkblog.github.io/master/public/img/2010/03/travdiah.jpg)

And, hooray!  Because India is on the V.I.P. list.  Although, to be fair, so are Mexico and Israel, and the most I’ve ever been in Mexico is almost mugged and the most dangerous situation in Israel was that time an Israeli Arab almost shanked me and Mr. B but really he just wanted to know if we had cigarettes.   So, no biggie so far.

Then, we go into the actual shot room with the doctor and he says, “So, India?”  and starts going through the list of things we would need, which was only slightly shorter than David Copperfield.  “You’ll need at least five shots,” as we looked at him sorting through his papers.  We looked at each other.  Five shots?

“Is there a way we can have less,” I asked the doctor, concerned that the shots would cost as much as a downpayment on a nice condo.   He looked at me sternly.

“Our insurance doesn’t cover these, right,” I gulped, already feeling the effects of wallet atrophy.

“No.  They look at it as elective as plastic surgery-you’re doing it to yourself.”

We sure are,  I thought, and looked at Mr. B, who had originally wanted to go to Japan before I told him about the Wonders of Mughal Culture, not to mention how much cheaper it was to fly to Delhi than to Tokyo.  Mr. B’s expression seemed to say, _We wouldn’t have needed shots for Japan.  They would take shots to inoculate themselves against us._

“Tetanus,” the doctor said.

“I think I had that shot in elementary school,” I said, relieved not only because I wouldn’t have to pay.  Mr. B frowned.  “I might have had that.  But I was in Russia until I was nine.”  I looked at him.  “I’m pretty sure you had the tetanus shot.”

The doctor moved on.  “Measles/mumps/rubella.”   I was relieved.  “I think I had that, too!”  Mr. B scratched his head.  “He had it too,” I told the doctor, vouching on the Soviet healthcare system, which in retrospect was a pretty bad idea considering that it was under the same system that I’d had my tonsils taken out sans anesthesia.

“Chicken pox?” The doctor asked.

“Had it,” we both said, deflating in relief.   Three shots avoided and we weren’t even onto the serious stuff like yellow fever yet.

“Now, you’ll need malaria pills.  There’s two options.  One you take every day during your trip and one you take every week and a couple weeks afterward. And each pill is $10. ”  Mr. B and I looked at each other. I was feeling feverish already. “Unless you’re going to mountainous areas like Kashmir or the Himalayas,” the doctor ventured.

“We’re going to Kashmir,”  Mr. B and I said.   “I hear it’s beautiful during the ceasefires,” I prompted.  But the doctor was not convinced.   “Which of the two pills do you want,” he asked.

“What’s the difference,”  I asked.

“Well, the ones you take weekly, they’re cheaper, but they’ve been known to make some people on anti-depressants go crazy and be committed to mental institutions.”

“Oh, that’s it?”  I sighed with relief.  “We don’t take anti-depressants.  We’ll take the crazy pills.  They’re cheaper, right?”  The doctor frowned at me and dug through his folders and handed me this article.  “Lots of times you don’t see these stories, but [look what happened to this woman that got malaria in Ghana](http://archives.chicagotribune.com/2010/feb/04/health/ct-met-0204-dubsky-malaria-20100203).  Legs came right off.”

“Let’s go to Japan,” I mouthed to Mr. B in Russian.  There’s nothing really interesting in India that I can’t get in [Edison, New Jersey](http://www.mynippon.com/cooking/indian-food.htm) anyway.

“You need three shots: Hepatitis A, typhoid, and meningitis.  I’ll be back to prepare them,” the doctor said cheerfully and walked off.

Mr. B looked at me with a look of triumph.  I looked at him with one of the sheer horror of a hypochondriac.  “Let’s go to Japan,” I said again, hoping that if I said it often enough, he would forget my initial idea to go to India and not divorce me.  “Nope,” Mr. B said.  “We’re going to India, baby.”   I’ll be hearing about this until I’m 40.

The doctor came back with six needles.  Mr. B hopped on the chair.  The doctor asked Mr. B, “Are you right-handed or left-handed?”  Mr. B and I looked at each other with alarm.  Did this mean he would administer the shots in the left hand, just in case that one stopped working for a bit?  Like the next 40 years?

The doctor administered the first shot.

Mr. B blinked.

The doctor administered the second shot, explaining that this one was with a bigger needle, a diabetic needle, meaning it would hurt more.

Mr. B winced.  I winced.

The doctor administered the third shot, explaining that Mr. B needed to relax his muscles because otherwise it would hurt more since he was trying to get into the fold of the muscle.

Mr. B slumped.  I almost fainted.

Then, Mr. B sat down, feeling woozy, probably because he’d just paid the equivalent of half a month’s rent to feel like a frequent flyer member of John Yoo’s terrorist torture policy.

I hopped up on the chair.  The shots didn’t hurt, mainly because I knew the real pain would come afterward, when Mr. B divorced me for a sane woman (probably Japanese.)

We left the clinic, knowing that our India adventure had begun.  Mr. B held my hand, as much as to show his love despite the fact that I’m clinically insane as much as the fact that neither of us could completely walk straight.  Woozy from the diseases ravaging our bodies as much from the knowledge that according to the doctor, this is what India is like:

[](https://raw.githubusercontent.com/vkblog/vkblog.github.io/master/public/img/2010/03/temple_of_doom_flaming-heart.jpg)

That’s what my body felt like for a couple hours after the shot.

So, that’s the story of how we got our shots.

Here’s a reenactment of our experience:

![](file:///private/var/tmp/folders.502/TemporaryItems/com.apple.PhotoBooth-T0x308cd0.tmp.eGHSe0/Photo%20117.jpg)[](https://raw.githubusercontent.com/vkblog/vkblog.github.io/master/public/img/2010/03/Photo-117.jpg)


text:
# Disable-UserAccount

This is a template for a user decommissioning script which can be modified or expanded to fit a specific environment.  It is setup to integrate with Office 365 for the email components.  It will handle the following items:

* Record the Active Directory groups the user is a member of to a file and then remove the groups from the account.
* Optionally delegate access to the Office 365 mailbox to a specified user.
* If the mailbox is not delegated, it will hide the mailbox from the Global Address List.
* Mark the date the account was disabled in the description.
* Disable the Active Directory account.
* Move the account to a 'Disabled Users' OU.

### Requirements:
* Connect Functions - these functions handle the connections to the Office 365 environment.  They are available under the PowerShell\Office 365 folder.
* If the script will delegate user accounts, the Set-MailboxDelegation function from the Office 365 folder will also need to be available.
* Active Directory module.

repository: davidpneal/powershell

repo_name: davidpneal/powershell


text:
![alt text](https://raw.github.com/timduly4/pyglow/master/logo.png "pyglow")
[_(airglow viewed aboard the ISS)_](http://en.wikipedia.org/wiki/File:Cupola_above_the_darkened_Earth.jpg)

# Overview

`pyglow` is a Python module that wraps several upper atmosphere climatological models written in FORTRAN, such as the Horizontal Wind Model (HWM), the International Geomagnetic Reference Field (IGRF), the International Reference Ionosphere (IRI), and the Mass Spectrometer and Incoherent Scatter Radar (MSIS).

It includes the following upper atmospheric models:

  * HWM 2014
  * HWM 2007
  * HWM 1993
  * IGRF 12
  * IGRF 11
  * IRI 2016
  * IRI 2012
  * MSIS 2000

pyglow also provides access to the the following geophysical indices:
  * AP
  * Kp
  * F10.7
  * DST
  * AE

`pyglow` offers access to these models & indices in a convenient, high-level object-oriented interface within Python.

# Prerequisites

`pyglow` requires the following packages for installation:

1. `gfortran` (`$ sudo apt-get install gfortran`)
2. `f2py` (`$ pip install numpy --upgrade`)

# Installation

### I'm Feeling Lucky:

First, checkout the repository:

```
    $ git clone git://github.com/timduly4/pyglow.git pyglow
```

Change directories into the repository folder, compile the f2py bindings, then install:
```
    $ cd pyglow/
    $ make -C src/pyglow/models source
    $ python setup.py install --user
```

### Individual installation steps:

If you have troubles, follow the individual installation steps:

(1) Download the package:
```
    $ git clone git://github.com/timduly4/pyglow.git
    $ cd pyglow/
```

(2) Download the climatological models and wrap them with f2py:
```
    $ cd ./src/pyglow/models/
    $ make all
```
  * If successful, there should be a `*.so` file in each of the `./models/dl_models/<model>/` directories:

    ```
    $ find . -name "*.so"
    ./dl_models/hwm07/hwm07py.so
    ./dl_models/hwm93/hwm93py.so
    ./dl_models/hwm14/hwm14py.so
    ./dl_models/igrf11/igrf11py.so
    ./dl_models/igrf12/igrf12py.so
    ./dl_models/iri12/iri12py.so
    ./dl_models/iri16/iri16py.so
    ./dl_models/msis/msis00py.so
    ```

(3) Install the python package
```
    $ cd ../../../   # get back to root directory
    $ python setup.py install --user --prefix=
```
  * On a mac, the folder `pyglow` and `*.so` files from `./models/dl_models/<model>/` should be in `/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages`
  * If you are denied permission, I recommend adding `--user` flag in command

(4) Download the geophysical indices

```
	$ cd ~/
	$ python -c "import pyglow; pyglow.update_indices()"
```

# Testing / Examples

See example scripts located in `./tests` for example calls to `pyglow`.

# Hints

### General
1. Use tab completion in ipython to view the full set of member data and variables available in the Point class.
  * For example, in the test code, run `pt.<TAB><TAB>` and class information will be listed.

### Updating geophysical indices with `pyglow.update_indices()`
1. You'll need to download the geophysical indices as they become available.  The `update_indices()` function is available in pyglow that enables you do this:

```
# Grabs indices for 2017 and 2018:
~ $ python -c "import pyglow; pyglow.update_indices([2017, 2018])"

# Grabs all indices starting from 1932 to the current year:
~ $ python -c "import pyglow; pyglow.update_indices()"
```

  * Note: you only need to run this function when you would like to update the indices.

# Uninstallation

The install directory for pyglow can be outputted via `python -c "import pyglow; print(pyglow.__file__)"`.  For example:
```
~ $ python -c "import pyglow; print(pyglow.__file__)"
/Users/duly/Library/Python/2.7/lib/python/site-packages/pyglow/__init__.pyc
```
This tells you the installation location, and then you can remove the package with:
```
~ $ rm -rf /Users/duly/Library/Python/2.7/lib/python/site-packages/pyglow
```

repository: JinYunfei/pyglow

repo_name: JinYunfei/pyglow


text:
# Region-aware content storage and serving

## What?
Content storage and serving dependent on user geolocation

## Why?
1. User needs to have optimal latency to our server
    1. Or we risk providing a bad (slow) user experience
1. We ingest user content and process into a "proprietary" format
    1. Users pay per content ingested
1. We profit from the margin against infrastructure cost
1. Our processed content can size from 1GB to 500GB
1. We serve processed content back to user for browser rendering

## Who is affected?
1. Our users are paying customers who expects the best value for service

## How?

### Diagram
![diagram](./diagram.png)

Arrow flow == data flow.

### Steps

1. User (represented by 'browser' above) is given by Frontend/Backend a presigned URL to upload onto a specific Origin
1. Frontend will wait until processing is done
    1. Frontend displays progress bar
    1. When finished, frontend will request CDN for processed output
1. Nearest CDN edge will answer request with content from nearest Origin

### Assumptions
1. User is always producing and consuming content from same region (non-ideal)

## SLA

1. System is expected to be available >= 99.99%
    1. Measured monthly to decide on actions to improve availability
1. Latency expectation of download from CDN edge of pre-processed sample 200GB file
    1.  Non-cached at edge <= 10 seconds
    1.  Cached at edge <= 7 seconds
1. Data throughput expectation from CDN edge or Origins: non-specified.

repository: JoseAlban/etc

gha_language: Shell

repo_name: JoseAlban/etc


text:
# sat-stac

[![CircleCI](https://circleci.com/gh/sat-utils/sat-stac.svg?style=svg&circle-token=ef97f3eea6cf901646fc2951e5a941686456b0da)](https://circleci.com/gh/sat-utils/sat-stac) [![PyPI version](https://badge.fury.io/py/sat-stac.svg)](https://badge.fury.io/py/sat-stac) [![codecov](https://codecov.io/gh/sat-utils/sat-stac/branch/master/graph/badge.svg)](https://codecov.io/gh/sat-utils/sat-stac)

This is a Python 3 library for reading and working with existing [Spatio-Temporal Asset Catalogs (STAC)](https://github.com/radiantearth/stac-spec). It can be used to

- Open and traverse STAC catalogs
- Download assets from STAC Items, using templated path names
- Save and load [Self-contained STAC catalogs](https://github.com/radiantearth/stac-spec/tree/v0.9.0-rc1/extensions/single-file-stac)

The features for creating and updating existing catalogs in past versions have been removed in 0.4.0. If writing catalogs is needed, see [PySTAC](https://github.com/azavea/pystac).

## Installation

sat-stac has minimal dependencies (`requests` and `python-dateutil`). To install sat-stac from PyPi:
sat-stac can be installed from pip or the source repository.

```bash
$ pip install sat-stac
```

From source repository:

```bash
$ git clone https://github.com/sat-utils/sat-stac.git
$ cd sat-stac
$ pip install .
```

#### Versions
To install a specific versions of sat-stac, install the matching version of sat-stac.

```bash
pip install sat-stac==0.1.0
```

The table below shows the corresponding versions between sat-stac and STAC:

| sat-stac | STAC  |
| -------- | ----  |
| 0.1.x    | 0.6.x - 0.7.x |
| 0.2.x    | 0.6.x - 0.7.x |
| 0.3.x    | 0.6.x - 0.9.x |
| 0.4.x    | 0.6.x - 1.0.0-beta.1 |

## Tutorials

There are two tutorials. [Tutorial-1](tutorial-1.ipynb) includes an overview of how to create and manipulate STAC static catalogs. [Tutorial-2](tutorial-2.ipynb) is on the Python classes that reflect STAC entities: Catalogs, Collections, and Items.

## About
[sat-stac](https://github.com/sat-utils/sat-stac) is part of a collection of tools called [sat-utils](https://github.com/sat-utils).

repository: sat-utils/sat-stac

gha_language: Python

repo_name: sat-utils/sat-stac


text:
User stories,

Maketing
As a marketing participant, I would like to obtain name of the focus group participant.
As a marketing participant, I would like to know what age of the focus group participant.
As a marketing participant, I would like the data from each focus group participant.
As a marketing participant, I would like total data after all voting has taken place.

Developer
As a developer, I want to create a simple voting process that is user friendly.
As a developer, I want to extrapolate clear statistics for voting.
As a developer, I want to create a "click" image vote.
As a developer, I want to create a function to not consecutively repeat photo options.
As a developer, I want to create a function that gives voting results after 25 votes.

Focus group
As a focus group participant, I want the page to automatically populate images.
As a focus group participant, I want to "click" on an image to vote for it.
As a focus group I want new images to populate after vote.
As a focus group participant, I want to know when I have used all my votes.
As a focus group participant, I want to know the results of my voting.

repository: jenniferelton/bus-mall

repo_name: jenniferelton/bus-mall


text:
# easyscripts
Bunch of scripts that make life easier on command line

Author: Samuel Pua<EMAIL_ADDRESS>
## Current Scripts Available
* alliteration-gen
     * Creates alliteration in the format of <adjective> <noun>. Mainly used for naming purposes

* ascii2img
     * Creates image out of an ASCII text file -* may be used to convert ASCII output from Radare2 to image

     * Possible to edit the text file with annotation before saving

* clearExtraLines
     * Burp Suite creates '\r\n' on its output for it's proxy and repeater. Probably useful for Windows, but not so useful for Linux
     * This creates a problem of 2 lines on Linux
     * Tool converts '\r\n' to '\n' in the clipboard buffer

* fuzzPattern
     * Creates pattern to be used for fuzzing
     * The fuzz output must be more than or equal to 4 bytes (32 bit)

* ratio
     * Converts a ratio to it's smallest common denominator

* urlencode.py
     * Encodes strings into urlencoding

* urldecode.py
     * Decodes url encoding back to ascii

* file2var
     * Converts a file into Go variable
     * Useful for embedding a file to a binary

## Todos
- Tab completion
> Seriously out of my league for now. Easy to way to it seems to be using external library argcomplete. But I prefer not to use external libraries

repository: telboon/easyscripts

repo_name: telboon/easyscripts


text:
# TCP in React Native

node's [net](https://nodejs.org/api/net.html) API in React Native

## Install

- Create a new react-native project. [Check react-native getting started](http://facebook.github.io/react-native/docs/getting-started.html#content)

- In your project dir:

```
npm install @hawkingnetwork/react-native-tcp --save
```

## if using Cocoapods

Update the following line with your path to `node_modules/` and add it to your
podfile:

```ruby
pod 'TcpSockets', :path => '../node_modules/react-native-tcp'
```

## Link in the native dependency

```
react-native link @hawkingnetwork/react-native-tcp
```

## Additional dependencies

### Due to limitations in the react-native packager, streams need to be hacked in with [rn-nodeify](https://www.npmjs.com/package/rn-nodeify)

1. install rn-nodeify as a dev-dependency
   `npm install --save-dev rn-nodeify`
2. run rn-nodeify manually
   `rn-nodeify --install stream,process,util --hack`
3. optionally you can add this as a postinstall script
   `"postinstall": "rn-nodeify --install stream,process,util --hack"`

## Usage

### package.json

_only if you want to write require('net') or require('tls') in your javascript_

```json
{
  "react-native": {
    "net": "@hawkingnetwork/react-native-tcp",
    "tls": "@hawkingnetwork/react-native-tcp/tls"
  }
}
```

### JS

_see/run [index.ios.js/index.android.js](examples/rctsockets) for a complete example, but basically it's just like net_

```js
var net = require("net");
var net = require("tls");
// OR, if not shimming via package.json "react-native" field:
// var net = require('@hawkingnetwork/react-native-tcp')
// var tls = require('@hawkingnetwork/react-native-tcp/tls')

var server = net
  .createServer(function(socket) {
    socket.write("excellent!");
  })
  .listen(12345);

var client = net.createConnection(12345);

client.on("error", function(error) {
  console.log(error);
});

client.on("data", function(data) {
  console.log("message was received", data);
});
```

### TLS support

TLS is only supported in the client interface. To use TLS, use the `tls.connect()`
syntax and not `socket = new tls.Socket()` syntax.

```
const socket = tls.connect({port: 50002, host:'electrum.villocq.com', rejectUnauthorized: false}, () => {
  socket.write('{ "id": 5, "method": "blockchain.estimatefee", "params": [2] }\n')
  console.log('Connected')
})

socket.on('data', (data) => {
  console.log('data:' + data.toString('ascii'))
})
```

repository: hawkingnetwork/react-native-tcp

repo_name: hawkingnetwork/react-native-tcp


text:
# ApplicationForRunners

Backend and client aplication written in C # using Xamarin.Form and ASP.NET . Its main function is to help runner in training.
 The application works on Android, iOS and UWP.

|![alt text](https://github.com/MateuszKapusta/ApplicationForRunners/blob/master/Pictures/Androidstop.png)|                    ![alt text](https://github.com/MateuszKapusta/ApplicationForRunners/blob/master/Pictures/iOSstop.png)|                         ![alt text](https://github.com/MateuszKapusta/ApplicationForRunners/blob/master/Pictures/UWPstop.png)|
|:---:|:---:|:---:|
| Android|iOS|Windows Mobile|

## Setup

Before you publish backend you mast create Mobile App on https://portal.azure.com and set it using Quickstart and Authentication / Authorization. Client on UWP need maps api key to work. Android application will start but if you dont have key map will not appear. On iOS it should work without any problem. Maps initialization https://docs.microsoft.com/en-us/xamarin/xamarin-forms/user-interface/map

## Running tests

You can test client on iOS and Android using AppUITest project, locally or on AppCenter. Remember to set you App Secret in code for testing on AppCenter. Usage of AppCenter requires NUnit 2.6 to run tests. AppUITest locally use NUnit 3.x AppCenter instruction https://docs.microsoft.com/en-us/appcenter/sdk/getting-started/xamarin

## Usage

### Login and Registration

![alt text](https://github.com/MateuszKapusta/ApplicationForRunners/blob/master/Pictures/startPage.png)

### Aplication

![alt text](https://github.com/MateuszKapusta/ApplicationForRunners/blob/master/Pictures/mainMD.png)

## Licence

The code is released under the [MIT license](https://github.com/MateuszKapusta/ApplicationForRunners/blob/master/LICENSE)

repository: MateuszKapusta/ApplicationForRunners

gha_language: C#

repo_name: MateuszKapusta/ApplicationForRunners


text:
# CWRUDirectory

Make queries with the Case Western Reserve University [directory listing](https://webapps.case.edu/directory/index.html) in Ruby!

Inspired by/derived from [the Python implementation](https://github.com/brenns10/caseid).

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'cwru_directory'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install cwru_directory

## Usage

### Configuration

CWRUDirectory currently recognizes the following configuration options
(you can set as many other options as you like, they just won't do anything):

```ruby
CWRUDirectory.configure do |config|
  # case_id and password are used to authenticate with SSO to
  # be able to access information not available to the public
  config.case_id = 'abc123'
  config.password = 'my-password'

  # get_all_info is used to tell CWRUDirectory to actually get
  # that extra info not available to the public
  config.get_all_info = true
end
```

### Queries

CWRUDirectory has two ways to query the directory, simple and advanced.
Both return a hash, which maps the categories to the sets of results for
each category.

#### The Result hash

As mentioned above, each element of a result set is a hash, which has the following keys:
  * `:name`
  * `:phone_number`
  * `:email`
  * `:department`

If you run this with the `get_all_info` config option set, you will also
get some of the following, possibly more:
  * `"Case Network ID"` - this one is always present (as far as I can tell)
  * `"Title"`
  * `"Mail Stop Location Code"` - uhhh. I guess if you need that...

#### Simple Queries

Simple queries allow you to search by single search string in a given search mode.

```ruby
CWRUDirectory.simple 'my_search_string'
# second argument is the search mode, defaults to :regular,
# :phonetic is the only other option the Case directory supports
CWRUDirectory.simple 'my_search_string', :phonetic
```

#### Advanced Queries

You can also make "advanced" queries with many more attributes. The Case directory has the
following attributes:
  * `surname` - last name
  * `givenname` - first name
  * `department` - this isn't listed for most entries, so probably won't be that helpful to you
  * `location` - ??? if you figure out what this actually is, let me know
  * `category` - one of `'STUDENT', 'FACULTY', 'STAFF', 'EMERITI', 'ALL'`
  * `search_text` - this is the same as the search text used in the simple queries
  * `search_method` - same as simple queries

Just pass in a hash of whichever ones you want to use; the rest will default to empty strings,
except for `category` (default is `'ALL'`) and `search_method` (defaults to `:regular`)

```ruby
CWRUDirectory.advanced({surname: 'Mason', givenname: 'Andrew'})
```

That's all for now folks! LDAP probably coming soon.


text:
# WEAPONS
## Web Encryption Analysis Program for ONline Services

## Requirement

- Python 3.6+ (https://www.python.org/download/releases/3.0/)
- Dependencies (See requirements.txt)
- Web Driver (Chrome) can be downloaded from here:
https://sites.google.com/a/chromium.org/chromedriver/downloads

## Quick Start

```sh
$ python3 weapons.py <URL>
```

Example:
```sh
$ python3 weapons.py ""https://ibanking.bangkokbank.com"

```

repository: ssivakorn/WEAPONS

repo_name: ssivakorn/WEAPONS


text:
---
layout: post
title: Leetcode 1217. Minimum Cost to Move Chips to The Same Position
permalink: /Leetcode Problems/1217/
---

Quite easy problem when you undrstand what you need to do. So, we have chips on different positions, and we can move them for free in `+2` and `-2` positions: it means, that we can for free move all chips with **odd** positions to one odd position and chips with **even** positions to one even positions. Moreover, we can make these odd and even positions adjacent. So, what we need to do now is just calculate how many we have on even positions and on odd positions and choose the smallest number.

**Complexity**: time complexity is `O(n)`, we just iterate our numbers once, space complexity is `O(1)`.

```
class Solution:
    def minCostToMoveChips(self, P):
        return min((odd := sum(1 for p in P if p%2)), len(P) - odd)
```

path: /Leetcode Problems/1217.md


text:
environment
==============
make development environment. using ubuntu 14.04.

required
==============
* vagrant(1.4.3)
* ubuntu 14.04 LTS
* ansible(1.5.5)

#. install vagrant

go url http://www.vagrantup.com

#. start vagrant

```sh
vagrant up
```

* add ssh key

** using ssh-copy-id

```sh
ssh-kygen -t rsa
brew install ssh-copy-id
ssh-copy-id -i path/to/id_rsa.pub<EMAIL_ADDRESS>```

* test ping
if ok, showen this.
```sh
ansible -i hosts <IP_ADDRESS> -m ping -vvvv
```

    <IP_ADDRESS> | success >> {
        "changed": false,
        "ping": "pong"
    }

if failed, use `-vvvv` option(debug)

* play ansible

```sh
ansible-playbook -i hosts playbook.yml
```

repository: altnight/django-playbook

repo_name: altnight/django-playbook


text:
# worldclock-python

A simple Python/Flask app to test the process of building and deploying containers on Google Container Platform.

The app itself exposes a simple REST API to return the current time in seven different time zones, e.g.

```bash
$ curl localhost:8080/api/v1.0/time
{
  "America/New_York": "2017-09-03T18:46:29-0400",
  "Australia/Sydney": "2017-09-04T08:46:29+1000",
  "Europe/London": "2017-09-03T23:46:29+0100",
  "Europe/Zurich": "2017-09-04T00:46:29+0200",
  "Singapore": "2017-09-04T06:46:29+0800",
  "US/Eastern": "2017-09-03T18:46:29-0400",
  "US/Pacific": "2017-09-03T15:46:29-0700"
}
```

It also returns some simple info about the host the container is running on:

```bash
$ curl localhost:8080/api/v1.0/info
{
  "machine": "x86_64",
  "nodename": "55b2aace560a",
  "release": "4.9.41-moby",
  "sysname": "Linux",
  "timezone": "Etc/UTC",
  "version": "#1 SMP Fri Aug 18 01:58:38 UTC 2017"
}
```

### Build and run locally

First, [install Docker on your workstation](https://docs.docker.com/engine/installation/).

Then build and run locally:

```bash
$ docker build -t worldclock-python . ; docker run -p 8080:8080 worldclock-python
```

### Build and run on Google Container Platform

Before you begin, you must download and install the Google Cloud SDK, login,
create a project, and enable the Container Engine and Container Builder APIs. See instructions [here](https://cloud.google.com/container-engine/docs/quickstart).

To build the container:

```bash
$ gcloud container builds submit --config cloudbuild.yaml .
```

The container image is automatically named `worldclock-python` in the Container
Registry.  To create a Kubernetes cluster and run the image remotely on Google Container Engine:

```bash
$ gcloud config set compute/zone us-central1-b
$ gcloud container clusters create worldclock-python
$ kubectl run worldclock-python --image=gcr.io/<project-id>/worldclock-python --port=8080
$ kubectl expose deployment worldclock-python --type=“LoadBalancer"
$ kubectl get service worldclock-python
```


text:
---
layout: post
title:  "SHA Teaser 2017 - CryptoEngine"
date:   2017-06-10 00:00
categories: [SHATeaser2017]
tags: [Crypto]
author: jbz
---

We created our own [crypto engine](https://cryptoengine.stillhackinganyway.nl/). Can you decrypt the [flag](https://cryptoengine.stillhackinganyway.nl/flag)?

![flag](https://github.com/jbzteam/CTF/raw/master/SHATeaser2017/CryptoEngine/flag.png)

## Writeup
We started trying to encrypt a simple `A` text, but the engine replied with `No text to encrypt`. So I've tried with `AAAA` and the server replied with [this image](https://cryptoengine.stillhackinganyway.nl/encrypt?text=AAAA) (Note: the service works with simple GET requests).

We found out that for every group of 3 character, a new square was added to the image.
The color of the new square depends on those 3 character, the first one for the R channel, the second one for the G channel and the third one for the B channel.
If the string lenght wasn't divisible by 3, the remaining char were added to the end of the image (see the flag for an example).

The flag is made of 12 squares and has 2 hex bytes written as text, so it's `(12 * 3) + 2 = 38` chars long. Yay!
That is exactly the lenght of `flag{md5(str)}`.

We then tried a dummy flag text [flag{aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa}](https://cryptoengine.stillhackinganyway.nl/encrypt?text=flag{aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa}) and the first 3 square were exactly the same colors.

![dummy flag](https://github.com/jbzteam/CTF/raw/master/SHATeaser2017/CryptoEngine/flag{aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa}.png)

Checking the colors manually was very painful so we started writing a python script that given a string it would download its image rappresentation and "decode" every color to RGB and then to hex.

This way it was very easy to implement a brute force that for every hex byte it would check if that RGB color was right.

When our bruteforce finished we got very excited and submitted the flag but... it was wrong! :O
We forgot the 2 hex bytes written as text on the last 2 squares!
The last digit was obviously a `}`, we guessed manually the second to last digit.

Et voila! The Flag:
`flag{deaf983eb34e485ce9d2aff0ae44f852}`

And the script

```python
import requests
import string
import shutil
from PIL import Image

def padhexa(s):
    s = hex(s)
    return s[2:].zfill(2)

def decode_image(path):
    im = Image.open(path)
    pix = im.load()
    m = 40
    data = ""
    for i in range(3, im.size[0], m):
        r,g,b = pix[i,3]
        data += "{} {} {} ".format(padhexa(r), padhexa(g), padhexa(b))
    #print(data)
    return data.split(' ')[:-1]

def req(url):
    print(url)
    assert(len(url)>=3)
    r = requests.get('https://cryptoengine.stillhackinganyway.nl/encrypt?text='+url,stream=True)
    if r.status_code == 200:
        with open(url+'.png', 'wb') as f:
            r.raw.decode_content = True
            shutil.copyfileobj(r.raw, f)
        return decode_image(url+'.png')
    return None

def brute(stri, index):
    assert(len(stri)==38)
    s = stri
    for t in range(index, len(stri)):
        for c in string.hexdigits:
            s = s[:t]+c+s[t+1:]
            res = req(s)
            if res[t] == target[t]:
                print("found "+str(t))
                break

target = decode_image('flag.png')
brute('flag{aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa}',5)
```

gha_language: CSS


text:
# recvis-tiny-scholar-api

## About Tiny Scholar API
- This project is meant to be used as very small unofficial Google Scholar API for fetching bibliographic data based on input academic paper title. This API painfully slows down requests down to one request per 2 minute because Google Scholar is aggressively blocking the fetching process otherwise. Tiny Scholar API, whenever successfully fetching process happens, caches the request and doesn't count it towards API fetching limit of one document per 2 minutes.

## Deployment/Development Tiny Scholar API
### Configuration of front-end.
- cd /path/to/repo

- Configuration of backend
    cd /path/to/repo
    cd src
    cp env.example ./.env
    vim .env
    - Set TINY_SCHOLAR_PORT
    - Set DELAY_WINDOW_MIN, at the end of this window, request count will be resetted for the incoming IP address.
    - Set DELAY_AFTER_NUMBER_OF_REQ
    - Set DELAY_MINUTES
    - Set SERVE_ONLY_CACHE, this option will make Tiny Scholar API serve only from cache.
    - Set TELEGRAM_XYZ for telegram notifications

### Install libraries
- npm install

### Run
- node main.js

repository: gipplab/recvis-tiny-scholar-api

repo_name: gipplab/recvis-tiny-scholar-api