text:
Argument Processing - Wick
==========================

There are several functions that will help you parse arguments that are passed into your script.  This document shows real-world scenarios where you can use each of the functions.  For information on how to call them, refer to the [library functions](../lib/README.md).

* `wickGetArgument`
* `wickGetArguments`
* `wickGetOption`
* `wickGetOptions`

It is assumed that scripts here have access to these functions.  They must either be running within a Wick environment or they sourced `/usr/local/lib/wick-infect` from the [`wick-infect` formula](../formulas/wick-infect/README.md).

Options versus Arguments
------------------------

An option is a command-line parameter that looks like `--option-name`, `-v` or `--thing=value`.  They all have a hyphen at the beginning.

Arguments can be options, which can be confusing.  To keep things consistent inside the codebase, `wickGetArgument` and `wickGetArguments` return only non-option arguments, with one caveat:  any options (eg. --thing) is an argument when it occurs after a double-hyphen argument.

Example:

    # This shows options (opt) and arguments (arg)
    # Note how the double hyphen will change everything after it into
    # arguments.
    scriptName --opt -o arg1 --opt2=value arg2 -- --arg3=value -a

Retrieving Single Options
-------------------------

Consider the times when you want a simple flag that would enable features, such as a verbose mode.

    # Find if `--verbose` was passed.
    wickGetOption VERBOSE_FLAG verbose "$@"

    [[ -n "$VERBOSE_FLAG" ]] && echo "Verbose mode enabled"

Checking if a flag was passed in seems easy.  It's not any harder to also look for particular values.

    # The --user and --role options are mandatory.
    # Because "set -e" is enabled by default when running scripts,
    # this will exit if there are errors.
    wickTestForOptions user role -- "$@"

    # Get the user and role.
    wickGetOption USER user "$@"
    wickGetOption ROLE role "$@"

    # The --verbose option is optional.
    wickGetOption VERBOSE verbose "$@"

    echo "USER:  $USER"
    echo "ROLE:  $ROLE"

    [[ -n "$VERBOSE" ]] && echo "Verbose flag enabled"

Retrieving Single Arguments
---------------------------

Normally one would use `$1` to get the first argument, but arguments to functions could include both options and non-option arguments.  To make sure you get the first non-option argument you would use `wickGetArgument`.

    # Get the first non-option argument and save it as SOURCE.
    # Get the second non-option argument and save it as DESTINATION.
    wickGetArgument SOURCE 0 "$@"
    wickGetArgument DESTINATION 1 "$@"

Please be careful.  The indexing on this command starts at zero.

If there are not enough arguments in `$@` then the variable is set to an empty string.

You can see how useful this is when we start mixing arguments and options.  Let's make a helper function:

    diagnose() {
        wickGetArgument FIRST 0 "$@"
        wickGetArgument SECOND 1 "$@"
        echo "${FIRST}...${SECOND}"
    }

    # In comments I will show you the output of the following commands

    diagnose
    # ...

    diagnose a b
    # a...b

    diagnose a b --option1 --option2
    # a...b

    diagnose --key=value -abc "complex example" --left --right "still works"
    # complex example...still works

That last example really illustrates the goal of these functions.

Passing Arguments Through
-------------------------

Imagine a function that will consume one argument and pass the rest to another function.  Perhaps we get a username as the first argument and a home directory as a second.

    setupUserDir() {
        local args oldIfs

        # Get a list of all non-option arguments
        wickGetArguments args "$@"

        # Remove the first item from the list. The IFS notation is to
        # ensure this works even in bash 3, regardless of IFS settings.
        oldIfs=$IFS
        IFS=
        args=("${args[@]:1}")
        IFS=$oldIfs

        # Pass the remaining arguments to another function
        setupDir "${ARGS[@]}"
    }

Passing Options Through
-----------------------

Let's say you have a function called `setupService` and it wants to support all of the options that `wickMakeFile` supports.

    setupService() {
        local OPTIONS

        wickGetOptions OPTIONS "$@"

        # OPTIONS is now set to a list of all options that were passed
        # in to this function.

        wickMakeMile source-file.txt /dest/folder/ "${OPTIONS[@]}"
    }

To make it more complex, we alter `setupService` to accept a `--reload` parameter but we don't want to pass `--reload` to `wickMakeFile`.

    setupService() {
        local OPTIONS

        wickGetOptions OPTIONS "$@"

        # OPTIONS could have `--reload`
        # This is how we remove items from the array

        wickFilterArray OPTIONS setupServiceOptionsFilter "${OPTIONS[@]}"

        # OPTIONS now will not have `--reload`

        wickMakeFile source-file.txt /dest/folder "${OPTIONS[@]}"
    }

    setupServiceOptionsFilter() {
        case "$1" in
            --reload|reload=*)
                # Return failure and wickFilterArray will remove the
                # value from the list.
                #
                # We match against both --reload and --reload=* because the
                # option could be specified in either way.
                return 1
                ;;
        esac

        # Return success and wickFilterArray preserves the value.
        return 0
    }


text:
# Fast Bernoulli

*fast generation of long sequences of Bernoulli-distributed random variables*

## Overview

**Fast Bernoulli** — a library for sampling from Bernoulli distribution
with a specific parameters. Performant Bernoulli samplers are highly useful in
scientific and engineering fields: modeling, random graphs, coding theory, etc.

The standard way to obtain Bernoulli distributed random value is sampling from
uniform distribution and thresholding with a parameter. The library exploits a
different property of Bernoulli random variables to attain better efficiency in
the sense of (P)RNG invocations.

Namely, logical operation (like not, or, and, xor) on two Bernoulli random
variables gives another random variable distributed according to Bernoulli law
with a new parameter. So, the concept behind is that Bernoulli distribution
with any parameter can be approximated with a sequence of other Bernoulli
random variables with different parameters and logical operators applied to the
sequence. Set of logical operators is not constrained in general but this
implementation is based on `and(&)` and `not(~)` operators. As soon as a target
distribution parameter is "quantized" in a sequence logical operators, one can
apply the transformations to a sequence of random values in run-time to draw a
sample.

In order to archive better performance on practice, one need to improve sample
efficiency in sense of memory consumption. Standard implementation returns a
value of random variable as a bool-typed value which in fact consumes one byte.
In contrast, library returns block of random values. Each random value encoded
as a bit in a block. This fact allows to use vector extensions to instruction
set.

Another important assumption is that (P)RNG generates random number and bits in
generated numbers are distributed uniformly. In general, this is true
especially for top-quality (P)RNG (mt19937 as example). So, the assumption
allows to apply the described algorithm to bits of numbers obtained with
(P)RNG.

Another one improvement is related to implementation. Execution of a sequence
of logical operations on bits requires iterations in loop. Many iterations
affect performance through context switch and (un)conditional branching. The
best performance could be archived if distribution parameter or a set of
logical operators is known in compile-time. Just-in-time (JIT) compilation
facilitates overcoming the obstacle. The library supports LLVM which provides
JIT compiler infrastructure.

### Features

- [x] High efficiency per random bit.
- [x] Vectorization with AVX.
- [x] JIT compilation with LLVM.
- [x] Thread-safe.
- [x] Python bindings.

## Benchmarking

The only reason for creation of the project is efficient sampling. So, in this
section we present some benchmarks of sampler in different configurations. One
can see that the proposed implementation is ahead of standard Bernoulli sampler
(prefix `Std` in table or figure).

```
Run on (4 X 3400 MHz CPU s)
CPU Caches:
  L1 Data 32K (x2)
  L1 Instruction 32K (x2)
  L2 Unified 256K (x2)
  L3 Unified 4096K (x1)
--------------------------------------------------------------------------------
Benchmark                             Time          CPU  Iterations   Throughput
--------------------------------------------------------------------------------
BM_RandomNumberGeneration/128      4786 ns      4783 ns      147228  816.740 M/s
BM_StdSampler/128              72260140 ns  72208458 ns          10  55.3952 k/s
BM_GenericSampler/128            104076 ns    103545 ns        6745  37.7252 M/s
BM_AvxSampler/128                 71017 ns     70982 ns        9759  55.0314 M/s
BM_JitGenericSampler/128         103482 ns    103431 ns        6735  37.7669 M/s
BM_JitAvxSampler/128              55667 ns     55640 ns       12393  70.2053 M/s
```

Since one of the aims is to generate bulks of random values, it is interesting
to look at sampling efficiency in sense of bitrate with regards length of
generated sequence.

![Benchmark: bitrate vs number of blocks.](doc/benchmark-rate-vs-noblocks.png)

## Assembly

Build dependencies are (a) compiler with support C++17, (b) CMake as
build-system generator, (c) Make as default build system. Also building
requires (d) Google GTest for testing, and (e) Google Benchmark for
benchmarking. Optional dependency is (f) LLVM which provides JIT compiler
facility.
```bash
mkdir -p build/release && cd build/release
cmake ../.. -DCMAKE_BUILD_TYPE=Release -DBUILD_WHEEL=ON -DUSE_LLVM=ON
make
```
LLVM is not required by default, so it could be turned on/off with option
`-DUSE_LLVM=ON/OFF` (as it is shown on the snippet above). Option `BUILD_WHEEL`
triggers building of Python bindings which could be find in directory
`fast-bernoulli/python/`. Target for building Python bindings is not included
to a set of default targets, so one should to run building of target
`fast-bernoulli-python-wheel` in advance.
```bash
make fast-bernoulli-python-wheel
```

## Usage

The simplest way to construct sampler in C++ is just calling `CreateSampler()`
routine with target probability. The function returns a functor which should be
invoked with an instance of (P)RNG and aligned memory buffer. Finally, one
could bring samples to common representation (vector of bools).

```cpp
#include <fast-bernoulli/fast-bernoulli.h>

using namespace NFastBernoulli;

// Assume 65536 bits with probability 0.6 should be generated.
auto probability = 0.6;
auto nobits = 65536;

// Create an instance of ISampler and make buffer for sampling.
auto sampler = CreateSampler(probability);
auto ptr = sampler.MakeBuffer(nobits);

// Use Mersenne Twister as a pseudo-random number generator.
std::mt19937_64 rng;

// Draw samples from Bernoulli distribution.
sampler(rng, ptr);

// Expand compressed representation of random values to vector of bools.
auto values = Expand(ptr, nobits);
```

The function `CreateSampler()` is overridden in order to provide an advanced way
to instantiate sampler with structure `TSamplerOpts`.

Also, the library delivers Python bindings and an extremely simple usage
interface. Module `fast_bernoulli` provides function `sample()` which generates
random bits and returns memory view on resulting buffer of type `ui8`.

```python
import numpy as np
import fast_bernoulli as fb

# Assume 65536 bits with probability 0.6 should be generated.
probability = 0.6;
nobits = 65536;

# Draw samples from Bernoulli distribution. JIT is used.
res = fb.sample(probability, nobits, seed=42, jit=True)  # memoryview
arr = np.array(res)  # np.ndarray with dtype=np.uint8
```

repository: daskol/fast-bernoulli

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: daskol/fast-bernoulli


text:
# GO-TPM

Go-TPM is a library written in Golang (or Go) for accessing TPM 2.0 (and 1.2) devices. The current state of the 1.2 libraries is limited so not all functionality is provided and the libraries are not being actively maintained.

