text:
# Embed for Vaadin

Embed for Vaadin is a library allowing you to quickly initialize Vaadin from your IDE. It provides an easy-to-use API to initialize an embed Tomcat container running a particular component or Vaadin application.

The API also allows you to open the default browser automatically and allocates an available HTTP port is none is provided. The API is extensible so that you can it you to your own needs.

# Building from Source

Clone the git repository using the URL on the Github home page:

    $ git clone git@github.com:bsblabs/embed-for-vaadin.git
    $ cd vaadin-embed

## Command Line

Use Maven, then on the command line:

    $ mvn install

Make sure you have access to the central repository.

## Usage

To use the Vaadin embed in your own projects, add the jar to your project's classpath or simply add the following dependency to your Maven project:

    <dependency>
        <groupId>com.bsb.common.vaadin</groupId>
        <artifactId>com.bsb.common.vaadin.embed</artifactId>
        <version>0.1</version>
    </dependency>

To visualize a component that you have built, simply pass it to the `VaadinEmbed` builder.

    EmbedVaadin.forComponent(new Button("Hello")).start();

And if you want to open the default browser automatically at the proper URL, you could just add an extra parameter:

    EmbedVaadin.forComponent(new Button("Hello")).openBrowser(true).start();

You can as easily embed a Layout or a Window. Note that this mode is purely for development purpose as you pass an initialized component to the application. Multi-sessions are therefore not supported.

It is also possible to specify the `Class` of an `Application`. In that case, the server starts closer to the full thing.

    EmbedVaadin.forApplication(MyVaadinApplication.class).start();

## Configuration

There are two ways to change the default values of the embed server:

 - Through the presence of a `vaadin-embed.properties` file at the root of the classpath overriding default values
 - By using the API

At this stage the following can be customized:

 - `http.port`: the HTTP port the server listens to (an available port is taken by default)
 - `context.path`: the context of the generated web application (by default, the *root* context)
 - `context.rootDir`: the root directory of the generated web application to serve static files such as CSS and images (not necessary, unless you want to use themes or static resources)
 - `server.await`: to block the thread that started the server (by default, *true*)
 - `vaadin.theme`: the vaadin theme to apply to the generated application. Ignored if an application class is used (by default, *reindeer*)

And this showcase how the API can be used to customize these settings

        EmbedVaadin.forComponent(new Label("Hello World!"))
            .withContextPath("/foo")
            .withHttpPort(7070)
            .withContextRootDirectory("src/main/webapp")
            .withVaadinTheme("default")
            .openBrowser(true)
            .start();

# Release notes

## 0.2 (_not released yet_)

 - Custom WidgetSet can be specified
 - Clearer separation between an embed server deploying a single component and one deploying a full application
 - Development header: ability to shutdown the server and close the tab from the user interface itself

## 0.1

Initial release

repository: coekie/vaadin-embed

repo_name: coekie/vaadin-embed


text:
# reactive-assignments

Make javascript assignments reactive via a compiler

> This is an actively developed project. PRs, feedback, feature requests, and bug reports are always welcome here!

## Installation

```shell
npm i reactive-assignments
```

## Usage

```js
import { compile } from 'reactive-assignments/compiler';

console.log(compile(`written code`, options));
// -> { code: `reactive code`, sourcemap: { version: 3, mappings: ';;AAA...', ... } }
```

[See some examples](/tests/compiler/fixture) for information on how the syntax works.

### Compiler Options

Valid options are:

-   `file` _(optional)_ - The name of the file that is being compiled.
-   `sections` _(optional)_ - An array of strings specifing which tasks to run. Valid strings are 'import', 'references', 'declarations', 'assignments', or 'labels'. By default, all tasks are run
-   `predefinedGlobals` _(optional)_ - An array of variables that are not to be messed with. Default is `['console']`
-   `runtime` _(optional)_ - The path to the reactive-assignments runtime. Default is `reactive-assignments`
-   `sourcemap` _(optional)_ - If the compiler should generate sourcemaps or not. Default is `true`

## Strategy

