text:
For this engine, there is a single mode: censored regression

## Tuning Parameters

This model has 2 tuning parameters:

- `penalty`: Amount of Regularization (type: double, default: see below)

- `mixture`: Proportion of Lasso Penalty (type: double, default: 1.0)

The `penalty` parameter has no default and requires a single numeric value. For more details about this, and the `glmnet` model in general, see [parsnip::glmnet-details]. As for `mixture`:

* `mixture = 1` specifies a pure lasso model,
* `mixture = 0`  specifies a ridge regression model, and
* `0 < mixture < 1` specifies an elastic net model, interpolating lasso and ridge.

## Translation from parsnip to the original package

The **censored** extension package is required to fit this model.

```r
library(censored)

proportional_hazards(penalty = double(1), mixture = double(1)) %>%
  set_engine("glmnet") %>%
  translate()
```

```
## Proportional Hazards Model Specification (censored regression)
##
## Main Arguments:
##   penalty = 0
##   mixture = double(1)
##
## Computational engine: glmnet
##
## Model fit template:
## censored::coxnet_train(formula = missing_arg(), data = missing_arg(),
##     weights = missing_arg(), alpha = double(1))
```

## Preprocessing requirements

Factor/categorical predictors need to be converted to numeric values (e.g., dummy or indicator variables) for this engine. When using the formula method via \\code{\\link[=fit.model_spec]{fit()}}, parsnip will convert factor columns to indicators.

Predictors should have the same scale. One way to achieve this is to center and
scale each so that each predictor has mean zero and a variance of one.
By default, [glmnet::glmnet()] uses the argument `standardize = TRUE` to center and scale the data.

## Other details

The model does not fit an intercept.

The model formula (which is required) can include _special_ terms, such as [survival::strata()]. This allows the baseline hazard to differ between groups contained in the function. The column used inside `strata()` is treated as qualitative no matter its type. This is different than the syntax offered by the [glmnet::glmnet()] package (i.e., [glmnet::stratifySurv()]) which is not recommended here.

For example, in this model, the numeric column `rx` is used to estimate two different baseline hazards for each value of the column:

```r
library(survival)
library(censored)
library(dplyr)
library(tidyr)

mod <-
  proportional_hazards(penalty = 0.01) %>%
  set_engine("glmnet", nlambda = 5) %>%
  fit(Surv(futime, fustat) ~ age + ecog.ps + strata(rx), data = ovarian)

pred_data <- data.frame(age = c(50, 50), ecog.ps = c(1, 1), rx = c(1, 2))

# Different survival probabilities for different values of 'rx'
predict(mod, pred_data, type = "survival", time = 500) %>%
  bind_cols(pred_data) %>%
  unnest(.pred)
```

```
## # A tibble: 2 × 5
##   .time .pred_survival   age ecog.ps    rx
##   <dbl>          <dbl> <dbl>   <dbl> <dbl>
## 1   500          0.666    50       1     1
## 2   500          0.769    50       1     2
```

Note that columns used in the `strata()` function _will_ also be estimated in the regular portion of the model (i.e., within the linear predictor).

Predictions of type `"time"` are predictions of the mean survival time.

## Linear predictor values

Since risk regression and parametric survival models are modeling different characteristics (e.g. relative hazard versus event time), their linear predictors will be going in opposite directions.

For example, for parametric models, the linear predictor _increases with time_. For proportional hazards models the linear predictor _decreases with time_ (since hazard is increasing). As such, the linear predictors for these two quantities will have opposite signs.

tidymodels does not treat different models differently when computing performance metrics.  To standardize across model types, the default for proportional hazards models is to have _increasing values with time_. As a result, the sign of the linear predictor will be the opposite of the value produced by the `predict()` method in the engine package.

This behavior can be changed by using the `increasing` argument when calling `predict()` on a \pkg{parsnip} model object.

## Case weights

This model can utilize case weights during model fitting. To use them, see the documentation in [case_weights] and the examples on `tidymodels.org`.

The `fit()` and `fit_xy()` arguments have arguments called `case_weights` that expect vectors of case weights.

## Saving fitted model objects