The TPM 2.0 libraries however are in good shape and relatively easy to use. It is important to note that that libraries conform to the TPM 2.0 specification and do not try to provide any convenience interfaces - this is a deliberate design decision - which means there are some surprises.

 The Go community and the Go-TPM team are pretty friendly however :-)

## Installation

OK, I'm going to assume you have golang installed GOPATH set up and everything works...OK here'a test - save this as `helloworld.go`:

```go
package main

import "fmt"

func main() {
    fmt.Println("Hello World")
}
```

compile and run with

```bash
go build helloworld.go
./helloworld
```

## Go-TPM
Found here: https://github.com/google/go-tpm

"Go-TPM is a Go library that communicates directly with a TPM device on Linux or Windows machines."

Unlike tpm2tools, GoTPM is a library for communicating with the TPM and supports both TPM 1.2 and 2.0 to some degree - actually TPM 1.2 is depreciated so YMMV. Most of the TPM 2.0 specification is supported.

The library is also very faithful to the specification and provides little in the way of convenience functions. There are some caveats when using the library which need to worked around, but again this is due to the fact that it implements the specification!

So, overall a very useful, functional library for accessing the TPM, but does require some knowledge of the TPM's workings.

## Some Sample Code
In the following sections we show some annotated sample code.

   * gotpm_quote.md

repository: jnaulty/TPMCourse

repo_name: jnaulty/TPMCourse