Modern javascript frameworks have become quite good at making javascript reactive. [React](https://reactjs.org), [Vue](https://vuejs.org), and [Svelte](https://svelte.dev) are all reactive. The problem is that they are all linked to the browser. They all have some sort of templating engine, and thus can sometimes be a bit large and slow. The idea of this library is to just make plain javascript reactive. Implementations can come later.

The plan is that normal javascript gets executed normally, but when the compiler comes across this:

```js
$: foo = bar;
```

The value of `bar` will always be bound to `foo`.

The following is the plan to accomplish this.

> Note: To really understand the following examples, you need to be familiar with [reactive-assignments stores](#stores-api).

Via the compiler, this code...

```js
let foo = `bar`;
```

...gets compiled into this:

```js
import $$store from 'reactive-assignments';

const foo = $$store.writableStore(`bar`);
```

References to the variable like this...

```js
if (foo === 'bar') console.log(`Hello, World!`);
```

...are compiled like this:

```js
if (foo.get() === 'bar') console.log(`Hello, World!`);
```

And this...

```js
foo = `baz`;
```

...gets compiled into this:

```js
foo.set(`baz`);
```

Therefore, this...

```js
// Assuming bin has already been declared
$: bin = foo;
```

...can be compiled into this...

```js
$$store.updatable(() => bin.set(foo), foo);
```

...and make `bin` reactive.

Written code:

```js
let foo = `bar`;
let bin;

$: bin = foo;

foo = `baz`;
```

Compiled code:

```js
import * as $$store from 'reactive-assignments';

const foo = $$store.writableStore(`bar`);

const bin = $$store.writableStore();
$$store.updatable(() => bin.set(foo), foo);

foo.set(`baz`);

// bin now equals 'baz' because the $$store.updatable function
// calls the first parameter everytime one of the subsequent parameters
// emits an update.
```

## Development

Pull Requests are encouraged and always welcome!

```sh
# fork repo
git clone https://github.com/[your_username]/reactive-assignments
cd reactive-assignments
npm i
npm test # or npm test -- -w
```

The code can be built via the `npm run build` command. To watch the file system and rebuild on changes, use `npm run build -- -w`.

The runtime library is located in the `src/runtime` folder. The compiler is in the `src/compiler` folder.

This project uses [Prettier](https://prettier.io) for code formatting.

## Stores API

### writableStore

```ts
store = writableStore(value: any);
```

`store` is an object with four methods:

-   `set(value: any) => void` - Sets the store to a new value
-   `get() => any` - Returns the store's current value
-   `update(fn: (currentValue: any) => any) => void` - Will set the value of the store to whatever is returned from `fn`
-   `subscribe(fn: (value: any) => void) => () => void` - Calls `fn` everytime the value of the store changes. Returns a function that will unsubscribe (stop calling `fn` when the value changes) when called

### readableStore

```ts
store = readableStore(startValue: any, actions: ({ set, update }) => void);
```

`store` is an object with all the properties as `writableStore` gives it, except `set` and `update`.

`actions` is a function that is passed in one property, an object containing the missing properties from `store`.

### updatable

```ts
updatable(fn: () => void, ...stores)
```

Calls `fn` everytime one of the store's value changes.

If a value is passed into `stores` that is not a store, reactive-assignments will silently ignore it.

Returns a function that will 'unsubscribe' from the stores when called.

### isStore

```ts
isStore(testValue: any): boolean
```

Just checks to see if `testValue` contains the appropriate `subscribe` and `get` methods.

## License

[MIT](/LICENSE)

license: MIT

repository: Vehmloewff/reactive-assignments

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: Vehmloewff/reactive-assignments


text:
# Office365-QuotedLinePrefix
An Office 365 plugin that enables quoted-line prefix in Outlook Web App

## What is quote-line prefix?

Internet-style quoting consists of putting a > character in front of the original message when you reply (or forward) it. Then you reply below the quoted text. Recipients can easily distinguish the original message from your comments.

Learn more [on Wikipedia](https://en.wikipedia.org/wiki/Posting_style#Quoted_line_prefix):

> When Usenet and e-mail users respond to a message, they often want to include some context for the discussion. This is often accomplished by quoting a portion of the original message using Usenet conventions. In essence the convention is to communicate in plain text format (not HTML) and quote with ">" at the beginning of each line, ">>" for a quote of quote, and so on. Most email clients can perform Usenet quoting automatically.)

## Why this plugin?

Quote-line prefix is currently not available inside Outlook Web App for Exchange 365.

## Screenshots?

Sure!
- Here is the [original message](http://captures.debugg.in/original-message.png)
- Here is the [quoted line "Reply to" default view](http://captures.debugg.in/reply.png) when using this plugin
- Here is a [conversation sample](http://captures.debugg.in/conversation.png) made possible by the plugin

## Roadmap

- colored conversation levels
- better conformation with [RFC1849](http://www.faqs.org/rfcs/rfc1849.html)
- automatic word-wrapping of the quoted text lines at 72 characters
- ability to replace the > character

## Contact

For any question please raise an issue on GitHub or ask @italic_fr on Twitter.


text:
Precision Medicine Word Cloud
========================

![image of final word cloud](https://dl.dropboxusercontent.com/u/38640281/github_img/precision_wordcloud.png)

Background
----
There are some experts online now (Feb 2015) giving definitions of
precision medicine. They are in the NEJM Open Forum hosted by Medstro.
https://medstro.com/posts/1701

I want to make a word cloud of their definitions. I want to exclude
the obvious words "precision" and "medicine". I found a word cloud
tool with nice layout, but it doesn't understand that it should lump
plural forms or other inflected forms in with their singular forms.

Usage
----

0. Copy and paste the experts' definitions into a file. I called it
`precision defs.txt`.

1. `./end_s.pl precision\ defs.txt | sort | uniq > s_words.txt`

2. Manually curate `s_words.txt` and save it in a new file
`curated_s_words.txt`

3. `./lumper.pl precision\ defs.txt > output.txt`

4. Paste `output.txt` into http://www.jasondavies.com/wordcloud

repository: zimolzak/precision-medicine-word-cloud

repo_name: zimolzak/precision-medicine-word-cloud


text:
# Solutions of ctflearn
# https://ctflearn.com
![ctflearn](https://github.com/root-ji218at/ctflearn.com/blob/master/Image/ctflearn.png)

 Due to some issues, the CTF challenges created by "kcbowhunter" are not allowed to be uploaded. Thus the flag and other relevant contents related to those CTF challenges are either removed or modified.

repository: ExcuseMeBro/CTFLearn

repo_name: ExcuseMeBro/CTFLearn


text:
# Arduino Joystick Controller for Stepper Motors

The joystick is used to move 3 NEMA-17 stepper Motors, to control the player in an Air Hockey Robot.

## Initialization
![Initialization](gifs/init.gif)

## Playing
![Playing](gifs/play.gif)

gha_license_id: MIT


text:
# NYC Traffic Speed API

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

Capture Real-time NYC Traffic Speed Data and make it available through API.

## Description

API is capturing real-time traffic data of NYC from public source. Data is stored in MongoDB and avaliable in a meaningful way with Flask Restful API

Credits to [@miguelgrinberg](https://github.com/miguelgrinberg) for awesome Flask tutorials and examples.
### Data

New York City DOT’s traffic speed detector feed is a free service that allows various user groups (i.e. the general public, private sector, commercial vendors, transportation agencies, researchers, media and others) to download traffic speed information on a regular basis to use in their applications and research efforts. This data feed contains 'real‐time' traffic information from locations where NYCDOT has installed sensors, mostly on major arterials and highways within the City limits. NYCDOT uses this information for emergency response and management.

More: [NYC Open Data, Real-Time Traffic Speed Data](https://data.cityofnewyork.us/Transportation/Real-Time-Traffic-Speed-Data/xsat-x5sa)

[Metadata](https://data.cityofnewyork.us/api/assets/5695AD48-E3BE-4C04-8E26-4170EBC34B55?download=true)

## Install

### System dependencies:
* Python 2.7
* MongoDB v3.2.1
* virtualenv

### Installation and Python dependencies:

    $ git clone https://github.com/tcufer/nyc_traffic_speed_api.git
    $ cd nyc_traffic_speed_api
    $ virtualenv venv
    $ source venv/bin/activate
    (venv)$ pip install -r requirements.txt

### Unit Tests

To check your installation was successful you can run the unit tests:

    (venv)$ python manage.py test
    test_bad_url_insert_traffic_data (tests.common.test_data_ingestion.TestDataIngestion) ... ok
    test_insert_traffic_data (tests.common.test_data_ingestion.TestDataIngestion) ... ok
    test_bad_auth (tests.resources.test_resources.TestAPI) ... ok
    test_link (tests.resources.test_resources.TestAPI) ... ok
    test_password_auth (tests.resources.test_resources.TestAPI) ... ok
    test_speed (tests.resources.test_resources.TestAPI) ... ok

    Name                       Stmts   Miss  Cover   Missing
    --------------------------------------------------------
    common.py                      0      0   100%
    common/auth.py                13      0   100%
    common/data_ingestion.py      22      0   100%
    common/helper.py               8      0   100%
    common/models.py              32      1    97%   45
    resources.py                  18      0   100%
    resources/link_data.py        20      0   100%
    resources/speed_data.py       52      0   100%
    --------------------------------------------------------
    TOTAL                        165      1    99%
    ----------------------------------------------------------------------
    Ran 6 tests in 6.998s

    OK

The report above presents a summary of the test coverage.

## User Registration

The API is using user authentication, therefore a new user has to be registered. Multiple users can be registered (with different usernames) as they are stored in a database.

    (venv) $ python manage.py adduser <username>
    Password: <password>
    Confirm: <password>
    User <username> was registered successfully.

## API Resources
The API contains two top-level resources, available on these urls:

- `/trafficSpeed`: The list of speed sensors with the current state
    * with sub-level resources:
        - `/trafficSpeed/<int:sensorId>/`: Current state of the sensor with requested Id
        - `/trafficSpeed/<int:sensorId>/[YYYY-MM-DD]`: All collected data for this sensor on a requested date
- `/trafficLink`: The list of traffic links and additional data about sensors
    * with sub-level resource:
        - `/trafficlink/<int:id>`: All data about the traffic link with requested id

API supports resource representations in JSON format only.

## Traffic Speed Resource

The resource has the following structure:

    {
      "speedSensor": [
        {
          "dataAsOf": [timestamp (EST timezone)],
          "linkId": [traffic link id],
          "sensorId": [sensor id],
          "speed": [traffic speed (mph)],
          "travelTime": [needed time to travel thorugh the traffic link (sec)]
        },
        {
        ...
        }
      ]
    }

Resource with requested sensor id returns data only for one sensor in a described structure above.

Resource with requested sensor id and date has the following structure:

    {
      "speedSensor": [
        {
          "linkId": [traffic link id],
          "measures": [
            {
              "timestamp": [timestamp_1],
              "speed": [traffic speed (mph)],
              "travelTime": [needed time to travel thorugh the traffic link (sec)]
            },
            {
              "timestamp": [timestamp_2],
              ...
            },
            ...
        }
        ]
    }

## Traffic Link Resource

The resource has the following structure:

    {
      "trafficLinkList": [
        {
          "borough": [Borough where link is located],
          "encodedPolyLine": [Encoded set of latitude/longitude pairs],
          "encodedPolyLineLvls": [Encoded polyyine levels],
          "linkId": [traffic link id],
          "linkName": [Name of the link, usually describes with the name of the street/road],
          "linkPoints": [latitude/longitude pairs describing the road link],
          "owner": [Link's owner]
        },
        {
        ...},
        ...
    }

Resource with requested link id returns data only for one link in a described structure above.

## Rate Limiting

Rate limiting is an optional feature of the API, however is highly recommended to enable it to prevent the abuse of the api if it's deployed to production.
To enable rate limiting change the following line in config.py:

    USE_RATE_LIMITS = True

The default configuration limits clients to 10 API calls per 1 minute interval. When a client goes over the limit a response with the 429 status code is returned immediately, without carrying out the request. The limit resets every minute.

## TODOs
This project is still work in progress :) I appreciate pull requests and any suggestions!

* Pagination
* HTTP Caching
* Token Authentication
* Improvements on existing features


text:
# Laravel Nova Inbox Tool

# COMING SOON =)

## Requirements

Laravel Nova, only =)

## Installation

//

## Usage

//

## Changelog

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

## Contributing

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

## Security

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

## Credits

- [Gustavo Bissolli](https://github.com/bissolli)

## License

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

repository: bissolli/nova-inbox-tool

repo_name: bissolli/nova-inbox-tool


text:
# Aliasing

In pseudospectral methods, computing nonlinear terms results in aliasing errors. (Read more about
aliasing errors in the [FourierFlows.jl Documentation](https://fourierflows.github.io/FourierFlowsDocumentation/stable/aliasing/).) To avoid aliasing errors, we need to apply some dealiasing to our fields
in Fourier space before transforming to physical space to compute nonlinear terms.

!!! info "De-aliasing scheme"
    FourierFlows.jl currently implements dealiasing by zeroing out the highest-`aliased_fraction`
    wavenumber components on a `grid`. By default in FourierFlows.jl, `aliased_fraction=1/3`.
    Users can construct a `grid` with different `aliased_fraction` via

    ```julia
    julia> grid = OneDGrid(; nx=64, Lx=2π, aliased_fraction=1/2)

    julia> OneDimensionalGrid
             ├─────────── Device: CPU
             ├──────── FloatType: Float64
             ├────────── size Lx: 6.283185307179586
             ├──── resolution nx: 64
             ├── grid spacing dx: 0.09817477042468103
             ├─────────── domain: x ∈ [-3.141592653589793, 3.0434178831651124]
             └─ aliased fraction: 0.5
    ```
    or provide the keyword argument `aliased_fraction` to the `Problem()` constructor of each
    module, e.g.,

    ```julia
    julia> prob = GeophysicalFlows.TwoDNavierStokes.Problem(; aliased_fraction=1/2)
    Problem
      ├─────────── grid: grid (on CPU)
      ├───── parameters: params
      ├────── variables: vars
      ├─── state vector: sol
      ├─────── equation: eqn
      ├────────── clock: clock
      └──── timestepper: RK4TimeStepper

    julia> prob.grid.aliased_fraction
    0.5
    ```

Currently, all nonlinearities in all modules included in GeophysicalFlows.jl modules are quadratic
nonlinearities. Therefore, the default `aliased_fraction` of 1/3 is appropriate.

All modules apply de-aliasing by calling, e.g., `dealias!(prob.sol, prob.grid)` both before
computing any nonlinear terms and also during updating all variable, i.e., within `updatevars!`.

To disable de-aliasing you need to create a problem with a grid that has been constructed with
the keyword `aliased_fraction=0`.

branch_name: refs/heads/main

gha_language: Julia


text:
---
layout: page
title: "about"
date: 2013-09-30 21:05
comments: false
sharing: true
footer: true
keywords:
description:
---

Malcolm Noyes has worked as a software developer/author for several years; just how many can be deduced from the information that he started programming C++ using a Zortech compiler. He wrote several string classes before discovering the STL and several thread classes before multi-threading got standardised. He has never written a Unit Test framework but probably would have done if [Phil Nash hadn't got there first](https://github.com/philsquared/Catch "Catch main")!

You can contact me [on twitter @ColonelSammy](http://twitter.com/colonelsammy "ColonelSammy @ twitter") or by email (mnoyes @ this domain).

repository: colonelsammy/octopress

extension: markdown

repo_name: colonelsammy/octopress


text:
---
layout: post
title:      "Send Contact Forms in Heroku Apps to Gmail with PHPMailer"
date:       2019-09-07 08:04:29 +0000
permalink:  send_contact_forms_in_heroku_apps_to_gmail_with_phpmailer
---

Awhile back I ran into a problem with a contact form. I had no idea how to actually make it work. Designing and creating one with HTML/CSS? No problem.  Not so much. I never thought sending a form for a Heroku single-page HTML/CSS website could be so difficult. I spent forever trying so many different solutions recommended by tutorials and online resources to no avail. I eventually figured it out but it did take a lot of trial and error. So, to spare someone else the same frustration I went through, here's how to get a contact form.

1. Download, unzip, and add the  [PHPMailer](https://www.dropbox.com/s/079t2fb66j7765v/phpmailer.zip?dl=0) folder to your project's root directory

2.	Go into your Google account. Select 'Security' from the menu on the left and enable 2-Step Verification

3.	While still in 'Security' choose App Passwords. Then choose Select App and choose the app and device you're using. Click 'Generate'. The App Password is the 16-character code in the yellow bar on your device. Copy and paste it somewhere right now

4.	Create a file called sendmail.php in your main project directory, and copy and paste the following.

```
<?php
    require('phpmailer/PHPMailerAutoload.php');

		// NAME, EMAIL, AND MESSAGE ARE VARIABLES FOR YOUR CONTACT FORM FIELDS.  Please check';
        }
        else{
            $mail = new PHPMailer;
            $mail->isSMTP();
            $mail->Host = 'smtp.gmail.com';
            $mail->SMTPAuth = true;
            $mail->Username = 'YOUR GMAIL EMAIL ADDRESS';
            $mail->Password = 'THE APP PASSWORD GENERATED IN THE PREVIOUS STEP';
            $mail->SMTPSecure = 'tsl';
            $mail->Port = 587;
            $mail->setFrom('YOUR GMAIL EMAIL ADDRESS';');
            $mail->addAddress('YOUR GMAIL EMAIL ADDRESS';');
            $mail->addReplyTo($email, $name);
            $mail->isHTML(true);
            $mail->Subject = 'New Contact Form Message';
            $mail->Body    = 'Name: '.$name.' <br />Message: '.$message;

            if(!$mail->send()) {
                echo 'Message could not be sent.';
                echo 'Mailer Error: ' . $mail->ErrorInfo;
            } else {
                $signal = 'ok';
                $msg = 'Form submitted';
            }
        }
    }
    else{
        $signal = 'bad';
        $msg = 'Please fill in all the fields.';
    }
    $data = array(
        'signal' => $signal,
        'msg' => $msg
    );
    echo json_encode($data);
?>
```

5. Change your index.html to index.php. Add <?php?> to the top of the file.
6. Create a composer.json file. Add a single pair of curly brackets {} to the file then save. This is needed for whatever reason so Heroku properly deploys your website


text:
app-arch-sandbox
================

This is a toy/sandbox/experiment project to explore the design space
of a web application.

Background
---------

A little while ago, I posted [this question]
(https://groups.google.com/forum/#!searchin/yesodweb/tdox/yesodweb/z8NViwlYA3Y/WwRo6-lsAvUJ)
to the Yesod Web Framework Google
group. This code is some stuff I hacked together to explore possible solutions.

To compile and run
-------------------

To compile and run it, you need to first get the Haskell platform, either from
your package manager (e.g., `apt-get install haskell-platform`), or from
[Haskell.org](http://www.haskell.org/platform/). Then do the following in
your shell:

    $ git clone git://github.com/tdox/app-arch-sandbox
    $ cd app-arch-sandbox
    $ cabal configure
    $ cabal build

This creates three executable web servers, which you can start with:

    $ dist/build/system/system
    $ dist/build/app/app
    $ dist/build/proxy/proxy

Then point your browser to http:/localhost:3000.

Overview
--------

system and app are Yesod apps and proxy is a WAI app.
The proxy sits in front, and sends requests to either system or app, depending
on the path. system and app both check for credentials, but only system provides
the hooks for authentication. (It might be better if proxy handled
authentication, but Yesod's authentication system is requires all of the
machinery of a full Yesod app,
and I couldn't see a simple way to do the same with the simpler proxy WAI app.)

The localhost:3000/system/documentList page contains links to open specific
docs on app.  app doesn't really do anything except show the name of the
organization, the document name and twice the doc ID.  (In the real system,
the proxy will send the request to the app server that is serving the doc
with the given doc ID.)

Note that all links (except for authentication) show localhost:3000, which
is actually proxyinig to both localhost:3001 (system) and localhost:3002 (app).

This was an interesting exercise that taught me a lot and I see room for
further experimentation and improvement.

repository: tdox/app-arch-sandbox

repo_name: tdox/app-arch-sandbox


text:
cin_redirection
==============================================

Program Description
----------------------------------------------

An example of redirecting (emulating) std::cin

Purpose:

Say you have a library that takes input from the console and processes it. You may want to generate sucn input in you program and feed it automatically to the library.

Documentation
----------------------------------------------

- All of the code is sufficiently commented.
- Doxygen generated documentation is in the __docs__ folder

Building Tips
----------------------------------------------

Set Project Properties:

* Configuration Properties > General > Output and Intermediate Directories
    - `build\$(Platform)\$(Configuration)\bin\`
    - `build\$(Platform)\$(Configuration)\obj\`

repository: zubrim/cpp-examples

repo_name: zubrim/cpp-examples


text:
# quantumc - A compiler for the quantum programming language.
´quantumc´ is the working title for a compiler for a language yet to be invented. It is written in [rust][1]. The goal is mainly to develop a compiler to learn more about a compilers inner workings and to learn more about programming language design.

# Features currently working
- Description of tokens using regular expressions and generation of a token stream from an input file.
- Description of a language grammar and parsing of that grammar.
- Basic error reporting.

# Acknowledgments
Special thanks goes to Torben Ægidius Mogensen, the author of the book [Basics of Compiler Design][2].

[1]: https://www.rust-lang.org/
[2]: http://www.diku.dk/~torbenm/Basics/basics_lulu2.pdf

repository: aticu/quantumc

repo_name: aticu/quantumc


text:
# TodarchWeb

This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 9.0.2.

## Development server

Run `ng serve` for a dev server. Navigate to `http://localhost:4200/`. The app will automatically reload if you change any of the source files.

```shell
ng serve
npm run api
```

## Code scaffolding

Run `ng generate component component-name` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module`.

```shell script
ng generate module module-name --routing
ng generate component module-name/component-name -m module-name
ng generate module shared/material --flat -d
```

## Build

Run `ng build` to build the project. The build artifacts will be stored in the `dist/` directory. Use the `--prod` flag for a production build.

## Running unit tests

Run `ng test` to execute the unit tests via [Karma](https://karma-runner.github.io).

## Running end-to-end tests

Run `ng e2e` to execute the end-to-end tests via [Protractor](http://www.protractortest.org/).

## docker

```shell
docker build -f Dockerfile -t todarch:web .
docker run -it -p 80:80 --rm todarch:web
```

## keycloak integration

- instead of using keycloak-js adapter, can use even a higher abstraction for angular.

```shell
npm i keycloak-js --save
# update main.ts
```

- add cors value on keycloak client configuration

### using angular-keycloak

```shell
npm i --save keycloak-angular

# install peer dependency, use same version as server
npm i --save<EMAIL_ADDRESS>```

repository: todarch/todarch-web

gha_language: TypeScript

repo_name: todarch/todarch-web


text:
---
id: 1874
title: Sam Smith
date: 2012-04-05T11:01:32+00:00
author: chito
layout: post
guid: https://ukdataservers.com/sam-smith/
permalink: /04/05/sam-smith/
---

* some text
{: toc}

## Who is  Sam Smith

English pop artist who broke onto the dance scene as a featured artist on the 2012 single “Latch” by electronic duo Disclosure. They were named Best New Artist at the 2015 Grammys and their single “Stay With Me” won Song of the Year.

## Prior to Popularity

They and their siblings were raised in the town of Bishops Stortford, Hertfordshire. They were a student at St. Mary’s Catholic School before starting their singing career in 2012.

## Random data

They’re also widely known for their hits “I’m not the Only One” and “Too Good At Goodbyes.” In 2016, they won the Gold Globe and Academy Award for Best Original Song for “Writing’s on the Wall” from the film Spectre.

## Family & Everyday Life of Sam Smith

Their father was a stay-at-home-dad and their mother, a successful banker. They came out as gay in May 2014 and began dating Jay Camilleri in 2016. They then had a relationship with Brandon Flynn from 2017 until 2018. They have also dated actor Jonathan Zeizel and dancer Khasan Brailsford.

## People Related With  Sam Smith

In March 2015, they recorded an alternate version of their single “Lay Me Down,” featuring vocals from John Legend.


text:
Files
- `built/` contains the contacts of the
- `built-config/[config_name]/`

- `//builder/config:raspberry_pi`

- `built-config/raspberry_pi-443did81a`

- `built-rust/`

Step 1:
- Need to know which profile is in use

-

`cross build --target=armv7-unknown-linux-gnueabihf --bin cluster_node --release --target-dir=/home/dennis/workspace/dacha/built-rust/1`

/*
rustc --crate-name usb_device --edition 2018 --crate-type rlib -o build/test.rlib pkg/usb_device/src/lib.rs

*/

Leverage BUILD files.
- For now, auto-add binaries for Cargo projects.

/*
    Every build runs with an ambient:
    - BuildConfig {}

    - Target specific parameters take priority
    - Followed by bundle configs
    - Followed by user provided flags.

    - So yes, we can build a single rule with many different settings
*/

Specifying the sources for a bundle:
- All targets can emit some files that it produces.
    - e.g. binary, intermediate files like compiled proto code, static files, etc.
- Only some should be added to bundles
    - (imtermediate files should normally not be added)
- But, we also want to support nested dependencies.
    - E.g.

- To build a bundle,
    - User specified 'deps'
    - Can be either direct dependencies or

repository: dennisss/dacha

repo_name: dennisss/dacha


text:
+++
hook = "A good story about technological optimistic and languages that might be a little too permissive."
location = "San Francisco"
published_at = 2017-04-07T15:39:30Z
title = "Shopify scripts, MRuby, and the $500,000 release"
+++

Here's a pretty good story about being a little too
optimistic with technological implementation, and
especially where applied to a language that lets you do
whatever you want.

Last year Shopify released a product called [Shopify
Scripts][shopify-scripts] that lets store owners run
arbitrary Ruby code after one of their customers adds an
item to their cart. This could be used to apply a product
discount or activate a promotion for example. The product
ran on MRuby, a lightweight version of the Ruby language
which is designed to be more embeddable than its
progenitor, and secured in a sandboxing engine of Shopify's
own design called [MRubyEngine][mruby-engine].

Shopify quickly found out the hard way that an extremely
permissive language combined with a nascent C codebase
wasn't a recipe for secure code, and vulnerability reports
started flowing in. A few examples:

* [Failure to do an array bound checks from MRuby, leading
  to possible remote code execution][vuln-1] (worth $20k).
* [Improper optimization in MRuby can lead to a null
  pointer dereference][vuln-2] (worth $10k).
* [Overriding `#to_s` to return a `nil` return leads to
  MRuby aborting][vuln-3] (worth $10k).

It's worth noting that as far as vulnerabilities go, these
are all pretty run-of-the-mill bugs. Many security
researchers work a lot harder to find problems that are
worth a lot less.

Shopify did the only thing they could which was to put in
kernel-level sandboxing around MRuby, but by then they must
have already paid in close to $450k (the all time total as
I'm reading it today is $479,300):

> Update Dec 9, 2016: We wish to thank the researchers who
> have submitted vulnerability reports to the Shopify
> Scripts program. As of today, we have implemented
> technical mitigations (seccomp-bpf sandboxing and process
> isolation) on the application servers hosting Shopify
> Scripts. As a result, we expect most vulnerabilities will
> no longer be exploitable without additional bugs in the
> kernel or seccomp itself, and so we are lowering the
> payout amounts for our program to 10% of previous levels.
> Researchers who have submitted issues prior to today will
> receive payouts under the old structure, however any new
> reports received will be eligible for payouts within the
> structure below.

A few takeways come to mind:

* Writing your own compiler from scratch might not be a
  good idea anymore, even if you've got 30 years of
  experience doing it (put another way, use LLVM).

* Overly permissive languages introduce a lot of scary
  possibilities that are difficult to protect against.
  Consider something that's not Ruby.

* It's not possible to have enough experience in C to be
  able to write it safely. Looking at some of these MRuby
  patches, the implementation's code is so obscuring that
  it introduces plenty of opportunity for error. When you
  get one, it's often a buffer overrun that leads to remote
  execution.

All of that said, Shopify Scripts is a great idea. I'm glad
to see that an approach involving a more depth-wise defense
seems to have been successful.

[hackerone]: https://hackerone.com/shopify-scripts
[mruby-engine]: https://github.com/Shopify/mruby-engine
[shopify-scripts]: https://help.shopify.com/api/tutorials/shopify-scripts
[vuln-1]: https://hackerone.com/reports/181321
[vuln-2]: https://hackerone.com/reports/181828
[vuln-3]: https://hackerone.com/reports/180977

repository: brandur/sorg

gha_language: Go

repo_name: brandur/sorg


text:
---
layout: creature
name: "Mohrg"
tags: [medium, undead, cr8, tome-of-horrors]
cha: 8 (-1)
wis: 10 (+0)
int: 11 (+0)
con: 17 (+3)
dex: 14 (+2)
str: 18 (+4)
size: Medium undead
alignment: chaotic evil
challenge: "8 (3,900 XP)"
languages: "--"
senses: "darkvision 60 ft., passive Perception 10"
damage_immunities: "poison"
condition_immunities: "charmed, exhaustion, frightened, paralyzed, petrified, poisoned, stunned"
speed: "30 ft."
hit_points: "112 (15d8 + 45)"
armor_class: "12"
---

***Create Spawn.*** Any humanoid creature slain by the mohrg rises as a
zombie at the beginning of the mohrg’s next turn. If this occurs, the mohrg
regains 10 hit points, and the morhg can immediately make one slam
attack as a reaction.

### Actions

***Multiattack.*** The mohrg makes two slam attacks and one attack with
its tongue.

***Slam.*** Melee Weapon Attack: +7 to hit, reach 5 ft., one target. Hit: 13
(2d8 + 4) bludgeoning damage, and the target is grappled and restrained
(escape DC15), and the morhg can’t grapple another creature or use its
slam attack.

***Tongue.*** Melee Weapon Attack: +7 to hit, reach 5 ft., one target. Hit:
The target must make a DC 16 Constitution saving throw. On a failed
save, the target takes 21 (6d6) necrotic damage and is paralyzed for 1
minute. The creature can repeat the saving throw at the end of each of its
turns, ending the effect on a success.

gha_language: CSS

gha_license_id: NOASSERTION


text:
# fridge-shopping-list
A Windows IoT Core app to show a little shopping list on a fridge.

## Build Status

|Debug|Release|
|-----|:-----:|
|[![Build status](https://ci.appveyor.com/api/projects/status/6y61x7ytm3kddh1f?svg=true)](https://ci.appveyor.com/project/pingzing/fridge-shopping-list)| None yet       |

repository: pingzing/fridge-shopping-list

repo_name: pingzing/fridge-shopping-list


text:
# Traits-Function
Synthesis and meta-analysis of traits and functional ecology.

It allows users to analyze traits (e.g. social traits) and their responses to environmental factors, as another way of exploring biodiversity.
It provides tools to clean (make sure you really want to do this) and organize data, test for phylogenetic signal, inpute data using phylogenetic distances/models and other methods, run multivariate analysis, and create some nice plots of functional groups or trait variations.

repository: silvijua/Traits-Function

repo_name: silvijua/Traits-Function


text:
# {PIZZA BASE}

## author
Brian Nyabuto
## Description
 web application where your customers order different sizes of pizzas with one or more toppings.
 customers can also:
 * Choose the size of pizza I want e.g Small, Medium, Large.
 * Place an order for my Pizza and see the total charge for it.
 * Have an option to have the pizza delivered or not.  If delivered I want to be alerted how much    thedelivery charge

## Installation Requirements
* You need to get git installed
* Git can be installed using a command in your     terminal "sudo apt install git-all"
* in a simple
* easy-to-understand
## setup
* To access this project on your local files,you can clone it using
* Open your terminal
* use this command to clone $ git clone https://github.com/Brian-nyabuto12/pizzaBase.git
# BDD
* Enter your name: brian nyabuto.
* Enter your Email<EMAIL_ADDRESS>* Enter your message or comments...
* press Submit.

## live link

 https://brian-nyabuto12.github.io/pizzaBase/
## Technologies Used
* HTML
* CSS
* bootstrap
* Jquery
## Support and contact details
{ If they run into any issues or have questions, ideas or concerns.EMAIL<EMAIL_ADDRESS>### License
This project is under [MIT](LICENCE) license


text:
# asynchronous-lecture

Code samples for a lecture on different ways to handle Javascript's asynchronousness

# Roadmap

Starting off

```
node -v
```

If it's not 7+,
```
sudo npm i -g n
n latest
```

Then,
```
git clone https://github.com/ben-pr-p/asynchronous-lecture.git
cd asynchronous-lecture
npm install
```

Now you can run the code samples!

## Callbacks (errbacks)

### Basic Example / Introduction

Why do we have to write asynchronous code?

Why is it a good thing that we get to?

Read and run `node ./callbacks/wtf.js`

### Passing a Callback is Not Returning Something

Read and run `node ./callbacks/noob.js`

### Non-Blocking

Read and run `node ./callbacks/non-blocking.js`

### Sequential Requests

Read and run `node ./callbacks/sequential.js`

### Parallel Requests

Read and run `node ./callbacks/parallel.js`

### Advanced control flow with `async`

Read and run `node ./callbacks/with-async.js`

### Recursive pagination

Read and run `node ./callbacks/pagination.js`

### Pagination with `async`

http://caolan.github.io/async/docs.html#waterfall

## Promises

### Basic Example / Introduction

Read and run `node ./promises/basic.js`

### Promise chaining

Read and run `node ./promises/chain.js`

### Promise.all

Read and run `node ./promises/all.js`

### Promise.resolve

Read and run `node ./promises/resolve.js`

### Creating a Promise vs. Resolving a Promise

Read and run `node ./promises/creating-vs-resolving.js`

### Promise implementations

Depending on your Javascript environment, you may or may not need to specify
the promise implementation. All browsers except Internet Explorer have native
support for promises, and it's in Node / Electron / React Native.

## `async` / `await`

Node 7+ required.

### Basic Example / Introduction

Read and run `node ./aa/basic.js`

### Only a function can be `async`

Read and run `node ./aa/wrong.js`

### Why Async / Await?

Read and run `node ./aa/control-flow.js`

#### While Loop Pagination

Read and run `node ./aa/while-loop-pagination.js`

### Gotchas

#### All Async Functions Return a Promise

Read and run `node ./aa/gotcha-promise-return.js`

#### Easy to Write Not Parallel Code

```javascript
async function asyncNoob () {
  const one = await getOne()
  const two = await getTwo()
  // do something with one, two
}
```

is the equivalent of

```javascript
function promiseNoob () {
  getOne()
  .then(one => {
    getTwo()
    .then(two => {
      // do something with one, two
    })
  })
}
```

Instead write

```javascript
async function asyncBoss () {
  const [ one, two ] = await Promise.all([getOne(), getTwo()])
  // do something with one, two
}
```

or

```javascript
function promiseBoss () {
  Promise.all([getOne(), getTwo()])
  .then(([one, two]) => {
    // do something with one, two
  })
}
```

#### For Each vs. For Of

Read and run `node ./aa/gotcha-for-each-without-async.js`

Read and run `node ./aa/gotcha-for-each-vs-for-of.js`

#### Runtimes

`async` / `await` is only supported in Node 7+ and using `babel-polyfill` for browsers.
If you're running an older Node version, you can use `babel-node` which I personally
don't like, and if you need to keep your build size down on the client you shouldn't
use it there either because `babel-polyfill` adds some overhead.

### Icing

#### Throttling

Read and run `node ./icing/throttling.js`

repository: ben-pr-p/asynchronous-lecture

repo_name: ben-pr-p/asynchronous-lecture


text:
# Setup a Java development environment on Ubuntu
The guidance below is an _opinionated_ (my opinion) set of steps to setup and configure a simple Java development environment on [Ubuntu Desktop](https://ubuntu.com/download/desktop).  The guidance includes

- installing the Java Development Kit (JDK) and Java Runtime Environment (JRE), and
- configuring Visual Studio Code Java extensions

> This has been tested and verified on Ubuntu 20.04 (LTS) running on physical hardware.  However, it should work the same on a virtual machine.

## Pre-requisites
The following are required to leverage and use this content:
- Ubuntu Desktop, v20.04 (LTS)
- Visual Studio Code, v1.57.1 (or later)

## Install JDK and JRE
Since I use VS Code as my IDE, I tend to default to the [VS Code supported languages documentation](https://code.visualstudio.com/docs/languages/overview) to learn what I need to support development in a particular language.  As expected, I found the [Java in Visual Studio Code](https://code.visualstudio.com/docs/languages/java) page with guidance to get started.  Unexpectedly, I learned that the _Coding Pack for Java_ that bundles together everything you need is only available for Windows and macOS.  Meaning, I'm on my own to install a JDK, JRE, and VS Code Java extensions. :confused:

With all the Java distributions available, it's not an obvious choice on which one to go with.  My exploration led me to finally go with [Microsoft's Build of OpenJDK](https://www.microsoft.com/openjdk).  This build is supported on macOS, Windows, and Linux.  However, what really got my attention was the "General Availability" note indicating the binaries are ready for "production", as explained in [this blog post](https://devblogs.microsoft.com/java/announcing-general-availability-of-microsoft-build-of-openjdk/).  Satisfied with my findings, I proceeded to install **OpenJDK 11** using the native installer for Ubuntu 18.04 (and newer) following [these steps](https://docs.microsoft.com/en-us/java/openjdk/install#install-on-ubuntu-1804).

> Be sure to update the URL in the `wget` command to specify your Ubuntu version, "20.04" in my case.  You can see all the Ubuntu versions that packages exist for [here](https://packages.microsoft.com/config/ubuntu/).

## Install and configure VS Code Java extensions
The Java extensions to install are just the extensionsions from the [Java Extension Pack](https://marketplace.visualstudio.com/items?itemName=vscjava.vscode-java-pack).  You may choose to install all or just a few.  At a minimum, I suggest installing the following extensions.

- [Language Support for Java (TM) by Red Hat](https://marketplace.visualstudio.com/items?itemName=redhat.java), providing intellisense, code-completion, syntax highlighting, etc.

  > NOTE: Since I used the native installers above to install the JDK and JRE, I didn't have to mess with configuring the `JDK_HOME` and `JAVA_HOME` environment variables.

- [Debugger for Java](https://marketplace.visualstudio.com/items?itemName=vscjava.vscode-java-debug), enabling you to run and/or debug your Java application.
- [Java Test Runner](https://marketplace.visualstudio.com/items?itemName=vscjava.vscode-java-test), providing unit testing support of your code.

## References
Some related references are listed below:
- Follow and/or contribute to [microsoft/openjdk](https://github.com/microsoft/openjdk) on GitHub.
- [Java on Azure tutorials](https://code.visualstudio.com/docs/java/java-on-azure).

repository: rickrain/java-setup-on-ubuntu

repo_name: rickrain/java-setup-on-ubuntu


text:
## 3 Second Song Challenge

The Song Challenge Web App is a React app that uses Firebase as the backend. We maintain most of the logic within the user browser with some calls to the Spotify Web API.

The single player mode allows the user to select a challenge that they would like to attempt. Users will attempt to guess the title of songs that are played for a specified duration of time. For example, the user may choose 3 seconds to listen to a song and identify it from the four options that are provided to them.

## Getting Started
These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.

## Clone the repository
https://github.com/perrenwright/3_second_song_challenge.git

Navigate to the repository directory:

  `cd 3_second_song_challenge`

## Prerequisites
What things you need to install the software and how to install them:

NPM

Firebase

## Installing
A step by step series of examples that tell you how to get a development env running

If you have not installed npm please navigate to this site and follow the steps:

`https://www.npmjs.com/get-npm`

If you have  not installed Firebase:

Install Firebase tools

sudo npm install -g firebase-tools

Install Firebase

npm install firebase

Run npm start

## Running the tests

To run the automated tests for this system

Navigate to the source folder

cd 3_second_song_challenge

Run npm test

## Break down into tests

We tested each component to ensure that their functionality behaves as expected. We majorly focused on unit testing each feature.

`Example: Clicking the Challenge length button`

    test('Challenge_length button sets length', () => {

    let setChallenge_length = jest.fn();

    const { getByTestId } = render(<Challenge_length challenge_length={5} setChallenge_length={setChallenge_length} gameState=       {null}/>);

    act(() => {
      fireEvent.click(getByTestId("button1"));
    });

    expect(setChallenge_length).toHaveBeenCalledWith(5);
    });
## Deployment
Run firebase serve then deploy
## Built With
REACTJS - The web framework used
## Authors
Oluwatoni Oshikanlu

Perren Wright

Aghogho Biakolo

Mikayla Orange

Prabin Sapkota

## License
This project is licensed under the MIT License
## Acknowledgments

JM Perez for the Spotify API Wrapper

Inspiration from The Beat by Shazam

Google Tech Exchange Team


text:
# linked-list-kth (lab 07)

## Challenge

- Return the _node’s value_ that is **k** places from the tail of the linked list.

## Whiteboard and Process

![Whiteboard](./image/linked-list-kth.PNG)

## test result

![test](./image/code07-test.PNG)

## Approach & Efficiency

- Create a Node class that has properties for the value stored in the Node
- Create a Linked List class
- Within your Linked List added data then added to the last of the list
- return the node's value of the index k
- by kthFromEnd method in the class

gha_language: JavaScript


text:
# dragster-ts

TS Port of Dragster
[Better HTML drag events](https://github.com/bensmithett/dragster)

:sparkles::sparkles:**[Demo](http://bensmithett.github.io/dragster)**:sparkles::sparkles:

HTML5 `dragenter` and `dragleave` events
[are crap](http://www.quirksmode.org/blog/archives/2009/09/the_html5_drag.html).
Dragster gives you sane new `dragster:enter` and `dragster:leave` events that
behave just like `mouseenter` and `mouseleave`.

It usually involves transparent overlay elements, listening to the
constantly-firing `dragover` event or nuking every other event with
`pointer-events: none`.

Dragster is tiny, unobtrusive & doesn't do much - it just add a couple of event
listeners for `dragenter` and `dragleave` on the elements that you specify. It
never does anything automagically, and doesn't cancel the original events.

Dragster works in latest stable Chrome, Firefox, Safari & Opera. It does nothing
at all in IE 7-10 (IE
[doesn't support DOM event constructors](http://www.2ality.com/2013/06/triggering-events.html)).

@catmanjan maintains a
[jQuery plugin version](https://github.com/catmanjan/jquery-dragster) of
Dragster if you'd like better cross browser support.

## Setup

Meant to be vendored (file cloned directly in your project's working directy) and compiled by your Typescript compilation process (whatever that may be.)

Then just include Dragster in your app, then register your dropzone elements with
Dragster so they can start emitting `dragster:` events.

```javascript
const dropzone = document.getElementById("my-dropzone");
const dragster = new Dragster(dropzone);
```

Then you can add some plain old event listeners without pulling your hair out.

```javascript
document.addEventListener("dragster:enter", function (e) {
  e.target.classList.add("dragged-over");
}, false);

document.addEventListener("dragster:leave", function (e) {
  e.target.classList.remove("dragged-over");
}, false);
```

You can teardown a Dragster instance by calling `removeListeners`

```javascript
// Dragging over dropzone emits dragster: events
dragster.removeListeners();
// Dragster events no longer emitted from dropzone
```

## License

Dragster is released under the [MIT License](http://ben.mit-license.org/)


text:
{
    "cmd_aliases": [],
    "cmd_class": "basic",
    "date": "2018-07-06 22:13:11-07:00",
    "lastmod": "2018-07-06 22:36:13-07:00",
    "title": "gg branch",
    "usage": "gg branch [-d] [-f] [-r REV] [NAME [...]]"
}

list or manage branches

Branches are references to commits to help track lines of
development. Branches are unversioned and can be moved, renamed, and
deleted.

Creating or updating to a branch causes it to be marked as active.
When a commit is made, the active branch will advance to the new
commit. A plain `gg update` will also advance an active branch, if
possible. If the revision specifies a branch with an upstream, then
any new branch will use the named branch's upstream.

## Options

-d

-delete

delete the given branches

-f

-force

force

-r rev

revision to place branches on

repository: ijt/gg

repo_name: ijt/gg


text:
---
title: "Jay Dyer"
created_at: Sat Jan  5 04:00:47 MST 2019
kind: article
tags:
  - orthodox_christianity
  - orthodox_people
  - jay_dyer
---

  jaysanalysis.com

You have selected the Gold membership level.
Full Access
The price for membership is $60.00 per Year.
Membership expires after 1 Year.

Invoice #3DEB2B17B1 on February 12, 2019
Account: Craig Anderson<EMAIL_ADDRESS>Membership Level: Gold
Membership Expires: February 11, 2020

run youtube-dl-mp3 on arch vm

$ youtube-dl --version
2019.01.02
  This ran much faster than older version on Debian host.

Feuding with AncientFaith.com

  Jay Dyer youtube
  Bird Box (2018) Meaning Explained - JaysAnalysis

  Jay Dyer youtube
  Bird Box, Vegan Millennial Diets & The Hidden Story of Blade Runner - Jay & Primal Edge

youtube heard

  Jay Dyer youtube
  [ ] Why I Became Orthodox - Jay Dyer

  Jay Dyer youtube
  [ ] Defense of Metaphysics & Traditional Philosophy Ep 1 - Jay Dyer

  Jay Dyer youtube
  The Secret of All History is Found in Daniel - Jay Dyer (Half)

  Jay Dyer youtube
  [ ] The Spooky Subversion of American Orthodoxy - How It's Done - Jay Dyer

  Jay Dyer youtube
  Orthodox Christian Basics - Rome, Ecumenism, Theophanies, Idols - FAQs - Jay Dyer

  Jay Dyer youtube
  Patriarch of Constantinople, Orthodox Ukrainian Schism, Ecumenism & Freemasonry - Jay Dyer

  Jay Dyer youtube
  Eyes Wide Shut 30 Years BEFORE? Eye of the Devil Analysis - Jay Dyer

  Alternative View youtube
  AV9 - Jay Dyer - Hollywood Trans-Humanism : Rise of the Machines

  Jay Dyer youtube
  The Secret Society That Ruined the World 1: Rhodes, Rothschild, Milner

The Anglo-American Establishment - Carroll Quigley

  Jay Dyer youtube
  The Secret Society That Ruined the World 2: Rhodes, Rothschild, Milner

  Jay Dyer youtube
  Aristotle, Simplicity, St John of Damascus & Defense of the Orthodox Faith BK I - Jay Dyer (Half)

Writings: The Fount of Knowledge- The Philosophical Chapters, on Heresies,
the Orthodox Faith (The Fathers of the Church, Vol. 37)

ISBN-10:<PHONE_NUMBER>
ISBN-13:<PHONE_NUMBER>246

  Ex Fontibus Company

Aristotle East and West by David Bradshaw

Publisher: Cambridge University Press; 1 edition (March 26, 2007)
Language: English
ISBN-10:<PHONE_NUMBER>
ISBN-13:<PHONE_NUMBER>569

  Jay Dyer youtube
  Hidden Metaphysics - Logos and Logoi - Jay Dyer (Half)

  Jay Dyer youtube
  Collins Brothers Interview No. 1, Part 1

Books

  amazon.com
  The Ascendancy of the Scientific Dictatorship: An Examination of
  Epistemic Autocracy, From the 19th to the 21st Century by Paul Collins
  by Paul Collins

Publisher: BookSurge Publishing (1794)
ASIN: B01N9LKDZQ

Tragedy & Hope: A History of the World in Our Time
by Carroll Quigley

The Anglo-American Establishment
by Carroll Quigley

David Brown review

How real history is made. This book will disabuse you of all the false
history you have learned through state sponsored and state controlled
schools. Quigley gives names, dates and documents on the real shakers and
movers who controlled geopolitics behind the scenes. Great read. See also
Quigley's 'Tragedy and Hope' which is the basis of two other shorter and
more readable books: 1) Gary Alan's famous book called None Dare call
it Conspiracy and 2) Joseph Plummer's Tragedy & Hope 101: The Illusion
of Justice, Freedom and Democracy. AT 200 pages, Tragedy & Hope 101 is
a great primer for Quigley's larger 1,300 plus page book or even a great
companion book.

  Jay Dyer youtube
  JaysAnalysis: Basic Metaphysics – Logos and Logoi

Jay Dyer Uploaded on Oct 5, 2016

In this talk, I give a basic introduction to classical metaphysics
and theology based on St. John of Damascus’ Fount of Knowledge: The
Philosophical Chapters. We cover the seminal terms and concepts and
how they relate to forming a proper worldview and critical thinking,
and how the modern world has robbed us of this inheritance.

  Jay Dyer youtube
  Defense of Traditional Philosophy Ep 3 - Absolute Simplicity, Essence - Energy & the 6th Council

Jay Dyer Streamed live on Jan 1, 2019

Not a newbie stream. Hardcore.
Today we will cover divine simplicity in the Roman view, the Orthodox
view, the meanings of our terms, the revealed doctrines, the patristic
usages, the essence - energy distinction, St John of Damascus, St Gregory
of Nyssa Against Eunomius, St Maximos, St Sophronius, and much more!

Free Choice in St. Maximus the Confessor by Joseph P. Farrell

https://www.scribd.com/doc/138363605/Joseph-P-Farrell-Free-Choice-in-St-Maximus-the-Confessor

gha_language: HTML


text:
# Strawpoll-lib

npm package for the [strawpoll](https://www.strawpoll.me) API

## Installation

Use [npm](https://www.npmjs.com/) to install strawpoll-lib.

```bash
npm i strawpoll-lib --save
```

## Usage

Get Poll Information
```Node.js
const strawpoll = require('strawpoll-lib')

let pollID = 1
strawpoll.getPoll(pollID).then(res => {
	console.log(res)
})
```

Create Poll
```Node.js
const strawpoll = require('strawpoll-lib')

strawpoll.createPoll("Question?", ["Yes", "No"]).then(res => {
	console.log(res)
	console.log(strawpoll.getURL(res.id))
})
```

## Functions

Getting Poll Information
```Node.js
getPoll(pollID) // returns a Promise that will attempt to get a JSON Object based on schema at https://github.com/strawpoll/strawpoll/wiki/API.

getTitle(pollID) // returns a Promise that will attempt to get the poll's title question.

getOptions(pollID) // returns a Promise that will attempt to get the poll's options.

getResults(pollID) // returns a Promise that will attempt to get a JSON Object that associates poll options with number of votes.

getURL(pollID) // returns the URL of the poll.
```

Creating A Poll
```Node.js
createPoll(title, options, multi=false, dupcheck="normal", captcha=false) // returns a Promise that will attempt to get a JSON Object based on schema at https://github.com/strawpoll/strawpoll/wiki/API.
```

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


text:
# Load Testing

This sample illustrates use of the peformance testing modules:

- [BrowserPerf](https://github.com/axemclion/browser-perf)
- [Artillery](https://artillery.io)

## Usage

BrowserPerf is configured to use the existing Selenium E2E tests developed for the Beta External web application.

You will need to set the SauceLabs environment variables before running the script as follows:

`npm start`

Artillery uses the `external.yaml` configuration to run a sample load test against several pages from the Alpha external web app, so you should have this running locally on your own machine at `http://localhost:3000`

Launch the test using:

`npm run-script test-artillery`

The script will run for the configured duration and will output a `artillery_report_.*.json` file in the working directory

You can view the HTML report for this output by running:

`artillery report <artillery_report.*.json>`

repository: ministryofjustice/apvs

branch_name: refs/heads/develop

repo_name: ministryofjustice/apvs


text:
ec2-tools
=========

Tools for working with ec2 nodes

Prerequisites
-------------
1. RHEL/CentOS 6.3 or later
2. Passphraseless ssh-key, default ~/.ssh/id_rsa (because if a user knows nothing of ssh, this is the default)
2. Git installed
3. Use the "Name" tag on the EC2 instance to set the hostname of the node

Bootstrap the node
------------------
The bootstrap and initial configuration tool makes use of ec2-host (and you get [ec2-ssh](https://github.com/Instagram/ec2-ssh) for free).

Set the env vars below:
`export AWS_ACCESS_KEY_ID=""`
`export AWS_SECRET_ACCESS_KEY=""`
`export AWS_EC2_REGION=""`

Run the following to bootstrap the node:
`wget --delete-after -q -O - https://raw.githubusercontent.com/sakserv/ec2-tools/master/init_node | bash`


text:
Loader (size="m"):

```jsx
<Loader />
```

Small loader:

```jsx
<Loader size="s" />
```

Large loader:

```jsx
<Loader size="l" />
```

repository: pvburkov/av-test-app

repo_name: pvburkov/av-test-app


text:
The Ember Cookbook provides answers and solutions to common Ember questions and problems. Anyone is welcome to
[contribute](./understanding_the_cookbook_format).

If you are new to Ember, we recommend that you spend some time reading the guides and tutorials before coming
to the Cookbook. Cookbook recipes assume that you have a basic understanding of Ember's concepts.

If you have experience with Ember and would like to contribute to the Cookbook, the discussion section of each
recipe is a great place to start.

### Recipes

1. [Understanding the Cookbook Format](./understanding_the_cookbook_format)
1. [Participating If You Know Ember](./participating_if_you_know_ember)
1. [Participating If You Don't Know Ember](./participating_if_you_dont_know_ember)
1. [Deciding If A Recipe is a Good Fit](./deciding_if_a_recipe_is_a_good_fit)
1. [Suggesting A Recipe](./suggesting_a_recipe)

repository: ember-learn/guides-source

repo_name: ember-learn/guides-source


text:
---
title: "Documentation"
date: 2021-02-02T20:46:28+01:00
draft: false
---

The documentation is build with [Hugo](https://gohugo.io/) and uses the theme [Learn](https://learn.netlify.app/en/). The source code is located in the [docs](https://github.com/DefectDojo/django-DefectDojo/tree/dev/doc) folder. Static files for the webside are build with github actions and are publish in the gh-pages branch.

## How to run a local preview

1. [Install Hugo](https://gohugo.io/getting-started/installing/)
2. Clone the DefectDojo git repository with the option `--recurse-submodules`. If you have already cloned the repository, make sure that you have checkouted out the hugo theme learn or use git submoduls check it out `cd docs/themes/learn && git submodule init && git submodule update`
3. Switch to the docs folder and start the hugo server with hot reloading `hugo server -D`
4. Visit [http://localhost:1313/django-DefectDojo](http://localhost:1313/django-DefectDojo).

repository: TarlogicSecurity/django-DefectDojo

repo_name: TarlogicSecurity/django-DefectDojo


text:
---
layout: project
title: MUX74HC4067
description: Arduino library for interfacing with the 74HC4067 mux / demux
date: 2014-01-21 00:00:00
categories: [ software, embedded ]
tags: [ c++, multiplexer, switch ]
filename: 2014-01-21-mux74hc4067
img: mux74hc4067.png
carousel: [ 1.png, 2.png, 3.png ]
website: https://github.com/nlamprian/MUX74HC4067
---

MUX74HC4067 is an **Arduino library** that offers an API for interfacing with the **74HC4067 multiplexers / demultiplexers**.

**Multiplexers** are devices that choose among a number of different inputs and channel that input to a single output. This way, a handful of sensors are now able to connect in turn to a computing device through a common bus. **Demultiplexers** work in the opposite direction. That is, they take one input signal and convey it to one of several outputs. They allow a computing device to use a single port to control many modules.

MUX74HC4067 simplifies the use of the **MUX** module and offers **safe operation**. That is, it makes sure that no signals get mixed up by always setting/resetting the right **channel** before anything is read or written to the **signal pin**.

There is a **tutorial** on MUX74HC4067 on [codebender's blog](http://blog.codebender.cc/2014/01/30/mux74hc4067/). The **source code** is available on [GitHub](https://github.com/nlamprian/MUX74HC4067).


text:
---
schema: pacelf
title: Benefit of insecticide-treated nets, curtains and screening on vector borne diseases, excluding malaria  a systematic review and meta-analysis
organization: Wilson, A.L., Dhiman, R.C., Kitron, U., Scott, T.W., van den Berg, H., Lindsay, S.W.
notes: Introduction  Insecticide-treated nets (ITNs) are one of the main interventions used for malaria control. However, these nets may also be effective against other vector borne diseases (VBDs). We conducted a systematic review and meta-analysis to estimate the efficacy of ITNs, insecticide-treated curtains (ITCs) and insecticide-treated house screening (ITS) against Chagas disease, cutaneous and visceral leishmaniasis, dengue, human African trypanosomiasis, Japanese encephalitis, lymphatic filariasis and onchocerciasis.
access: Open

resources:
- name: Benefit of insecticide-treated nets, curtains and screening on vector borne diseases, excluding malaria  a systematic review and meta-analysis
  url: '/docs/MULTICOUNTRY_GlobalWilson-2014-Benefit_of_Insectici.pdf'
  format: Electronic
  access: Open
  pages: e3228

category: Scientific Papers
access: Open
journal: PLoS Neglected Tropical Diseases
publisher: N/A
language: English
hardcopy_location: N/A
work_location: Multicountry Global
year: 2014
decade: 2010
PacELF_ID: 1038
---

repository: DanielBaird/jkan

repo_name: DanielBaird/jkan


text:
# Excel-Document-Writer

## Techonology Used
    C# 6.0
    .NET 4.5.2
    Visual Studio 2015 Update 3

## Summary
Excell Document Writer is a dot NET Console to Create Excel File running on Windows Platform.

## Features
* Excel Styled Table.
* Custom Values for Table Headers.
* Writing Different Type of data in one Iteration.
* Writing Hyperlink with Custom Link Text.
* Saves File in Documents folder with DateTime Stamp.
* Releasing Resources.

## Resources
### Used Official Microsoft Office Interop Library

    Microsoft.Office.Interop.Excel

repository: fahidnasir/Excel-Document-Writer

repo_name: fahidnasir/Excel-Document-Writer


text:
# A Car Racer JavaScript Game Exercise Using Vanilla JavaScript [Video]
This is the code repository for [A Car Racer JavaScript Game Exercise Using Vanilla JavaScript [Video]](https://www.packtpub.com/in/game-development/car-racer-javascript-game-exercise-using-vanilla-javascript-video), published by [Packt](https://www.packtpub.com/?utm_source=github). It contains all the supporting project files necessary to work through the video course from start to finish.

## About the Video Course
Have you ever wanted to build amazing and interactive games? If yes, then this course is perfect for you.
A basic knowledge of JavaScript is desirable as the course covers only JavaScript relevant to building a game. Also, HTML and CSS knowledge is essential as the scope of this course focuses entirely on JavaScript.

The course is designed to teach you to use JavaScript. We cover the following:-

Learn how to set up your gameplay area using HTML and CSS
Add JavaScript setting event listeners
Add keyboard actions to move an HTML div using keyboard arrow keys
Run AnimationFrame() to change element position and respond to the user's commands
Set up and start game functionality
Create a dynamic JavaScript road
Create elements within JavaScript
Access the JavaScript Document Object Model to manipulate element properties
Set up and add values within an object to track location and movement
Set up a dashboard to output variables for the user such as the score and speed
Add road movement
Track speed dynamically with braking and accelerating
Add other cars and have them move within the gameplay area
Check for element overlap and detect collisions
Score and extend gameplay
Practicability is the key to this course. Using JavaScript, you have a wide variety of options whereby you can take the code provided within this course and expand it in any number of directions. Learn, practice, and create your own interactive game..

What You Will Learn

 Create a car racing game from scratch

 Apply JavaScript and move elements within a page using JavaScript

 Detect overlapping collision between two elements

 Run animations within JavaScript

## Instructions and Navigation
### Assumed Knowledge
To fully benefit from the coverage included in this course, you will need:

 Fundamental JavaScript concepts

 Use of editor to write code

 HTML and CSS knowledge

## Related Products
* [JavaScript Game Exercise - Quick Click Popper Game [Video]](https://www.packtpub.com/in/application-development/javascript-game-exercise-quick-click-popper-game-video)

* [JavaScript Game Exercise - WildWest Shootout Game Practice [Video]](https://www.packtpub.com/in/web-development/javascript-game-exercise-wildwest-shootout-game-practice-video)

* [A JavaScript Game Exercise Built from Scratch to Catch Objects [Video]](https://www.packtpub.com/in/web-development/javascript-game-exercise-built-scratch-catch-objects-video)


text:
---
title: Developer SDKs
position: 2
---

There are multiple developer SDKs available. To see how to install and use them, refer to the links below:

- Ruby SDK: [https://github.com/ElderScrollsLegends/elder-scrolls-legends-sdk-ruby](https://github.com/ElderScrollsLegends/elder-scrolls-legends-sdk-ruby)
- Python SDK: [https://github.com/ElderScrollsLegends/elder-scrolls-legends-sdk-python](https://github.com/ElderScrollsLegends/elder-scrolls-legends-sdk-python)


text:
Install Plex Media Server On Ubuntu / CentOS 7.1 / Fedora 22
================================================================================
In this article we will show you how easily you can setup Plex Home Media Server on major Linux distributions with their latest releases.  After its successful installation of Plex you will be able to use your centralized home media playback system that streams its media to many Plex player Apps and the Plex Home will allows you to setup your environment by adding your devices and to setup a group of users that all can use Plex Together. So let’s start its installation first on Ubuntu 15.04.

### Basic System Resources ###

System resources mainly depend on the type and number of devices that you are planning to connect with the server. So according to our requirements we will be using as following system resources and software for a standalone server.

注：表格

Plex Home Media Server

Base Operating System
Ubuntu 15.04 / CentOS 7.1 / Fedora 22 Work Station

Plex Media Server
Version <IP_ADDRESS>.1173-937aac3

RAM and CPU
1 GB  , 2.0 GHZ

Hard Disk
30 GB

### Plex Media Server <IP_ADDRESS> on Ubuntu 15.04 ###

We are now ready to start the installations process of Plex Media Server on Ubuntu so let’s start with the following steps to get it ready.

#### Step 1: System Update ####

Login to your server with root privileges Make your that your system is upto date if not then do by using below command.

    root@ubuntu-15:~#apt-get update

#### Step 2: Download the Latest Plex Media Server Package ####

Create a new directory and download .deb plex Media Package in it from the official website of Plex for Ubuntu using wget command.

    root@ubuntu-15:~# cd /plex/
    root@ubuntu-15:/plex#
    root@ubuntu-15:/plex# wget https://downloads.plex.tv/plex-media-server/<IP_ADDRESS>.1173-937aac3/plexmediaserver_<IP_ADDRESS>.1173-937aac3_amd64.deb

#### Step 3: Install the Debian Package of Plex Media Server ####

Now within the same directory run following command to start installation of debian package and then check the status of plekmediaserver.

    root@ubuntu-15:/plex# dpkg -i plexmediaserver_<IP_ADDRESS>.1173-937aac3_amd64.deb

----------

    root@ubuntu-15:~# service plexmediaserver status

![Plexmediaserver Service](http://blog.linoxide.com/wp-content/uploads/2015/06/plex-status.png)

### Plex Home Media Web App Setup on Ubuntu 15.04 ###

Let's open your web browser within your localhost network and open the Web Interface with your localhost IP and port 32400 and do following steps to configure it:

    http://<IP_ADDRESS>:32400/web
    http://localhost:32400/web

#### Step 1:Sign UP before Login ####

After you have access to the web interface of Plesk Media Server make sure to Sign Up and set your username email ID and Password to login as.

![Plex Sign In](http://blog.linoxide.com/wp-content/uploads/2015/06/PMS-Login.png)

#### Step 2: Enter Your Pin to Secure Your Plex Media Home User ####

![Plex User Pin](http://blog.linoxide.com/wp-content/uploads/2015/06/333.png)

Now you have successfully configured your user under Plex Home Media.

![Welcome To Plex](http://blog.linoxide.com/wp-content/uploads/2015/06/3333.png)

### Opening Plex Web App on Devices Other than Localhost Server ###

As we have seen in our Plex media home page that it indicates that "You do not have permissions to access this server". Its because of we are on a different network than the Server computer.

![Plex Server Permissions](http://blog.linoxide.com/wp-content/uploads/2015/06/33.png)

Now we need to resolve this permissions issue so that we can have access to server on the devices other than the hosted server by doing following setup.

### Setup SSH Tunnel for Windows System to access Linux Server ###

First we need to set up a SSH tunnel so that we can access things as if they were local. This is only necessary for the initial setup.

If you are using Windows as your local system and server on Linux then we can setup SSH-Tunneling using Putty as shown.

![Plex SSH Tunnel](http://blog.linoxide.com/wp-content/uploads/2015/06/ssh-tunnel.png)

**Once you have the SSH tunnel set up:**

Open your Web browser window and type following URL in the address bar.

    http://localhost:8888/web

The browser will connect to the server and load the Plex Web App with same functionality as on local.
Agree to the terms of Services and start

![Agree to Plex term](http://blog.linoxide.com/wp-content/uploads/2015/06/5.png)

Now a fully functional Plex Home Media Server is ready to add new media libraries, channels, playlists etc.

![PMS Settings](http://blog.linoxide.com/wp-content/uploads/2015/06/8.png)

### Plex Media Server <IP_ADDRESS> on CentOS 7.1 ###

We will follow the same steps on CentOS-7.1 that we did for the installation of Plex Home Media Server on Ubuntu 15.04.

So lets start with Plex Media Servers Package Installation.

#### Step 1: Plex Media Server Installation ####

To install Plex Media Server on centOS 7.1 we need to download the .rpm package from the official website of Plex. So we will use wget command to download .rpm package for this purpose in a new directory.

    [root@linux-tutorials ~]# cd /plex
    [root@linux-tutorials plex]# wget https://downloads.plex.tv/plex-media-server/<IP_ADDRESS>.1173-937aac3/plexmediaserver-<IP_ADDRESS>.1173-937aac3.x86_64.rpm

#### Step 2: Install .RPM Package ####

After completion of complete download package we will install this package using rpm command within the same direcory where we installed the .rpm package.

    [root@linux-tutorials plex]# ls
    plexmediaserver-<IP_ADDRESS>.1173-937aac3.x86_64.rpm
    [root@linux-tutorials plex]# rpm -i plexmediaserver-<IP_ADDRESS>.1173-937aac3.x86_64.rpm

#### Step 3: Start Plexmediaservice ####

We have successfully installed Plex Media Server Now we just need to restart its service and then enable it permanently.

    [root@linux-tutorials plex]# systemctl start plexmediaserver.service
    [root@linux-tutorials plex]# systemctl enable plexmediaserver.service
    [root@linux-tutorials plex]# systemctl status plexmediaserver.service

### Plex Home Media Web App Setup on CentOS-7.1 ###

Now we just need to repeat all steps that we performed during the Web app setup of Ubuntu.
So let's Open a new window in your web browser and access the Plex Media Server Web app using localhost or IP or your Plex server.

    http://<IP_ADDRESS>:32400/web
    http://localhost:32400/web

Then to get full permissions on the server you need to repeat the steps to create the SSH-Tunnel.
After signing up with new user account we will be able to access its all features and can add new users, add new libraries and setup it per our needs.

![Plex Device Centos](http://blog.linoxide.com/wp-content/uploads/2015/06/plex-devices-centos.png)

### Plex Media Server <IP_ADDRESS> on Fedora 22 Work Station ###

The Basic steps to download and install Plex Media Server are the same as its we did for in CentOS 7.1.
We just need to download its .rpm package and then install it with rpm command.

![PMS Installation](http://blog.linoxide.com/wp-content/uploads/2015/06/plex-on-fedora.png)

### Plex Home Media Web App Setup on Fedora 22 Work Station ###

We had setup Plex Media Server on the same host so we don't need to setup SSH-Tunnel in this time scenario. Just open the web browser in your Fedora 22 Workstation with default port 32400 of Plex Home Media Server and accept the Plex Terms of Services Agreement.

![Plex Agreement](http://blog.linoxide.com/wp-content/uploads/2015/06/Plex-Terms.png)

**Welcome to Plex Home Media Server on Fedora 22 Workstation**

Lets login with your plex account and start with adding your libraries for your favorite movie channels , create your playlists, add your photos and enjoy with many other features of Plex Home Media Server.

![Plex Add Libraries](http://blog.linoxide.com/wp-content/uploads/2015/06/create-library.png)

### Conclusion ###

We had successfully installed and configured Plex Media Server on Major Linux Distributions. So, Plex Home Media Server has always been a best choice for media management. Its so simple to setup on cross platform as we did for Ubuntu, CentOS and Fedora. It has simplifies the tasks of organizing your media content and streaming to other computers and devices then to share it with your friends.

--------------------------------------------------------------------------------

via: http://linoxide.com/tools/install-plex-media-server-ubuntu-centos-7-1-fedora-22/

作者：[Kashif Siddique][a]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译，[Linux中国](https://linux.cn/) 荣誉推出

[a]:http://linoxide.com/author/kashifs/

url: https://raw.githubusercontent.com/Juneor/TranslateProject/55ab470b0e38195a48dae9580bd8e641a7efe990/sources/tech/20150515 Install Plex Media Server On Ubuntu or CentOS 7.1 or Fedora 22.md

repository: Juneor/TranslateProject

repo_name: Juneor/TranslateProject


text:
TreeTagger builder
------------------

This image acts as builder for the **TreeTagger** docker images.

Its purpose is to download and to install the TreeTagger's source (by version) in order to create a bundle.

gha_language: Python


text:
# react-chessboard
~~Simple~~who am I kidding? Chessboard built with React and Grid

## Todo

### Build the Game
1. ~~Identify components~~
2. ~~Create components~~
3. ~~Add game state~~

### Add drag and drop interaction
1. ~~Set up drag and drop context~~
2. ~~Define drag types~~
3. ~~Make knight draggable~~
4. ~~Make board squares droppable~~
5. ~~Add overlay for incorrect, possible, and correct moves~~
6. ~~Add drag preview image~~
7. Fix drag preview image

### Add additional pieces and piece logic
1. King
2. Queen
3. Bishop
4. Rook
5.

repository: koakekuna/react-chessboard

repo_name: koakekuna/react-chessboard


text:
# Changelog

## [0.7.0] - 2021-12-13

### Added
- JWT opaque token support with `--secret-key <secret-key>`

### Changed
- Dropped Python 3.5
- Validated support for Python 3.9

## [0.6.0] - 2021-06-07
### Added
- CORS support using `--allow-origin HOST:PORT` or `$TRANQUILIZER_ALLOW_ORIGIN`

### Fixed
- Example in README

## [0.5.0] - 2020-07-20
### Changed
- Migrated from flask-restplus to flask-restx
- Relax werkzeug pin to allow version 1.x

## [0.4.1] - 2019-12-22
### Fixed
- Fixed tranquilizer.__version__

## [0.4.0] - 2019-09-30
### Changed
- Added Python 3.7 support (rewrite type checking)
- Utilize Versioneer

### Added
- anaconda-enterprise @publish compatiblity
- @publish: When methods is set un-typed arguments are returned
  as a list-of-strings.
- nearly complete test coverage
- Travis CI

## [0.3.3] - 2019-09-06
## Changed
- Fixed ProxyFix call for werkzeug>=0.15

## [0.3.2] - 2019-05-30
### Changed
- Updated setup.py to include more classifiers and requirements
- Python 3.7 typing.List and derivatives does not work

## [0.3.1] - 2019-03-13
### Changed
- Report when nbconvert is not installed, but needed

## [0.3.0] - 2019-03-06
### Changed
- pillow and numpy not required

## [0.2.1] - 2019-03-06
### Added
- Set maximum content length for all endpoints
- Allow --port, --address, and --prefix arguments

## [0.2.0] - 2019-01-23
### Added
- Support serving from Jupyter Notebooks

## [0.1.2] - 2018-12-29
### Added
- Customize application name in Swagger with `--name`

## [0.1.1] - 2018-10-26
- Add `--version`

## [0.1.0] - 2018-09-28
### Added
- Support for sphinx `:param:`, `:raises:` in swagger documentation
- Exceptions return a 500 status code

### Changed
- Removed custom types from `__init__.py`
- Support common datayptes: `list()`, `typing.List[]`, `datetime.datetime`, `datetime.date`.
- Support file handles: `typing.BinaryIO` and `typing.TextIO`
- Support images and arrays: `PIL.Image.Image`, `numpy.ndarray`

repository: ContinuumIO/tranquilizer

repo_name: ContinuumIO/tranquilizer


text:
# Implant Container Image

## Description

### MITRE Description

> Adversaries may implant cloud container images with malicious code to establish persistence. Amazon Web Service (AWS) Amazon Machine Images (AMI), Google Cloud Platform (GCP) Images, and Azure Images as well as popular container runtimes such as Docker can be implanted or backdoored. Depending on how the infrastructure is provisioned, this could provide persistent access if the infrastructure provisioning tool is instructed to always use the latest image.(Citation: Rhino Labs Cloud Image Backdoor Technique Sept 2019)

A tool has been developed to facilitate planting backdoors in cloud container images.(Citation: Rhino Labs Cloud Backdoor September 2019) If an attacker has access to a compromised AWS instance, and permissions to list the available container images, they may implant a backdoor such as a [Web Shell](https://attack.mitre.org/techniques/T1505/003).(Citation: Rhino Labs Cloud Image Backdoor Technique Sept 2019) Adversaries may also implant Docker images that may be inadvertently used in cloud deployments, which has been reported in some instances of cryptomining botnets.(Citation: ATT Cybersecurity Cryptocurrency Attacks on Cloud)

## Aliases

```

```

## Additional Attributes

* Bypass: None
* Effective Permissions: None
* Network: None
* Permissions: ['User']
* Platforms: ['GCP', 'Azure', 'AWS']
* Remote: None
* Type: attack-pattern
* Wiki: https://attack.mitre.org/techniques/T1525

## Potential Commands

```

```

## Commands Dataset

```

```

## Potential Detections

```json

```

## Potential Queries

```json

```

## Raw Dataset

```json

```

# Tactics

* [Persistence](../tactics/Persistence.md)

# Mitigations

* [Audit](../mitigations/Audit.md)

* [Privileged Account Management](../mitigations/Privileged-Account-Management.md)

* [Code Signing](../mitigations/Code-Signing.md)

# Actors

None


text:
---
id: caching
title: Caching
---

## Usage

To use client-side caching on your requests you can add the cache middleware and then use the config option `cache` to specify how long in ms a response should be kept in browser:

```typescript {6} title="/api.ts"
import {CacheMiddleware} from "api-def";

const api = new Api({
  name   : "My Backend",
  baseUrl: "http://localhost:5000/v1",
  middleware: [new CacheMiddleware({ defaultExpiry: 1000 * 60 * 20 /* 20 mins */ })]
});
```

### Predicate

You can also pass in a predicate function to disable caching upon certain conditions (for example a super user toggle for debugging):

```typescript
    middleware: [
        CacheMiddleware({
            predicate: () => isCacheEnabled()
        })
    ]
```

## Cache Backend

By default `api-def` will use `localStorage` to store the data for the cache. You can specify your own cache backend using `setCacheBackend`.

If you use [localforage](https://www.npmjs.com/package/localforage) you can use it as your cache backend for a small performance increase:

```typescript
import localforage from "localforage";
import {setCacheBackend, LocalForageCacheBackend} from "api-def";

setCacheBackend(new LocalForageCacheBackend(localforage));
```

repository: Censkh/api-def

repo_name: Censkh/api-def


text:
# nbaser

[![nimble](https://raw.githubusercontent.com/yglukhov/nimble-tag/master/nimble.png)](https://nimble.directory/pkg/nbaser)

[![tester](https://github.com/D-Nice/nbaser/workflows/tester/badge.svg)](https://github.com/D-Nice/nbaser/actions?query=workflow%3Atester+branch%3Amaster)
[![linter](https://github.com/D-Nice/nbaser/workflows/linter/badge.svg)](https://github.com/D-Nice/nbaser/actions?query=workflow%3Alinter+branch%3Amaster)
[![GitHub deployments](https://img.shields.io/github/deployments/d-nice/nbaser/github-pages?label=docs&style=plastic)](https://github.com/D-Nice/nbaser/deployments?environment=github-pages#activity-log)
[![GitHub file size in bytes](https://img.shields.io/github/size/D-Nice/nbaser/src/nbaser.nim?style=plastic)](https://github.com/D-Nice/nbaser/blob/master/src/nbaser.nim)
[![GitHub tag (latest SemVer)](https://img.shields.io/github/v/tag/d-nice/nbaser?label=version&style=plastic)](https://github.com/D-Nice/nbaser/releases)

Library allowing for consistent and reversible encode/decode
operations between arbitrary unicode character bases.
Supports bases from 2 to 256.

<!-- vim-markdown-toc GFM -->

* [Install](#install)
* [Docs](#docs)
* [Benchmark](#benchmark)
* [Notes](#notes)

<!-- vim-markdown-toc -->

## Install

`$ nimble install nbaser`

import in your project and use

```nim
import nbaser

const bs58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
echo bs58.decode("1Q2TWHE3GMdB6BZKafqwxXtWAWgFt5Jvm3")
# @[0, 252, 145, 111, 33, 58, 61, 127, 19, 105, 49, 61, 95, 163, 15, 97, 104, 249, 68, 106, 45, 17, 33, 166, 54]
```

## Docs

Available @ <https://d-nice.github.io/nbaser/>

Includes examples.

## Benchmark

Check the [benchmarker CI task](https://github.com/D-Nice/nbaser/actions?query=workflow%3Abenchmarker+branch%3Amaster)
for current benchmark numbers.

or to test locally

`$ nimble benchmark`

## Notes

This library does not support padding, such as that found in "standard"
base32 and base64.

It utilizes the leading zero compression found in base58, thereby supports it
and its variants, and does not require padding.

Due to the unicode support, there is quite some performance
overhead relatively to just supporting ASCII. It results
in up to an order of magnitude slowdown, but should still
be fast enough. Check [benchmarks](#benchmark).

repository: D-Nice/nbaser

gha_language: Nim

repo_name: D-Nice/nbaser


text:
# Introduction to JavaScript

---

# This Week

- Including JavaScript
- Variables
- Referencing HTML Elements
- Functions
- Events

---

# Including JavaScript

Including on the page

**Only for debugging / quick prototyping**

```html
<script>
  console.log("Hello There");
</script>
```

Importing an external file

```html
<script src="js/fun.js"></script>
```

Put all `<script>`s at the end of your `<body>`

```html
  <script src='js/fun.js'>
  </script>
</body>
```

---

# Variables

A variable is a container for some data

We can change that data <!-- .element: class="fragment" -->

We can make it a number, for example <!-- .element: class="fragment" -->

```js
let myBag = 5;
```

<!-- .element: class="fragment" -->

Or it could be a word (string)

```js
let myBag = "brown";
```

# Demo

---

# Getting HTML Elements

You might want to do something to an element on the page

To do this, you need a reference to that element <!-- .element: class="fragment" -->

This is where id is very useful <!-- .element: class="fragment" -->

# The Document Object

We use the document object

What's an object? <!-- .element: class="fragment" -->

# What's an Object

An object in JavaScript is really just another variable.

But supercharged a little. <!-- .element: class="fragment" -->

Objects can contain data - properties. <!-- .element: class="fragment" -->

Objects can do things - methods. <!-- .element: class="fragment" -->

We will discuss more another week. <!-- .element: class="fragment" -->

# The Document Object

We use the document object to get a HTML element
It has a method to get an element with a given id

```js
document.getElementById("navbar");
```

We can store this reference in a variable

```js
let menu = document.getElementById("navbar");
```

So that we can do other things to it.

# Demo

---

# Functions

A function is a defined chunk of code

```js
addThese = () => {
  // one or more lines of code
};
```

If we want it to run, we call it

```js
addThese();
```

We can pass data into a function

```js
updateDisplay = (score) => {
  console.log("Score", score);
};

updateDisplay(15);
```

We can get data back from a function

```js
shotRock = (score) => {
  let newScore = score + 10;
  return newScore;
};

console.log("New Score", shotRock(15));
```

# Demo

---

# Events

We can detect a range of events.

- Form element change
- Mouse over
- Key up
- Mouse drag
- Mouse out
- Key down
- Form element focussed
- Form element lost focus
- Data loaded
- error

notes: Reference list of events: <https://developer.mozilla.org/en-US/docs/Web/Events>

# Responding

We first get a reference to the element

Then we add an event listener <!-- .element: class="fragment" -->

```js
document.getElementById("buyButton").addEventListener();
```

<!-- .element: class="fragment" -->

We need to tell the event listener two things.

1. What event are we listening for <!-- .element: class="fragment" -->
2. What to do when the event occurs <!-- .element: class="fragment" -->

```js
document.getElementById("buyButton").addEventListener("click", addToCart);
```

<!-- .element: class="fragment" -->

# Demo

---

# This Week

- Variables
- Functions
- Referencing Elements
- Events

---

# Any Questions?

---

# Thank You

repository: thomcorah/dmu-multimedia

repo_name: thomcorah/dmu-multimedia


text:
# Simple Store
![CI](https://github.com/uber/simple-store/workflows/CI/badge.svg?branch=main)
[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/3000/badge)](https://bestpractices.coreinfrastructure.org/projects/3000)
[![Maven Central](https://img.shields.io/maven-central/v/com.uber.simplestore/simplestore.svg)](https://search.maven.org/artifact/com.uber.simplestore/simplestore)
[![Maven Central](https://img.shields.io/maven-central/v/com.uber.simplestore/simplestore-proto.svg)](https://search.maven.org/artifact/com.uber.simplestore/simplestore-proto)

This project is stable and being incubated for long-term support.

Simple yet performant asynchronous file storage for Android.

SimpleStore aims to provide developers an extremely robust and performant solution for storing key-value data on disk asynchronously. It is built using only Android and Java primitives and avoids taking on external dependencies making it ideal for critical startup storage. It has no opinion on how data is serialized, only storing `string`-`byte[]` pairs of small to moderate size. The core library only exposes a thread-safe, executor-explicit async API ensuring clear thread selection and no UI jank.

All values are stored on disk as plain files that are “namespaced” in a matching on-disk folder structure. The library also supports configuring a namespace to store data on a cache or transient partition.

## Basic usage

To include in a gradle project, add to your dependencies:

```groovy
dependencies {
    implementation 'com.uber.simplestore:simplestore:0.0.8'
    // If using protocol buffers, also add:
    implementation 'com.uber.simplestore:simplestore-proto:0.0.8'
}
```

Out of the box, SimpleStore uses `ListenableFuture` to store `byte[]`, `String`, primitives and protocol buffers on internal storage.
```java
SimpleStore simpleStore = SimpleStoreFactory.create(this, "<some-uuid-or-name>");
ListenableFuture<String> put = simpleStore.putString("some_key", "Foo value");
Futures.addCallback(
        put,
        new FutureCallback<String>() {
          @Override
          public void onSuccess(@NonNull String s) {

          }

          @Override
          public void onFailure(@NonNull Throwable t) {
            Log.e("MyActivity", "Save failure", t);
          }
        },
        mainExecutor());
simpleStore.close();
```

Note that if you use RxJava, Rx comes with a `fromFuture` method that allows you to wrap `ListenableFuture`:

```java
Single<String> value = Single.fromFuture(simpleStore.getString("some_key"));

```

## Fundamentally Async
IO operations are fundamentally async, and any storage solution should be async all the way through.

The implementation is written using async work queues. This allows us to implement under-the-hood optimizations that do not block consumers such as prefetching and pruning old cached values.

`Futures.get` from Guava is available for consumers who wish to run synchronously.

## Interface
Only one interface is exposed for general use. Implementations of the interface provide a factory method for instantiating any variations.

Usage:
```java
SimpleStore store = SimpleStoreFactory.create(context, “feature/mystuff”, NamespaceConfig.DEFAULT);
ListenableFuture<String> value = store.putString("some_key", value);
```

The interface is designed to allow composition with higher level wrappers such as a protocol buffers, Rx, or ListenableFuture transforms.

ListenableFuture was chosen over Rx for the implementation as:
* Future transformations require explicit assignment to an Executor, making it difficult to accidentally perform IO operations in the incorrect pool.
* Executors do not suffer from the round-robin scheduler design of Rx, making deadlock between IO work impossible.
* AndroidX and most Google libraries already ship ListenableFuture and associated Guava classes with them, so most Android apps can take on ListenableFuture without increasing binary size.
* Interop with Futures is built into Rx via `Observables.fromFuture`.

The base interface and implementation purposely leave out a synchronous API as disk IO is fundamentally async. A safe-ish synchronous API can be obtained via `Futures#getChecked` if absolutely needed for compatibility reasons, but most users who think they need sync will probably find the Futures helpers adequate for their needs.

## Closing a namespace

SimpleStore is closable per namespace, and may only have one open instance per namespace process-wide. When a namespace is closed, the in-memory cache is destroyed. The store will deliver failures to all pending callbacks when closed. This ensures that the consumer is always notified if data does not make it to disk and can handle the failure appropriately such as logging a non-fatal. Any reads or writes attempted on the store after closure will result in an exception.

In the future, we can arbitrarily clear portions of the memory cache of an open namespace when desired such as when the OS informs of a trim level. Since the API is fully async, consumers will not be janked and will just see original load latencies.

## Threading

All operations are guaranteed to be executed in-order within the same namespace. A singular cached thread pool backs all stores process wide, and can be replaced with a custom executor via a static configuration method. It is safe to enqueue any operation from any thread, including the main thread. All future callbacks are paired with an executor to be run on, this forces parsing or other processing actions to get out of the way of ordered disk I/O.

This model makes deadlock across namespaces impossible, as even a blockingGet cannot be issued on the ordered IO executor. Adopting this model leaves us room to experiment later with using explicit thread priority for different namespaces.

## License

    Copyright (C) 2020 Uber Technologies

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

repository: uber/simple-store

gha_language: Java

repo_name: uber/simple-store