text:
# Traversal Combinators

There are many ways to traverse a tree.
For example, a bottom-up traversal, visits the subterms of a node before it visits the node itself, while a top-down traversal visits nodes before it visits children.
One-pass traversals traverse the tree one time, while fixed-point traversals, such as innermost, repeatedly traverse a term until a normal form is reached.

Rather than provide built-in implementations for all traversals needed in transformations, Stratego defines traversals in terms of the primitive ingredients of traversal.
For example, a top-down, one-pass traversal strategy will first visit a node, and then descend to the children of a node in order to recursively traverse all subterms.
Similarly, the bottom-up, fixed-point traversal strategy innermost, will first descend to the children of a node in order to recursively traverse all subterms, then visit the node itself, and possibly recursively reapply the strategy.

Traversal in Stratego is based on the observation[@LuttikV97] that a full term traversal is a recursive closure of a one-step descent, that is, an operation that applies a strategy to one or more direct subterms of the subject term.
By separating this one-step descent operator from recursion, and making it a first-class operation, many different traversals can be defined.

Here we explore the ways in which Stratego supports the definition of traversal strategies.
We start with explicitly programmed traversals using recursive traversal rules. Next, congruences operators provide a more concise notation for such data-type specific traversal rules.
Finally, generic traversal operators support data type independent definitions of traversals, which can be reused for any data type.
Given these basic mechanisms, we conclude with an exploration of idioms for traversal and standard traversal strategies in the Stratego Library.

## Congruence Operators

Congruence operators provide a convenient abbreviation of [traversal with rewrite rules](../../../background/stratego/strategic-rewriting/traversal-with-rules.md).
A congruence operator applies a strategy to each direct subterm of a specific constructor.
For each n-ary constructor `c` declared in a signature, there is a corresponding congruence operator `c(s1 , ..., sn)`, which applies to terms of the form `c(t1 , ..., tn)` by applying the argument strategies to the corresponding argument terms.
A congruence fails if the application of one the argument strategies fails or if constructor of the operator and that of the term do not match.

For example, consider the following signature of expressions:

```stratego
module expressions
signature
  sorts Exp
  constructors
    Int   : String -> Exp
    Var   : String -> Exp
    Plus  : Exp * Exp -> Exp
    Times : Exp * Exp -> Exp
```

The following applications apply the congruence operators `Plus` and `Times` to a term:

```stratego
<Plus(!Var("a"), id)> Plus(Int("14"),Int("3")) => Plus(Var("a"),Int("3"))

<Times(id, !Int("42"))> Plus(Var("a"),Int("3")) // fails
```

The first application shows how a congruence transforms a specific subterm, that is the strategy applied can be different for each subterm.
The second application shows that a congruence only succeeds for terms constructed with the same constructor.

<!-- The import at the start of the session is necessary to declare the constructors used; the definitions of congruences are derived from constructor declarations.
Forgetting this import would lead to a complaint about an undeclared operator:

```stratego
stratego> !Plus(Int("14"),Int("3"))
Plus(Int("14"),Int("3"))
stratego> Plus(!Var("a"), id)
operator Plus/(2,0) not defined
command failed
```
-->

## Defining Traversals with Congruences

Since congruence operators define a one-step traversal for a specific constructor, they capture the pattern of [traversal rules](../../../background/stratego/strategic-rewriting/traversal-with-rules.md).
That is, a traversal rule such as

```stratego
proptr(s) : And(x, y) -> And(<s>x, <s>y)
```

can be written by the congruence `And(s,s)`.
Applying this to the `prop-dnf` program we can replace the traversal rules by congruences as follows:

```stratego
module prop-dnf10
imports prop-rules
strategies
  proptr(s) = Not(s) <+ And(s, s) <+ Or(s, s) <+ Impl(s, s) <+ Eq(s, s)
  propbu(s) = try(proptr(propbu(s))); s
strategies
  dnf = propbu(try(DN <+ (DefI <+ DefE <+ DMA <+ DMO <+ DAOL <+ DAOR); dnf))
  cnf = propbu(try(DN <+ (DefI <+ DefE <+ DMA <+ DMO <+ DOAL <+ DOAR); cnf))
```

<!-- Observe how the five traversal rules have been reduced to five congruences which fit on a single line. -->

## Traversing Tuples and Lists

Congruences can also be applied to tuples, `(s1,s2,...,sn)`, and lists, `[s1,s2,...,sn]`.
A special list congruence is `[]` which ‘visits’ the empty list.
As an example, consider again the definition of `map(s)` using recursive traversal rules:

```stratego
map(s) : [] -> []
map(s) : [x | xs] -> [<s> x | <map(s)> xs]
```

Using list congruences we can define this strategy as:

```stratego
map(s) = [] <+ [s | map(s)]
```

The `[]` congruence matches an empty list.
The `[s | map(s)]` congruence matches a non-empty list, and applies `s` to the head of the list and `map(s)` to the tail.
Thus, `map(s)` applies `s` to each element of a list:

```stratego
<map(inc)> [1,2,3] => [2,3,4]
```

Note that `map(s)` only succeeds if `s` succeeds for each element of the list.
The `fetch` and `filter` strategies are variations on map that use the failure of `s` to list elements.

```stratego
fetch(s) = [s | id] <+ [id | fetch(s)]
```

The `fetch` strategy traverses a list until it finds a element for which `s` succeeds and then stops.
That element is the only one that is transformed.

```stratego
filter(s) = [] + ([s | filter(s)] <+ ?[ |<id>]; filter(s))
```

The `filter` strategy applies `s` to each element of a list, but only keeps the elements for which it succeeds.

```stratego
even = where(<eq>(<mod>(<id>,2),0))

<filter(even)> [1,2,3,4,5,6,7,8] => [2,4,6,8]
```

## Format Checking

Another application of congruences is in the definition of format checkers.
A format checker describes a subset of a term language using a recursive pattern.
This can be used to verify input or output of a transformation, and for documentation purposes.
Format checkers defined with congruences can check subsets of signatures or regular tree grammars.
For example, the subset of terms of a signature in a some normal form.

As an example, consider checking the output of the `dnf` and `cnf` transformations.

```stratego
conj(s) = And(conj(s), conj(s)) <+ s
disj(s) = Or (disj(s), disj(s)) <+ s

// Conjunctive normal form
conj-nf = conj(disj(Not(Atom(id)) <+ Atom(id)))

// Disjunctive normal form
disj-nf = disj(conj(Not(Atom(id)) <+ Atom(id)))
```