This model object contains data that are not required to make predictions. When saving the model for the purpose of prediction, the size of the saved object might be substantially reduced by using functions from the [butcher](https://butcher.tidymodels.org) package.

# References

 - Simon N, Friedman J, Hastie T, Tibshirani R. 2011. "Regularization Paths for Cox’s Proportional Hazards Model via Coordinate Descent." _Journal of Statistical Software_, Articles 39 (5): 1–13. \doi{10.18637/jss.v039.i05}.

 - Hastie T, Tibshirani R, Wainwright M. 2015. _Statistical Learning with Sparsity_. CRC Press.

 - Kuhn M, Johnson K. 2013. _Applied Predictive Modeling_. Springer.

repository: tidymodels/parsnip

gha_language: R

repo_name: tidymodels/parsnip


text:
# Stencil Router

The developer experience of the router is designed to be similar to [React Router](https://reacttraining.com/react-router/), and it should make it easy to build apps of all size, from the very simple to the very complex.

## Adding the collection

First thing, ensure that the `collections` entry in `stencil.config.js` has the `@stencil/router` package. If it does not, please add it.

## Configuring the Router

Applications built with Stencil should have one `stencil-router` element for the entire application. Make sure to specify an `id` attribute on it.

```
<stencil-router id="router">
...
</stencil-router>
```

Within the `stencil-router` element, we want to declare our set of `stencil-route`s. Each `stencil-route` needs to take a reference to the router, a url, and then an HTML element tag name.

```
<stencil-router id="router">
  <stencil-route url="/" component="landing-page" router="#router" exact={true}/>
  <stencil-route url="/demos" router="#router" component="demos-page"/>
  <stencil-route url="/demos/rendering" router="#router" component="fiber-demo"/>
  <stencil-route url="/docs" router="#router" component="docs"/>
  <stencil-route url="/docs/getting-started" router="#router" component="getting-started"/>
  <stencil-route url="/components" router="#router" component="basics-components"/>
</stencil-router>
```

When navigating to `/demos/rendering` based on the above configuration, the `demos-page` component will be loaded with a child component `fiber-demo`. Nested routes/components just work.

## Navigating

To navigate around an app, use the `stencil-route-link` component.

```
<stencil-route-link router="#router" url="/">
<stencil-route-link router="#router" url="/demos">
<stencil-route-link router="#router" url="/docs/getting-started">
```

license: MIT

repository: danangiswadi/stencil-site

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: danangiswadi/stencil-site


text:
GoogleCharts is a ruby wrapper to the Google Chart API (http://code.google.com/apis/charttools/)

## Summary

For now, the plugin supports the following charts:
- pie chart
- line chart
- bar chart
- column chart
- area chart

Basically, you can give the chart all the options you would give a GoogleChart when using the Google library: height, width, title, and so on...

For a detailed description of which options to use visit the Google Visualization API and check out the charts there: http://code.google.com/apis/visualization/documentation/gallery.html

## Installation

System wide:

```console
gem install google_charts
```

Or in your Gemfile:

```ruby
gem 'google_charts'
```

## Usage

GoogleCharts is based on a collection of elements. Usually they are records from the database, but can also just be an array.

The following **Stock** class is a Mongoid document and used to keep track of how much we have of any product in our online store. All we need is the product's name and the amount. For simplicity, we'll skip any default values or validations.

```ruby
class Stock
  include Mongoid::Document

  field :name,    type: String
  field :amount,  type: Integer
end
```

Now, let's supply some data for our store.

```ruby
Stock.create name: "Apple",  amount: 10
Stock.create name: "Pear",   amount: 5
Stock.create name: "Banana", amount: 1
```

### Example: Pie chart

In order to figure out how much we have of any product, all we need to do is:

```erb
<%= pie_chart Stock.all do |c| %>
  <% c.title "Total Stock" %>

  <% c.label "Name",    :name %>
  <% c.value "Amount",  :amount %>
<% end %>
```

### Example: Pie chart with block parameters for label and value

In order to dynamically display labels or values within a chart, you may also pass a block:

```erb
<%= pie_chart Stock.all do |c| %>
  <% c.title "Total Stock" %>

  <% c.label("Name")        { |s| "#{s.name} (percent)" } %>
  <% c.value("Percentage")  { |s| s.amount / Stock.sum(:amount) * 100 } %>
<% end %>

```
NOTE: I know that Stock.sum(:amount) is not good practice, but it serves the example.

Copyright © 2010 - 2012 Rudolf Schmidt, released under the MIT license.

gha_language: Ruby


text:
---
layout: 'page'
path: /about
title: About
hero: /img/about-1920x.jpg
---
Hi! I'm Brian Cruikshank. I am a certified Acro Revolution teacher based in Washington, D.C.

I've been practicing acro for over 6 years, traveling the country, and learning some of the most advanced movements and techniques.

Some large events I've taught acro at include NY Acrofest, AcroLove East Coast, DC Acrobatic Convention, and the Interfusion Festival.

When I'm not teaching I'm always learning. I'm also an avid rock climber, traveler, and activist for things that matter.

### Private Lessons
I offer 1.5 hour private acro lessons for $90. You can include up to 2 friends at no extra charge.

### Classes and Workshops
I co-teach a regular class with Maren Hill at Earth Treks Crystal City every 1st and 3rd Monday of the month at 8:30pm.

Maren and I sometimes offer intermediate workshops too and travel to festivals. Check the events page.

### Photography
I've been photographing acro and events for 3 years. All the pictures on this site are mine. Let me know if you're interested in photography.

### Web Development
I design and build professional websites for a living including the one you see here. You can find more of my work at https://www.brianswebstudio.com

repository: brianrc/acrowithbrian-site

gha_language: JavaScript

gha_license_id: MIT

repo_name: brianrc/acrowithbrian-site


text:
>This repository is part of the [Pelias](https://github.com/pelias/pelias)
>project. Pelias is an open-source, open-data geocoder originally sponsored by
>[Mapzen](https://www.mapzen.com/). Our official user documentation is
>[here](https://github.com/pelias/documentation).

# Pelias Point-in-Polygon Service

## Overview

This service provides Who's on First-based point-in-polygon lookup functionality.

## Requirements

Node.js is required.

See [Pelias software requirements](https://github.com/pelias/documentation/blob/master/requirements.md) for required and recommended versions.

## Installation

```bash
$ git clone git@github.com:pelias/pip-service.git
$ cd pip-service
$ npm install
```

[![NPM](https://nodei.co/npm/pelias-pip-service.png?downloads=true&stars=true)](https://nodei.co/npm/pelias-pip-service)

## NPM Module

The `pelias-pip-service` npm module can be found here:

[https://npmjs.org/package/pelias-pip-service](https://npmjs.org/package/pelias-pip-service)

#### Usage

To start the PiP service, use the start script `./bin/start`, or use `npm start`.

It will look for Who's on First data in the place configured in `pelias.json`.

Requests are made to the endpoint in the format:  `http://localhost:3102/<lon>/<lat>`.

For example: `http://localhost:3102/-106.937/34.060`

#### Downloading data

Because [pelias/whosonfirst](https://github.com/pelias/whosonfirst) is a dependency of this package, its downloader can be used:

`npm run download`

This will download Who's on First data using the same [configuration options](https://github.com/pelias/whosonfirst#downloading-the-data) from `pelias.json` as the whosonfirst downloader.
That means it will automatically put the data in the place the service will expect to load it from.

##### Privacy Concerns

The service supports the [DNT](https://en.wikipedia.org/wiki/Do_Not_Track) header by looking for one of the following headers:

- `DNT`
- `dnt`
- `do_not_track`

When any of these headers are supplied in the request (with any value), the request log will output `/[removed]/[removed]` instead of the longitude/latitude values.

#### Configuration via Environment Variables

The service supports additional environment variables that affect its operation:

| Environment Variable | Default | Description |
| -------------------- | ------- | ----------- |
| `HOST` | `undefined` | The network address that the PiP service will bind to. Defaults to whatever the current Node.js default is, which is currently to listen on `<IP_ADDRESS>` (all interfaces). See the [Node.js Net documentation](https://nodejs.org/api/net.html#net_server_listen_port_host_backlog_callback) for more information. |
| `PORT` | `3102` | The TCP port that the PiP service will use for incoming network connections |

repository: pelias/pip-service

repo_name: pelias/pip-service


text:
# Preallocation

## Initialize value

If you want to preallocate an array with a initial value, you can use [`Array.from()`](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/from):

```js
const n = 5

// simple
[...Array(n).keys()] // [ 0, 1, 2, 3, 4 ]

// more powerful
Array.from({length: n}, (value, index) => index) // [ 0, 1, 2, 3, 4 ]
```

## Reusing instances

It's typical to use an `Array` as a temporal container of data.

!> If you need to work with binary data, use a [Buffer](https://www.npmjs.com/package/buffer).

Instead of allocating a new `Array` every time, a good approach in terms of
performance is to reuse the same array instance.

To clean the elements of an `Array` the most evident approach is to use `.pop`
in a loop to remove them all.

```js
const array = [1, 2, 3, 4, 5]
while (array.length) array.pop()
console.log(array) // []
```

However, a better and simpler method is to use [`Array.prototype.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length). This property is writable, and will remove all the elements if you set its value to `0`.

```js
const array = [1, 2, 3, 4, 5]
array.length = 0
console.log(array) // []
```

gha_language: SCSS


text:
# euphony-listener
**version 1.0.0** 🌏 (
[English](https://github.com/euphony-io/euphony-listener/blob/master/README.md),
[한국어](https://github.com/euphony-io/euphony-listener/blob/master/README_KR.md)
)

## Introduction
'Euphony-Listener' receives and recognizes data through sound waves from 'Speaker'.

The frequency occurs when the speaker sends data. The Listen button is pressed, 'Listener' recognizes the data and you can check the results.

It only works on android.

## Euphony Library
Acoustic Data Telecommunication Library. This is for Android version.

Euphony provides a handiness library designed to communicate with other devices(android and web) using mic and recorder.

Official Facebook Page : https://www.facebook.com/euphonyproject

Official Library Site : https://dev.jbear.co/euphony

## Prerequisite
build.gradle in app module
```gradle
dependencies {
    implementation 'euphony.lib:euphony:<IP_ADDRESS>'
}
```
AndroidManifest.xml
```xml
<uses-permission android:name="android.permission.RECORD_AUDIO" />
```

## Quick Start
### 1. Repository clone
```bash
$ git clone https://github.com/euphony-io/euphony-listener.git
```
![clone](https://user-images.githubusercontent.com/47289893/128968369-e30bfc36-3c57-418d-b3b2-b8976436493b.png)

### 2. Open in Android Studio
Find the path of the cloned project and open it.

![open](https://user-images.githubusercontent.com/47289893/128968509-21778091-1c48-432d-8c68-856d89c59a07.png)

Press the 'Trust Project' button.

![trust](https://user-images.githubusercontent.com/47289893/128968544-78756386-1740-43e7-9f27-78f9322307f8.png)

### 3. JDK settings
JDK location error may occur when opening the file for the first time.

![set jdk-1](https://user-images.githubusercontent.com/47289893/128968605-e73af820-0ae7-4e8c-997a-1c1cdbef7129.png)

Click 'Change JDK location' to specify Gradle JDK.

![set jdk-2](https://user-images.githubusercontent.com/47289893/128968614-0988ac95-1672-411d-8e9e-336503be69cd.png)

When you reopen the project, the build starts.

![build](https://user-images.githubusercontent.com/47289893/128968741-00b1cd80-a9f7-4481-bd1a-ff388141080f.png)

### 4. Connect the device
By default, there is no device.

![no device](https://user-images.githubusercontent.com/47289893/128968845-d0868890-cb57-4721-a956-857b871e7393.png)

It is automatically recognized when devices with developer mode are connected.

![yes device](https://user-images.githubusercontent.com/47289893/128968864-35b7ae72-6fb8-4bb2-8706-1ec2257faf73.png)

### 5. Test
Operate 'euphony-listener' app on the connected device.

![run](https://user-images.githubusercontent.com/47289893/128968893-cca8c520-4dcc-41e7-9e04-9d4849143176.png)

![run-build](https://user-images.githubusercontent.com/47289893/128969518-043e50ae-aa45-4d0a-b145-9e7d1176353c.png)

#### Speaker
Speaker demo is available at [here](https://dev.jbear.co/euphony/). Enter short text and press the 'broadcast' button.

![speaker](https://user-images.githubusercontent.com/47289893/128968935-b4cd781a-5de0-42cf-a01a-ec87a47f77b6.png)

#### Listener
When the 'LISTEN' button is pressed, recognition begins.

![device](https://user-images.githubusercontent.com/47289893/128969127-1b7847ec-43c7-42cb-8b6b-a6602f51db7f.png)

#### Log
![logcat](https://user-images.githubusercontent.com/47289893/128969052-3b70b562-f4ce-4ba6-98e5-d9be4096ab76.png)

## Euphony Listener is very easy to use
```java
EuRxManager mRxManager = new EuRxManager();
mRxManager.setAcousticSensor(new AcousticSensor() {
    @Override
    public void notify(String letters) {
        //when data is received
    }
});
mRxManager.listen();  //Listening Start
// if you want to finish listening, call the finish();
// mRxManager.finish();
```

## Contributing
Changes and improvements are more than welcome! Feel Free to fork and open a pull request. Please make your changes in a specific branch and request to pull into master.

## License
Euphony is licensed under the Apache 2.0 license. (https://github.com/euphony-io/euphony-listener/blob/master/LICENSE)

repository: designe/euphony-listener

repo_name: designe/euphony-listener


text:
| master          | develop           |
| :-------------: |:-------------:|
| [![Build Status](https://travis-ci.org/palmithor/springboot-musicapi.svg?branch=master)](https://travis-ci.org/palmithor/springboot-musicapi)        | [![Build Status](https://travis-ci.org/palmithor/springboot-musicapi.svg?branch=develop)](https://travis-ci.org/palmithor/springboot-musicapi) |

# springboot-musicapi
Small project for testing out Spring Boot. It is a webservice which exposes one RESTful resource for getting information about an artist from different sources.
The sources used are Music Brainz API, Wikipedia and Cover Art Archive.

Its dependencies and build functions are configured using Maven.

## Testing
The tests can be run via maven:
```bash
mvn test
```

## Building
Maven package creates an executable jar file
```bash
mvn package
```

# Running
The service is built with Spring Boot and can be run with the Spring Boot Maven plugin:

```bash
mvn spring-boot:run
```
An example request:
 ```
 http://localhost:8080/artists/5b11f4ce-a62d-471e-81fc-a69a8278c7da
 ```

repository: palmithor/springboot-musicapi

repo_name: palmithor/springboot-musicapi


text:
# Angular _ngrx-data_ Overview

## Zero Ngrx Boilerplate

> You may never write an action, reducer, selector, effect, or HTTP dataservice again.
>
> **ngrx-data is still NgRx**!

[_Ngrx_](faq.md#ngrx) helps Angular applications manage shared state in a "reactive" style, following the [redux](faq.md#redux) pattern.

Everyone complains about the amount of boilerplate code you must write and maintain to manage [entity](faq.md#entity) data with ngrx.

In standard ngrx, every entity type has a multitude of actions, reducer cases, and selectors that look virtually the same across all entity types.

Several libraries offer to _reduce_ the boilerplate. Some will _generate_ it for you.
Ngrx-Data _eliminates it altogether_.

_Ngrx-data_ stores entities by type in distinct collections in an entity cache within the ngrx state tree. To fetch and modify entity data, it dynamically generates the corresponding ngrx actions, reducers, selectors and effects as you need them.

## It's still _ngrx_

This is a _library for ngrx_, not an ngrx alternative.

Every entity has its own actions. Every operation takes its unique journey through the store, reducers, effects, and selectors. You just let _ngrx-data_ create these for you.

You can still add more store properties, actions, reducers, selectors, and effects. You can override any ngrx-data behavior for an individual entity type or for all entities.

See the [README.md](../readme.md) for instructions on installing the library and running the demo app.

Learn about _ngrx-data_.

* Read the demo app source code in `src/client`.
* Read and run the tests (`ng test`).
* Review the library source code in the `lib` folder.
* Read the guides in the `docs` folder.

## _Ngrx-Data_ guides

This page and other guide pages are markdown pages in the repository `docs` folder.

* [Quick Start](quickstart.md)
* [Introduction](introduction.md)
* [Entity Metadata](entity-metadata.md)
* [Entity Collection](entity-collection.md)
* [Entity Service](entity-service.md)
* [Entity DataService](entity-dataservice.md)
* [Entity Actions](entity-actions.md)
* [Entity Reducer](entity-reducer.md)
* [Entity Change Tracker](entity-change-tracker.md)
* [Extension Points](extension-points.md)
* [Limitations](limitations.md)
* [FAQ: Frequently Asked Questions](faq.md)

repository: DerejeKitaw/angular-ngrx-data

repo_name: DerejeKitaw/angular-ngrx-data


text:
# react-shimmer

> A powerful, customisable, `<img>` component that simulates a [**shimmer**](https://github.com/facebook/Shimmer) effect while the image is __loading__. (with zero dependencies!) Currently compatible with React, but **RN** compatibility is also on the way.

[![NPM](https://img.shields.io/npm/v/react-shimmer.svg)](https://www.npmjs.com/package/react-shimmer) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com) [![Maintainability](https://api.codeclimate.com/v1/badges/a99a88d28ad37a79dbf6/maintainability)](https://codeclimate.com/github/codeclimate/codeclimate/maintainability)

### [__Live Demo__](https://stackblitz.com/edit/react-shimmer-demo?embed=1&file=index.js)

![](https://cdn.rawgit.com/gokcan/react-shimmer/master/media/rs-demo.gif)

## Install

```bash
npm install --save react-shimmer
```

## Usage

```jsx
import React, { Component } from 'react'

import ShimmerImage from 'react-shimmer'

export default class App extends Component {
  render () {
    return (
      <div>
        <ShimmerImage
          src={'https://example.com/test.jpg'}
          width={120} height={120}
          style={{objectFit: 'cover'}} // Style your <img> as you would normally do.
          delay={25}
          duration={0.9} // Customize the animation duration (s).
        />
      </div>
    )
  }
}
```

### Properties

Property | Type | Required | Default value | Description
:--- | :--- | :--- | :--- | :---
`src`|string|yes||
`color`|string|no|`#f6f7f8`| Background color of the loader.
`duration`|number|no|`1.6`| Animation duration (s) Higher value == slower animation.
`width`|number|yes||
`height`|number|yes||
`style`|object|no||
`onError`|func|no||
`onLoad`|func|no||
`loadingIndicatorSource`|string|no||
`delay`|number|no|| Delay the starting time of the animation. (ms)
-----

## Contributing
---
Feel free to send PRs.

## License

MIT © [gokcan](https://github.com/gokcan)

repository: Lin-dev/react-shimmer

repo_name: Lin-dev/react-shimmer


text:
# Project Ibis

|  |  |
| --- | ---------- |
| ![Project Logo](images/ibis.png) | This is a [Ibis (Rapp)](https://a-z-animals.com/animals/ibis/) |

## Angular 2 services and injections

This project shows ...

* How to define CSS styles inside the Angular 2 Component
* how to enable Angular 2 productive mode
* What is dependency injection ([part 1](src/ng2/app/part1))
* How to use Angluar dependency injection ([part 2](src/ng2/app/part2))
* How to use Angluar services ([part 2](src/ng2/app/part2))
* How to create and register a logger service ([part 2](src/ng2/app/part2))
* How to use injector providers ([part 2](src/ng2/app/part2))
* How to use dependency injective tokens ([part 3](src/ng2/app/part3))
* How to use optional dependencies ([part 4](src/ng2/app/part4))

Open [Angular 2 guide DEPENDENCY INJECTION](https://angular.io/docs/ts/latest/guide/dependency-injection.html)
and work through.

See file [main.ts](src/ng2/app/main.ts) to see how to enable productive mode.
Uncomment the two productive mode statements to enable productive mode.

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

This tutorial uses Netbeans, Gulp.js, Node.js, Express Web-Server.
Follow these links to find some more information for
[Netbeans IDE](http://netbeans.org/),
[Gulp.js](https://www.npmjs.com/package/gulp),
[Node.js](https://nodejs.org/en/),
[Express Web-Server](https://www.npmjs.com/package/express),
[Angular 2](https://angular.io/docs/) and
[TypeScript](https://www.typescriptlang.org/).

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

## How to run the project

To do (on Linux OS) ...

1. open shell and clone git repository
  `git clone <repository-url>`
2. change working directory to project and install node modules
  `cd <project-dir>/ibis`
  `npm install`
3. build the project and start the server
  `npm start`
4. start a web-client and test the server
  [http://localhost:8080](http://localhost:8080)

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


text:
---
title: "Workflows"
date: 2021-08-31T17:27:16-04:00
draft: false
weight: 40
description: >
    A Workflow is a series of steps or tasks to be executed as part of an analysis.
---

A Workflow is a series of steps or tasks to be executed as part of an analysis. To run a workflow using Amazon Genomics CLI, first you must
have deployed a context with suitable compute resources and with a workflow engine that can interpret the language of
the workflow.

## Specification in Project YAML

In an Amazon Genomics CLI project you can specify multiple workflows in a YAML map. The following example defines four WDL version 1.0
workflows. The `sourceURL` property defines the location of the workflow file. If the location is relative then the
relevant file is assumed to be relative to the location of the project YAML file. Absolute file locations are also possible
although this may reduce the portability of a project if it is intended to be shared. Web URLS are supported as locations
of the workflow definition file.

At this time Amazon Genomics CLI does *not* resolve path aliases so, for example, a `sourceURL` like `~/workflows/worklfow.wdl` is not
supported.

The `type` object declares the `language` of the workflow (eg, wdl, nextflow etc). The run a workflow there must be a
deployed [context]( {{< relref "contexts" >}} ) with a matching language. The `version` property refers to the workflow language version.

```yaml
workflows:
  hello:
    type:
      language: wdl
      version: 1.0
    sourceURL: workflows/hello.wdl
  read:
    type:
      language: wdl
      version: 1.0
    sourceURL: workflows/read.wdl
  haplotype:
    type:
      language: wdl
      version: 1.0
    sourceURL: workflows/haplotypecaller-gvcf-gatk4.wdl
  words-with-vowels:
    type:
      language: wdl
      version: 1.0
    sourceURL: workflows/words-with-vowels.wdl
```

### Multi-file Workflows

Some workflow languages allow for the import of other workflows. To accommodate this, Amazon Genomics CLI supports using a directory as
a source URL. When a directory is supplied as the `sourceURL`, Amazon Genomics CLI uses the following rules to determine the name of
the main workflow file and any supporting files:

1. If the source URL resolves to a single non-zipped file, then the file is assumed to be a workflow file. Dependent resources (if any) are hardcoded in the file and must be resolvable by the Wes adapter or implicitly the workflow engine (e.g the Wes adapter figures out if the engine can resolve them and if not it resolves them itself).
2. The source URL resolves to a zipped file (`.zip`).  The zip may contain a manifest.
    1. If the zip file does *not* contain a file named `MANIFEST.json`:
        1. The zip file must contain one workflow file with the prefix main followed by the conventional suffix for the workflow, e.g. `main.wdl`
        2. Any subworkflows or tasks referenced by the main workflow must either be in the zip at the appropriate relative path or they must be referenced by URLs that are resolvable by the workflow engine. The WesAdapter may attempt to resolve them for the engine but this is a convenience and not required.
        3. Any variables not defined in the workflows must be provided in an inputs file named with the prefix inputs and the conventional suffix for the workflow engine (e.g `inputs.json`). For workflow engines that support multiple input files an index suffix must be provided (e.g. inputs_a.json or inputs_1.json) if there is more than one inputs file.
        4. A workflow options file may be included and must be named with the options prefix followed by the conventional suffix of the workflow. The WesAdapter may chose to make use of this depending on the context of the workflow engine. It may also choose to pass this to the workflow engine or pass a modified copy to the workflow engine.
    2. If the zip file *does* contain a manifest:
        1. The manifest must contain a parameter called mainWorkflowURL. If it does then the value of the parameter must either be a URL, including the relevant protocol, or the name of a file present in the zip archive. Any subworkflows or tasks imported by the main workflow must either be referenced as URLs in the workflow or be present in the archive as described above.
        2. The manifest may contain an array of URLs to inputs files called inputFileURLs. The WesAdapter must decide if it should resolve these or let the workflow engine resolve them.
        3. The manifest may contain a URL reference to an options files name optionFileURL. The WesAdapter may chose to make use of this depending on the context of the workflow engine. It may also choose to pass this to the workflow engine or pass a modified copy to the workflow engine.

The following snippet demonstrates the declaration of a mutlifile workflow:

```yaml
workflows:
  gatk4-data-processing:
    type:
      langauge: wdl
      version: 1.0
    sourceURL: ./gatk4-data-processing
```

The following snippet demonstrates a valid `MANIFEST.json` file:

```json5
{
  "mainWorkflowURL": "processing-for-variant-discovery-gatk4.wdl",
  "inputFileURLs": [
    "processing-for-variant-discovery-gatk4.hg38.wgs.inputs.json"
  ],
  "optionFileURL": "options.json"
}
```

## Engine Selection

When a workflow is submitted to run, Amazon Genomics CLI will match the workflow type with the map of engines in the context. For example,
if the workflow `type` is `wdl` Amazon Genomics CLI will attempt to identify and engine designated as the engine for that type. There
may only be one engine per type. If no suitable engine is found in the context an error will be reported.

## Workflow Instances

Any defined project workflow can be run multiple times. Each run is called an instance and assigned a unique instance ID.
When referring to a specific run of a workflow you should use the instance ID rather than the workflow name. It is possible
to submit multiple instances of the same workflow and to have these run concurrently.

## Context

All workflows are coordinated by the engine, they are submitted to and executed in the context that is specified at submission time.
The workflow engine decides how the workflow is to be run and the context provides compute resources to run the workflow.

## Commands

A full reference of workflow commands is available [here]( {{< relref "../Reference/agc_workflow" >}} )

### `run`

Invoking `agc workflow run <workflow-name> -c <context-name>` will run the named workflow in a specific context. The
unique ID of that workflow instance run will be returned if the submission is successful.

#### `workflow arguments`

Workflow arguments such as options files can be specified at submission time using the `a` or `--args` flag. For
example:

```shell
agc workflow run my-workflow --args inputs.json
```

If the inputs file references local files, these will be synced with S3 and those files in S3 will be used when the workflow
instance is run.

### `list`

The `agc workflow list` command can be used to list all workflows that are specified in the current project.

### `describe`

The `agc workflow describe <workflow-name>` command will return detailed information about the named workflow based on
the specification in the current project YAML file.

### `status`

To find out the status of workflow instances that are running, or have been run you can use the `agc workflow status` command.
This will display details on 20 recent workflows from the project, to display more, or fewer you can use the `--limit number` flag
where the `number` may be as many as 1000.

To list the status of workflows run or running in a specific context use the `--context-name` flag and provide the name
of one of the contexts of the project.

You may get the status of workflow instances by workflow name using the `--workflow-name` flag.

To display the status of a specific workflow instance you can provide the id of the desired workflow instance with the `--instance-id` flag.

### `stop`

A running workflow *instance* can be stopped at any time using the `agc workflow stop <instance-id>` command. When issued,
Amazon Genomics CLI will look up the appropriate context and engine using the `instance-id` of the workflow and instruct the engine to
stop the workflow. What happens next depends on the actual workflow engine. For example, in the case of the Cromwell WDL
engine, any currently executing tasks will halt, any pending tasks will be removed from the work queue and no further
tasks will be started for that workflow instance.

### `output`

You can obtain the output (if any) of a completed workflow run using the output command and supplying the workflow run
id. Typically, this is useful for locating the files produced by a workflow, although the actual output generated depends on the workflow
specification and engine.

If the workflow declares outputs you may also obtain these using the command:

```shell
agc workflow output <workflow_run_id>
```

The following is an example of output from the "CramToBam" workflow run in a context using the Cromwell engine.

```shell
OUTPUT	id	aaba95e8-7512-48c3-9a61-1fd837ff6099
OUTPUT	outputs.CramToBamFlow.outputBai	s3://agc-123456789012-us-east-1/project/GATK/userid/mrschre4GqyMA/context/spotCtx/cromwell-execution/CramToBamFlow/aaba95e8-7512-48c3-9a61-1fd837ff6099/call-CramToBamTask/NA12878.bai
OUTPUT	outputs.CramToBamFlow.outputBam	s3://agc-123456789012-us-east-1/project/GATK/userid/mrschre4GqyMA/context/spotCtx/cromwell-execution/CramToBamFlow/aaba95e8-7512-48c3-9a61-1fd837ff6099/call-CramToBamTask/NA12878.bam
OUTPUT	outputs.CramToBamFlow.validation_report	s3://agc-123456789012-us-east-1/project/GATK/userid/mrschre4GqyMA/context/spotCtx/cromwell-execution/CramToBamFlow/aaba95e8-7512-48c3-9a61-1fd837ff6099/call-ValidateSamFile/NA12878.validation_report
```

## Cost

Your account will be charged based on actual resource usage including compute time, storage, data transfer charges etc.
The resources used will depend on the resources requested in your workflow definition as interpreted by the workflow engine
according the resources made available in the context in which the workflow is run. If a spot context is used then the costs
of the spot instances will be determined by the rules governing spot instance charges.

### Tags

Resources used by Amazon Genomics CLI are tagged including the username, project name and the context name. Currently, tagging is *not*
possible at the level of an individual workflow.

repository: sean-smith/amazon-genomics-cli

branch_name: refs/heads/main

repo_name: sean-smith/amazon-genomics-cli


text:
Introduction of Rem Language
--------------------------------

Rem language is currently implemented by CPython, and it's for people who're working on the fields of Python, Julia, R or MATLAB .etc...

Rem looks like Python, Ruby and many other dynamic languages, and it adopts some convenient features from many functional programming languages.

The **inverted syntax** in Rem is the core in some degree. As the result of unifying the manipulations on first-class functions, you can write these object-oriented-like codes in the following way:

```
>> ["foo", "bar"] . map {|x| x ++ "tail"}
```
However it's not really object-oriented, it's functional!

To explain, the codes above could be represented in Python codes:

```python
map (lambda x: x + "tail", ["foo", "bar"])
```
(Just **take care** that not all the codes in Rem can be directly translated to Python.

Also, we can try to imitate `keyword` with functions in Rem:

```
let x = 0
while { x < 10} {
    x = x + 1
}
```
And `while` here is just a function!

**Pattern Matching** and **Where Syntax** are both tasty, too. You can learn how to use them in the following manual.

All in all, Rem has a lot of features to support comfortable programming with modern paradigms.

I'm planning to write a C# backend for Rem sooner in order to get rid of too much Python(however we shouldn't ignore the requirements of works in real world),
and efficient compilers will come up, too.

## Hello World

Install `remlang` easily by using **PyPI** with Python 3.6+.

```shell
pip install remlang
```

If you want to use the `repl`, just type `irem`:
```
irem

Rem Language alpha, March 15 2018 02:14.
Backend CPython, Author thautwarm, MIT License.
Report at https://github.com/thautwarm/Rem/issues.

>> "Hello World"
'Hello World'

>> "Hello World" . print
Hello World
```
## Function(Lambda)

Something you need to take care is that **Functions are curried** in Rem.

```
>> let fn = {|x| x + 1}
>> fn 1
=> 2
>> let fn = {|x, y, z|
    y = y + z + x
    y
}
>> f1 = fn 5
>> f2 = fn 10
>> fn 20
=> 35
=> from x, y, z let x + y + z end # another way to define a lambda
```

## Applicative

```
>> let fn = {|x| x**2}
>> fn 2 + 3
=> 7  # 2**2 + 3
>> fn $ 2 + 3
=> 25 # (2+3) ** 2
>> let fn = {|x, y| x*y}
>> fn $ 1+2 $ 3+4
=>  21 # 3*7
```

## Scope

Partly **Dynamic Scoping**

```
>> let x = 0
>> call { x }
=> 0
>> call { x = 1; x}
=> 1
>> x
=> 1
>> call {let x = x; x = 10; x}
=> 10
>> x
=> 1
```

## Where Syntax
```
>> dictionary = %{
    c where
        c = 1
    end : 2
  }
>> dictionary
=> {1: 2}

>> from math import pi
>> S = S1 + 2*S2 where
        let S1 = pi*r**2
        let S2 = 2*pi*r
    end
```

## Inverted Syntax
```
>> let add = {|x, y| x + y}
>> 1 . add 2
=> 3
>> 1 then add 2
=> 3
```
However, the **priority** of `.` is different from `then`.

Here is the table of priorities in Rem:

| syntax           | priority  | sample              |
| -------          | ---       | ---                 |
| then             | 1         | `a then func`       |
| `$`(applicative) | 1         | `f $ 1 2`           |
| case             | 2         | `case ... end`      |
| binary expr      | 2         | `1 * 2`             |
| unary expr       | 3         | `a?`, `a??`, `not a`|
| `.`(inverted)    | 4         | `a . add`           |
| function call    | 4         | `f 1 2`, `call f`   |
|expr with trailers| 5         | `a!.name`, `a![0]`  |
| atom             | 6         | lambda and so on    |

```
>> let concat = {|x| print x ; {|y| print y ;x ++ y}}
>> "left" . concat "right"
left
=> "leftright"
>> 1 then add 2
right
=> "rightleft"
```
Both of them are left associative.

## For Comprehension

Make a generator
```
>> from [1, 2, 3] yield {|x| x+1} . list
=> [2, 3, 4]
>> from [1, 2, 3], ["a", "b", "c"] yield {|a, b| (a, b)} . list
=> [(1, 'a'), (1, 'b'), (1, 'c'), (2, 'a'), (2, 'b'), (2, 'c'), (3, 'a'), (3, 'b'), (3, 'c')]
```

- for-loop: `not yield`

```
>>> from [1, 2, 3] not yield {|x|
        print x
        x
    }
 1
 2
 3
=> 3
```

## Pattern Matching

Very powerfull and can even be the alternative of `if-else`.

```
case (1, 2, 3)
    as 1, ...a when
        a![0] == 2

        => a

    as _ => raise
end
```
You can use it for only destruction:
```
>> case (1, 2, 3) as (a, b, c) end
>> print a*b*c
=> 6
>> let t = case (1, 2, (3, 5, (6, 5))) as [1, 2, [3, 5, [6,...a]]] => a end
>> t
=> <tuple_iterator object at 0x0000017689F95FD0>
>> t. tuple
=> (5, )
```

The return of `pack` destruction(`...a`) is of type tuple when length is 1, or it's of type
tuple_iterator.

## Into Statement

It is similar to `goto`, but I add some constraints on it: you cannot go to the previous steps,
but you can jump out of current closure until you're in specific closure.

If you want to use `into` in `for comprehension`
```
>> @here
>> from [1, 2, 3] not yield {|x|
    into here
    print x
   }
>> from [1, 2, 3] not yield {|x|
    print x
}
 1
 2
 3
=> 3
```

Take care that the literal construction of `list`, `tuple`, `set` and `dict` will ignore the `into` keyword, as well as `from ... not yield ...` for-loop.

## Collections

List: Just Python `list`
```
>> let l1 = [
    1,
    2,
    c where
        let c = 3
    end,
    4
]

>> l1 ++ [1, 2, 3]
=> [1, 2, 3, 4, 1, 2, 3]
>> l1 -- [1, 2, 3]
=> [4]
```

Dict: Just Python `dict`
```
>> let d1 = %{
            1: 2,
            expr where
                let expr = 3
            end : 4
}
```

Set is also Python `set` as well as `tuple`.

## OOP Support

- Access Member and Index
```
>> import math
>> math !. pi
=>  3.141592653589793
>> math !. pi . __class__
=>  <class 'float'>

>> import numpy as np
>> let arr_cons = np !. ndarray
>> arr_cons [1, 2, 3]
=>  array([[1, 2, 3]])
>> (arr_cons [[1, 2, 3]]) . slice [0, (1, 2)]
=> array([2])
>> (arr_cons [[1, 2, 3]]) ! [indexer [0, (1, 2)]]
=> array([2])
>> (arr_cons [[1, 2, 3]]) ! [0]
=> array([1, 2, 3])
```

[class.rem](https://github.com/thautwarm/Rem/blob/master/example_source_codes/class.rem)
```
/* define class here */
let class = {
    |fn_dict|
    # constructor
    {
        let self = call Object
        from
            fn_dict !. items then call
        not yield {
            |tp|
            case tp as k, v
                =>

                    self. set k (v self)
            end
        }
        self
    }
}

# spec
let cls1 = class %{
                "go":  {|x, y| y},
            }

let inst = call cls1

inst !. go $ 1
```

repository: thautwarm/Rem

repo_name: thautwarm/Rem


text:
# Dynamic routes usage

You can also register event listeners (or subscribers) to populate your sitemap(s).

Imagine that your application is (or has) a blog, and that you want to add to your sitemap
all blog posts that your administrator has created.

> **Note:** We choose an `event subscriber` as example, but you can also do it with an `event listener`.

If you are not familiar with the concept of event listener/subscriber/dispatcher,
please have a look to Symfony's [official documentation](http://symfony.com/doc/current/event_dispatcher.html).

## EventListener class

```php
<?php

namespace App\EventListener;

use App\Repository\BlogPostRepository;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Presta\SitemapBundle\Event\SitemapPopulateEvent;
use Presta\SitemapBundle\Service\UrlContainerInterface;
use Presta\SitemapBundle\Sitemap\Url\UrlConcrete;

class SitemapSubscriber implements EventSubscriberInterface
{
    /**
     * @var BlogPostRepository
     */
    private $blogPostRepository;

    /**
     * @param BlogPostRepository $blogPostRepository
     */
    public function __construct(BlogPostRepository $blogPostRepository)
    {
        $this->blogPostRepository = $blogPostRepository;
    }

    /**
     * @inheritdoc
     */
    public static function getSubscribedEvents()
    {
        return [
            SitemapPopulateEvent::class => 'populate',
        ];
    }

    /**
     * @param SitemapPopulateEvent $event
     */
    public function populate(SitemapPopulateEvent $event): void
    {
        $this->registerBlogPostsUrls($event->getUrlContainer(), $event->getUrlGenerator());
    }

    /**
     * @param UrlContainerInterface $urls
     * @param UrlGeneratorInterface $router
     */
    public function registerBlogPostsUrls(UrlContainerInterface $urls, UrlGeneratorInterface $router): void
    {
        $posts = $this->blogPostRepository->findAll();

        foreach ($posts as $post) {
            $urls->addUrl(
                new UrlConcrete(
                    $router->generate(
                        'blog_post',
                        ['slug' => $post->getSlug()],
                        UrlGeneratorInterface::ABSOLUTE_URL
                    )
                ),
                'blog'
            );
        }
    }
}
```

> **Note:** you should not use this snippet as is. With large dataset, `findAll` is not a good idea.
>            Please read Doctrine documentation, to learn about iterator and array hydrate.

## Service definition

If you are using PSR4 service discovery, your event listener is already registered.
Otherwhise you will have to register it by hand.

**Using XML**

```xml
<services>
    <service id="app.sitemap.blog_post_subscriber" class="App\EventListener\SitemapSubscriber">
        <argument type="service" id="<your repository service id>"/>
        <tag name="kernel.event_subscriber" priority="100"/>
    </service>
</services>
```

**Using YAML**

```yaml
services:
    app.sitemap.blog_post_subscriber:
        class: App\EventListener\SitemapSubscriber
        arguments:
            - "@<your repository service id>"
        tags:
            - { name: "kernel.event_subscriber", priority: 100 }
```

> **Note:** Choosing a priority for your event listener is up to you.

---

« [Static routes usage](3-static-routes-usage.md) • [Decorating URLs](5-decorating-urls.md) »

repository: prestaconcept/PrestaSitemapBundle

gha_language: PHP

repo_name: prestaconcept/PrestaSitemapBundle


text:
# NF
NFT backend for creating tokens

Following a tutorial on how to build an NFT, I ended up bulding it without using it, apparently, I could just upload an image on opensea.io and just sell it off.

Anyways, moving forward, I am not even sure i did a good job or this is utter rubbish, buh follow up, you might gain one or two.

You'll need Truffle, Ganache, Nodejs, Openzeppelin.

*clears throat* So, install Truffle and Ganache
After that, run *npm init*, enter those time wasting npm details, then run *truffle init*
Your truffle will start up, after that install Openzeppelin by running npm install *@openzeppelin/contracts*
Please try to install v3.4.0, that version is sane, the newer versions are psychopaths.

Copy code, I myself don't know what it does...

*truffle compile*
*truffle migrate*

I am tired.


text:
# Conventions

The core conventions delineate the contract between ColdBox and you for file/directory locations and more. Below is a table of the core conventions:

## Directory/File Conventions

* **config/Coldbox.cfc** - Your application configuration object \(_optional_ \)
* **config/Router.cfc** - Your application URL Router \(_optional_ \)
* **config/CacheBox.cfc** - Your application CacheBox configuration \(_optional_ \)
* **config/WireBox.cfc** - Your application WireBox Configuration \(_optional_ \)
* **handlers** - This holds the app's event handlers \(controller layer\)
* **layouts** - Your HTML layouts \(view layer\)
* **models** - This holds your app's CFCs  \(model layer\)
* **modules** - This holds the CommandBox tracked modules
* **modules\_app** - This holds your app's modules
* **views** - Your HTML views will go here \(view layer\)

## Execution Conventions

ColdBox also has several execution conventions.  This means that we have a convention or a default for the event, action and layout to be used if you do not tell it what to use:

| **Convention** | **Default Value** | **Description** |
| :--- | :--- | :--- |
| Default Event | `main.index` | The default event to execute when no event is specified |
| Default Action | `index()` | The default action to execute in an event handler controller if none is specified |
| Default Layout | `layouts/Main.cfm` | The default system layout to use |

repository: alorne/coldbox-docs

repo_name: alorne/coldbox-docs


text:
# gatsby-bootstrap3-starter

Install this starter (assuming Gatsby is installed) by running from your CLI:
```
gatsby new gatsby-site https://github.com/publipromueve/gatsby-bootstrap3-starter
```

This starter comes with:

- styled components for managing styles.
- eslint based on standardjs with a few extra rules
- prettier for autoformatting

## Running in development
`npm run develop`

## Build
`npm run build`

## Serve production version
`npm run serve`


text:
# SpaceInvaders2D
 The project is just a simple personal practice for programming using Unity engine. It is a remake of the classic video game "Space Invaders".  This project was inspired on the private course "Criando um Jogo do Zero com a Unity 5" of Alexandre de Sá Ribeiro (http://academiadeproducaodejogos.com.br/).

## Demo
http://danbit.github.io/space-invaders-2d/

## ScreenShots
![Main Menu](https://github.com/danbit/danbit.github.io/blob/master/space-invaders-2d/images/screenshot_01.png)
![GamePlay](https://github.com/danbit/danbit.github.io/blob/master/space-invaders-2d/images/screenshot_02.png)
![Death](https://github.com/danbit/danbit.github.io/blob/master/space-invaders-2d/images/screenshot_03.png)
![Game Over](https://github.com/danbit/danbit.github.io/blob/master/space-invaders-2d/images/screenshot_04.png)

## Assets

* http://kenney.nl/assets
* https://github.com/unity3d-jp-tutorials/2d-shooting-game/blob/master/Assets/Sprites/Explosion/Explosion.png
* http://opengameart.org/sites/default/files/seamless%20space_0.PNG
* http://freesound.org/
* http://github.grumdrig.com/jsfxr/
* http://www.1001fonts.com/arcadeclassic-font.html


text:
# Responsive rems typography
---
##Introduction
This repository contains demo page using SCSS mixins for generating font size depending on screen size.

##Browser support
Rem units are supported in all modern browsers. They are ok to use in IE 9+ browsers (see http://caniuse.com/#search=rem). For browsers who don't support this units there is simple fallback with size in pixels.

##How to use
First you define breakpoints and base font size (great read on base font size matter http://csswizardry.com/2011/05/font-sizing-with-rem-could-be-avoided/)
```scss
$break-small: 360px;
$break-large: 768px;
$base-font-size: 16;
```
Doing math (calculating rems from desired font size in pixels and browser default font-size).
```scss
@mixin rem($px, $base){
	font-size: $px + px; // pixel font-size fallback
    font-size: ($px / $base) * 1rem; // rem font-size
}
```
###Example
This mixin above for h1 with desired size of 36px and base font size of 16px will be compiled like this:
```css
h1{
    font-size: 36px;
    font-size: 2,25rem;
}
```
## Adding responsiveness
```scss
@mixin respond-to($media, $px, $base-font-size) {
    @if $media == handhelds {
        @media only screen and (max-width: $break-small) { @include rem($px, $base-font-size); }
    }
    @else if $media == medium-screens {
        @media only screen and (min-width: $break-small + 1) and (max-width: $break-large - 1) { @include rem($px, $base-font-size); }
    }
    @else if $media == wide-screens {
        @media only screen and (min-width: $break-large) { @include rem($px, $base-font-size); }
    }
}
```
As you can see I created 3 cases for different screen sizes and in each instance I included rem mixin to calculate rem size.

Finally all you need to do is call this mixin in desired class or element.

```scss
h1 { @include respond-to(handhelds, 30, $base-font-size);  @include respond-to(medium-screens, 38, $base-font-size);  @include respond-to(wide-screens, 42, $base-font-size) }
```
Each of these integers represent the desired size of font in pixels in deifferent screen size.

License
----

MIT

repository: dzuver/responsive-rems-typography

repo_name: dzuver/responsive-rems-typography


text:
### [CVE-2022-0951](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-0951)
![](https://img.shields.io/static/v1?label=Product&message=star7th%2Fshowdoc&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=%3C%202.10.4%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Vulnerability&message=CWE-434%20Unrestricted%20Upload%20of%20File%20with%20Dangerous%20Type&color=brighgreen)

### Description

File Upload Restriction Bypass leading to Stored XSS Vulnerability in GitHub repository star7th/showdoc prior to 2.10.4.

### POC

#### Reference
- https://huntr.dev/bounties/b3a983a3-17f9-4aa8-92d7-8a0c92a93932

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

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
# [1406. Stone Game III][enTitle]

**Hard**

Alice and Bob continue their games with piles of stones. There are several stones **arranged in a row** , and each stone has an associated value which is an integer given in the array  *stoneValue* .

Alice and Bob take turns, with **Alice**  starting first. On each player's turn, that player can take **1, 2 or 3 stones**  from the **first**  remaining stones in the row.

The score of each player is the sum of values of the stones taken. The score of each player is **0**  initially.

The objective of the game is to end with the highest score, and the winner is the player with the highest score and there could be a tie. The game continues until all the stones have been taken.

Assume Alice and Bob **play optimally** .

Return  *"Alice"*  if Alice will win,  *"Bob"*  if Bob will win or  *"Tie"*  if they end the game with the same score.

**Example 1:**

```
Input: values = [1,2,3,7]
Output: "Bob"
Explanation: Alice will always lose. Her best move will be to take three piles and the score become 6. Now the score of Bob is 7 and Bob wins.

```

**Example 2:**

```
Input: values = [1,2,3,-9]
Output: "Alice"
Explanation: Alice must choose all the three piles at the first move to win and leave Bob with negative score.
If Alice chooses one pile her score will be 1 and the next move Bob's score becomes 5. The next move Alice will take the pile with value = -9 and lose.
If Alice chooses two piles her score will be 3 and the next move Bob's score becomes 3. The next move Alice will take the pile with value = -9 and also lose.
Remember that both play optimally so here Alice will choose the scenario that makes her win.

```

**Example 3:**

```
Input: values = [1,2,3,6]
Output: "Tie"
Explanation: Alice cannot win this game. She can end the game in a draw if she decided to choose all the first three piles, otherwise she will lose.

```

**Example 4:**

```
Input: values = [1,2,3,-1,-2,-3,7]
Output: "Alice"

```

**Example 5:**

```
Input: values = [-1,-2,-3]
Output: "Tie"

```

**Constraints:**

-  *1 <= values.length <= 50000*
-  *-1000 <= values[i] <= 1000*

# [1406. 石子游戏 III][cnTitle]

**困难**

Alice 和 Bob 用几堆石子在做游戏。几堆石子排成一行，每堆石子都对应一个得分，由数组  *stoneValue*  给出。

Alice 和 Bob 轮流取石子，**Alice**  总是先开始。在每个玩家的回合中，该玩家可以拿走剩下石子中的的前 **1、2 或 3 堆石子**  。比赛一直持续到所有石头都被拿走。

每个玩家的最终得分为他所拿到的每堆石子的对应得分之和。每个玩家的初始分数都是 **0**  。比赛的目标是决出最高分，得分最高的选手将会赢得比赛，比赛也可能会出现平局。

假设 Alice 和 Bob 都采取 **最优策略**  。如果 Alice 赢了就返回  *"Alice"*   *，* Bob 赢了就返回 *"Bob"，* 平局（分数相同）返回  *"Tie"*  。

**示例 1：**

```
输入：values = [1,2,3,7]
输出："Bob"
解释：Alice 总是会输，她的最佳选择是拿走前三堆，得分变成 6 。但是 Bob 的得分为 7，Bob 获胜。

```

**示例 2：**

```
输入：values = [1,2,3,-9]
输出："Alice"
解释：Alice 要想获胜就必须在第一个回合拿走前三堆石子，给 Bob 留下负分。
如果 Alice 只拿走第一堆，那么她的得分为 1，接下来 Bob 拿走第二、三堆，得分为 5 。之后 Alice 只能拿到分数 -9 的石子堆，输掉比赛。
如果 Alice 拿走前两堆，那么她的得分为 3，接下来 Bob 拿走第三堆，得分为 3 。之后 Alice 只能拿到分数 -9 的石子堆，同样会输掉比赛。
注意，他们都应该采取 最优策略，所以在这里 Alice 将选择能够使她获胜的方案。
```

**示例 3：**

```
输入：values = [1,2,3,6]
输出："Tie"
解释：Alice 无法赢得比赛。如果她决定选择前三堆，她可以以平局结束比赛，否则她就会输。

```

**示例 4：**

```
输入：values = [1,2,3,-1,-2,-3,7]
输出："Alice"

```

**示例 5：**

```
输入：values = [-1,-2,-3]
输出："Tie"

```

**提示：**

-  *1 <= values.length <= 50000*
-  *-1000 <= values[i] <= 1000*

# 算法思路

# 测试用例
```
1406. Stone Game III 1406. 石子游戏 III Hard
```

[enTitle]: https://leetcode.com/problems/stone-game-iii/
[cnTitle]: https://leetcode-cn.com/problems/stone-game-iii/

repository: philippzhang/leetcodeLearnJava

gha_language: Java

repo_name: philippzhang/leetcodeLearnJava


text:
Weather widget that is built with Node.js, React and OpenWeatherMap API

How to run it:

Start first the Node.js API server

1. You have to edit api/routes/weatherAPI.js and insert the API Key in appid. eg: const appid = "166d00e26d3ff2c6149....";

2. cd into the 'api' folder

3. npm start

The server is now listening on: http://localhost:8888/weatherAPI

You can now start React

1. cd into the 'client' folder

2. npm start

You can now access the widget from: http://localhost:3000

Optional:

3. You can run 'npm t' to start the unit tests

4. You can edit client/src/index.js to change the api url

5. You can edit client/public/index.html and change: 'data-default-city' attribute value to replace the default city on the initial page load


text:
# Umbraco Acceptance Tests

### Prerequisites
- NodeJS 12+
- A running installed Umbraco on url: [https://localhost:44331](https://localhost:44331) (Default development port)
   - Install using a `SqlServer`/`LocalDb` as the tests execute too fast for `SqlCE` to handle.

### Getting started
The tests are located in the project/folder as `Umbraco.Tests.AcceptanceTests`. Make sure you run `npm install` in that folder, or let your IDE do that.

The script will ask you to enter the username and password for a superadmin user of your Umbraco CMS.

### Executing tests
There are two npm scripts that can be used to execute the test:

1. `npm run test`
   - Executes the tests headless.
1. `npm run ui`
   - Executes the tests in a browser handled by a cypress application.

 In case of errors it is recommended to use the UI to debug.

### Enviroment Configuration

The enviroment configuration is begin setup by the npm installation script.
This results in the creation of this file: `cypress.env.json`.
This file is already added to `.gitignore` and can contain values that are different for each developer machine.

The file has the following content:
```
{
    "username": "<email for superadmin>",
    "password": "<password for superadmin>"
}
```
You can change this if you like or run the config script to reset the values, type "npm run config" in your terminal.


text:
# Auction
## Introduction
-Online Bidding System project is developed using PHP, CSS, and JavaScript. Talking about the project, it has almost all the essential features required for a bidding system.

-This project contains an admin and user’s side where Admin can manage all the bidding activities and product information.

-Whereas from the user side, users can view products and bid on it easily.

-Admin plays an important role in the management of the system. In this project, the user should perform major functions from the Admin side.

### Features:

- Login/Register.

- Admin Panel.

- Add products for bid.

- Add Products category.

- Bidding notifications.

- Account activation.

- Highest bidder.


text:
# foreign_enum!

With usage of `foreign_enum!` macro you can "export" `enum` (`C` like enum) to foreign language:

```rust,no_run,noplaypen
{{#include ../../jni_tests/src/java_glue.rs.in:foreign_enum_usage}}
```

This allow you can use it as input or output types for `foreign_class!` methods.

repository: saks/flapigen-rs

repo_name: saks/flapigen-rs


text:
# OpenWeatherMap-app for Homey

This app allows you to poll the OpenWeatherMap API for localised weather data and use this in your Homey home automation flows. Several instances (locations) can run simultaneously.

# Current weather

The 'current weather' data comes from the OWM current weather data, refer to http://openweathermap.org/current. It includes visibility, sunrise and sunset data which are not included in the forecast tables. Note that the max. and min. temperatures in the current data indicate the possible range in which the actual temperature is expected, it can be seen as a measure for the standard deviation of the current temperature.

# Forecast up to 5 days

The five day forecast data (refer to http://openweathermap.org/forecast5) includes forecasts in 3-hour intervals up to 5 days in the future. During pairing you can choose the 3-hour interval you want to have weather data from. Interval 0 gives you data from the currently running 3-hour interval (between one hour ago/two hours ahead) which should be close to the current weather. Interval 8 gives data 24 hours ahead, etc. In this dataset the maximum and minimum temperatures are the expected maximum and minimum temperature, as you would expect.

# Long term weather

The long term weather forecast gives data for up to 15 days in the future, in daily intervals (refer to http://openweathermap.org/forecast16). Included in the data is the daily, morning, evening and night temperature.

The OpenWeatherMap polling is inspired by the 'openweather-apis', refer to https://github.com/CICCIOSGAMINO/openweather-apis.

Please use the forum for questions and comments related to the app: https://forum.athom.com/discussion/4225/.

# Screenshots
The mobile interface looks as follows:

The pairing view:

Settings can be changed after pairing.

# Flow cards
For nearly all parameters trigger and condition cards are included, see screenshot for most flowcards available for the current weather:

# Requirements
To use the app, you need to get a (free) OpenWeatherMap API key at http://openweathermap.org.


text:
# Document

GIVEN a configuration

~~~json
{
  "glossaries": [{
    "file": "glossary.md",
    "import": { "file": "./glossary.json" },
    "showUris": "- ${uri}"
  }]
}
~~~

WITH file `glossary.md` missing
AND file `glossary.json` existing WITH terms
- *Glossary*
- *Taxonomy*
- *Thesaurus*

THEN

1. the system MUST NOT fail from the missing `glossary.md`
1. AND glossarify-md MUST generate a file `glossary.md`
   1. AND the file MUST have a title `# Glossary`
   1. AND the file MUST have a heading `## ...` for each term
   1. AND the file MUST have each term's URI rendered as a markdown list below the term's definition
1. AND the system MUST linkify the terms mentioned above in *this* file
1. AND the terms must be linked to the generated file `glossary.md`

repository: about-code/glossarify-md

repo_name: about-code/glossarify-md


text:
# SwiftyTasks

[![CI Status](http://img.shields.io/travis/victor-pavlychko/SwiftyTasks.svg?style=flat)](https://travis-ci.org/victor-pavlychko/SwiftyTasks)
[![Pod Version](https://img.shields.io/cocoapods/v/SwiftyTasks.svg?style=flat)](http://cocoapods.org/pods/SwiftyTasks)
[![Carthage: compatible](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](https://github.com/Carthage/Carthage)
[![License: MIT](https://img.shields.io/badge/license-MIT-3b3b3b.svg?style=flat)](https://github.com/victor-pavlychko/SwiftyTasks/blob/master/LICENSE)
[![Swift: 3.0](https://img.shields.io/badge/swift-3.0-orange.svg?style=flat)](https://github.com/victor-pavlychko/SwiftyTasks)
[![Platform: iOS](https://img.shields.io/badge/platform-ios-lightgrey.svg?style=flat)](https://github.com/victor-pavlychko/SwiftyTasks)

## Overview

Most task/operation manadgement libraries either build task infrastructure from scratch or
focus on defining custom `Operation` subclasses.

SwiftyTask aims to build workflows on top of existing `Operation` infrastructure extending
it with result/error handling. Any third-parrty `Operation` subclasses can be easily extended
to support `TaskProtocol` and participate in complex workflows.

### Tasks

SwiftyTasks defines following task-related protocols:
* `AnyTask`: provides list of backing tasks, is adopted by `Operation` class
* `TaskProtocol`: extenda `AnyTask` adding access to execution result

Library also defines following task-related classes:
* `Task<ResultType>`: base class, conforms to `TaskProtocol`, provides result handling
* `BlockTask<ResultType>`: subclass to wrap any code block into a `Task`
* `AsyncTask<ResultType>`: extenda `Task` class with asynchronous `Operation` state handling
* `AsyncBlockTask<ResultType>`: subclass to wrap any asynchronous code block into an `AsyncTask`
* `AdapterTask<ResultType>`: subclass wrapping list on operations custom result block

### Operators

Following operators are defined to manage tasks:
* `+=`: enqueue task in OperationQueue
* `<~`: performs partial function application where operand on the right may be either value or task
* `~>`: performs deferred function call given value/task list on the right
* `~~`: adds task on the right as a dependency to task on the left

### Partial Application

`Task` workflows circulate around partial application and functions returning `Task`s.

 Function on the left will be wrapped into a task
scheduled to be executed after value on the right is ready.

Use `~>` operator to convert list of values. Function on the right will be wrapped into a task
scheduled to be executed when all values on the left are ready.

Finally `+=` operator is overloaded to enqueue tasks into `OperationQueue`

## Real-world Example

Following is an example of real-world use to create video,
save it to photo library and put into a gallery folder.

```swift
let createVideoOperation = OperationQueue.main
    += CreateVideoOperation()

let createVideoAssetOperation = OperationQueue.main
    += CreateVideoAssetOperation.init(videoURL:)
    <~ createVideoOperation

let createAssetCollectionOperation = OperationQueue.main
    += CreateAssetCollectionOperation.init(title:)
    <~ "Convenience"

let addAssetToCollectionOperation = OperationQueue.main
    += AddAssetToCollectionOperation.init(asset:collection:)
    <~ createVideoAssetOperation
    <~ createAssetCollectionOperation

addAssetToCollectionOperation.completionBlock = {
    completionBlock()
}
```

## Installation

SwiftyTasks is available through [CocoaPods](http://cocoapods.org). To install
it, simply add the following line to your Podfile:

```ruby
pod "SwiftyTasks"
```

## Author

Victor Pavlychko<EMAIL_ADDRESS>
## License

SwiftyTasks is available under the MIT license. See the LICENSE file for more info.

repository: victor-pavlychko/SwiftyTasks

repo_name: victor-pavlychko/SwiftyTasks


text:
# Functions

* Functions are objects
* Linked to `Function.prototype`
* Function created two additional hidden properties
  * it's context
  * it's implementation
* Function also has a `prototype` property whose value is
  * an object with a `constructor` property whose value is
    * a function
      * this function is different than the link to `Function.prototype`

## Function Literal

* The function literal has four parts
  * The reserved word, `function`
  * An optional name - this function name is important when calling a function recursively and also for debuggers
  * Set of zero or more parameters, wrapped in parentheses - initialized to the arguments supplied when function is invoked
  * Set of statements, wrapped in curly braces that represents the function body
* Inner function enjoys access to its parameters and variables
* Inner function also enjoys access to the parameters and variables of the functions it is nested within

## Invocation

* Function invocation suspends execution of the current function, passing control and parameters to the new function
* Function receives two additional parameters: `this` and `arguments`
  * The value of `this` is determined by the invocation pattern
* If too few arguments are specified, and the argument values will be initialized to `undefined`
* If too many arguments are specified, the extra arguments will be ignored

### Method Invocation Pattern

* A method is a function that is stored as a property of an object
* When a method is invoked, `this` is bound to that object

```javascript
var example = {
  value: 0,
  increment: function(amount) {
    this.value += typeof amount === 'number' ? amount : 1;
  },
};

example.increment() // increments value by 1
example.value // is 1

example.increment(2) // increments value by 2
example.value // is 3
```

### Function Invocation Pattern

* Occurs when a function is not the property of an object
* `this` is bound to the global object
* This means that a method (i.e a function that is a property of an object) cannot use an inner function to do work because the inner function's `this` is bound to the global object while the method's `this` is bound to the containing object
* Workaround is to assign a `that` variable in the method that the inner function then references

```javascript
myObject.foo = function() {
  var that = this;

  var bar = function() {
    console.log(that.bar);
  }

  bar();
};
```

### Constructor Invocation Pattern

* JavaScript is a prototypal language meaning that it is class-free
* JavaScript is not confident in its prototypal nature so it offers an object-making syntax that is reminiscent of class-based languages
* If a function is invoked with the `new` prefix then a new object will be created with a hidden link to the value of the function's `prototype` member, and `this` will be bound to that new object

```javascript
// Creates a constructor
var Quo = function(status) {
  this.status = status;
};

// Gives all instances of Quo a public method to get the status property
Quo.prototype.getStatus = function() {
  return this.status;
};

// Make an instance of Quo
var myQuo = new Quo('confused');

myQuo.getStatus(); // confused
```

### Apply Invocation Pattern

* Functions have methods - one of these methods is the `apply` method
* The `apply` method takes two parameters
  * The first parameter specifies the value of `this` to use
  * The second parameter is an array of parameters that will be used when invoking the function

```javascript
var seven = add.apply(null, [3, 4]);

var status = {
  status: 'ok',
};

// Remember the Quo.prototype.getStatus method?
// We can call that using the apply method and the new status object
// The "this" in the case of getStatus points to the status object

Quo.prototype.getStatus.apply(status); // ok
```

## Arguments

* The other parameter that functions have access to is `arguments`
* `arguments` is an array-like collection of all the parameters that the function was called with
  * Has a `length` property but does not have any array methods
  *

```javascript
// Function that adds all its parameters

var sum = function() {
  var i, sum = 0;
  for (i = 0; i < arguments.length; i += 1) {
    sum += arguments[i];
  }
  return sum;
};

sum(1, 2, 3, 4, 5) // 15
```

## Scope

* JavaScript does not have block scope (i.e. variables in a block scope are visible outside the block)
* JavaScript has function scope
  * Variables in a function are not visible outside the function
  * Variables anywhere in a function *are* visible everywhere within the function
  * This means that it is best to declare variables used in a function at the top of the function body

```javascript
var foo = function() {
  var a = 1, b = 2;

  // a is 1, b is 2

  var bar = function() {
    // only get here when bar is invoked

    var b = 3, c = 4;
    // a is 1, b is 3, and c is 4
    // note that b from outer scope was not reassigned

    a += b + c;
    // a is 8, b is 3, and c is 4
  };

  // bar has not been invoked yet so
  // a is 1, b is 2, c is undefined

  bar();

  // a is 8, b is 2, c is undefined
}
```

## Closure

* Function's have access to the context in which they were created - this is called closure
* Function's have access to the parameter itself - not a copy

```javascript
// myObject is immediately initialized as the function is called immediately
// myObject's value variable can only be modified via the increment method

var myObject = (function() {
  var value = 0;

  return {
    increment: function(amount) {
      return value += typeof amount === 'number' ? amount : 1;
    },
    getValue: function() {
      return value;
    },
  };
}());
```

```javascript
var addEventHandlers = function(nodes) {
  var i;
  for (i = 0; i < nodes.length; i += 1) {
    nodes[i].onClick = function(e) {
      // this will always be nodes.length - 1 because when it is invoked
      // it will point to the variable i
      // which has finished looping
      alert(i);
    };
  }
};

var betterAddEventHandlers = function(nodes) {
  // helper has the correct function scope such that i will be the current value when it's invoked
  var helper = function(i) {
    return function(e) {
      alert(i);
    };
  };

  var i;
  for (i = 0; i < nodes.length; i += 1) {
    nodes[i].onClick = helper(i);
  }
};
```

## Module

* A module is a function or object that is an interface - it hides its state and implementation
* Here's a trivialized example - let's augment the `String.prototype` with a `deentitytify` method that replaces HTML entities
  * We will need a mapping of HTML entities to their counter parts
  * Where to store this mapping?
  * Could store as a global variable but globals are not great
  * Could put in function but adds runtime cost since it must be evaluated every time the function is invoked
  * Can use closures to advantage here

```javascript
// Note how outer function is invoked immediately
// This will assign deentitytify to the returned inner function
// This inner function uses regex to replace a matching entity (or keep the existing character if it doesn't match)
// The entities mapping is now private and can only be accessed through the deentityify method

String.method('deentitytify', function() {
  var entities = {
    quot: '"',
    lt: '<',
    gt: '>',
  };

  return function() {
    return this.replace(/&([^&;]+);/g,
      function(a, b) {
        var r = entity[b];
        return typeof r === 'string' ? r : a;
      }
    );
  };
}());
```

* General module pattern is
  * Create a function that defines private variables / functions
  * Create privileged functions that will access these variables / functions via closures
  * Return these privileged functions for public use

## Currying

* The act of currying is combining a function and arguments

```javascript
var add1 = add.curry(1);

// add1 will now add 1 to any passed in argument
add1(6); // 7
```

* JavaScript doesn't come with a built-in `curry` method so an implementation might look like

```javascript
// curry uses closures to keep context of "original" function
// which will be called by the returned function
// which combines the arguments passed to the invocation of curry
// with the arguments passed to the invocation of the function returned by the curry (whew)

Function.method('curry', function() {
  // arguments are not arrays, so need to use slice to replace with arrays
  var slice = Array.prototype.slice,
      args = slice.apply(arguments),
      that = this;

  return function() {
    // this is where the "original" function gets called with the combined arguments
    // Note how the arguments here will be for parameters passed to the invocation of the inner function
    return that.apply(null, args.concat(slice.apply(arguments));)
  };
});
```

repository: jaebradley/notes

repo_name: jaebradley/notes


text:
### About Istanbul Atatürk Airport (IST | LTBA)
*Istanbul Atatürk Airport* is the main airport of Turkey. It serves as a hub for *AtlasGlobal*, *Onur Air* and, most importantly, *Turkish Airlines*, which has the biggest share at the airport and serves numerous destinations worldwide. The airport is also used for cargo operations by cargo airlines such as *Turkish Airlines Cargo*, *MNG Airlines*, *MyCargo Airlines* and *Qatar Airways Cargo*.
The airport was originally named *Yeşilköy Airport*. In the 1980s, it was renamed *Istanbul Atatürk International Airport* in honour of *Mustafa Kemal Atatürk*, the founder and first president of the Republic of Turkey. It served more than 60 million passengers in 2015, making it the 11th-busiest airport in the world in terms of total passenger traffic and the 10th-busiest in the world in terms of international passenger traffic. As of 2017, it is Europe's 5th-busiest airport after *London Heathrow*, *Paris Charles de Gaulle*, *Frankfurt Airport* and *Amsterdam Schiphol Airport*, having fallen from third place after a decline in passengers due to security fears.

#### Statistics
* **Total passengers**: *63,727,448* (2017)
* **International passengers**: *44,277,101* (2017)
* **Aircraft movements**: *460,777* (2017)
* **Cargo**: *790,744 tonnes* (2017)

### Airspace
The airspace of the Yeşilköy Approach/Radar Sector encompasses a large area around Istanbul up to FL240. It extends up to 80nm from the airport.
The Yeşilköy Approach/Radar Sector also controls arrivals and departures of Istanbul's secondary airport *Sabiha Gökçen International Airport (SAW | LTFJ)*.

### Runways
The airport has 3 runways. The southeastern runway (05/23) is 2580m (8465ft) long. The other two runways (17R/35L; 17L/35R) are parallel but too close for independent simultaneous approaches. *Atatürk Airport* applies a *"Preferential Runway System"* (PRS) indicating the runway or runways that are considered by ATC to be the most suitable for take-off or landing, taking aircraft performance, surface wind speed and other components into consideration. During *PRS* operations the following runway configuration is usually used:

* Runway 05 for landing
* Runway 35L for take-off

**This is also the configuration in use in openScope**

### Instrument Procedures
*Istanbul Atatürk Airport* has a large quantity of SIDs and STARs, RNAV and non-RNAV. However, only the RNAV procedures are normally used.
The procedure's suffix indicates the runway, the procedure is for.

SIDs:

| Runway |  Suffix  |
|:------:|:--------:|
|   05   | P        |
|   23   | V        |
|   17L  | R, T     |
|   17R  | S, U     |
|   35L  | Q, X, Y  |
|   35R  | E, N, Z  |

STARs:

|  Runway  |  Suffix  |
|:--------:|:--------:|
|   05     | A        |
|   17L/R  | B        |
|   23     | C        |
|   35L/R  | D        |

### Sectors Available in OpenScope
The sim features a combination of these sectors:

|     *Yeşilköy Approach/Radar* Sector    | Frequencies       |             |             |
|:---------------------------------------:|:-----------------:|:-----------:|:-----------:|
| North                                   |    121.100 MHz    | 126.425 MHz | -           |
| East                                    |    120.700 MHz    | 122.675 MHz | -           |
| South                                   |    120.500 MHz    | -           | -           |
| West                                    |    119.475 MHz    | 121.250 MHz | 127.100 MHz |
| (Gökçen)                                |    127.825 MHz    | -           | -           |

### Other aerodromes of interest

##### Istanbul New Airport, LTFM
*Istanbul New Airport*  is an international airport under construction in the *Arnavutköy* district on the European side of Istanbul, with the aim of replacing the current *Istanbul Atatürk Airport*, which has reached its capacity limits.
The construction of the airport began in May 2015 and its inauguration is scheduled for the 29th of October 2018, although delays are expected. Once the new airport commences operations, *Istanbul Atatürk Airport* will be closed down for scheduled passenger flights. The construction of the airport is set to take place in several stages, expanding the airport and its facilities over time. For the first stage, *Istanbul New Airport* will have a main terminal with a total passenger capacity of 90 million and 2 independent runways.
Once fully completed however, the airport will have a total of 6 runways and a capacity of 150 million passengers annually, expandable to 200 million.

Planned runways:
Runway 17L/35R, 3,750m (12,303ft)
Runway 17R/35L, 3,750m (12,303ft)
Runway 18L/36R, 3,750m (12,303ft)
Runway 18C/36C, 4,100m (13,451ft)
Runway 18R/36L, 3,750m (12,303ft)
Runway 09/27 , 3,750m (12,303ft)
34 km (21.2 mi) north of LTBA

##### Sabiha Gökçen International Airport, LTFJ
*Sabiha Gökçen International Airport* is the secondary international airport of Istanbul.
It serves as the hub for *Pegasus Airlines* but is also used by *Turkish Airlines* and other airlines since the airport isn't as busy as *Istanbul Atatürk Airport*.
The departures and arrivals of LTFJ are also handled by *Yeşilköy Approach/Radar*

Runway 06/24, concrete, 3,000m (9,843ft)
43 km (26.7 mi) east of LTBA

##### Istanbul Hezarfen Airfield, LTBW
*Istanbul Hezarfen Airfield* is a privately owned airport located in *Çatalca* district of Istanbul.
It is mainly used for general aviation.

Runway 05/23, asphalt, 681m (2,230ft)
26 km (16.3 mi) northwest of LTBA

##### Istanbul Samandıra Army Air Base, LTBX
*Istanbul Samandıra Army Air Base* is a military airport located in *Kartal* district of Istanbul.
The air base is used by the Turkish Army and is home to Army Regiment of the Turkish First Army.

Runway 04/22, concrete, 1,372m (4,500ft)
Runway 18/36, concrete, 764m (2,506ft)
34 km (21.2 mi) east of LTBA

##### Tekirdağ Çorlu Airport, LTBU
*Tekirdağ Çorlu Airport* is a military as well as public airport in *Çorlu*. The airport is 10.5 km (6.5 mi) east of Çorlu.
Besides being used by the Turkish Army, there is only one passenger connection according to Wikipedia.
AnadoluJet serves a route between Çorlu and Ankara.

Runway 05/23, paved, 3,000m (9,843ft)
77 km (48.2 mi) west of LTBA

##### Bursa Yenişehir Airport, LTBR
*Yenişehir Airport* is an airport in the city of Yenişehir in the Bursa Province of Turkey.
There are a couple of domestic connections served by AnadoluJet.

Runway 07R/25L, concrete, 2,993m (9,818ft)
Runway 07L/25R, concrete, 2,993m (9,818ft)
102 km (63.9 mi) southwest of LTBA

### Additional Resources
VATSIM Charts
Additional information can be found in the European AIS Database (requires a free registration)
Or the Turkish AIP (requires a subscription)

repository: openscope/openscope

branch_name: refs/heads/develop

gha_license_id: NOASSERTION

repo_name: openscope/openscope


text:
hipchat
=======

Bitrise HipChat message Step.

This Step requires a HipChat account. To sign up on HipChat for free, [click here](https://www.hipchat.com/sign_up)

You can get your HipChat auth token in Account settings > API access. If you do not have an auth token, select Create token, at the bottom
You can get the room id of any HipChat room by selecting Rooms > Summary > API ID

This Step is part of the [Open StepLib](http://www.steplib.com/), you can find its StepLib page [here](http://www.steplib.com/step/hipchat)

# Input Environment Variables
- **HIPCHAT_TOKEN**

    at [https://bitfall-team.hipchat.com/admin/api](https://bitfall-team.hipchat.com/admin/api)
- **HIPCHAT_ROOMID**

	at [https://bitfall-team.hipchat.com/admin/rooms](https://bitfall-team.hipchat.com/admin/rooms)
- **HIPCHAT_FROMNAME**

	the name of the sender, maximum 15 characters; optional, "Bitrise" by default
- **HIPCHAT_MESSAGE_COLOR**

	the color of the message; optional, "yellow" by default
- **HIPCHAT_MESSAGE**

	the text message you would like to send

# How to test/run locally?

- clone this repository
- cd into the repository folder
- run: HIPCHAT_TOKEN=[your-hipchat-token] HIPCHAT_ROOMID=[your-hipchat-roomid] HIPCHAT_FROMNAME=[max-15-characters] HIPCHAT_MESSAGE_COLOR=[color] HIPCHAT_MESSAGE=[the-hipchat-message] bash step.sh

repository: erosdome/steps-hipchat

repo_name: erosdome/steps-hipchat


text:
OpenOMF Readme [![Build Status](https://travis-ci.org/omf2097/openomf.png?branch=master)](https://travis-ci.org/omf2097/openomf)
=======

OpenOMF is a Open Source remake of "One Must Fall 2097" by Diversions Entertainment. Since the original DOS game from 1994 still uses IPX networking and is a pain to set up, the community needed a better solution to keep playing the game we love. Together with networking, we try to make it easier to play One Must Fall in original glory on multiple platforms (Linux, Mac OSX, Windows, BSD to name a few), although it might take some time to set it up.

For mode detailed information about the project, please see [http://omf2097.github.io/openomf/](http://omf2097.github.io/openomf/).

For installing & compiling, please see [INSTALL.md](https://github.com/omf2097/openomf/blob/master/INSTALL.md).

Links
-----
* There are some videos of openomf at http://www.youtube.com/user/openomf
* We have a forum thread at http://omf.justinoakley.com/viewtopic.php?t=312299
* Our official wiki & documentation is at http://www.omf2097.com/wiki/doku.php?id=openomf:start
* We can also be reached on IRC (freenode) at #omf.

Project goals
-------------
1. At first, as faithful a game binary to the original as possible. When this is reached, we can work on new features.
2. Better game controller support (new gamepads etc.)
3. Better networking support (dosbox IPX/SPX routing is annoying to set up + the original game will run slowly). At first only 1 vs. 1 matches; later maybe full multiplayer tournaments and stuff :)
4. Support for new graphics and audio. The game already supports loading alternate audio files. Support for alternate sprites is coming after the game is otherwise working okay.
5. Enhanced tournament mode!
6. Enjoying challenges in reverse-engineering and coding :)

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

* libShadowDive: https://github.com/omf2097/libShadowDive
* libdumb: https://bitbucket.org/kode54/dumb
* SDL2 (>=2.0.2): http://www.libsdl.org/download-2.0.php
* OpenAL: http://kcat.strangesoft.net/openal.html
* confuse: http://www.nongnu.org/confuse/
* Gettext (if you have problems with libintl)
* Enet: http://enet.bespin.org/

Optional:
* libvorbis: https://www.xiph.org/downloads/
* libogg: https://www.xiph.org/downloads/
* libpng: http://www.libpng.org/pub/png/libpng.html
* zlib: http://www.zlib.net/

Several of these are probably available as packages for your operating system, but some you will have to install from source.

License
-------
OpenOMF is developed under the MIT License. Please read [LICENSE](https://github.com/omf2097/openomf/blob/master/LICENSE) for more information.

Contribute
----------
You may submit patches to this project by forking this repository and making a pull request.

If you want to become a regular contributor, please contact us on [#omf](http://webchat.freenode.net?channels=omf) on [irc.freenode.net](irc://chat.freenode.net/omf).

We appreciate all kinds of contributions, whether it's big or small.

Contact
-------
Join us on [#omf](http://webchat.freenode.net?channels=omf) on [irc.freenode.net](irc://chat.freenode.net/omf) if you want to get in contact with us.

repository: adamlincoln/openomf

repo_name: adamlincoln/openomf


text:
# ECMAScript notes:

## Data Type

- Undefined
- Null
- Boolean
- String
- Number
- Symbol

## 属性特性

- [[Value]]
- [[Writable]]
- [[Enumerable]]
- [[Configurable]]

## Function Objects

- [[GetPrototypeOf]]
- [[SetPrototypeOf]]
- [[IsExtensible]]
- [[PreventExtensions]]
- [[GetOwnProperty]]
- [[DefineOwnProperty]]
- [[HasProperty]]
- [[Get]]
- [[Set]]
- [[Delete]]
- [[OwnPropertyKeys]]

- [[Call]]
- [[Construct]]

## Exectuion Contexts

An execution context is a specification device that is used to trace the runtime evaluation of code by an ECMAScript implementation. At any point in time, there is at most one execution context per agent that is actually executing code. This is known as the agent's running execution context. All references to the running execution context in this specification denote the running execution context of the surrounding agent.

repository: donaldcao/simpleS

path: /notes/ECMAScript notes.md

filename: ECMAScript notes.md

repo_name: donaldcao/simpleS


text:
# Changelog
All notable changes to this project will be documented in this file.

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

## 1.1.0 [06/06/2019]
### Fixes
- Fixed giving X coordinate instead of Z.

## 1.0.0 [05/29/2019]
### Additions
- Initial release.

repository: hparcells/bettersmp

repo_name: hparcells/bettersmp


text:
---
layout: post
title: 'Friday Links'
---
Links I found interesting this week.

[Understanding IIS7 Request Restrictions on Windows Vista](http://blogs.iis.net/thomad/archive/2008/05/01/understanding-iis7-request-restrictions-on-windows-vista.aspx) - Just how many concurrent requests does IIS7 allow?

[Wicked Code: Silverlight Page Turning Made Simple](http://msdn.microsoft.com/en-us/magazine/cc507644.aspx) - Great introduction to the world of Silverlight. Cool page turning demo.

[Bright Focus](Bright Focus (for buttons, links, and textboxes) | userstyles.org (http://userstyles.org/styles /305)) - Firefox add on that highlights buttons, links and textboxes similar to what Safari does.

[11 More Visual Studio Shortcuts You Should Know](http://www.dev102.com/2008/05/06/11-more-visual-studio-shortcuts-you-should-know/%20%20%20%20%20%20%20%20%20%20%20%20%20%20http://www.dev102.com/2008/05/06/11-more-visual-studio-shortcuts-you-should-know/) - I particularly like the CTRL + "K" + "M" tip.

[Solar House](http://www.viking-house.ie/solar-house) - Great looking sun space that can reduce utility bills significantly.

[Addictomatic: Inhale the Web](http://addictomatic.com/) - Search with an emphasis on blogs and news sources.

[When Is](http://www.when-is.com/) - Dates of Religious and Civil Holidays Around the World.

[Copy Link Text (CoLT)](http://www.borngeek.com/firefox/colt/) - tiny extension for [Firefox](http://www.mozilla.org/products/firefox/) which makes it easier than ever to copy a hyperlink’s associated text

[Terrafugia, Inc.](http://www.terrafugia.com/vehicle.html) - The Transition® is a roadable Light-Sport Aircraft that will be able to land at the airport, fold up its wings, and drive on the road. Cool videos

[Luxim Plasma Light Bulb Kicks Some Serious LED Butt](http://www.treehugger.com/files/2008/04/luxim-plasma-lifi-light-bulb-led-cfl.php) - See a bulb the size of a puffed rice used as a street light. Way cool

[Simultaneous Invention](http://www.kk.org/thetechnium/archives/2008/05/simultaneous_in.php) - Great inventions created by the same people at the same time. Though provoking

[Change the Font of Command Prompt Window to Consolas](http://www.labnol.org/software/tutorials/change-font-dos-command-prompt-window-consolas-programming-font/3253/) - Use the superior Consolas ClearType font in your DOS box.

[Is Google trying solid-state disks?](http://www.news.com/8301-10784_3-9941647-7.html?part=rss&subj=news&tag=2547-1_3-0-5) - Rumor has it Google is trying out solid state disk drives to lower energy costs.

[Json.NET Library](http://james.newtonking.com/pages/json-net.aspx) - Json.NET library makes working with JavaScript and JSON formatted data in .NET simple

[Nissan plans electric car by 2010](http://reviews.cnet.com/8301-13746_7-9942980-48.html?part=rss&subj=news&tag=2547-1_3-0-5) - Nissan plans to be the first major automaker to ship a plug-in electric.  From StarDock, makers of Window Blinds. Nice

[Create a Live Survey for your Site with GoogleDocs](http://adsense.blogspot.com/2008/05/creating-live-survey-for-your-site.html) - Create surveys and collect results with GoogleDocs.

[Choosing the Right Garbage Collector Settings for Your Application](http://www.atalasoft.com/cs/blogs/rickm/archive/2008/05/14/choosing-the-right-garbage-collector-settings-for-your-application-net-memory-management-part-4.aspx) - Great article on tweaking the garbage collector settings in .NET applications.

[Google Doctype](http://code.google.com/doctype/) - A Wiki style online encyclopedia for Web authors

[SpaceTime 3D Browser](http://www.spacetime.com) - A unique and free browser application that time lines your browsing habits. Nice 3D effects. Not sure how useful it really is however.


text:
# Programming cheat-sheets
These cheat-sheets are meant for everyone who can already code, but is struggling to get started with a new programming language.
They aim to provide a structured overview of the core language features and an introduction on the surrounding tooling.

## Cheat-sheets
- [ANSI C](c.md)
- [Go](golang.md)
- [JavaScript (ES6)](javascript.md)
- [Rust](rust.md)

## Contributing
Any help towards completing these cheat-sheets is highly appreciated!

If you spot any mistakes in existing cheat-sheets or can even contribute new ones (not mistakes, sheets), feel free to get in touch or just create a pull request.

repository: Malpaux/programming-cheat-sheets

repo_name: Malpaux/programming-cheat-sheets


text:
Someone I know is working on an RPG Maker game, and wanted to add achievements without the hassle of writing lots of C++ code. Good news is as of Steamworks SDK 1.32, exports have been added so C++ is not necessary to use most of Steamworks. As such, I have created a script that requires no DLLs other than the Steamworks DLL itself.

Here's how to use the script:

* Copy steam_api.dll from the Steamworks SDK to your project root folder. **Important: you must use Steamworks SDK 1.48 or above for r7!** Check tagged revisions if you need a version for an older SDK version.
* Paste the script into the script editor.
* In an event script or wherever you need it, write the following:

        steam = SteamUserStatsLite.instance
        steam.set_achievement 'YOUR_ACH_ID_HERE'
        steam.update

* If that second line returns true, the achievement has been set. Otherwise, you'll want to check if you set up achievements properly on Steam.

Please go to https://gmman.github.io/RGSS_SteamUserStatsLite for documentation.


text:
# SonarWan

#### Recognize devices of a private network by sniffing NAT'd traffic

This project's objective is to process NAT'd traffic only and be able to detect and classify devices connected to the private network behind the NAT.

## How to run

**Python 3 is required.**

[OPTIONAL]
Create a virtual environment and activate it:
```bash
$ virtualenv -p /path-to-bin-python-3 env
$ source env/bin/activate
```

Install dependencies:

```bash
$ pip install -r requirements.txt
```

Run:
```bash
$ python sonarwan.py path/to/pcap-file
```

## 🚧 work in progress 🚧

repository: SonarWAN/sonarwan-core

gha_language: Python

repo_name: SonarWAN/sonarwan-core