text:
## Description
pokersolver is a poker hand solver and comparison tool written in Javascript. It was written for and is being used in production on [**CasinoRPG**](http://casinorpg.com), an HTML5 MMORPG that features Texas Hold'em as one of its main casino games. It is designed for use on either the client (browser) or the server (Node.js). This library is capable of:

* Evaluating a hand of up to 7 cards
* Calculating the score of the hand (0-9)
* Returning the name of the hand (Pair, Flush, etc)
* Returning a detailed description (Two Pair, A's & 8's)
* Comparing an array of hands and returning the winner(s)
* Identifying all cards involved in creating the winning hand
* Works in both the browser and Node.js

## Installation
```
npm install pokersolver
```

## Examples
#### Server Usage
```javascript
var Hand = require('pokersolve').Hand;
```

#### Browser Usage
```javascript
<script src="/path/to/pokersolver.js"></script>
<script>
  var hand = Hand.solve(['...']);
  ...
</script>
```

Solve two hands and then determine the winner between the two of them.
```javascript
var hand1 = Hand.solve(['Ad', 'As', 'Jc', 'Th', '2d', '3c', 'Kd']);
var hand2 = Hand.solve(['Ad', 'As', 'Jc', 'Th', '2d', 'Qs', 'Qd']);
var winner = Hand.winners([hand1, hand2]); // hand2
```

Solve a hand and return the type and the description.
```javascript
var hand = Hand.solve(['Ad', 'As', 'Jc', 'Th', '2d', 'Qs', 'Qd']);
console.log(hand.name); // Two Pair
console.log(hand.descr); // Two Pair, A's & Q's
```

## API
### Methods
#### solve(cards)
Solves the hand passed in, whether 3 cards or 7. Returns various information such as name, description, score and cards involved.
* **cards**: `Array` All cards involved in the hand, example: `['Ad', '2d', '3d', '4d', 'Qc', 'Ks', '7h']`.

#### winners(hands)
Compare the passed hands and determine which is the best hand(s). Can return multiple if there is a tie.
* **hands** `Array` All hands solved with `Hand.solve` that should be compared.

#### toString()
Returns a formatted string of all cards involved in the identified hand type (maximum of 5 cards).

### Solved Hand Properties
#### cardPool `Array`
All of the cards passed into the hand.
#### cards `Array`
All of the cards involved in the identified hand type.
#### descr `String`
Detailed description of the identified hand type (`Two Pair, A's & Q's` for example).
#### name `String`
Type of hand identified (`Two Pair` for example).
#### rank `Number`
Ranking of the hand type (0-9, 0 being High Card and 9 being Straight Flush).

## Testing
```
npm install
npm test
```

## License
Copyright (c) 2016 James Simpson and GoldFire Studios, Inc.

Released under the MIT License.

license: MIT

repository: wschmrdr/pokersolver

repo_name: wschmrdr/pokersolver


text:
# Burnout

Burnout occurs from an excessive and prolonged state of emotional, mental, and physical exhaustion.
The more it accumulates the less interested one becomes in the thing they are responsible for.

## Signs of Burnout

- Work-life imbalance.
- Lack of control.
- Feeling you're not making a difference.
- Insufficient reward.
- Lack of community.
- Absence of fairness.
- Conflict in values.
- Work overload.
- Detachment.


text:
# 🐠 Guppy

### A friendly application manager and task runner for React.js

![Guppy project screen](https://github.com/joshwcomeau/guppy/raw/master/docs/images/main-image.png)

There are a lot of "meta" skills around React web development that don't really have anything to do with building great web products.

For example, the terminal. For those of us who didn't grow up on a unix shell, the terminal is an inscrutable box of cryptic and indecipherable commands. It's undoubtedly powerful, and a valuable skill to develop... but should it really be a pre-requisite for modern web development?

Guppy is a free-to-use desktop application designed to make it easier to get started building React web products. It provides a friendly GUI for many of the typical tasks facing React developers:

- Creating new projects
- Running a development server
- Executing tasks (building for production, running tests)
- Managing dependencies (adding, updating, searching)

Guppy is made for beginners - folks who are just starting out with web development. We hope that it's powerful enough for advanced users as well, but we'll always prioritize the new-developer experience. We'll never charge money for Guppy, it'll always be free-to-use.

> **NOTE**: This is _super early pre-release alpha_. Truthfully it's probably not ready for beginner usage yet (there may be some frustrating bugs). The goal is to build a community of folks to work on this and create something truly useful and wonderful for beginners.

### Current Status

This project is in early pre-release Alpha.

Want to help build something great for newcomers? We're actively looking for contributors to help develop this pre-release alpha into something amazing. This is a great time to get involved and help shape the future of Guppy!

Also, important to note: this is a side-project worked on during spare time. We appreciate any bug reports, but realistically we may not be able to fix issues in a timely manner (feel free to contribute fixes though!)

### Installation

To use Guppy, you'll first need to have a modern version of Node (a Javascript runtime) installed. [Download Node](https://nodejs.org/en/download/current/). The "Current" version is recommended over LTS due to a bug in NPM 5.6.0 that can corrupt dependencies.

Once Node is installed, you can [download Guppy](https://github.com/joshwcomeau/guppy/releases).

Double-click the downloaded executable to open Guppy. Mac users may need to right-click and select "Open" if MacOS complains about the fact that this was downloaded from the internet.

> Note: In future stable releases, I hope to remove the need to download Node by using the Node runtime that comes with Guppy (see [#44](https://github.com/joshwcomeau/guppy/issues/44)). I also plan to create a proper installer so that it's easy to copy Guppy to the Applications folder (see [#26](https://github.com/joshwcomeau/guppy/issues/26)). Contributions welcome!

### Getting Started

Learn more about using Guppy in our [Getting Started guide](https://github.com/joshwcomeau/guppy/blob/master/docs/getting-started.md).

### Internationalization

Unfortunately, Guppy is only available in English right now. Internationalization is being tracked in [#66](https://github.com/joshwcomeau/guppy/issues/66), although truthfully it's pretty far in the horizon.

In the meantime, some folks have started translating the docs into different languages! So, while the app is English-only, at least the docs are translated:

[![china](https://raw.githubusercontent.com/gosquared/flags/master/flags/flags/shiny/24/China.png) **中文/Chinese**](https://github.com/chinanf-boy/guppy-docs-zh)

### How it works

Guppy is an electron application that secretly runs terminal commands for you in the background. It uses **create-react-app** and **gatsby-cli**. Support could conceivably be added for Next, and other project types (including non-React ones)

Guppy adds a new top-level key to your `package.json` to store project-related information. It also reads from `package.json` to figure out the current dependencies, and see which tasks are available (via `scripts`).

Guppy has intelligent modules built around task types. For example, the dev server is no ordinary task, it's one that ought to be running throughout your time working on the project, and so it's given its own module at the top of the page.

For more information on learning more about Guppy and contributing, see our [contribution docs](https://github.com/joshwcomeau/guppy/blob/master/CONTRIBUTING.md)

### Future Vision

Right now, Guppy's feature-set is pretty limited. It consists of 3 modules: a "dev-server" pane, a "tasks" pane, and a "dependencies" pane.

The first big change I'd like to see is better support for common dev tools like running tests, linting, code formatting, and so on. Some examples of potential improvements:

- Testing shouldn't just be a thin row in a list, it should have its own module, like the Dev Server does. It should run in "interactive" mode, and allow users to re-run tests by clicking buttons.

- Dependencies should be easy to update. I imagine an "update core dependencies" button that updates react, react-dom, and any associated packages, with built-in codemod support. I imagine it being able to find security problems (via [`npm audit`](https://docs.npmjs.com/getting-started/running-a-security-audit)).

I'd also like to see Guppy become far more useful for educating users about web development. The philosophy of Guppy is that anybody can learn web development, and it should provide resources to help learners along. Guppy has full access to the project code and settings, and so I wonder if there are opportunities to suggest solutions to problems the user runs into... I don't have any concrete ideas yet, but it's interesting to think about.

### Chat

Come hang out with us [on Gitter](https://gitter.im/guppy-gui/Lobby)!

### Contributing

Guppy has an active community of contributors and collaborators that enjoy working together to continuously improve the application's form and function. Please note that this project is released with a [Contributor Code of Conduct](CODE_OF_CONDUCT.md). By participating in this project, you agree to abide by its terms. If you would like to get involved, have a look at our [Contributing Guide](CONTRIBUTING.md)!

### License

[ISC](LICENSE.md), Copyright 2018-present Joshua Comeau

license: ISC

gha_license_id: ISC


text:
# Brewlit #

 Dota 2 custom games library

 Current Features
------------------
* Setup - GameRules and GameMode setup
* GameStateManager -
* GameTime - game mode time and night/day cycles
* Find - query units in the world
* Event - listen to the working game events
* Animation - apply and remove gestures with a priority queue
* Camera - preset camera angle and updating camera for each player
* Ability - spell casting info and different linear projectile presets
* Helper - useful miscellaneous functions
* ItemManager - manage dropped items
* Input - custom input for sending cursor and directional input to the server
* PlayerHelper - helper functions for player entities
* Task - delay function calls or call functions at intervals
* Debugger UI - logging to a custom debugging UI in the HUD (not finished)
* HUD - server communicate with the HUD (not finished)

 Road Map
--------
* Debuger UI
  * API
  * option to start opened
  * fix bug with logging multiple msgs at once
  * input commands
* Find
  * units with modifier
* Quest System
  * Quest Notifications
    * new quest
	* new objective
  * Triggers
    * kill unit
	* fetch item
	* enter area
	* dialogue
  * Rewards
    * items
	* expierence
	* gold
  * use cases:
    * linear
	* linear optional
	* split and join
	* skip
	* spawn new quest
	* and/or gate
* Simplify filters
  * xp
  * gold
  * runes
  * unit
  * damage
  * projectile
  * execute order
  * inventory
  * modifer gained
* GameMode mangement
  * custom states
  * rounds
  * custom clock
* Ability
  * charges
  * tracking projectiles
  * changing projectiles direction
  * spiral/arc projectiles
* AI
  * state
  *  state transitions
  * events
  * queue commands (such as path finding)
* Camera
  * set yaw and pitch with delay
  * more camera presets
    * forward follow
	* smooth forward follow
	* Disable all players for cutscenes
* Helper
  * move GetAllPlayers and GetAllPlayerIDs to PlayerHelper
* UI library
  * drop downs
  * checkboxes
  * dragging and dropping
* UI
  * Custom chat
  * overlays for minimap
  * overlay for new round
  * help/info
* Cosmetics
* Physics

repository: pohka/Brewlit

repo_name: pohka/Brewlit


text:
---
priority: 1
---

So you want to build a Github-hosted static site for your band? Turns out this is all surprisingly easy...

First, you need the _gh-pages_ gem. Add it to your Gemfile (or just use [ours](https://github.com/rawfunkmaharishi/rawfunkmaharishi.github.io/blob/master/Gemfile)) and `bundle`, or just

```
gem install gh-pages
```

## Create some content

Create a file called _index.md_ at the root of the project that looks like this:

    ---
    ---

    Hello from Jekyll

Those dashes at the top are _important_ - without them Jekyll doesn't know that you intend this to be content.

Now from a console do

```
jekyll serve --watch
```

and point your browser at [http://localhost:4000/](http://localhost:4000/) and you should see those three words. You have successfully Jekylled.

## A wild *_site* appears

This is all about building a static site, right? What Jekyll has done, is create a directory called *_site* and filled it with the generated HTML of your actual site. This is an artefact and you don't really want it in Github. So

```
echo _site/ > .gitignore
```

to make git leave that well alone. Probably a good time to commit:

```
git init && git add . && git commit -m 'Committe the Fyrst'
```

Now it's time to look at [hosting your site on Github]({{ site.url }}/blog/2014/11/11/hosting-your-site-on-github/).

gha_language: SCSS

gha_license_id: MIT


text:
![MIT LICENSE](https://img.shields.io/github/license/William-Krug/weekend-movie-sagas.svg?style=flat-square)
![REPO SIZE](https://img.shields.io/github/repo-size/William-Krug/weekend-movie-sagas.svg?style=flat-square)
![TOP_LANGUAGE](https://img.shields.io/github/languages/top/William-Krug/weekend-movie-sagas.svg?style=flat-square)
![FORKS](https://img.shields.io/github/forks/William-Krug/weekend-movie-sagas.svg?style=social)

# Weekend Movie Sagas

## Description

_Duration: 1 Weekend Sprint_

This app was designed to generate a movie list similar to IMDB. Users are presented with a movie list view where they can drill into specifics about a movie by clicking on the movie poster of their choice. The details page will display a movies:

- movie poster
- title
- description
- genre(s)

Users have the option of adding a movie to the database through the **Add Movie** form. This form captures all of the pertinent information about a movie to be later displayed on the movie's details page.

### Prerequisites

- [Node.js](https://nodejs.org/en/)
- [Express.js](https://expressjs.com/)
- [React](https://reactjs.org/)
- [Redux](https://redux.js.org/)
- [PostgreSQL](https://www.postgresql.org)
- [Postico](https://eggerapps.at/postico/)

## Installation

1. Create a database named `saga_movies_weekend`,
2. The queries in the `database.sql` file are set up to create all the necessary tables and populate the needed data to allow the application to run correctly. The project is built on [Postgres](https://www.postgresql.org/download/), so you will need to make sure to have that installed. We recommend using Postico to run those queries as that was used to create the queries,
3. Open up your editor of choice and run an `npm install`
4. Run `npm run server` in your terminal
5. Run `npm run client` in your terminal
6. The `npm run client` command will open up a new browser tab for you!

## Usage

1. The home page of the app will display a list of all movies stored in the database. Each movie's title and poster will be rendered to the DOM
2. A user can click on a movie's poster to be taken to a new page with details about the selected movie
3. A user can add a new movie by clicking on **Add Movie** where they can input a new movie's title, description, url to the movie poster, and associated genres with the movie

## Built With

- HTML
- CSS
- JavaScript
- Node
- Express
- React
- Redux
- PostgreSQL
- Postico

## License

[MIT](https://choosealicense.com/licenses/mit/)

Copyright (c) [2021] [William Krug]

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.

## Acknowledgement

Thanks to [Prime Digital Academy](www.primeacademy.io) who equipped and helped me to make this application a reality.

## Support

If you have suggestions or issues, please email me at [william.p.krug<EMAIL_ADDRESS>

repository: William-Krug/movie-sagas

repo_name: William-Krug/movie-sagas


text:
# Exploration
[Design Doc](/dist/docs/designDoc.md) | [Discovery](/dist/docs/discovery.md) | Exploration | [Go to market](/dist/docs/goToMarket.md)

---
## Ideation
Keep the refined problem statement in mind when exploring solutions:
${problemStatement}

---
### Hypotheses
Get help with a [hypothesis framework](https://docs.google.com/forms/d/1YJZIdEaZPN2K59O-gOHGNW2kXPRtLsPwiM32BSd0pHI/edit?usp=sharing).

${hypotheses}

---
### Artifacts
Drawings, surveys, flow charts, prototypes. UI, code repos, and more.

| Date | Creator | Artifact |
| --- | --- | --- |
|  |  |  |

---
#### Solution brainstorm
For when multiple ideas to solve the problem statement are needed. Use the table below or this [google sheet](https://docs.google.com/spreadsheets/d/1QCye8bQ4Nvg6S0Vlzem7flVsTL73BDOMhGFVaLgBE98/edit?usp=sharing).

| Person | Concept |
| --- | --- |
|  |  |

| Grouped concepts |
| --- |
|  |

---
#### Concept selection matrix
For ranking solutions against the right problems. Use the table below or this [google sheet](https://docs.google.com/spreadsheets/d/1QCye8bQ4Nvg6S0Vlzem7flVsTL73BDOMhGFVaLgBE98/edit?usp=sharing).
| Needs | Grouped concept 1 | Grouped concept 2 |
| --- | --- | --- |
| Need 1.1 (main or sub or indv) |  |  |
| Need 1.2 |  |  |
| Need 2.1 (main or sub or indv) |  |  |
| Need 2.2 |  |  |
| Cost (difficulty) |  |  |
| Wow factor |  |  |
| Elegance & beauty |  |  |
| Scalability |  |  |
| Totals|  |  |

---
## Validation

---
### Test Plan
Use the following questions to understand what you need to learn from your user test.

**General**
What business challenges are being addressed?
What questions are being answered?
What needs to be understood from this study?

**Users**
Who might be using this part of the product, experience, service, app, site, etc?

**Goals**
What specific questions need answers?
How will the insights be used from this study?

---
### User testing results
${userTesting}

---
Next is [go-to-market](/dist/docs/goToMarket.md)

repository: ryanallen/designDoc

branch_name: refs/heads/main

repo_name: ryanallen/designDoc


text:
Basic (Locked to 60%):

```js
<ProgressBar progress={60} />
```

Stripes:

_`stripes` should be used if you do not have access to the progress of a particular task/job.

```js
<ProgressBar stripes={true} />
```

repository: coulterpeterson/local-components

repo_name: coulterpeterson/local-components


text:
# Python-CRUD

Derek Merck
<EMAIL_ADDRESS>
University of Florida and Shands Hospital
Gainesville, FL

Python framework for implementing CRUD (create, retrieve, update, delete) service endpoints and management daemons.  Supports distributed task management with [celery[].

[celery]: http://www.celeryproject.org

The [Python-DIANA][] library extends Python-CRUD with DICOM-relevant items, endpoints, tasks, and daemons.

[python-diana]: http://github.com/derekmerck/diana2

The [Python-WUPHF][] library extends Python-CRUD with SMTP and SMS messenger endpoints and a dispatcher daemon.

[python-wuphf]: http://github.com/derekmerck/wuphf

## Usage

Endpoints provide an abstraction layer between application specific logic and technical implementations of specific services such a file directories or servers (generically called Gateways here).  Method syntax generally follows standard KV nomenclature (get, put, find, etc.)

Endpoints handle Items, which may include metadata, data, and other attributes.  Items may be referenced by an ItemID for Get or Delete requests.  Put requests require an Item type argument.  And Find requests describe Items by a mapping Query.

### Command-line Interface

Command-line bindings for "service-level" tasks are also provided in `crud-cli`.  Specifically, given a service description file (endpoint kwargs as yaml), an endpoint can be created and methods (get, put, etc) called on it via command-line.

## License

MIT

repository: derekmerck/pycrud

repo_name: derekmerck/pycrud


text:
# Terraform module for crazy-berlin-weather service
This module can be used to prepare AWS S3 solution for **crazy-berlin-weather** service. Was developed as test exercise.

## How to use
#### Add environment variables
Bash example:
```shell
AWS_DEFAULT_REGION="<YOUR APP REGION>"
AWS_ACCESS_KEY_ID="<YOUR AWS_ACCESS_KEY_ID>"
AWS_SECRET_ACCESS_KEY="<YOUR AWS_SECRET_ACCESS_KEY>"
```
Fish example:
```shell
set -Ux AWS_DEFAULT_REGION <YOUR APP REGION>
set -Ux AWS_ACCESS_KEY_ID <YOUR AWS_ACCESS_KEY_ID>
set -Ux AWS_SECRET_ACCESS_KEY <YOUR AWS_SECRET_ACCESS_KEY>
```

Create main.tf file with:
```terraform
module "weather_reports" {
  source              = "github.com/behoof4mind/tf-module-weather-reports?ref=0.0.2"
  bucket_name_prefix  = "crazy-berlin-weather"
  s3_acl_type         = "private"
  origin_website      = "https://weather-service.com"

  hourly = {
    suffix            = "hourly"
    acl_type          = "private"
    expiration        = 90
    transition_1_sc   = "STANDARD_IA"
    transition_1_days = 30
    transition_2_sc   = "GLACIER"
    transition_2_days = 60
  }

  daily = {
    suffix            = "daily"
    acl_type          = "private"
    expiration        = 180
    transition_1_sc   = "STANDARD_IA"
    transition_1_days = 30
    transition_2_sc   = "GLACIER"
    transition_2_days = 60
  }

  weekly = {
    suffix            = "weekly"
    acl_type          = "private"
    expiration        = 360
    transition_1_sc   = "STANDARD_IA"
    transition_1_days = 30
    transition_2_sc   = "GLACIER"
    transition_2_days = 60
  }
}

output "weekly_endpoint" {
  description = "Endpoint for weekly S3 bucket"
  value       = module.weather_reports.weekly_endpoint
}

output "daily_endpoint" {
  description = "Endpoint for daily S3 bucket"
  value       = module.weather_reports.daily_endpoint
}

output "hourly_endpoint" {
  description = "Endpoint for hourly S3 bucket"
  value       = module.weather_reports.hourly_endpoint
}
```
_- these variables in example are default, if you don't want to override them - only source line should be specified;_<br>
_- dont forget to use latest varion of module in ref=0.0.2 notation_
Make init
```shell
terraform init
```

Apply changes
```shell
terraform apply
```

As result, you should see output with access points like:
```shell
daily_endpoint = "crazy-berlin-weather-daily-307150142929.s3-accesspoint.us-east-2.amazonaws.com"
hourly_endpoint = "crazy-berlin-weather-hourly-307150142929.s3-accesspoint.us-east-2.amazonaws.com"
weekly_endpoint = "crazy-berlin-weather-weekly-307150142929.s3-accesspoint.us-east-2.amazonaws.com"
```

## Contributing

Thanks for considering contributing! There’s information about how to [get started with tf-module-weather-reports module](CONTRIBUTE.md)

## License

[The MIT License (MIT)](LICENSE.md)

Copyright © 2021 [Denis Lavrushko](https://dlavrushko.de)


text:
---
layout: post
title: How to delete OTRS Webservice
tags: [otrs, OTRS]
---

If you search for a delete option in the Webservice at OTRS UI you'll
find nothing. But there is a way.

There is a script that can do this:

```
su -c 'bin/otrs.Console.pl Admin::WebService::Delete --webservice-id <ID>' - otrs
```

Where `<ID>` is the webservice id. You can find a list of webservices IDs with
this select

```
cat <<EOS | mysql -u root -p otrs
select id, name from gi_webservice_config;
EOS
```

Cheers

gha_language: HTML

gha_license_id: NOASSERTION


text:
# eth-challenge-base

xinetd docker for building ethereum contract challenges in capture the flag (CTF).

## Getting Started

### Quick Demo

```bash
docker run -it -p 20000:20000 -e WEB3_PROVIDER_URI=uri chainflag/eth-challenge-base:0.9.2
nc <IP_ADDRESS> 20000
```

## Usage

### Create challenge project based on [example](https://github.com/chainflag/eth-challenge-base/tree/main/example)
* `contracts` is the challenge contract directory, you should code [isSolved()](https://github.com/chainflag/eth-challenge-base/blob/main/example/contracts/Example.sol#L18) function for the contract to check if it is solved
* `challenge.yml` is the config for specifying challenge description, flag, contract name, constructor, gas limit etc. See comments in this file for more detail
* `.env` is used to set environment variables of docker container, including web3 provider, token secret and proof of work difficulty

**Environment variable defaults**

| Name              | Default Value
| ----------------- | ----------------------------------
| TOKEN_SECRET      | [/dev/urandom](https://github.com/chainflag/eth-challenge-base/blob/main/entrypoint.sh#L7-L10)
| POW_DIFFICULTY    | 0(no proof of work)

>You can build multi-contract challenges by deploying contracts in a setup contract's constructor

### Start serving your contract challenge
```bash
docker run -d -p 20000:20000 --env-file .env -v `pwd`/contracts:/home/ctf/contracts -v `pwd`/challenge.yml:/home/ctf/challenge.yml chainflag/eth-challenge-base:0.9.2
```

or

```bash
docker-compose up -d
```

## Development

### Prerequisites
* Python3
* Packages
```bash
pip install -r requirements.txt
```

### Run in dev mode
```bash
python develop.py
```

### Format python source
```bash
pip install -r requirements-dev.txt
make format
```

## License

Distributed under the MIT License. See LICENSE for more information.

## Acknowledgements

* https://github.com/eth-brownie/brownie
* https://github.com/hitcxy/blockchain_template
* https://github.com/paradigm-operations/paradigm-ctf-2021
* https://github.com/balsn/proof-of-work

repository: codingsafe/eth-challenge-base

repo_name: codingsafe/eth-challenge-base


text:
project_path: /web/_project.yaml
book_path: /web/ilt/pwa/_book.yaml

{# wf_auto_generated #}
{# wf_updated_on: 2018-04-06 #}
{# wf_published_on: 2016-01-01 #}

# Live Data in the Service Worker {: .page-title }

## Introduction

Offline support and reliable performance are key features of Progressive Web Apps. This text describes some recommendations for storing different kinds of data in a PWA.

## Where should offline data be stored?

A general guideline for data storage is that URL addressable resources should be stored with the  [Cache](https://developer.mozilla.org/en-US/docs/Web/API/Cache) interface, and other data should be stored with  [IndexedDB](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API). For example HTML, CSS, and JS files should be stored in the cache, while JSON data should be stored in IndexedDB. Note that this is only a guideline, not a firm rule.

### Why IndexedDB and the Cache interface?

There are a  [variety of reasons](https://medium.com/dev-channel/offline-storage-for-progressive-web-apps-70d52695513c#.lm82vlyt8) to use IndexedDB and the Cache interface. Both are asynchronous and accessible in service workers, web workers, and the window interface. IndexedDB is  [widely supported](http://caniuse.com/#feat=indexeddb), and the Cache interface  [is supported](https://jakearchibald.github.io/isserviceworkerready/) in Chrome, Firefox, Opera, and Samsung Internet.

In this text we use Jake Archibald's  [IndexedDB Promised](https://github.com/jakearchibald/indexeddb-promised) library, which enables promise syntax for IndexedDB. There are also  [other IndexedDB libraries](https://medium.com/dev-channel/offline-storage-for-progressive-web-apps-70d52695513c#.lm82vlyt8) that can be used to abstract some of the less convenient aspects of the API.

Debugging support for IndexedDB is available in Chrome, Opera, Firefox and Safari. Debugging support for Cache Storage is available in Chrome, Opera, and Firefox. These are covered in [Tools for PWA Developers](tools-for-pwa-developers).

Note: Some developers have run into issues with Safari 10's IndexedDB implementation. Test your app to make sure it works on your target browser. File browser bugs with your browser's vendor so that browser implementors and library maintainers can investigate.

### How Much Can You Store

Different browsers allow different amounts of offline storage. This table summarizes storage limits for major browsers:

Browser

Limitation

Notes

Chrome, Opera, and Samsung Internet

Up to a  quota. Check usage with the  Quota API

Storage is per origin not per API (local storage, session storage, service worker cache and IndexedDB all share the same space)

Firefox

No limit

Prompts after 50 MB of data is stored

Mobile Safari

50MB

Desktop Safari

No limit

Prompts after 5MB of data is stored

Internet Explorer (10+)

250MB

Prompts after 10MB of data is stored

## Using IndexedDB and the Cache interface

### Storing data with IndexedDB

IndexedDB is a noSQL database. IndexedDB data is stored as key-value pairs in __object stores__. The table below shows an example of an object store, in this case containing beverage items:

#

Key (keypath 'id')

Value

0

1234

{id: 123, name: 'coke', price: 10.99, quantity: 200}

1

9876

{id: 321, name: 'pepsi', price: 8.99, quantity: 100}

2

4567

{id: 222, name: 'water', price: 11.99, quantity: 300}

The data is organized by a __`keypath`__, which in this case is the item's __`id`__ property. You can learn more about IndexedDB in the corresponding  [text](working-with-indexeddb), or in the  [code lab](lab-indexeddb).

The following function could be used to create an IndexedDB object store like the example above:

#### service-worker.js

```
function createDB() {
  idb.open('products', 1, function(upgradeDB) {
    var store = upgradeDB.createObjectStore('beverages', {
      keyPath: 'id'
    });
    store.put({id: 123, name: 'coke', price: 10.99, quantity: 200});
    store.put({id: 321, name: 'pepsi', price: 8.99, quantity: 100});
    store.put({id: 222, name: 'water', price: 11.99, quantity: 300});
  });
}
```

Note: All IndexedDB code in this text uses Jake Archibald's  [IndexedDB Promised](https://github.com/jakearchibald/indexeddb-promised) library, which enables promise syntax for IndexedDB.

Here we create a  'products' database, version 1. Inside the 'products' database, we create a 'beverages' object store. This holds all of the beverage objects. The `beverages` object store has a keypath of `id`. This means that the objects in this store will be organized and accessed by the `id` property of the `beverage` objects. Finally, we add some example beverages to the object store.

Note: If you're familiar with IndexedDB, you may be asking why we didn't use a transaction when creating and populating the database. In IndexedDB, a transaction is built into the database creation operation.

The service worker activation event is a good time to create a database. Creating a database during the activation event means that it will only be created (or opened, if it already exists) when a new service worker takes over, rather than each time the app runs (which is inefficient). It's also likely better than using the service worker's installation event, since the old service worker will still be in control at that point, and there could be conflicts if a new database is mixed with an old service worker. The following code (in the service worker file) could be used to create the database shown earlier on service worker activation:

#### service-worker.js

```
self.addEventListener('activate', function(event) {
  event.waitUntil(
    createDB()
  );
});
```

Note: `event.waitUntil` ensures that a service worker does not terminate during asynchronous operations.

Once an IndexedDB database is created, data can then be read locally from IndexedDB rather than making network requests to a backend database. The following code could be used to retrieve data from the example database above:

#### service-worker.js

```
function readDB() {
  idb.open('products', 1).then(function(db) {
    var tx = db.transaction(['beverages'], 'readonly');
    var store = tx.objectStore('beverages');
    return store.getAll();
  }).then(function(items) {
    // Use beverage data
  });
}
```

Here we open the `products` database and create a new transaction on the `beverages` store of type `readonly` (we don't need to write data). We then access the store, and retrieve all of the items. These items can then be used to update the UI or perform whatever action is needed.

Note: A transaction is wrapper around an operation, or group of operations, that ensures database integrity. If one of the actions within a transaction fail, none of them are applied and the database returns to the state it was in before the transaction began. All read or write operations in IndexedDB must be part of a transaction. This allows for atomic read-modify-write operations without worrying about other threads acting on the database at the same time.

### Storing assets in the Cache interface

URL addressable resources are comparatively simple to store with the Cache interface. The following code shows an example of caching multiple resources:

#### service-worker.js

```
function cacheAssets() {
  return caches.open('cache-v1')
  .then(function(cache) {
    return cache.addAll([
      '.',
      'index.html',
      'styles/main.css',
      'js/offline.js',
      'img/coke.jpg'
    ]);
  });
}
```

This code opens a `cache-v1` cache, and stores __index.html__, __main.css__, __offline.js__, and __coke.jpg__.

The service worker installation event is a good time to cache static assets like these. This ensures that all the resources a service worker is expected to have are cached when the service worker is installed. The following code (in the service worker file) could be used to cache these types of files during the service worker install event:

#### service-worker.js

```
self.addEventListener('install', function(event) {
  event.waitUntil(
    cacheAssets()
  );
});
```

Once assets are cached, they can be retrieved during fetch events. The following code (in the service worker file) allows resources to be fetched from the cache instead of the network:

#### service-worker.js

```
self.addEventListener('fetch', function(event) {
  event.respondWith(
    caches.match(event.request).then(function(response) {
      // Check cache but fall back to network
      return response || fetch(event.request);
    })
  );
});
```

This code adds a `fetch` listener on the service worker that attempts to get resources from the cache before going to the network. If the resource isn't found in the cache, a regular network request is still made.

## Further reading

*  [Offline Storage for Progressive Web Apps](https://medium.com/dev-channel/offline-storage-for-progressive-web-apps-70d52695513c#.lm82vlyt8)
*  [IndexedDB Promised](https://github.com/jakearchibald/indexeddb-promised)
*  [Support for the Cache interface](https://jakearchibald.github.io/isserviceworkerready/#caches)
*  [Support for IndexedDB](http://caniuse.com/#feat=indexeddb)

repository: shanselman/WebFundamentals

repo_name: shanselman/WebFundamentals


text:
# Install Sublime

Sublime was written by and for developers. Unfortunately that makes it tricky to configure, but it has everything that good developer's want. The first step, installing it is pretty easy, just make sure you get Sublime Text 2, so you don't get nagged as much:

[Sublime Text 2 Free Edition](http://www.sublimetext.com/2)

## Package Manager

Next you'll need a "package manager" to make it easy to add plugins to Sublime. Copy and paste this python code into your sublime's built-in python interpreter. To get to subplime python interpretter/console, launch Sublime and then hit CTRL+<kbd` . That's CTRL-BACKTICK. BACKTICK is the key in the upper left below the Tilde (~). That should open up a console at the bottom of Sublime where you can paste this:

```python
import urllib2,os,hashlib; h = '2915d1851351e5ee549c20394736b442' + '8bc59f460fa1548d1514676163dafc88'; pf = 'Package Control.sublime-package'; ipp = sublime.installed_packages_path(); os.makedirs( ipp ) if not os.path.exists(ipp) else None; urllib2.install_opener( urllib2.build_opener( urllib2.ProxyHandler()) ); by = urllib2.urlopen( 'http://packagecontrol.io/' + pf.replace(' ', '%20')).read(); dh = hashlib.sha256(by).hexdigest(); open( os.path.join( ipp, pf), 'wb' ).write(by) if dh == h else None; print('Error validating download (got %s instead of %s), please try manual install' % (dh, h) if dh != h else 'Please restart Sublime Text to finish installation')
```

## Syntax Highlighting and Linting

So the packages for syntax highlighting and "linting" in Python are awesome. The mandatory one for me is Pep8Lint, it nags you to keep your code pythonic, so others can read it.

To install a package in Sublime hit the CTRL+SHIFT-p key. This will bring up a list of commands in Sublime. Start typing "install" and hit enter when "install package" is highlighted at the top. Then you can type "Pep8" and hit return when "Pep8Lint" is highlighted.  Another one that is useful if you want to catch even more errors and enforce more strict style guides on yourself or your team, is "Flake8Lint"

## Configuration

Talk to me if you want me to send you my configuration files so your Sublime is as sublime as mine.


text:
---
layout: page
current: about
title: About
navigation: true
logo: 'assets/images/ghost.png'
class: page-template
subclass: 'post page'
---

# What I do

At Zoho, I work as Technical Product Manager of the product. My day to day activities include talking with developers on architecture for new features, giving feedback on the UX/UI, coordinating the testing and release management process; and also mainly work with other product managers to focus on the new features release and helping them to understand techncial challenges and ship them effectively.

# Contribution to Open source

I love contributing to Open source technologies. I have been contributing to Mozilla from 2013.  I have done various contribution to the community which I would like to list few below.

## Mozilla

#### MozillaTN ( 2014 - Present)

Along with 2 other MozillaReps from Tamilnadu started regional community to strengthen Open source communities around Tamilnadu. One of the strongest regional community in India and which bring lot of new initiative to grow contributors. Active engagement channel is [Telegram](https://t.me/mozillatnc)

  - Designed first [Weeks Of Contribution](https://vp7techie.wordpress.com/2015/06/24/weeks-of-contribution/) program where new contributors were trained using Youtube in 2015, which acted as seed for todays's contributors around Tamilnadu.
  - Organized [First MozillaTN meetup](https://vp7techie.wordpress.com/2017/02/24/mozillatn-first-meetup/) in 2017.
  - In 2017, to spread more information about Software freedom day, created a short template for first time contributors [SFD17](https://mozillatn.github.io/sfd17/)
  - Collaborated with more than 20 colleges and brought around 200 contributors.

#### Mozilla TechSpeaker (2017-2020)

  - [Mozilla Tech Speakers](https://wiki.mozilla.org/TechSpeakers) was a program to bring together volunteer contributors who are already speaking to technical audiences (developers/web designers/computer science and engineering students) about Firefox, Mozilla and the Open Web in communities around the world.
  - Focused more on WebExtension development. Released Free book on Leanpub with title [`Building Browser Extension`](https://leanpub.com/mozwebext/) and [Youtube Videos](https://youtube.com/playlist?list=PLdIyyZgtQZ7CJR5XFB5xvZH0oaBIT_gTD) to support it.

#### Senior Firefox OS App Reviewer (2014-2016)

  - I got opportunity to review apps which are built using HTML5/JS/CSS for Firefox OS based Mobile phones. Will be checking the UX of the apps and help other developers to understand the guidelines of app publishing to the Firefox Marketplace.
  - Mentored other Firefox OS app reviewers who are specialized in reviewing [Firefox OS Tarko Devices](https://wiki.mozilla.org/Firefox_OS/Tarako).
  - Helped Mozilla to launch Firefox OS in India.

#### VP of Technology, Firefox Students Ambassador Program (2013-2015)

  - Helped Firefox Students Ambassador program as [VP of Tech](https://wiki.mozilla.org/StudentAmbassadors/ExecutiveBoard/Roles/2015)
  - Launched `App of the Month` contest where students were encouraged to build Firefox OS apps and submit each month, with community and board members voting best apps are selected.
  - Helped students to understand about Open source contribution and made them aware of contributions areas like Documentation, Social Media support and manual Testing.

# Community Engagements

## Crio.do

[Crio.do](https://www.crio.do/) Project based learning for developers.

#### Crio Winter of Doing Mentor (Jan 2021 - Apr 2021)

Crio organized one of the [Crio Winter of Doing](https://www.crio.do/crio-winter-of-doing/). Crio Winter of Doing is a one of a kind program focussed on bringing together budding engineering talent to work on challenging projects for the most exciting startups in the country.

- Got opportunity to Mentor young upcoming developers to build site based contextual chatbox.

## Google

#### Google Students Ambassador (Aug 2012- May 2013)

GSA act as liasion between Google and Institute where students studies.

- My role was to evangelize about Google Drive and Youtube to colleges and help in adoption them for their education purpose.
- Led a team of 7 members in Google Map maker contest and topped it among other 125 Google Student Ambassadors.
- Was one of top 16 Google Student Ambassador for year 2012-2013. Due to this got a chance to give panel discussion at Google India Community Summit 2013 for new set of Google Students Ambassador(2013-2014).

# Contact
Feel free to reach out to me on [Twitter](https://twitter.com/heyvp7) and [LinkedIn](https://www.linkedin.com/in/viswaprasathks/). I’ll be happily chat with you or answer any questions you may have.

Thanks all!

gha_language: JavaScript


text:
# django-image-upload-crop
A widget for image upload with features like preview, zoom, crop functionality

## Installation

1. Clone repository
2. Create a file called local.py under imgcrop/settings/ directory
3. Add your local database details to imgcrop/settings/local.py
5. Activate your environment (if you are using miniconda just type "source activate YOUR_ENVIRONMENT_NAME")
6. Then run "python manage.py migrate" from project root
7. Run "python manage.py runserver".
8. Open your browser type "http://<IP_ADDRESS>:8000" (This may be different on your machine)

### Frontend

I am using webpack and laravel-mix for asset management, please feel free to play with the webpack.mix.js file and composer.js file for frontend changes. Please make sure that you run "npm install" and "npm run dev" to update the frontend changes.

Please feel free to contact me on<EMAIL_ADDRESS>for any queries you may have.

repository: shineklbm/django-image-upload-crop

repo_name: shineklbm/django-image-upload-crop


text:
---
layout : manual
title  : Don't Panic!
---
This is the manual page, it's friendlier than other manual pages, in some circles even known as "THE manual". Please consult it first for any TextExt related question, and if you don't find your answers, please consult it second and third. If all else fails, use the towel to wipe your tears and then reach out to me on the TextExt Twitter hot support line. The "hotness" of said support line may or may not be actually all that hot. The temprature will vary greatly based on your time zone, my time zone and whenever or not somebody recently purchased the whole shenanigans.

If you are curious what "TextExt" stands for, not unlike the "PHP", it's a double reverse self referencing anagram where "TExt" expands to "TextExt". Also stands for "Text EXTREME!!!!" with that exact number of exclamation signs and to only be said out loud with the coarse, rustic, honed in one hundred battles kind of voice.

For the sake of filling in the rest of the page with something useful, here's the "README" again. If you are asked once again to refer to the manual page, you may skip this step at your leisure since you are already on that page.

{% include about.html %}

repository: alexgorbatchev/jquery-textext-doc

gha_language: Ruby

repo_name: alexgorbatchev/jquery-textext-doc


text:
I use these script to build the help, keep StickFigure.pde in sync, and ensure all the sketches run OK in some different flavors of Processing.

# Prerequisites

* [php](http://php.net/)
* The [javadoc](https://en.wikipedia.org/wiki/Javadoc) command (part of the [JDK](http://www.oracle.com/technetwork/java/javase/downloads/index.html))
* One or more versions of the [Processing](https://processing.org/)

Then modify config.php to reflect where Processing is installed on your system, and where any web-browsers you'd like to test with are installed.


text:
# MS-SVConv : 3D Point Cloud Registration with Multi-Scale Architecture and Self-supervised Fine-tuning

Compute features for 3D point cloud registration. The article is available on [Arxiv](https://arxiv.org/abs/2103.14533).
It relies on:
- A multi scale sparse voxel architecture
- Self-supervised fine-tuning
The combination of both allows better generalization capabilities and transfer across different datasets.

The code is available on the [torch-points3d repository](https://github.com/nicolas-chaulet/torch-points3d).
This repository is to show how to launch the code for training and testing.

## Demo
If you want to try MS-SVConv without installing anything on your computer, A Google colab notebook is available [here](https://colab.research.google.com/github/humanpose1/MS-SVConv/blob/main/notebook/demo_MSSVConv.ipynb) (it takes few minutes to install everything). In the colab, we compute features using MS-SVConv and use Ransac (implementation of Open3D) to compute the transformation.
You can try on 3DMatch on ETH. With this notebook, you can directly use the pretrained model on your project !

## Installation

The code have been tried on an NVDIA RTX 1080 Ti with CUDA version 10.1. The OS was Ubuntu 18.04.

### Installation for training and evaluation
This installation step is necessary if you want to train and evaluate MS-SVConv.

first you need, to clone the [torch-points3d repository](https://github.com/nicolas-chaulet/torch-points3d)
```
git clone https://github.com/nicolas-chaulet/torch-points3d.git
```
Torch-points3d uses [poetry](https://python-poetry.org/) to manage the packages. after installing Poetry, run :
```
poetry install --no-root
```
Activate the environnement
```
poetry shell
```
If you want to train MS-SVConv on 3DMatch, you will need pycuda (It's optional for testing).
```
pip install pycuda
```
You will also need to install [Minkowski Engine](https://github.com/NVIDIA/MinkowskiEngine) and [torchsparse](https://github.com/mit-han-lab/torchsparse)
Finally, you will need [TEASER++](https://github.com/MIT-SPARK/TEASER-plusplus) for testing.

If you have problems with installation (espaecially with [pytorch_geometric](https://github.com/rusty1s/pytorch_geometric)), please visit the [Troubleshooting section](https://github.com/nicolas-chaulet/torch-points3d#troubleshooting) of torch-points3d page.

## Training

### registration

If you want to train MS-SVConv with 3 heads starting at the scale 2cm, run this command:
```
poetry run python train.py task=registration models=registration/ms_svconv_base model_name=MS_SVCONV_B2cm_X2_3head data=registration/fragment3dmatch training=sparse_fragment_reg tracker_options.make_submission=True training.epochs=200 eval_frequency=10
```

automatically, the code will call the right yaml file in `conf/data/registration` for the dataset and `conf/model/registration` for the model.
If you just want to train MS-SVConv with 1 head, run this command
```
poetry run python train.py task=registration models=registration/ms_svconv_base model_name=MS_SVCONV_B2cm_X2_1head data=registration/fragment3dmatch training=sparse_fragment_reg tracker_options.make_submission=True training.epochs=200 eval_frequency=10
```
You can modify some hyperparameters directly on the command line. For example, if you want to change the learning rate of `1e-2`, you can run:
```
poetry run python train.py task=registration models=registration/ms_svconv_base model_name=MS_SVCONV_B2cm_X2_1head data=registration/fragment3dmatch training=sparse_fragment_reg tracker_options.make_submission=True training.epochs=200 eval_frequency=10 training.optim.base_lr=1e-2
```

To resume training:
```
poetry run python train.py task=registration models=registration/ms_svconv_base model_name=MS_SVCONV_B2cm_X2_3head data=registration/fragment3dmatch training=sparse_fragment_reg tracker_options.make_submission=True epochs=200 eval_frequency=10 training.checkpoint_dir=/path/of/directory/containing/pretrained/model
```

WARNING : On 3DMatch, you will need a lot of disk space because the code will download the RGBD image on 3DMatch and build the fragments from scratch. Also the code takes time (few hours).

For 3DMatch, it was supervised training because the pose is necessary. But we can also fine-tune in a self-supervised fashion (without needing the pose).

To train on Modelnet run this command:
```
poetry run python train.py task=registration models=registration/ms_svconv_base model_name=MS_SVCONV_B2cm_X2_3head data=registration/modelnet_sparse_ss training=sparse_fragment_reg tracker_options.make_submission=True training.epochs=200 eval_frequency=10
```

To fine-tune on ETH run this command (First, download the pretrained model from 3DMatch [here](https://cloud.mines-paristech.fr/index.php/s/hRc6y2YIFtYsGAI/)):
```
poetry run python train.py task=registration models=registration/ms_svconv_base model_name=MS_SVCONV_B4cm_X2_3head data=registration/eth_base training=sparse_fragment_reg_finetune tracker_options.make_submission=True training.epochs=200 eval_frequency=10 models.path_pretrained=/path/to/your/pretrained/model.pt
```
To fine-tune on TUM, run this command:
```
poetry run python train.py task=registration models=registration/ms_svconv_base model_name=MS_SVCONV_B4cm_X2_3head data=registration/testtum_ss training=sparse_fragment_reg_finetune tracker_options.make_submission=True training.epochs=200 eval_frequency=10 models.path_pretrained=/path/to/your/pretrained/model.pt
```

For all these command, it will save in `outputs` directory log of the training, it will save a `.pt` file which is the weights of

### semantic segmentation

You can also train MS-SVConv on scannet for semantic segmentation. To do this simply run:
```
poetry run python train.py task=segmentation models=segmentation/ms_svconv_base model_name=MS_SVCONV_B4cm_X2_3head lr_scheduler.params.gamma=0.9922 data=segmentation/scannet-sparse training=minkowski_scannet tracker_options.make_submission=False tracker_options.full_res=False data.process_workers=1 training.wandb.log=True eval_frequency=10 training.batch_size=4
```
And you can easily transfer from registration to segmantation, with this command:
```
poetry run python train.py task=segmentation models=segmentation/ms_svconv_base model_name=MS_SVCONV_B4cm_X2_3head lr_scheduler.params.gamma=0.9922 data=segmentation/scannet-sparse training=minkowski_scannet tracker_options.make_submission=False tracker_options.full_res=False data.process_workers=1 training.wandb.log=True eval_frequency=10 batch_size=4 models.path_pretrained=/path/to/your/pretrained/model.pt
```

## Evaluation

If you want to evaluate the models on 3DMatch,  download the model [here](https://cloud.mines-paristech.fr/index.php/s/hRc6y2YIFtYsGAI) and run:

```
poetry run python scripts/test_registration_scripts/evaluate.py task=registration models=registration/ms_svconv_base model_name=MS_SVCONV_B2cm_X2_3head data=registration/fragment3dmatch training=sparse_fragment_reg cuda=True data.sym=True training.checkpoint_dir=/directory/of/the/models/
```
on ETH (model [here](https://cloud.mines-paristech.fr/index.php/s/pUmGPtHUG2ASxlJ)),
```
poetry run python scripts/test_registration_scripts/evaluate.py task=registration models=registration/ms_svconv_base model_name=MS_SVCONV_B4cm_X2_3head data=registration/eth_base training=sparse_fragment_reg cuda=True data.sym=True training.checkpoint_dir=/directory/of/the/models/
```
on TUM (model [here](https://cloud.mines-paristech.fr/index.php/s/LUVEZvutaDpEkVD)),
```
poetry run python scripts/test_registration_scripts/evaluate.py task=registration models=registration/ms_svconv_base model_name=MS_SVCONV_B2cm_X2_3head data=registration/testtum_ss training=sparse_fragment_reg cuda=True data.sym=True training.checkpoint_dir=/directory/of/the/models/
```
You can also visualize matches, you can run:
```
python scripts/test_registration_scripts/see_matches.py task=registration models=registration/ms_svconv_base model_name=MS_SVCONV_B4cm_X2_3head data=registration/eth_base training=sparse_fragment_reg cuda=True data.sym=True training.checkpoint_dir=/directory/of/the/models/ data.first_subsampling=0.04 +ind=548 +t=22
```

You should obtain this image
 <img src="image/match.png"  height="600">

## Model Zoo
You can find all the pretrained model  (More will be added in the future)

## citation
If you like our work, please cite it :
```
@inproceedings{horache2021mssvconv,
      title={3D Point Cloud Registration with Multi-Scale Architecture and Self-supervised Fine-tuning},
      author={Sofiane Horache and Jean-Emmanuel Deschaud and François Goulette},
      year={2021},
      journal={arXiv preprint arXiv:2103.14533}
}
```
And if you use ETH, 3DMatch, TUM or ModelNet as dataset, please cite the respective authors.

## TODO
 - Add other pretrained models on the model zoo
 - Add others datasets such as KITTI Dataset

repository: Abdurrasith/MS-SVConv

repo_name: Abdurrasith/MS-SVConv


text:
# Embedded collaboration pad

## About
Software of Master Thesis that enable students to develop embedded IoT in a collaborative environment.
It consist of

* realtime colaboration text editor
* video chat system based on webrtc
* mqtt client
* are to include tutorial content
* user authentication to organize groups

## Installation
Use an instance of mysql database, create a database and execute the following sql statement to create the two nessesary tables.

```
CREATE TABLE `securitytokens` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `user_id` int(10) NOT NULL,
  `identifier` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
  `securitytoken` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=210 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

CREATE TABLE `users` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `passwort` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
  `login` varchar(255) COLLATE utf8_unicode_ci NOT NULL DEFAULT '',
  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `updated_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=22 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
```

This create two tables. Use the **users** table to insert/create group logins.

After you've done this copy the content of this repository to a webserver of your choice that is able to connect to the database you created. Alter the **inc/config.inc.php** file and enter your database credentials.

The project is now ready to go.

repository: gokugiant/embeddedcollaborationpad

gha_language: CSS

repo_name: gokugiant/embeddedcollaborationpad


text:
# LAP1PortfolioProject
Community journaling website created by Callum, Elena and Quinn

## Project Description
This is a community journaling website where users can create journal entries anonymously and interact with other users posts with reactions and comments.

- Usera can view other peoples' entries.
- Users can react to other peoples’ entries with an emoji.
- Users have three emojis to choose from.
- Users can comment on other people’s entries.
- Users scan search post by keywords to filter the timeline.
- Users scan use the website on different devices and screen sizes
##

## Installation & Usage

### Installation

* Clone or download the repo.
* npm install to install dependencies

### Usage

* Open the terminal.
* Navigate to main folder
* Type `npm start` to start server (server is currently hosted on heroku but this can be changed to localhost)

## Technologies

* JavaScript
* Express
* Cors
* Heroku
* Netlify
* Bootstrap

### Testing

* Jest
* Jest-fetch-mock
* Test coverage is approximately 60% on the server side, but significantly less on the client side as we struggled with this

## Process
* We began by designing a draft using Excalidraw to plan out the layout and functionality
* Created some skeleton code for the general layout we wanted for the project
* We created a kanban board with issue cards to distribute tasks to group members
* Each issue was assigned to one or more people
* We started with creating the HTML and the server on localhost with a few routes
* Then we worked on the basic functionality of the website along with testing
* We migrated from using localhost to using heroku so our website could be deployed
* Finally we worked on styling the website using mainly bootstrap

## Wins & Challenges

### Wins
* Getting the server and client to communicate properly for all functionality
* Implementing an additional feature, a search function which allows the user to search posts by keyword
* Learning how to deploy on Heroku and seeing our website live

### Challenges
* client side testing was a challenge as none of us are familiar with how to do this
* We ran into some CORS issues which slowed us down
* Figuring out the right request to use when fetching from the server

## Bugs
* If description doesn't have 3 significant words, the entry will not post
* Its possible to exploit the emoji feature to add more than you should be able to

## Future features
* Multiple gifs previewing at once so you get a better collection
* Ability to sort the timeline by number of reactions and/or comments

## Licence
* MIT


text:
[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/vaadin-flow/Lobby#?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)

# Demo to integrate NGL Viewer in a Vaadin project

A simple demo to integrate [http://nglviewer.org/](http://nglviewer.org/) in a Vaadin project.

The JS files of NGL used during the run are from CDN.

To access it directly from github, clone the repository and import the project to the IDE of your choice as a Maven project. You need to have Java 8 or 11 installed.

Run using `mvn jetty:run` and open [http://localhost:8080](http://localhost:8080) in the browser.

If you want to run your app locally in the production mode, run `mvn jetty:run -Pproduction`.

repository: mjschnie/ngl-demo

repo_name: mjschnie/ngl-demo


text:
# Learn from Syntax: Improving Pair-wise Aspect and Opinion Terms Extraction with Rich Syntactic Knowledge

```
@inproceedings{lagcn_ijcai21,
title = {Learn from Syntax: Improving Pair-wise Aspect and Opinion Terms Extraction with Rich Syntactic Knowledge},
author = {Wu, Shengqiong and Fei, Hao and Ren, Yafeng and Ji, Donghong and Li, Jingye},
booktitle = {Proceedings of the Thirtieth International Joint Conference on Artificial Intelligence (IJCAI)},
pages = {3957--3963},
year = {2021}
}
```

links
- [ijcai](https://www.ijcai.org/Proceedings/2021/545)

gha_language: Jupyter Notebook


text:
# Meeting Notes: Governance, Jan 29 2019

Governance meeting held Jan 29 2019 @ 3PM [UTC](http://www.timebie.com/std/utc.php) in [grin/Lobby on Gitter](https://gitter.im/grin_community/Lobby), full chat transcript [here](https://gitter.im/grin_community/Lobby?at=5c506ab18aa5ca5abf4eee12). Meeting lasted ~ 90 min.

Notes are truncated, and conversations sorted based on topic and not always chronological. Quotes are edited for brevity and clarity, and not always exact.

**Community attendance:**
* antiochp
* bitcoinpizza
* catheryne_n_twitter
* davidburkett
* dewdeded
* garyyu
* hashmap
* ignopeverell
* jaspervdm
* kargakis
* lehnberg
* mcdallas
* quentinlesceller
* raghavsood
* rentenmark
* yeastplume

_(apologies if I missed someone - open a PR or contact @lehnberg to add)_

## Agenda points & Actions

### 1. Agenda review
[Proposed agenda](https://github.com/mimblewimble/grin-pm/issues/46) accepted.

### 2. Action point follow ups from previous meetings

[Previous actions](https://github.com/mimblewimble/grin-pm/blob/master/notes/20190103-meeting-governance.md):

* **Decision making process:** No update.
* **Decision log:** [Implemented](https://github.com/mimblewimble/grin-pm/issues/30)
* **@yeastplume to add status section to end of each point of libsecp audit:** Not done yet, expected to be done by next meeting.
* **@lehnberg to create request for proposal for how to handle promotion of other projects:** [done](https://github.com/mimblewimble/grin-pm/issues/52)
* **New website design:** Merged.
* **Grin stack exchange:** Not done. Tracked in [an issue](https://github.com/mimblewimble/grin-pm/issues/48) now. Discussed in other questions below.
* **Create Communities wiki page:** Not done
* **Create Events wiki page:** Not done

### 3. POW
* Discussion on [Ethical Mining Policy](https://forum.grin.mw/t/innosilicons-grin-asic-miner-or-paper-tiger/3241/2):
   > An ethical policy adoption, mandated by the Coin devs and community towards setting the right rules for manufacturers early in to ensure that the coins’ network is not rendered un-mineable by its community of miners and supporters. The disclosure of actual and factual quantities of ASICS being produced for every batch, quantities shipped as well as a full transparent disclosure of intent to self mine and what percentage or number of ASICS allocated to said practice. This helps miners buying into new ASICS, as well as the protection through policy for asic makers to ensure protection to the coin network with factual transparency enforcement.
   * _igno:_ Half of it is unenforceable. The part that's enforceable would be with hard forks, which we've discussed aplenty we're not doing and would only force ASIC manufacturers toward more secrecy. We can definitely encourage good practices, help out good actors and point out bad ones however. But I think we tend to do that regardless as part of orienting and policing this project, we're usually not too shy on our opinions. We can definitely start with a page listing what we'd like to see, more as an encouragement, and add manufacturers that are close to those wishes there.
   * _hashmap:_ Instead of restricting, we could encourage good behaviour, like a "fairtrade logo" or something.

### 4. [Security audits](https://github.com/mimblewimble/grin/issues/1609)
* _catheryne_n_twitter:_ I have 3 updated bids that include the wallet crate now. I will send the proposals, including my own recommendations, to Igno that can then share w/team. Once I have received a ranking, I will then proceed.

### 5. Dev fund

#### 5.1 Fund spending transparency report
* _lehnberg:_ Questions have come in about our spending, which right now is non existent. It probably makes sense to make that clear however, by by having a spending transparency report, showing money in and (no) money out.
* Yeastplume's campaigns are separate and should not be part of that.

##### Decision: Fund transparency report
To be created by @lehnberg.

#### 5.2 Decision: Donation addresses
* @ignopeverell to run a https listener for the developer fund.

#### 5.3 Yeast funding
* $8 received since Grincon.us.

##### Decision: Yeastplume fund raise chase
@ignopeverell to send another email and post on the forum to raise funds.

### 6. Promotion of other projects

* _lehnberg:_ I believe we received a fairly big donation yesterday or so. Not sure whether it was part of fair mining or not. But thought it migt be nice to create a new section related to our “friends” section that transparently shows which company/entity donated to the dev fund (and what amount) as part of their ongoing pledge to do so. Maybe its own page, as the list could get long (hopefully). Commending those who fulfil their pledges about donating to us as part of their ongoing operations, and we need to be transparent about what we receive, from whom etc.
* Additional proposals could be made in the [relevant issue on grin-pm](https://github.com/mimblewimble/grin-pm/issues/52).

### 7. Exchange integrations

* _lehnberg:_ https://github.com/mimblewimble/docs/wiki/Exchange-A-Questions have now been answered and submitted.
[General exchange FAQ](https://github.com/mimblewimble/docs/wiki/Exchange-FAQ) I’ve not had a chance to touch, last edit was in december by @kargakis. Seems like exchanges are neverthless able to list us. So doesn't seem like the most pressing problem to tackle.
   * _igno:_ looks like it, and if there are issues they face we can help with beyond that, they're welcome to keep asking.

### 8. Website

 New website looks great (shout out to @nijynot), we’ve dicussed some more content to add in this meeting already related to funding and spending.

### 9. Risk mgmt brainstorm
* Only yeastplume left to complete [risk assessment](https://github.com/mimblewimble/docs/wiki/Risk-Brainstorming).

### 10. Other questions

#### 10.1 Grin stackexchange
* Need >200 rep to propose a site.
* We've plenty of good candidates in community that could make the proposal, like mcdallas, rentenmark, or raghavsood.
* `grin` or `grincoin` would be suitable names.
* _rentenmark:_ The alternative to having your own site is a tag in some other SE site. Basically for low question volume topics it is often claimed that they're better off as tags in some other SE site.
   * _raghavsood:_ The closest one is bitcoin.SE, and although it is open to non-bitcoin questions, once a coin deviates too much it tends to be better off on its own site.
* _raghavsood:_ I can outline the SE process for those unfamiliar with it quickly:
   You make a proposal on Area51, which includes a justification as to why its own SE site is good. You also need to provide (anyone can provide, not just the person who proposed the site) with a list of sample questions (doesn't need answers, just the questions). Once enough sample questions with enough upvotes exist, the site moves into a beta phase. During the beta, you have to hit a certain number of metrics (questions per day, % answered, number of users with high rep (regular users), traffic, etc.).
   If the site is receiving enough interest for a few months/around a year, it will move from beta into a full site. If not, it will shut down after the beta.
   During the area51 proposal, you also need enough SE users to commit to/support the proposal before it can go to beta, which can take a few months.
   In the meantime, it may be worth pointing users to Bitcoin.SE's grin tag from the grin forums/main site.
   There's already a [tag for Grin](https://bitcoin.stackexchange.com/questions/tagged/grin) there. Bit sparse on questions, but I suppose it's a matter of letting users know where to ask.

##### Decision: stackexchange approach
We steer questions toward https://bitcoin.stackexchange.com/questions/tagged/grin and in the meanwhile we can work on a mimblewimble/grin specific site, which will take a few months even if it moves fast. @mcdallas to lead on this.

**Meeting adjourned.**

repository: mimblewimble/grin-pm

gha_language: Shell

repo_name: mimblewimble/grin-pm


text:
---
layout: post
title: Final Project Update
author: kaminalu
published: true
---

Okay, so as of my last post, my research question was:
I am studying Twitter responses to the question "what is art" in order to understand how art impacts people's daily lives so that there is a greater understanding of the public appreciation and perception of art.  Potentially this research could assist curators and social media professionals at galleries and museums to develop methods of outreach, educational tools, and programming for their spaces.

And my argument was:
  1. Twitter users have few but varied interactions with art day-to-day.
  2. Most Twitter users implementing the hashtag #art do so quite frequently.
  3. Common users of the hashtag #art are artists peddling their work, or organizations with an agenda, not average users.
  4. Complications would include representation of users who do not use the hashtag #art.
  5. When people reference art on the internet, it is generally for promotional reasons, and not an expression of discovery or appreciation.

As of now, I am still moving in this direction, but I've hit a few roadblocks.  The first is that the Twitter Archiver tool that we learned to use in class is only free for one use.  Meaning, when I ran my test fetch on November 2nd of all posts with the hashtag #art, that was the one and only time I could perform that request.  All further research will either need to be completed manually, or with that test data set.

Additionally, my idea to create a kind of heat map of the world based on where the hashtag was used and the frequency, get somewhat impacted by this new, severely limited quantity of data.  I was not really anticipiating this little to work with, so I might need to alter my final presentation of my data from a world map to something else, perhaps a language graph or image-based infographic detailing the user demographics.  I definitely want to try to use Google Charts to develop my output, if possible.

Currently, that is as far as I've gotten.  Hopefully, in the coming weeks, I will have come to terms with my lack of data and nailed down how I'm going to present what I've learned - if anything - to the class.


text:
# vue-floating-buttons

---

# API

## Props

| Option | Type | Required | Description |
| --- | --- | --- | --- |
| mainStyle | String | No | Additional styling for main component wrapper. |
| mainButtonStyle | String | No | Additional styling for main button wrapper. |
| optionsStyle | String | No | Additional styling for all option buttons wrappers. |
| direction | String | No | Direction where it will pop out options to. |
| buttons | Array | Yes | All buttons configurations. |
| expanded | Boolean | No | Used to set expanded state from mount. |

## Buttons array object

| Option | Type | Description |
| --- | --- | --- |
| html | String | This is the button content. It be interpreted as HTML. |
| radius | Number | Adjust button radius. |
| color | String | Background color. |
| click | Function | Function to be called on click. Only works on option buttons. |
| disabled | Boolean | Disable button. |
| disabledColor | String | Background color when is disabled. |

**Note: First button will be used as the main button.**

# Instructions

## Props

### mainStyle
This is a convenience prop to adjust the main component wrapper div style. A common use could be to change the `position` from `relative` (default) to `absolute` and position at will.

**Example**:
Position component to bottom right corner of screen.
```html
<FloatingButtons main-style="position: absolute; right: 20px; bottom: 20px;" direction="up" :buttons="buttons" />
```

### mainButtonStyle
This is a convenience prop to adjust the main button wrapper div style.

**Example**:
Change main button cursor to progress.
```html
<FloatingButtons main-button-style="cursor: progress;" :buttons="buttons" />
```

### optionsStyle
This is a convenience prop to adjust the option buttons wrapper div style.

**Example**:
Change all option buttons cursor to progress.
```html
<FloatingButtons options-style="cursor: progress;" :buttons="buttons" />
```

### direction
This prop is used to set the direction where it will pop out options to. Adjust it based on the positioning of your component.

Valid values: "down" (default), "up", "left", "right".

**Example**:
Set option buttons to pop from left to right.
```html
<FloatingButtons direction="right" :buttons="buttons" />
```

### buttons
This prop is used to configure all buttons. It is an array that should have a minimum length of 2 (main button and one option).

**Example**:
```html
[
    {
        html: '<i class="fas fa-bars" />'
    },
    {
        html: '<i class="fas fa-compass" />',
        click: () => alert('hello')
    }
]
```

### expanded
This prop is used set the options expanded from mount.

**Example**:
```html
<FloatingButtons expanded :buttons="buttons" />
```

# Installation and use
Install using npm:
```
npm install vue-floating-buttons
```

**Script**
```javascript
import Vue from 'vue'
import FloatingButtons from 'vue-floating-buttons'
Vue.component('FloatingButtons', FloatingButtons)
```

**Template**
```html
<FloatingButtons :buttons="buttons" />
```

# LICENSE
MIT

repository: waldou/vue-floating-buttons

repo_name: waldou/vue-floating-buttons


text:
UNRELEASED [XXXX-XX-XX]
-------------------

v1.0.0 [2023-04-07]
-------------------

- General
  - bump to go 1.18
  - bump to arrow/go/v8
  - remove useless count script
  - add gci linter
  - improve documentation
  - improve error handling
  - improve code readability
  - remove code gen to prepare for Timestamp support
  - add Bow data type in Buffer to decouple Go native types from Arrow types
  - expose arrow record

v0.18.0 [2022-02-16]
-------------------

- General
  - bump to arrow/go/v7
  - improve CI to run benchmarks comparison for PR with the same runner
- Parquet
  - add new GetParquetMetaColTimeUnit method to extract column time unit from the metadata of a bow read from a parquet file
  - remove deprecated ConvertedType from the metadata

v0.17.0 [2021-10-27]
-------------------

- new Manipulation features
- bump Go to version 1.17
- bow interface: switch from colNames to colIndices arguments
- support special characters in Parquet read/write

v0.16.0 [2021-08-25]
-------------------

- general code refactoring
- improved performance, mostly with better memory usage and buffers rework
- introduced code generation with Metronlab/genius framework
- changed Find method and add Contains and FindNext
- improved bow generator by simplification and made it extensible by user for value creation strategy

v0.15.0 [2021-08-04]
-------------------

- Benchmarks and Profiling:
  - Moved benchmarks closer to functions
  - Simplified and faster benchmarks
  - Added AppendBows and NewBufferFromInterfaces benchmarks
  - Added Makefile rules for tests and benchmarks profiling

v0.14.0 [2021-07-20]
-------------------

- Adding `SetMetadata` method to `Bow`'s interface

v0.13.0 [2021-06-17]
-------------------

- Adding `AddCols` method to `Bow`'s interface

v0.12.1 [2021-06-16]
-------------------

- Apache Parquet: new tests and UX improvements

v0.12.0 [2021-06-10]
-------------------

- Apache Parquet file read/write support
- Add Schema Metadata support
- Add golangci-lint usage

v0.11.0 [2021-05-17]
-------------------

- Add new bow.Diff function
- Depreciate Difference aggregation

v0.10.0 [2021-05-11]
-------------------

- Rolling:
    - improved code readability
    - aggregation/fill: it is now possible to pass a previous row option to the rolling to enable the correct interpolation of the first row of its first window, in the case of missing window start row

v0.9.0 [2021-03-24]
-------------------

- General:
    - Fix typos
    - Improve robustness and code clarity of functions IsColEmpty, IsColSorted and FillLinear with better error management
    - Remove unused variables
    - Remove bow.marshalJSONRowBased

- Bow Generator:
    - Improve randomness of values
    - Added support for String and Bool data types
    - New ColNames and DataTypes options for more flexibility
    - Improve user experience with better error management

- Benchmarks improvements:
    - Added new test cases
    - Added usage of benchstat on the CircleCI pipeline to compare benchmark results with master branch

- New Functions:
    - NewValuesFromJSON

- Bug fix:
  - Rolling inclusive window with duplicated indexes now correctly iterate keeping windowing integrity

v0.8.0 [2021-02-12]
-------------------

- New functions:
    - IsEmpty
    - FindFirst
    - IsSupported
    - GetReturnType
- Adding strong typing support
- Refactoring Bow's logic to return a valid schema instead of nil when no data is found
- Fixing tests

v0.7.3 [2021-01-12]
-------------------

- New functions:
    - NewBowEmpty
    - NewBowFromColNames
    - EncodeBowToJSONBody
    - DecodeJSONRespToBow
- New aggregation tests
- Minor code refactoring

v0.7.2 [2020-09-14]
-------------------

### Bugfixes
- OuterJoin: support of bow without rows returning correct schema

v0.7.1 [2020-08-03]
-------------------

### Features
- Add SortByCol method to sort a bow by a column name

v0.6.2 [2020-06-02]
-------------------

#### Bugfixes
- InnerJoin

v0.6.1 [2020-04-22]
-------------------

#### Bugfixes
- bump arrow to apache-arrow-0.17.0

#### Known issues
arrow now allow several column with same name introducing new panics in bow if the case happen.
[corresponding issue](https://github.com/Metronlab/bow/issues/12)

v0.6.0 [2020-04-22]
-------------------

#### Features
- Add Fill functions for missing data interpolation
- Add OuterJoin method
- Refactor InnerJoin method
- Add new CI with CircleCI
- Refactor the sub package bow to have the main functionalities available in the root module

#### How to migrate to v0.6.0
It is necessary to replace the library import path from github.com/Metronlab/bow/bow to github.com/Metronlab/bow

0.2.0 [2019-02-19]
-------------------

#### Features

- Depreciate method to print in favor to a stringer interface
- Innerjoin based on column name for now, we'll have to let more liberty over the join later on
- Map based indexes for join optimisation (divide time per 5 on simple short sample)

#### Bugfixes

- Fix empty series that make the code segfault in arrow, can now have empty dataframe with schema/record set.

0.1.0 [2019-02-01]
-------------------

#### Features

- Row based json encoding and decoding
- New Bow fron row and column based [][]interfaces{}
- Method to print

0.0.0 [2019-01-11]
-------------------

#### Features

- Initial Release
- Simple dataframe with type and series based on apache arrow

repository: Metronlab/bow

gha_language: Go

repo_name: Metronlab/bow


text:
# OmniAuth Netatmo  [![Build Status](https://travis-ci.org/vincent-pochet/omniauth-netatmo.svg)](https://travis-ci.org/vincent-pochet/omniauth-netatmo)

This gem contains the [Natatmo](https://www.netatmo.com/) strategy for OmniAuth.

## Before You Begin

You should have already installed OmniAuth into your app; if not, read the [OmniAuth README](https://github.com/intridea/omniauth) to get started.

Now sign in into the [Netatmo developer area](https://dev.netatmo.com) and create an application.

## Using This Strategy

First start by adding this gem to your Gemfile:

```ruby
gem 'omniauth-netatmo'
```

Next, tell OmniAuth about this provider.

## Authentication Hash
An example auth hash available in `request.env['omniauth.auth']`:

```ruby
{
  :provider => "netatmo",
  :uid => "123456",
  :info => {
    :email =><EMAIL_ADDRESS>  },
  :credentials => {
    :token => "a1b2c3d4...", # The OAuth 2.0 access token
    :secret => "abcdef1234"
  },
  :extra => {
    :access_token => "", # An OAuth::AccessToken object
    :raw_info => {
      "status" => "ok",
      "body" => {
        "_id" => "ABCDEFGHJK",
        "administrative" => {
          "country" => "FR",
          "reg_locale" => "fr",
          "lang" => "fr",
          "unit" => 0,
          "windunit" => 0,
          "pressureunit" => 0,
          "feel_like_algo" => 0
        },
        "date_creation" => {
          "sec" =><PHONE_NUMBER>,
          "usec" => 0
        },
        "mail" =><EMAIL_ADDRESS>      },
      "time_exec" => 0.084523916244507,
      "time_server" =><PHONE_NUMBER>
    }
  }
}
```

## Supported Rubies

OmniAuth Netatmo is tested under 1.9.3, 2.0.0, 2.1.0, JRuby, and Rubinius.

## License

Copyright (c) 2011 by Vincent Pochet

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.

repository: vincent-pochet/omniauth-netatmo

repo_name: vincent-pochet/omniauth-netatmo


text:
repmgr
======

This role installs and configures repmgr for Postgresql replication

Requirements
------------

Assumes PostgreSQL is already installed and running.

You should have the `include_dir` directive set in your `postgresql.conf`. See the `repmgr_postgresql_conf` default.

Role Variables
--------------

See defaults/main.yml

Dependencies
------------

None

Usage
-----

In the playbook for the master:

```yaml
- host: servers
  roles:
  - role: modcloth.repmgr
    repmgr_is_master: yes
    repmgr_node_id: 1
```

In the playbook for the standby:

```yml
- hosts: servers
  roles:
  - role: modcloth.repmgr
    repmgr_node_id: 2
```

### Tricks and Tips

You will need to create a `repmgr` user on your master database with
appropriate permissions.  This two things.

1. Create a database use `repmgr` with the permissions
   `SUPERUSER,REPLICATION,LOGIN`
2. Add an entry to the `pg_hba.conf` file giving explicit access to the
   replication database to both the `repmgr` and the `postgres` users

  ```bash
  # pg_hba.conf
  host  replication  repmgr    <IP_ADDRESS>/16  trust
  host  replication  repmgr    <IP_ADDRESS>/8      trust
  host  replication  postgres  <IP_ADDRESS>/16  trust
  host  replication  postgres  <IP_ADDRESS>/8      trust

  ```

License
-------

MIT

Author Information
------------------

ModCloth Inc.

repository: modcloth/ansible-role-modcloth-repmgr

repo_name: modcloth/ansible-role-modcloth-repmgr


text:
# delete-react-zombies
[![npm version](https://badge.fury.io/js/delete-react-zombies.svg)](https://badge.fury.io/js/delete-react-zombies)
[![npm](https://img.shields.io/npm/dw/delete-react-zombies.svg)](https://www.npmjs.com/package/delete-react-zombies)

> CLI to search and delete unused 🧟 components in your react files

## Install

This package use the_silver_searcher, install [the_silver_searcher](https://github.com/ggreer/the_silver_searcher#installing) for your OS before.

```sh
$ npm install delete-react-zombies
```

## Usage

```sh
$ delete-react-zombies
```
**Options**:

* `--path` define the path where to search for zombies (default=process.cwd)
* `--extension` define the file extension to where to search for zombies (default=jsx)

## How it works

The package search in your files the keyword `import ${componentName}`.
The `componentName` variable is the name of the file that your component
have with `.jsx` extension.

Example:
If we have a component file name `Button.jsx`, the package will search
imports like `import Button`

## Contributing

Check the [issue list](https://github.com/CVarisco/delete-react-zombies/issues) to contribute on some activities or to advice new features!
The library is open to everybody, contribute improve your skills.

`delete-react-zombies` is maintained under [the Semantic Versioning guidelines](http://semver.org/).

Use `npm run watch` while coding.

## License

MIT © [Christian Varisco](https://github.com/CVarisco)

repository: JeffersonFilho/delete-react-zombies

repo_name: JeffersonFilho/delete-react-zombies