The strategies `conj(s)` and `disj(s)` check that the subject term is a conjunct or a disjunct, respectively, with terms satisfying s at the leaves.
The strategies `conj-nf` and `disj-nf` check that the subject term is in conjunctive or disjunctive normal form, respectively.

## Generic Traversal

Using congruence operators we constructed a generic, i.e. transformation independent, bottom-up traversal for proposition terms.
The same can be done for other data types.
However, since the sets of constructors of abstract syntax trees of typical programming languages can be quite large, this may still amount to quite a bit of work that is not reusable across data types; even though a strategy such as bottom-up traversal, is basically data-type independent.
Thus, Stratego provides generic traversal by means of several generic one-step descent operators.
The operator `all`, applies a strategy to all direct subterms.
The operator `one`, applies a strategy to one direct subterm, and the operator `some`, applies a strategy to as many direct subterms as possible, and at least one.

## Visiting All Subterms

The `all(s)` strategy transforms a constructor application by applying the parameter strategy `s` to each direct subterm.
An application of `all(s)` fails if the application to one of the subterms fails.
The following example shows how all (1) applies to any term, and (2) applies its argument strategy uniformly to all direct subterms.
That is, it is not possible to do something special for a particular subterm (that’s what congruences are for).

```stratego
<all(!Var("a"))>
  Plus(Int("14"), Int("3")) => Plus(Var("a"), Var("a"))

<all(!Var("z"))>
  Times(Var("b"), Int("3")) => Times(Var("z"), Var("z"))
```

## Defining Traversals with All

The `all(s)` operator is really the ultimate replacement for the [traversal with rules](../../../background/stratego/strategic-rewriting/traversal-with-rules.md) idiom.
Instead of specifying a rule or congruence for each constructor, the single application of the `all` operator takes care of traversing all constructors.
Thus, we can replace the `propbu` strategy by a completely generic definition of bottom-up traversal.
Consider again the last definition of `propbu`:

```stratego
proptr(s) = Not(s) <+ And(s, s) <+ Or(s, s) <+ Impl(s, s) <+ Eq(s, s)
propbu(s) = try(proptr(propbu(s))); s
```

The role of `proptr(s)` in this definition can be replaced by `all(s)`, since that achieves exactly the same, namely applying `s` to the direct subterms of constructors:

```stratego
propbu(s) = all(propbu(s)); s
```

Moreover, `all` succeeds on any constructor in any signature, so we can also drop the `try` as well, which was there only because `proptr` fails on the ``Atom(...)``, `True()`, and `False()` nodes at the leaves.

However, the strategy now is completely generic, i.e. independent of the particular structure it is applied to.
In the Stratego Library this strategy is called `bottomup(s)`, and defined as follows:

```stratego
bottomup(s) = all(bottomup(s)); s
```

It first recursively transforms the subterms of the subject term and then applies `s` to the result.
Using this definition, the normalization of propositions now reduces to the following module, which is only concerned with the selection and composition of rewrite rules:

```stratego
module prop-dnf11
imports prop-rules
strategies
  dnf = bottomup(try(DN <+ (DefI <+ DefE <+ DMA <+ DMO <+ DAOL <+ DAOR); dnf))
  cnf = bottomup(try(DN <+ (DefI <+ DefE <+ DMA <+ DMO <+ DOAL <+ DOAR); cnf))
```

In fact, these definitions still contain a reusable pattern.
With a little squinting we see that the definitions match the following pattern:

```stratego
dnf = bottomup(try(dnf-rules; dnf))
cnf = bottomup(try(cnf-rules; cnf))
```

In which we can recognize the definition of innermost reduction, which the Stratego Library defines as:

```stratego
innermost(s) = bottomup(try(s; innermost(s)))
```

The `innermost` strategy performs a bottom-up traversal of a term.
After transforming the subterms of a term it tries to apply the transformation `s`.
If successful the result is recursively transformed with an application of `innermost`.
This brings us to the final form for the proposition normalizations:

```stratego
module prop-dnf12
imports prop-rules
strategies
  dnf = innermost(DN <+ DefI <+ DefE <+ DMA <+ DMO <+ DAOL <+ DAOR)
  cnf = innermost(DN <+ DefI <+ DefE <+ DMA <+ DMO <+ DOAL <+ DOAR)
```

Different transformations can be achieved by using a selection of rules and a strategy, which is generic, yet defined in Stratego itself using strategy combinators.

## Visiting One Subterm

The `one(s)` strategy transforms a constructor application by applying the parameter strategy `s` to exactly one direct subterm.
An application of `one(s)` fails if the application to all of the subterms fails.
The following applications illustrate the behavior of the combinator:

```stratego
<one(!Var("a"))>
  Plus(Int("14"), Int("3")) => Plus(Var("a"), Int("3"))

<one(\ Int(x) -> Int(<addS>(x,"1")) \ )>
  Plus(Var("a"), Int("3")) => Plus(Var("a"), Int("4"))

<one(?Plus(_,_))>
  Plus(Var("a"), Int("4")) // fails
```

## Defining Traversals with One

A frequently used application of `one` is the `oncetd(s)` traversal, which performs a left to right depth first search/transformation that stops as soon as s has been successfully applied.

```stratego
oncetd(s) = s <+ one(oncetd(s))
```

Thus, `s` is first applied to the root of the subject term.
If that fails, its direct subterms are searched one by one (from left to right), with a recursive call to `oncetd(s)`.

An application of `oncetd` is the `contains(|t)` strategy, which checks whether the subject term contains a subterm that is equal to t.

```stratego
contains(|t) = oncetd(?t)
```

Through the depth first search of `oncetd`, either an occurrence of `t` is found, or all subterms are verified to be unequal to `t`.

Here are some other one-pass traversals using the one combinator:

```stratego
oncebu(s)  = one(oncebu(s)) <+ s
spinetd(s) = s; try(one(spinetd(s)))
spinebu(s) = try(one(spinebu(s))); s
```

Here are some fixe-point traversals, i.e., traversals that apply their argument transformation exhaustively to the subject term.

```stratego
reduce(s)     = repeat(rec x(one(x) + s))
outermost(s)  = repeat(oncetd(s))
innermostI(s) = repeat(oncebu(s))
```

The difference is the subterm selection strategy.

## Visiting Some Subterms

The `some(s)` strategy transforms a constructor application by applying the parameter strategy `s` to as many direct subterms as possible and at least one. An application of `some(s)` fails if the application to all of the subterms fails.

Some one-pass traversals based on some:

```stratego
sometd(s) = s <+ some(sometd(s))
somebu(s) = some(somebu(s)) <+ s
```

A fixed-point traversal with some:

```stratego
reduce-par(s) = repeat(rec x(some(x) + s))
```

## References

\bibliography

gha_language: TeX


text:
# Kibana stem

Kibana analytics and search dashboard for Elasticsearch[\*](https://www.elastic.co/products/kibana)

## Build

Build from the official [kibana](https://hub.docker.com/_/kibana/) docker image. Stick to current version.

## Configuration

Configuration based on the official [sample config](https://github.com/elastic/kibana/blob/7.0/config/kibana.yml).

Changes made:

* `server.host` set to `<IP_ADDRESS>`
* `elasticsearch.hosts` set to default url of [Elasticsearch stem](https://github.com/withinstem/elasticsearch).

## Deployment

Deploy with docker using embedded [ops-docker](https://github.com/ops-tools/ops-docker) tool.

Exec `scripts/start` to launch local instance.

## License

[The Unlicense](LICENSE).

license: Unlicense

repository: withinstem/kibana

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: withinstem/kibana


text:
---
layout: post
title: The best location for a coffee shop using Data Science!
---
# The First Week at Metis - Project Benson!
Just four days into the bootcamp, we were done with our first project- Benson. We were asked to come up with a backstory for a client based on the MTA Turnstile data in New York and come up with a solution for our client based on the data sets.

## The Backstory of our Client - Lets outsmart Starbucks!
Our client is a small generic coffee shop chain who is looking to expand and set up outlets near some of the ideal MTA stations in New York.  The idea is to target the coffee drinking demographic in order to maximize profits during their daily hours. Since the majority of people in New York commute through the MTA stations, the MTA turnstile data is crucial to estimating the conducive locations which would generate maximum revenue. They have requested our team to come up with a solution based on thorough data analysis.
We used the MTA data sets in combination with the U.S Census ACS 5 year estimates data sets to determine the ideal locations based on both the travel and socioeconomic factors.

## Ideal location for a Coffee Shop: factors?
Talking about the best location for a coffee shop, we would ideally look for some of the following factors:
* Close to an MTA Station which is busy during the popular times of a Coffee shop- when people generally hit the coffee shops!
* Someplace with the optimum coffee drinking demographic - Higher per-capita income, Higher concentration of post-graduates,etc.

## Popular Coffee Shop Hours
  The popular coffee shop hours in New York according to google is between 11 AM and 3 PM.

  ![Popular Coffee Shop Hours](http://www.cultureespresso.com/wp-content/uploads/2013/04/CE-overhead-web.jpg)

## Ideal Factors for a station
  The station should be highly populated- we would like a lot of people to be exiting the subway station between the hours of 11   AM and 3 PM. Also, there should be suustained growth and an upward trending model.

  ![Subway Stations New York](http://assets.nydailynews.com/polopoly_fs/1.1983020.1413985703!/img/httpImage/image.jpg_gen/derivatives/article_750/78939199.jpg)

## MTA Subway Station Data Analysis!
 We obtained the MTA Data sets from the website and used the pandas module in Python to convert them into data frames for easy analysis. After munging and parsing the data, we calculated the total exits from each of the stations between 11 AM and 3 PM for two years- 2015 and 2016.

![Trafficked Stations](http://i.imgur.com/UsqMJWM.png)

 We also calculated the stations with the highest upward trending growth in traffic between the two years.
 ![Highest Growth](http://i.imgur.com/fkw6mdN.png)

 We cross referenced both the lists and came up with top 24 stations that would be ideal in terms of traffic.
 ![MTA Data Analysis-Results](http://i.imgur.com/oFluylF.png)

## Census Data Analysis
 To further narrow down on the best possible location for our client, we introduced the demographic perspective and retrieved the census data for every tract in New York through the bureau's ftp server, and then narrowed down the data by geolocating the areas near the filtered stations from the previous analysis. With our census tracts and their proportions within the given radii identified, we were able to pull our chosen metrics from the Census’ API and extrapolate them to accurately reflect the socio-demographic characteristics of those most likely to frequent each terminal.

 ![Census Tract](http://i.imgur.com/LjXB79q.png)

 ![Census data](http://i.imgur.com/3OMLkrk.png)

## Market Research and Final Analysis!
 We analysed the census data that we pulled out, by referencing the market data from Small-Business development Community Network and the Coffee Shop Business Overview report. We allocated the weights to each of the factors in the population description - The Well educated, The High-Earners and the Singles- that have been known to purchase a lot of coffee! We also included a factor to weigh in the competitive angle- taking into account other coffee shops nearby so that our client stands out!

 Voila, here is our final scoreboard!

 ![Scoreboard](http://i.imgur.com/HprwJz7.png)

 Based on the final results, we presented our client with an accurate visualization of our final scoreboard-

 ![Comprehensive List](http://i.imgur.com/L1Kc4JT.png)

## Our Recommendations- Look out, Starbucks!
 ![Recommendation#1](https://s-media-cache-ak0.pinimg.com/564x/3a/6a/16/3a6a1689241b0ae920e4f2d0160db57f.jpg)

 ![Recommendation#2](http://www.brooklyneagle.com/sites/default/files/styles/free_style/public/pages/bay-ridge-86th-street-subway-elevator.jpg?itok=YDlnIQMF&c=188db6c16fadbb041b6fe9d1f2015ed2)

 ![Recommendation#3](http://subwaynut.com/irt/utican3/utican38.jpg)

license: MIT


text:
# Rolling Upgrades:  Neo4j in Kubernetes

[See the Neo4j-Helm User Guide: Rolling Upgrades](https://neo4j.com/labs/neo4j-helm/1.0.0/rolling-upgrades/) for documentation on this topic.

gha_language: Shell


text:
Charge tests
========
  - Charges a customer succesfully
  - Retrieves a charge succesfully
  - Updates a charge succesfully
  - Retrieves an expanded charge succesfully
  - Retrieves all charges
  - Captures a charge - 2 Step Payment Flow

Refund Tests
========
  - Creates a refund succesfully
  - Retrieves a refund succesfully
  - Retrieves a refund succesfully with expansion
  - Updates a refund succesfully
  - Retrieves all refunds for a Charge
  - Retrieves all refunds for a Charge with expansion

Customer tests
========
  - Creates an empty customer
  - Deletes a customer
  - Gets a customer
  - Gets a customer expandable
  - Gets customers
  - Gets customers expandable
  - Updates a customer

Card tests
========
  - Can create a Customer Card by CardNumber
  - Can create a Customer Card by TokenId
  - Can retrieve a Customer Card
  - Can retrieve a Customer's Card with expansion
  - Can retrieve a Customer's Cards
  - Can retrieve a Customer's Cards with Expansion
  - Can delete a Customer's Cards
  - Can update a Customer's Card

Recipient Card tests
========
  - Can create a RecipientCard by CardNumber
  - Can create a RecipientCard by Card TokenId
  - Fails to create a RecipientCard by BankAccount TokenId
  - Can retrieve a RecipientCard
  - Can retrieve a RecipientCard Expanded
  - Can retrieve a Recipient's Cards
  - Can retrieve a Recipient's Cards Expanded
  - Can delete a Recipient Card Expanded
  - Can update a Recipient's Card
  - Fails to add a Credit Card to a Recipient

Subscription tests
========
  - Succesfully creates a Subscription
  - Succesfully retrieves a Subscription
  - Succesfully retrieves a Subscription expanded
  - Succesfully retrieves a Customer's Subscriptions expanded
  - Succesfully retrieves a Customer's Subscriptions
  - Succesfully updates a Customer's Subscriptions
  - Succesfully cancels a Customer's Subscription

Plan tests
========
  - Succesfully creates a Plan
  - Succesfully creates a Plan and subscribes a customer with a TrialPeriod
  - Succesfully deletes a Plan
  - Succesfully updates a Plan
  - Succesfully retrieves a Plan
  - Succesfully retrieves a list of Plans

Coupon tests
========
  - Succesfully create a coupon
  - Succesfully retrieve a coupon
  - Succesfully delete a coupon
  - Succesfully update a coupon
  - Succesfully retrieves all coupons

Discount tests
========
  - Succesfully deletes a discount from a Customer
  - Succesfully deletes a discount from a Subscription

Invoice tests
========
  - Create an invoice and customer from a line item
  - Retrieve an Invoice
  - Retrieve an Invoice Expanded
  - Retrieve an Invoice's Line Items
  - Retrieve Invoices
  - Retrieve Invoices Expandable
  - Updates an Invoice
  - Retrieve an Upcoming Invoice
  - Pay an Invoice

Invoice item tests
========
  - Succesfully creates an invoice item
  - Succesfully retrieves an existing invoice item
  - Succesfully retrieves an existing invoice item expandable
  - Succesfully retrieves invoice items
  - Succesfully retrieves invoice items with expansion
  - Succesfully updates an existing invoice item
  - Succesfully deletes an invoice item

Dispute Tests
========
  - Creates a Dispute
  - Makes Dispute Under Review
  - Wins a Dispute
  - Loses a Dispute
  - Closes a Dispute

Transfer tests
========
  - Create a new transfer
  - Retrieves a transfer
  - Retrieves a transfer expandable
  - Retrieves transfers
  - Retrieves transfers expandable
  - Updates a transfer
  - Can't Cancel a committed transfer

Recipient tests
========
  - Succesfully creates an Individual Recipient
  - Succesfully creates a Corporation Recipient
  - Succesfully retrieves a Recipient
  - Succesfully retrieves a Recipient
  - Succesfully updates a Recipient
  - Succesfully deletes a Recipient

Application Fee tests
========
  - Succesfully fails to retrieve an unknown application fee
  - Succesfully retrieves all application fees

Application Fee Refund tests
========
  - Succesfully fails to refund an unknown application fee
  - Succesfully fails to retrieve a Application ID with an unknown Refund id
  - Succesfully fails to update an ApplicationRefund for an Invalid Fee ID
  - Succesfully fails to retrieve all ApplicationRefunds for an Invalid Fee ID

Account tests
========
  - Succesfully retrieves account information

Balance tests
========
  - Succesfully retrieves a Balance
  - Succesfully retrieves a Balance Transaction
  - Succesfully retrieves an Expanded Balance Transaction
  - Succesfully retrieves Balance Transaction History

Token tests
========
  - Can create a Card Token
  - Can create a Bank Account Token
  - Can retrieve an Existing Card Token
  - Can retrieve an Existing Bank Account Token

Event tests
========
  - Succesfully retrieves events

Finished in 195.9336 seconds
106 examples, 0 failures

repository: fieldstrength/stripe-haskell

gha_license_id: MIT

repo_name: fieldstrength/stripe-haskell


text:
# Interop + Factories
Instead of providing a module, a bundle, a bridge or similar framework integration `prooph/psr7-middleware` ships with
*interop factories*.

## Factory-Driven Middleware Creation

The concept behind these factories is simple but powerful. It allows us to provide you with bootstrapping logic for
the message buses without the need to rely on a specific framework. However, the factories have three requirements.

### Requirements

1. Your Inversion of Control container must implement the [interop-container interface](https://github.com/container-interop/container-interop).
2. [interop-config](https://github.com/sandrokeil/interop-config) must be installed
3. The application configuration should be registered with the service id `config` in the container.

*Note: Don't worry, if your environment doesn't provide the requirements. You can
always bootstrap a middleware by hand. Just look at the factories for inspiration in this case.*

## Customizing via Configuration

In the `config` folder of `prooph/psr7-middleware` you will find example configuration files.
Configuration is a simple PHP array flavored with some comments to help you understand the structure.

Now follow the simple steps below to integrate `prooph/psr7-middleware` in your framework and/or application.

1. Merge configuration into your application config either by hand or by using the mechanism of your framework.
2. Customize the configuration so that it meet your needs. The comments in the config file will tell you more.
3. (Only required if not done by your framework) Make your application config available as a service in the
Inversion of Control container. Use `config` as the service id (common id for application config).
4. Register the middleware as services in your IoC container and use the located in `src/Container` to create the different middleware.
How you can register a middlware depends on your container. Some containers like [zend-servicemanager](https://github.com/zendframework/zend-servicemanager)
or [pimple-interop](https://github.com/moufmouf/pimple-interop) allow you to map a service id to an `invokable factory`.
If you use such an IoC container you are lucky. In this case you can use the `prooph/psr7-middleware` factories as-is.
We recommend using `Prooph\Middleware\<CommandMiddleware/EventMiddleware/QueryMiddleware::class/MessageMiddleware::class` as service id.

*Note: If you're still unsure how to do it you might have a look at the `CommandMiddlewareFactoryTest` located in the `tests/Container` folder.

gha_language: PHP


text:
# API

API is under construction...

[Examples](examples.md)

## Globals

[Console](Console.md) - Write messages to terminal.

[Event](Event.md) - Create and handle events.

[Blocks](Blocks.md) - Manage in-game blocks.

## Objects

[Block](Block.md) - Represents an in-game block.

repository: rockyjvec/SpaceJS

gha_language: C#

repo_name: rockyjvec/SpaceJS


text:
# Bootstrap 4 template based on Webpack

### Installation

1. Execute command from root directory
```
npm install
```
2. Use '`app/index.html`' as home page
3. Edit '`src/js/index.js`' & '`src/scss/theme.scss`'
4. **Good luck!**

### Tasks

1. Build sources - ```npm run build```
2. Start file watcher for recompiling - ```npm run watch```
3. Start webpack dev server - ```npm run start```
4. Build sources for production - ```npm run production```


text:
# Optical-Character-Recognition
Optical Character Recognition

TRAINING:

Trained on two images training_chars.png and training_chars2.png.

Used the Tensorflow Inception model to train the data.

Steps:

To create training data,

python create_train_data.py

Arrange the data as required by the inception model.

To train on the created data(remember to copy-paste images to create more than 30 images for each class):

python train.py --bottleneck_dir=bottlenecks --how_many_training_steps=500 --model_dir=inception --summaries_dir=training_summaries/basic --output_graph=retrained_graph.pb --output_labels=retrained_labels.txt --image_dir=train

To test the data:

python test.py


text:
# Laravel ID Countries

[![Total Downloads](https://poser.pugx.org/ferdirn/laravel-id-countries/downloads.svg)](https://packagist.org/packages/ferdirn/laravel-id-countries)
[![Latest Stable Version](https://poser.pugx.org/ferdirn/laravel-id-countries/v/stable.svg)](https://packagist.org/packages/ferdirn/laravel-id-countries)
[![Latest Unstable Version](https://poser.pugx.org/ferdirn/laravel-id-countries/v/unstable.svg)](https://packagist.org/packages/ferdirn/laravel-id-countries)

Laravel ID Countries is a package for Laravel to supply all countries data to table countries including country name, iso country code, capital, currency, and calling code.

## Installation

Add `ferdirn/laravel-id-countries` to `composer.json`.

    "ferdirn/laravel-id-countries": "dev-master"

or in console type command

    composer require ferdirn/laravel-id-countries:dev-master

Run `composer update` to pull down the latest version of laravel packages.

Edit `app/config/app.php` file and add to `providers`

    'providers' => array(
        'Ferdirn\Countries\CountriesServiceProvider',
    )

also add to 'aliases'

    'aliases' => array(
        'Countries' => 'Ferdirn\Countries\CountriesFacade',
    )

## Model

If you want to edit the configuration then publish the config. This is an optional step and unrecommended to do, it will show the table name and you do not need to alter it if you do not know what you are doing. The default table name is `countries`, if it suits you, leave it. But if you know what you are doing, you can run the following command

    $ php artisan config:publish ferdirn/laravel-id-countries

Then you need to generate the migration file. Run the following command:

    $ php artisan countries:migration

This process will generate `<timestamp>_create_countries_table.php` migration file and a `CountriesSeeder.php` seed file.

Insert the following code in the `seeds/DatabaseSeeder.php`

    //Seed the countries
    $this->call('CountriesSeeder');
    $this->command->info('Seeded the countries!');

Finally, you can run the artisan migrate command with seed option to include the seed data:

    $ php artisan migrate --seed

Now you have a table 'countries' with all country data inside the table. Congratulation!

repository: ferdirn/laravel-id-countries

repo_name: ferdirn/laravel-id-countries


text:
# Arduino compatibility for Mongoose OS

This library provides a common Arduino compatibility layer, so that one could
pick an existing Arduino program, throw it into the Mongoose OS application
sources, and ideally, it "just works".

Currently, the following public headers are provided:

- `Arduino.h`
- `Print.h`
- `WString.h`
- `stdlib_noniso.h`

There are more specific Arduino-compatibility libraries available: for
[onewire](https://github.com/mongoose-os-libs/arduino-onewire),
[SPI](https://github.com/mongoose-os-libs/arduino-spi), etc.

repository: mongoose-os-libs/arduino-compat

gha_license_id: NOASSERTION

repo_name: mongoose-os-libs/arduino-compat


text:
# scheduler

## Required

- Docker
- Node.js v10+

## Install

Create docker image with mongo DB and install npm-libraries.

```
make install
```

## Run

Run import file and create emails one by one.

```
make run-all file="<path_to_file>" delimiter="|"
```

Field `delimiter` is optional. By default "|" is used, but you can use any of symbols for parsing .csv, .tsv or any data files.

### Or

Run scripts separatly.
1. Import file to database.
	 ```
	make import-file file="<path_to_file>" delimiter="|"
	 ```
2. Create emails and schedule them for sending.
	 ```
	make schedule-emails
	 ```

For starting tests use `npm test` command.
You can find all logs in `./logs/output.log` file. I've created comments inside the code. Probably, they should help you to check.


text:
# speechnotes-speech-recognizer
The speech recognition engine behind Speechnotes.

[Speechnotes](https://speechnotes.co) is an online dictation nontepad, and the code operating its core speech to text functionality is run through this code in this repository. The npm package has the same name.

What this engine does is basically wrap up the Webspeech-API with helper methods for easier integration into any website.

Currently, the webspeech api is supported only on the following browsers:
- Chrome

It has limited support, as it has to run a speech recognition engine, which is provided for free on Chrome by Google. Not yet provided by other companies (as of 2021-09-17)

branch_name: refs/heads/main


text:
# Data Expo 2009 - Airline on-time performance
## by (Mahmoud Lotfi)

## Dataset

- The data consists of flight arrival and departure details for all commercial flights within the USA, from October 1987 to April 2008.
- This is a large dataset: there are nearly 120 million records in total, and takes up 1.6 gigabytes of space compressed and 12 gigabytes when uncompressed.
- The data comes originally from RITA where it is described in detail.
- the data in bzipped csv file.
- These files have derivable variables removed, are packaged in yearly chunks and have been more heavily compressed than the originals.
- in this project we will discuss flight delay for 2008 data set
- Script locat

#### individual years:

1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008

#### This dataset is composed by the following variables:
01.	Year	           1987-2008
02.	Month	           1-12
03.	DayofMonth	       1-31
04.	DayOfWeek	       1 (Monday) - 7 (Sunday)

05.	DepTime	           actual departure time (local, hhmm)
06.	CRSDepTime	       scheduled departure time (local, hhmm)
07.	ArrTime	           actual arrival time (local, hhmm)
08.	CRSArrTime	       scheduled arrival time (local, hhmm)

09.	UniqueCarrier	   unique carrier code
10.	FlightNum	       flight number
11.	TailNum	           plane tail number: aircraft registration, unique aircraft identifier

12.	ActualElapsedTime  in minutes
13.	CRSElapsedTime	   in minutes
14.	AirTime	           in minutes

15.	ArrDelay	       arrival delay, in minutes: A flight is counted as "on time" if it operated less than 15 minutes later the scheduled time shown in the carriers' Computerized Reservations Systems (CRS).
16.	DepDelay	       departure delay, in minutes

17.	Origin	           origin IATA airport code
18.	Dest	           destination IATA airport code
19.	Distance	       in miles

20.	TaxiIn	           taxi in time, in minutes
21.	TaxiOut	           taxi out time in minutes

22.	Cancelled	       was the flight cancelled?
23.	CancellationCode   reason for cancellation (A = carrier, B = weather, C = NAS, D = security)
24.	Diverted	       1 = yes, 0 = no

25.	CarrierDelay	   in minutes:
    - Carrier delay is within the control of the air carrier.
    - Examples of occurrences that may determine carrier delay are:
        - aircraft cleaning, aircraft damage, awaiting the arrival of connecting passengers or crew,
        - baggage, bird strike, cargo loading, catering, computer, outage-carrier equipment,
        - crew legality (pilot or attendant rest), damage by hazardous goods, engineering inspection, fueling,
        - handling disabled passengers, late crew, lavatory servicing, maintenance, oversales,
        - potable water servicing, removal of unruly passenger, slow boarding or seating,
        - stowing carry-on baggage, weight and balance delays.
26.	WeatherDelay	   in minutes: Weather delay is caused by extreme or hazardous weather conditions that are forecasted or manifest themselves on point of departure, enroute, or on point of arrival.

27.	NASDelay	       in minutes: Delay that is within the control of the National Airspace System (NAS) may include: non-extreme weather conditions, airport operations, heavy traffic volume, air traffic control, etc.
28.	SecurityDelay	   in minutes:Security delay is caused by evacuation of a terminal or concourse, re-boarding of aircraft because of security breach, inoperative screening equipment and/or long lines in excess of 29 minutes at screening areas.
29.	LateAircraftDelay  in minutes: Arrival delay at an airport due to the late arrival of the same aircraft at a previous airport. The ripple effect of an earlier delay at downstream airports is referred to as delay propagation.

## Summary of Findings

### 01. Flights without cancellation nor divertion dataset:
#### What is the structure of your dataset?
> There are 6,851,832 flight observations with 26 features in 2008 without diverted/cancelled flights and missing or incorrect data.
#### What is/are the main feature(s) of interest in your dataset?
> Delayed flights in terms of carriers, origin & time.
#### What features in the dataset do you think will help support your investigation into your feature(s) of interest?
> ArrDelay, Month, DayOfWeek, DepTime, ArrTime, UniqueCarrier.
### 02. Flights that have been Cancellation:
#### What is the structure of your dataset?
> There are 137,434 flight observations with 12 features in 2008.
#### What is/are the main feature(s) of interest in your dataset?
 - what are the worstest airlines in terms of cancelled flighes?
 - what are the most cases of flights cancelled?
#### What features in the dataset do you think will help support your investigation into your feature(s) of interest?
> UniqueCarrier, CancellationCode

### 03. Flights that have been diverted:
#### What is the structure of your dataset?
> There are 17,265 flight observations with 12 features in 2008.
#### What is/are the main feature(s) of interest in your dataset?
> what are the Origin & Dest that have the most diverted flighes?
#### What features in the dataset do you think will help support your investigation into your feature(s) of interest?
> Origin & Dest.

## Key Insights for Presentation
### key findings:
01. Flights status distribution in 2008
02. Flight delay reasons and how much they contribute to the number of delayed flights
03. The worest day to travel.
04. Which Airlines have the longest delays?
05. What is the worst time of day to travel?

### insights :
01. It turn out most of flight arrive early , nearly 70%.
02. We also see that the weather is not the main reason for delays. Weather only contributes to 2% of the delays.
03. The wostest arrival time delay ocurr Tuesday for most of carriers
04. B6 had the worst for arrivals delay and the lowest departure delay, while AQ, HA and YV has the lowest arravial delay
05. unstable arrival delay between 12:00 AM to 05:00 AM, a huge crowd gathered between 05:00 AM to 06:00 AM

## How to Run the project:
- Insrt raw data download in __"./data/raw"__
- Run the script __"Communicate-Dtata-Finding\src\data\make_dataset.py"__
- Now you can find output data from script  __"Communicate-Dtata-Finding/data/interim/*.csv"__
- Run the notebook in __"Communicate-Dtata-Finding\notebooks\exploration.ipynb"__ to find __Exploratory data__
- Run the notebook in __"Communicate-Dtata-Finding\notebooks\explanatory.ipynb"__ to find __Explanatory data__

## Resources :
- [DataExpo2009](https://community.amstat.org/jointscsg-section/dataexpo/dataexpo2009)
- [Kaggle](https://www.kaggle.com/adveros/flight-delay-eda-exploratory-data-analysis)

repository: mlotfic/Communicate-Dtata-Finding

repo_name: mlotfic/Communicate-Dtata-Finding


text:
---
author: admin
comments: true
date: 2011-01-06 19:30:01+00:00
layout: post
slug: home-a-loan
title: 'Home: A Loan'
wordpress_id: 549
categories:
- The News
---

[Barry Ritholtz comments on a Massachusetts Supreme court case](http://www.ritholtz.com/blog/2011/01/can-banks-foreclose-on-mortgages-they-do-not-own/), where several homeowners have sued to void their foreclosures "because securitization-industry practices violate real-estate law governing how mortgages may be transferred."  He says:

> here are several issues in the case: The technical one is whether a mortgage can be transferred without naming the recipient, as is commonly done in securitizations. But the more important issue applies to mortgage rights — do they “detach” from the promissory note when that note is sold? Asked more plainly, _must someone asserting the right to foreclose actually own that Note_?
>
> This is more than a technical issue; at risk is whether we, as a nation, are going to allow corporate entities to violate existing law, or even worse, attempt to create their own, extra-legal, non democratic policies.

I usually find sweeping statements like that more irritating than inspiring, but Ritholtz is too educated to ignore. And the consequences are pretty straightforward: Wells Fargo foreclosed on Mr. and Mrs. Larace's house 10 months before the bank owned the mortgage. There are more sketchy details in [the original Bloomberg story](http://www.bloomberg.com/news/2011-01-06/foreclosures-may-be-undone-by-massachusetts-ruling-on-mortgage-transfers.html), but this case is pretty binary, like Ritholtz says; either banks get to break the law and take your stuff, or they don't.

repository: dominicmauro/blogipsa

extension: markdown

gha_language: SCSS

repo_name: dominicmauro/blogipsa


text:
# Get Programming with JavaScript

## Part 1 – Core concepts on the console

### Chapter 1 – Programming, JavaScript and JS Bin
* 1.1 Programming
* 1.2 JavaScript
* 1.3 Learning by doing and thinking
* 1.4 JS Bin
* 1.5 A text adventure: our running example
* 1.6 Further examples and practice

### Chapter 2 – Variables: storing data in your program
* 2.1 What is a variable?
* 2.2 Declaring variables and assigning values
* 2.3 Variable names
* 2.4 The Crypt - player variables

### Chapter 3 – Objects: a way to group data
* 3.1 A need for organization
* 3.2 Creating objects
* 3.3 Accessing object properties
* 3.4 Updating object properties
* 3.5 Further examples
* 3.6 The Crypt - a player object

### Chapter 4 – Functions: code on demand
* 4.1 Noticing repetition
* 4.2 Defining and calling functions
* 4.3 Reducing repetition
* 4.4 Making code easier to read and update
* 4.5 The Crypt - displaying player information

### Chapter 5 – Arguments: passing data to functions
* 5.1 Function reuse and versatility
* 5.2 Passing information to functions
* 5.3 The Crypt - displaying player information

### Chapter 6 - Return values: getting data from functions
* 6.1 Returning data from functions
* 6.2 Experimenting at the console prompt
* 6.3 The Crypt - building player information strings

### Chapter 7 - Object arguments: functions working with objects
* 7.1 Using objects as arguments
* 7.2 Returning objects from functions
* 7.3 Methods: setting functions as properties of objects
* 7.4 The Crypt - player objects as arguments

### Chapter 8 – Arrays: putting data into lists
* 8.1 Creating arrays and accessing elements
* 8.2 Array methods
* 8.3 The Crypt - a player items array

### Chapter 9 – Constructors: building objects with functions
* 9.1 Creating similar objects with a function
* 9.2 Constructor functions, this and new
* 9.3 Two examples of constructors
* 9.4 The Crypt - places to explore

### Chapter 10 – Bracket notation: flexible property names
* 10.1 Square brackets instead of dots
* 10.2 The Crypt - exit names
* 10.3 The Crypt - players and places

## Part 2 – Organizing our programs

### Chapter 11 – Scope: hiding information
* 11.1 The dangers of global variables
* 11.2 The benefits of local variables
* 11.3 Interfaces – controlling access and providing functionality
* 11.4 Creating a quick quiz app
* 11.5 The Crypt - hiding player info
* 11.6 The Crypt - hiding place info
* 11.7 The Crypt - user interaction

### Chapter 12 – Conditions: choosing code to run
* 12.1 Conditional execution of code
* 12.2 Generating random numbers with Math.random()
* 12.3 Further conditions with else if
* 12.4 Checking answers in the quiz app
* 12.5 The Crypt - checking user input

### Chapter 13 – Modules: breaking a program into pieces
* 13.1 Importing scripts on JS Bin
* 13.2 The spacer namespace
* 13.3 Collisions – when imported code overwrites your variables
* 13.4 Immediately invoked function expressions (IIFE)
* 13.5 Separating data from the view
* 13.6 The Crypt - separating map data from the game

### Chapter 14 – The Crypt: linking models and views with a controller
* 14.1 Creating models and views for players
* 14.2 Creating models and views for places
* 14.3 Talking to players - a message view
* 14.4 A game controller
* 14.5 Running the game

### Chapter 15 - Updates: making changes without breaking existing code
* 15.1 Challenges

## Part 3 - JavaScript in the browser

### Chapter 16 - HTML: building web pages
* 16.1 HTML - a very short introduction
* 16.2 Adding content to a web page with JavaScript
* 16.3 Displaying data from an array
* 16.4 The Crypt - displaying players and places with web views

### Chapter 17 - Events: text boxes and buttons
* 17.1 Buttons - responding to clicks
* 17.2 User input with text boxes
* 17.3 The Crypt - player commands via a text box

### Chapter 18 – Templates: replacing placeholders with data
* 18.1 Replacing one string with another
* 18.2 While loops - replacing a string multiple times
* 18.3 Simple templates
* 18.4 A template constructor
* 18.5 Keeping templates with the HTML
* 18.6 The Crypt - improving the views

### Chapter 19 - XHR: loading data
* 19.1 Loading web pages - clients and servers
* 19.2 Requesting data with the XMLHttpRequest object
* 19.3 JSON - a simple data format
* 19.4 Building a calendar widget with templates and xhr
* 19.5 The Crypt - loading a map on demand

### Chapter 20 - Get programming with JavaScript
* 20.1 Working locally with files
* 20.2 Getting help
* 20.3 What next?

## Part 4 – The server, Node, Express and Socket.io (online extras)

### Chapter 21 – Building an API with Node and Express
* 21.1 JavaScript on the server
* 21.2 Installing Node and using npm
* 21.3 Modules and require
* 21.4 Express
* 21.5 Loading our map JSON files and responding to API requests
* 21.6 Saving game state on the server

### Chapter 22 – Real-time messaging with Socket.io
* 22.1 Real-time updates
* 22.2 Using socket.io on the server and the browser
* 22.3 Sending and receiving game messages
* 22.4 Bumping into other characters
* 22.5 Swapping items

repository: ccmanuelf/GetProgramming

repo_name: ccmanuelf/GetProgramming


text:
# Junit Tips

# @BeforeClass Bhavior
1. If all test parents & child has same name method, only chid method will be active

![Child Overrid](./Images/sameNameMethod.JPG)

2. if all method names are different but all are @BeforeClass , it will be parent => child

![parent-child](./Images/differentMetohdNames.JPG)


text:
## Introduction
An effective lexical analysis platform by DUT-NLP Lab. The code is easy to use.

DUT-Nihao is an open-source toolkit for Chinese lexical analyzer developed by the Natural Language Processing Lab at Dalian University of Technology.

## Demo

We will update this module in the future. (The domain name has not been set.)

## Requirement

For the current release of DUT-Nihao, the requirement of code is limited. We will revise the code to support other versions of pip-packages in the future. If you have any questions, please contact [us](#jumpcontact).

```shell
python:3.5.0 # A higher version is available (e.g., 3.7.0)
pyTorch:1.2.0 # A higher version is available (e.g., 1.4.0;1.7.0)
pytorch_pretrained_bert:0.6.2 # A higher version is available
```

Due to the size of the pre-trained model (PTM), it must be downloaded by yourself.

The [link](https://github.com/ymcui/Chinese-BERT-wwm) is available, and please choose the `pytorch` version. Note that the PTM is unofficial and you can use it freely. You need cite the work that the [github](https://github.com/ymcui/Chinese-BERT-wwm) introduced. For convince, we are willing to open the PTM by ourselves. If you're also interested in PTM, please contact me ([kaiyuhuang@mail.dlut.edu.cn](mailto:kaiyuhuang@mail.dlut.edu.cn)).

## Workflow

> DUT-Nihao supports single-criterion and multiple-criteria Chinese word segmentation. Due to the specific adaptation, there is a little difference between `single` and `multiple` module. And all files must be **utf-8** code.
> > - Input format:
> >
> >   Each word is split with a blank character (you can check the format in `data/example/single-train.utf8`).
> >
> >   大连 理工 大学 坐落 于 美丽 的 大连 。
> >
> >   Each word is split with a blank character and a specific tag is added at the beginning of each sentence. (you can check the format in `data/example/multiple-train.utf8`).
> >
> >   pku<@@>大连 理工 大学 坐落 于 美丽 的 大连 。
> >
> >   msr<@@>大连理工大学 坐落 于 美丽 的 大连 。
> >
> >   The **dev and test** data have **non-blank** characters, which is different from the format of training data.
> >
> >   e.g. (you can check the format in `data/example/single-test.utf8` and `data/example/multiple-test.utf8`).
> >
> >   single: 大连理工大学坐落于美丽的大连。
> >
> >   multiple: pku<@@>大连理工大学坐落于美丽的大连。
> >
> >   For convenience, we supply a script for processing the Input file (e.g., whole width to half width, characters generalization). It can convert the sentence into specific format. The script is easy to use without any pip-packages.
> >
> >   > ```shell
> >   > # convert train data to half-width and generalization format
> >   > python utils.py -f p-train -i input_file -o output_file
> >   >
> >   > # convert dev/test data to half-width and generalization format
> >   > python utils.py -f p-test -i input_file -o output_file
> >   >
> >   > # add specific tag (e.g., pku,msr,ctb...) into train/dev/test data
> >   > python utils.py -f add-tag -c tag_name -i input_file -o output_file
> >   > ```
> >   >
>
>
>> - For training and testing, use the command line `python main.py -c config`. Training and testing details will be printed on the screen. `config` is the configuration of DUT-Nihao. All settings are in the configuration file. The meaning of each parameter is introduced in brief.
> >
> >   > ```shell
> >   > # is the annotation character
> >   > mode = (train/multi-train/test/multi-test)
> >   > load_file = (the path of training or testing file)
> >   > ...
> >   > ```
> >   >
> > - For post-editing, if you convert your personal file into specific format, we will also supply an auto post-editing code for recovering the half-width and generalization. The `original_file` (example/test.data) represents the original dev/test data.
> >
> >   > ```shell
> >   > python utils.py -f post -io original_file -i segmentation_file -o output_file
> >   > ```
> >   >

## License

The source code is dual licensed. Open source licensing is under the [BSD-3-Clause](https://opensource.org/licenses/BSD-3-Clause), which allows free use for research purposes. For commercial licensing, please email [kaiyuhuang@mail.dlut.edu.cn](mailto:kaiyuhuang@mail.dlut.edu.cn).

## Citation

Please cite the following paper:

> Kaiyu Huang, Degen Huang, Zhuang Liu, Fengran Mo. [A Joint Multiple Criteria Model in Transfer Learning for Cross-domain Chinese Word Segmentation](https://www.aclweb.org/anthology/2020.emnlp-main.318/). EMNLP 2020.

## Development Team

Project leaders: [Degen Huang](http://faculty.dlut.edu.cn/dlut_nlp/zh_CN/index.htm)

Project members:

Chinese word segmentation: Kaiyu Huang, Hao Yu, Wei Liu, Meng Sun

Machine Translation: Junpeng Liu, Yiming Zhang, Huan Liu

## Contact

Contact us. If you have questions, suggestions and bug reports, please email [kaiyuhuang<EMAIL_ADDRESS>or the email of each project member.

## Logs

It is the first release of DUT-Nihao with only Chinese word segmentation module (update on Dec. 2020)

repository: koukaiu/dlut-nihao

repo_name: koukaiu/dlut-nihao


text:
# Kaladin meets Highmarshal Azure
Kaladin met and joined the Wall Guard and was introduced to Highmarshal Azure.

## Details
While investigating the city of Kholinar, Kaladin found himself joining the city's Wall Guard, where he had the opportunity to meet Highmarshal Azure.

## Metadata
| Field | Value |
| ----- | ----- |
| chapter | *Oathbringer* Ch. 70 |

repository: jofwu/roshar-map

repo_name: jofwu/roshar-map


text:
# REAPER 1.0

A retro combat flight simulator for the MQ-9 Reaper military drone playable in the browser. The art style is inspired by classic 90s games like A-10 Attack! (1995) and SU-27 Flanker (1995).

### Links

https://answers.unity.com/questions/696271/how-create-modern-aircrafts-hud.html
https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript

### Inspiration

https://www.mobygames.com/game/macintosh/a-10-attack
https://www.mobygames.com/game/windows/a-10-cuba
https://www.mobygames.com/game/dos/falcon-30
https://www.mobygames.com/game/tfx

repository: raschiiii/reaper

repo_name: raschiiii/reaper


text:
Sample library using the Lua libary template
=========================
Module has a single function 'type()' that is identical to the regular Lua type() function, except that it returns a second value in case of a userdata; its metatable name.

The first time a metatable is searched for it will be searched for in the registry, once collected it will be stored in a proxy table for quicker retrieval the next time it is requested.

LICENSE
-------
Copyright 2012-2014, Thijs Schreijer. License is MIT/X11, the same as Lua itself

Example
-------
see test and sample Lua scripts.

gha_language: C


text:
# Password-Generator-
The best thing about creating our own password generator is that we can customize it as we like.

First, we will create a password generator that asks the length of the password and generates a random password containing digits, alphabets, and special characters.

Next, we will improve it by asking the number of each type of character, like the number of digits, alphabets, and special characters.

So, without further ado, let’s see the steps to create a password generator using Python.
Store all the characters as a list. We can use the string module of Python or type all of them.
Ask the user to enter the length of the password.
Shuffle the characters using the random.shuffle method.
Initialize an empty list to store the password.
Write a loop that iterates length times.
Pick a random character from all the characters using the random.choice method.
Append the random character to the password.
Shuffle the resultant password list to make it more random.
Convert the password list to string using the join method.
Print the password.
Follow the above steps and try to write code. Don’t worry, even if you are not able to write the code. Check out the code below.

repository: SJISTIC-LTD/Password-Generator-

repo_name: SJISTIC-LTD/Password-Generator-