text:
# pyHexBattle

# Memoir'44 Notes

These notes assume you have already read the main `README` file.

## Optional Downloads

For better display, download and install fonts that closely match the originals:

*   [Army](https://fonts2u.com/army.font)
*   [Gunplay](https://www.dafont.com/gunplay.font)

## A Memoir'44 Scenario File

**pyHexBattle** will allow you to create an output for a scenario that looks like the following (note the image has been rescaled to 30% of its original size):

![Hill102](battle.jpg)

The XML files that store the information for scenarios are the heart of **pyHexBattle**. An example scenario file looks this:

    <?xml version="1.0"?>
    <hbml:hexbattle
      id="hill102"
      type="memoir44"
      version="1.1"
      xmlns:hbml="http://www.daysofwonder.com/memoir44/"
      >

      <hbml:meta>
        <hbml:designer id="jw">
          <hbml:name>joewargamer</hbml:name>
          <hbml:email></hbml:email>
          <hbml:website>http://www.boardgamegeek.com/</hbml:website>
        </hbml:designer>
      </hbml:meta>

      <hbml:scenario status="draft" version="1">
        <hbml:name>Hill 102</hbml:name>
        <hbml:alternate></hbml:alternate>
        <hbml:title>(First Day)</hbml:title>
        <hbml:date year="1944" month="6" day="26"/>
        <hbml:period></hbml:period>
        <hbml:location>
          <hbml:country>France</hbml:country>
        </hbml:location>
        <hbml:description>
          Allied and German forces clash at Hill 102 near tributaries of the Loire.
        </hbml:description>
      </hbml:scenario>

      <hbml:terrain background="standard">
        <hbml:hex id="4" row="4" col="3" type="terrain" style="hill"></hbml:hex>
        <hbml:hex id="5" row="4" col="4" type="terrain" style="hill">Hill 102</hbml:hex>
        <hbml:hex id="10" row="7" col="12" type="terrain" style="river_straight" face="5">R. Moux</hbml:hex>
        <hbml:hex id="11" row="7" col="13" type="terrain" style="river_straight" face="2"></hbml:hex>
        <hbml:hex id="22" row="4" col="1" type="terrain" style="town">Poin Le Croix</hbml:hex>
        <hbml:hex id="25" row="2" col="6" type="marker" style="bridge" face="1"></hbml:hex>
        <hbml:hex id="26" row="9" col="10" type="marker" style="allied_wire"></hbml:hex>
        <hbml:hex id="27" row="9" col="11" type="marker" style="allied_hedgehog"></hbml:hex>
        <hbml:hex id="29" row="4" col="2" type="medal" style="allied_medal"></hbml:hex>
        <hbml:hex id="30" row="2" col="8" type="medal" style="german_medal"></hbml:hex>
      </hbml:terrain>

      <hbml:forces>

        <hbml:force id="ger" type="german" name="German">
          <hbml:unit id="XT01" type="armour"  row="4" col="2"></hbml:unit>
          <hbml:unit id="XI01" type="infantry" row="2" col="4"></hbml:unit>
          <hbml:unit id="XI02" type="infantry" row="4" col="3"></hbml:unit>
          <hbml:unit id="XA01" type="artillery" row="4" col="9"></hbml:unit>
          <hbml:unit id="XA02" type="artillery" row="5" col="4"></hbml:unit>
          <hbml:special>
            <hbml:instructions>
              <hbml:p>Take 5 command cards.</hbml:p>
              <hbml:p>You move last.</hbml:p>
            </hbml:instructions>
          </hbml:special>
        </hbml:force>

        <hbml:force id="all" type="allied" name="Allied">
          <hbml:unit id="AI01" type="infantry" row="1" col="3"></hbml:unit>
          <hbml:unit id="AI02" type="infantry" row="1" col="11"></hbml:unit>
          <hbml:unit id="AI03" type="infantry" row="5" col="1"></hbml:unit>
          <hbml:unit id="AI04" type="infantry" row="6" col="1"></hbml:unit>
          <hbml:unit id="AI05" type="infantry" row="8" col="2"></hbml:unit>
          <hbml:unit id="AI06" type="infantry" row="9" col="3"></hbml:unit>
          <hbml:unit id="AA01" type="artillery" row="1" col="12"></hbml:unit>
          <hbml:unit id="AA02" type="artillery" row="7" col="2"></hbml:unit>
          <hbml:special>
            <hbml:instructions>
              <hbml:p>Take 4 command cards.</hbml:p>
              <hbml:p>You move first.</hbml:p>
              <hbml:p>Take 2 special cards.</hbml:p>
              <hbml:p></hbml:p>
            </hbml:instructions>
          </hbml:special>
        </hbml:force>

      </hbml:forces>

      <hbml:notes>
        <hbml:note id="s" type="special">
          <hbml:p>Hill 102 is worth one medal towards victory to the  side in
          sole possession of the hill hexes.  No medal is earned if both sides
          occupy the hill at the game end.  Hill 102 is worth one medal towards
          victory to the  side in sole possession of the hill hexes.  No medal
          is earned if both sides occupy the hill at the game end.
          Rivers are crossable at any hex adjacent to a town.
    </hbml:p>
        </hbml:note>
        <hbml:note id="h" type="historical">
          <hbml:p>It's June 1944: the Allies are poised to invade Hitler's
          "Fortress Europe". The focal point of their attention is the beaches
          of Normandy, France.  Nearly a month of landing, attack and counter-
          attack battles are being fought in the French countryside.  This is
          one such battle...</hbml:p>
        </hbml:note>
        <hbml:note id="v" type="victory">
          <hbml:p>Any allied unit occupying a town will count as one medal
          towards victory. Any German unit occupying the bridge will count as
          one medal towards victory.</hbml:p>
        </hbml:note>
      </hbml:notes>

    </hbml:hexbattle>

A section-by-section explanation of this file now follows.

### Header Information

    <?xml version="1.0"?>
    <hbml:hexbattle
      id="hill102"
      type="memoir44"
      version="1.1"
      xmlns:hbml="http://www.daysofwonder.com/memoir44/"
      >

This section is the 'standard' header for an XML file - the only thing that will need to change will be the "id"; this is typically the name of the battle (in lowercase), and should be unique across all battles. For multi-day, or more complex, battles, a longer name might be required e.g. **arnhem-bridge-day1**. The `hbml:` is a prefix which appears in all subsequent tags; it is linked to a unique identifier for this type of XML file that distinguishes it from any other XML file.

### Meta Information

    <hbml:meta>
        <hbml:designer id="jw">
          <hbml:name>joewargamer</hbml:name>
          <hbml:email></hbml:email>
          <hbml:website>http://www.boardgamegeek.com/</hbml:website>
        </hbml:designer>
    </hbml:meta>
This section contains information on the `<designer>` of the scenario (the person's `<name>` and `<email>` and `<website>`) and which `<version>` of the scenario this particular file represents.

### Scenario Information

    <hbml:scenario status="draft" version="1">
        <hbml:name>Hill 102</hbml:name>
        <hbml:alternate></hbml:alternate>
        <hbml:title>(First Day)</hbml:title>
        <hbml:date year="1944" month="6" day="26"/>
        <hbml:period></hbml:period>
        <hbml:location>
          <hbml:country>France</hbml:country>
        </hbml:location>
        <hbml:description>
          Allied and German forces clash at Hill 102 near tributaries of the Loire.
        </hbml:description>
    </hbml:scenario>

This section contains details about the actual battle being represented. The attributes of 'status' can be "draft", "test" or "final", while 'version' is used to indicate earlier and later version that an author may want to track.

The `<name>` is the one conventionally assigned to the battle, while the `<alternate>` lists any other name(s) by which the battle is commonly referred to. The `<title>` is only used when a portion of the battle is being represented by the scenario (as might be the case for larger or longer battle). The `<date>` is when the battle was fought. The `<period>` is used when only a given day of the battle is being simulated. The `<hbml:description>` is brief synopsis of the battle that took place.

The `<location>` is usually the name of the country or area in which the battle took place. Typical names for locations of European battles would be France, Germany, Belgium, Italy or Russia.

### Terrain and Marker Information

    <hbml:terrain background="standard">
        <hbml:hex id="4" row="4" col="3" type="terrain" style="hill"></hbml:hex>
        <hbml:hex id="5" row="4" col="4" type="terrain" style="hill">Hill 102</hbml:hex>
        <hbml:hex id="10" row="7" col="12" type="terrain" style="river_straight" face="5">R. Moux</hbml:hex>
        <hbml:hex id="11" row="7" col="13" type="terrain" style="river_straight" face="2"></hbml:hex>
        <hbml:hex id="22" row="4" col="1" type="terrain" style="town">Poin Le Croix</hbml:hex>
        <hbml:hex id="25" row="2" col="6" type="marker" style="bridge" face="1"></hbml:hex>
        <hbml:hex id="26" row="9" col="10" type="marker" style="allied_wire"></hbml:hex>
        <hbml:hex id="27" row="9" col="11" type="marker" style="allied_hedgehog"></hbml:hex>
        <hbml:hex id="29" row="4" col="2" type="medal" style="allied_medal"></hbml:hex>
        <hbml:hex id="30" row="2" col="8" type="medal" style="german_medal"></hbml:hex>
    </hbml:terrain>

This section contains a `<hex>` entry for each piece of terrain, obstacle or medal (and other map marking pertinent to the scenario) that appears on the board. Each `<hex>` entry contains:

*  **row**s are numbered from "1" to "9" (starting at the 'top' of the board)
*  **col**umns are numbered from "1" to "13" (starting at the 'left' of the board)
*  **type** is one of: "terrain", "marker" or "medal":

   * for "terrain" type hexes, a **style** property is required to identify which specific terrain is displayed and, in some cases, a **face** property is used as well (to indicate direction). This is a value from 1 to 6 - a "1" indicating a facing to the top hex-point or "north east" hexside. See also the full [Terrain Tile Set](#tileset) list.
   * for "marker" types of hexes, a **style** property is required to identify which specific marker is used. See also the full [Terrain Tile Set](#tileset) list.
   * for "medal" types of hexes, a **style** property is required to identify which specific medal is used. See also the full [Terrain Tile Set](#tileset) list.

In addition, the name of the terrain feature (hill, buildings, wood, river and so on), or other notation can be supplied e.g. 'Poin Le Croix' for a town/river label.

**Tip:** In the case where one type of terrain feature has to overlay another - such as is the case for Sandbag placed on, say, a Hill - the overlying terrain `<hex>` entry should occur **after** (below) the entry for the base terrain. All "obstacle" hexes are also usually placed near the end, followed by "medal" hexes, as they typically provide additional annotation that must appear 'over' the underlying terrain.

### Forces Information

    <hbml:forces>

        <hbml:force id="ger" type="german" name="German">
        ...
          <hbml:special>
            <hbml:instructions>
              <hbml:p>Take 5 command cards.</hbml:p>
              <hbml:p>You move last.</hbml:p>
            </hbml:instructions>
          </hbml:special>
        </hbml:force>
        ...
    </hbml:forces>

This section contains information on the opposing sides in the battle. There will be one `<force>` section for each side. Each `<force>` entry identifies the force:

*   **id** is a unique identifier for each force (the defaults of "ger" for German, or "all" for Allied can be used)
*   **type** _must_ be either "allied" or "german" (this key information is used, for example, to identify corresponding image files)
*   **name** is used for display purposes

Each section also contains detailed force information (see below) as well as `<special>` information applicable to it. This is an `<instructions>` set, such as who it is that starts first.

### Units Information

    <hbml:unit id="XT01" type="armour"  row="4" col="2"></hbml:unit>
    <hbml:unit id="XI01" type="infantry" row="2" col="4"></hbml:unit>
    <hbml:unit id="XI02" type="infantry" row="4" col="3"></hbml:unit>
    <hbml:unit id="XA01" type="artillery" row="4" col="9"></hbml:unit>
    <hbml:unit id="XA02" type="artillery" row="5" col="4"></hbml:unit>

This section contains the detailed breakdown of a side's playing pieces (units). Each `<unit>` has associated details on:

*  **id** is a unique identifier for each unit in the nbattle; the suggested notation to be used is a four letter code:
   *   A or X - for Allied or Axis (German)
   *   I, T or A - for infantry, armour (tanks) or artillery
   *   A two-digit number (from 01 upwards...)
*  **type** must be one of "infantry", "armour" or "artillery"
*  **row**s are numbered from "1" to "9" (starting at the 'top' of the board)
*  **col**umns are numbered from "1" to "13" (starting at the 'left' of the board)

### Notes Section

    <hbml:notes>
      <hbml:note id="s" type="special">
        <hbml:p>Hill 102 is worth one medal towards victory to the  side in
          sole possession of the hill hexes.  No medal is earned if both sides
          occupy the hill at the game end.  Hill 102 is worth one medal towards
          victory to the  side in sole possession of the hill hexes.  No medal
          is earned if both sides occupy the hill at the game end.
          Rivers are crossable at any hex adjacent to a town.</hbml:p>
      </hbml:note>
      <hbml:note id="h" type="historical">
        <hbml:p>It's June 1944: the Allies are poised to invade Hitler's
          "Fortress Europe". The focal point of their attention is the beaches
          of Normandy, France.  Nearly a month of landing, attack and counter-
          attack battles are being fought in the French countryside.  This is
          one such battle...</hbml:p>
      </hbml:note>
      <hbml:note id="v" type="victory">
        <hbml:p>Any allied unit occupying a town will count as one medal
          towards victory. Any German unit occupying the bridge will count as
          one medal towards victory.</hbml:p>
      </hbml:note>
    </hbml:notes>

This section can contain three different types of notes. Typically, there will be a `<note>` for "special" rules, as indicated by the "special" type; one for "historical" rules and one for "victory" conditions. Each note can contain a `<p>`aragraph.

## The XSL "Map Making" Files

A number of XSL (stylesheet) files, each containing different instructions for processing any scenario XML file, are supplied in the `styles` directory.

*   The `battle2colorSVG.xsl` file will, when processed in conjunction with a scenario XML file, create a map layout in SVG, very similar to the conventional layout in the official scenarios.
*   The `battle2text.xsl` file will, when processed in conjunction with a scenario XML file, create a text file, that reproduces the key elements of the scenario in a simple text file, using a hex-numbering scheme to identify locations of forces and terrain.
*   The `battle2HTML.xsl` file will, when processed in conjunction with a scenario XML file, extract some of the key elements of the scenario into a simple HTML file, excluding map layout.
*   The `battle2bwSVG.xsl` file will, when processed in conjunction with a scenario XML file, create a simple map layout in SVG, using markers and standard symbology for units.

## Memoir'44 Resources

*   [Days of Wonder](http://www.daysofwonder.com/) maintains the [official web site](http://www.memoir44.com)
*   [The BoardGameGeek](http://www.boardgamegeek.com/) has reviews and resources for [Memoir'44](http://www.boardgamegeek.com/viewitem.php3?gameid=10630)

## Terrain and Marker Tile Set

This table summarises all the different types of terrain that can be referenced in an XML scenario file.

| Tile                            | Name     | Tile                                        | Name           |
|---------------------------------|----------|---------------------------------------------|----------------|
| ![woods](tiles/woods.png)       | woods    | ![hill](tiles/hill.png)                     | hill           |
| ![hedgerow](tiles/hedgerow.png) | hedgerow | ![river_straight](tiles/river_straight.png) | river_straight |
| ![lake](tiles/lake.png)         | lake     | ![river_curve](tiles/river_curve.png)       | river_curve    |
| ![beach](tiles/beach.png)       | beach    | ![waves](tiles/waves.png)                   | waves          |
| ![town](tiles/town.png)         | town     | ![bunker](pieces/bunker.png)                | bunker         |
| ![village](tiles/village.png)   |village   | ![bridge](pieces/bridge.png)                | bridge         |

## Other Game Pieces

This table summarises the different types of game pieces (apart from terrain) that can be referenced in an XML scenario file.

| Piece                                         | Name           | Piece                                          | Name            |
|-----------------------------------------------|----------------|------------------------------------------------|-----------------|
| ![allied_wire](pieces/allied_wire.png)        | allied_wire    | ![allied_hedgehog](pieces/allied_hedgehog.png) | allied_hedgehog |
| ![allied_sandbag](pieces/allied_sandbag.png)  | allied_sandbag |                                                |                 |
| ![german_wire](pieces/german_wire.png)        | german_wire    | ![german_hedgehog](pieces/german_hedgehog.png) | german_hedgehog |
| ![german_sandbag](pieces/german_sandbag.png)  | german_sandbag |                                                |                 |
| ![allied_medal](pieces/allied_medal.png)      | allied_medal   | ![allied_airborne](pieces/br_airborne.png)     | allied_airborne |
| ![german_medal](pieces/german_medal.png)      | german_medal   | ![german_special](pieces/ger_special.png)      | german_special  |

repository: gamesbook/pyHexBattle

repo_name: gamesbook/pyHexBattle


text:
# Heterogeneous Mini-Graph Neural Network and Its Application to Fraud Invitation Detection

```
@inproceedings{hmgnn_icdm20,
author = {Yong-Nan Zhu and Xiaotian Luo and Yu-Feng Li and Bin Bu and Kaibo Zhou and Wenbin Zhang and Mingfan Lu},
title = {Heterogeneous Mini-Graph Neural Network and Its Application to Fraud Invitation Detection},
booktitle = {{IEEE} International Conference on Data Mining (ICDM)},
year = {2020}
}
```

links
- [preprint](https://cs.nju.edu.cn/liyf/paper/icdm20-hmgnn.pdf)

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
---
layout: post
title:  "Stand ups are precious"
date:   2020-06-15 00:01:21
categories: stand-ups mastering-agile-ceremonies
permalink: stand-ups
published: true
---
Stand up meetings are famous for a simple 'today and yesterday' format that should be done in just 15 minutes. So it would appear simple to master - right?

Mastery isn't about being able to parrot out a ritual. It's about teaching a team how to have conversations at a responsible moment.

To make stand ups a habit you should help a team to:

* recognise when they need to talk
* have the right conversation
* realise the benefit of having it

To do this effectively, you must not be focussed on following the rules of a stand up - instead it’s about knowing how and when to change them.

## What are the rules of stand up?
### 1. Be short and regular
The type of conversation you see during stand ups can and should happen whenever they’re needed. Don’t just practice them during the same 15 minute slot once a day.

These conversations are not a meeting, so don’t treat them like one. Start by giving people the rules, tools and etiquette needed to carry them out well.

These could be:

* some agreed rules for working together (like the today /yesterday format)
* a check that you have the right people involved
* the tools that people need (like a Kanban board to look at)

### 2. Help people be clear about the right thing to do right now
Stand ups are not a status report, you should have other information radiators that do this job. Beware the people who use them as such.

Keep conversations relevant and focussed on the tactics needed for a group of people to achieve an outcome. Notice if that does not happen and make an observation. If it still keeps happening, give constructive feedback afterwards.

### 3. Be at the last responsible moment
There’s little point putting energy into the next most important thing. Do what’s important now and deliver it.

The more that you learn to do this, the more that you learn to respond to change over follow a plan.

So think of stand ups as being about how a team understands its context right now and the things it needs to do based on what people have just learnt about a given situation.

### 4. Make a commitment to help each other
Teach people to listen and respond to each other. This practice will help you notice and respond to peoples commitments. You might notice things like:

* someone giving the same update a few days in a row
* surprises or :tada: moments
* a task not getting done after it was committed to

In my experience this can easily go left unsaid, even if it’s obvious. This is only natural, and it's nobody’s fault, we build teams around a belief that everyone does their best, so it’s awkward and unnatural to call this out. It’s your job as a delivery manager to make this visible and do it with kindness. Often until things are said, nothing can be done. (Unless you employ a mind reader).

Teach the team to notice the invisible and make it visible, only then can they inspect and adapt.

### 5. Delivery people should be self destructive
You should want teams to not need a delivery manager.

You're not supposed to solve every blocker. Just the ones that remove focus, or would take someone in an unhelpful or random direction.

That doesn’t make us useless. We’re really not.

We have an important role to help build good habits of effectual tactical conversations. To do that you need to know what to notice, when give feedback and how to make experiments.

## Notice things
To really notice things, you need remove yourself from the equation so that you can look at the whole.

Stand outside of the group and use silence as your tool of choice:

* body language
* energy
* language
* alignment to a goal
* a sense of togetherness
* the physical space people use
* eye contact

Your measure of success is to look for a group of people who leave a conversation energised and enthused about getting something of value done.

## Give feedback and make observations
Feedback and observations are two subtly different things.

An observation is just a statement grounded on something that you've seen. Be specific and precise.

Feedback is a statement grounded on opinion and is usually best given if you are personally affected by a something.

If your making an observation do that, don't confuse it with feedback. If you do, your message will be confusing.

## Make experiments
You are an expert in agile methods, so you are well placed to offer ideas and small experiments to the team along with your hypothesis

Explain your thinking and get the explicit permission from the group to try it.

## Whatever you do, lead by example
You don’t really teach people to do these three things, it’s all about your leadership. Lead by example, bring your full self to any situation and make your best effort.

extension: markdown

gha_language: CSS

gha_license_id: MIT


text:
# Go Command Line Urban Dictionary
Just a basic go command line example that find a definition of a word from Urban Dictionary API and displays the first result to the user.

`	url := fmt.Sprintf("http://api.urbandictionary.com/v0/define?term=%s", *wordPtr)`

## Start
```
➜  go-command-line-urban-dictionary git:(master) ✗ go build .
➜  go-command-line-urban-dictionary git:(master) ✗ ./go-command-line-urban-dictionary -h
Usage of ./go-command-line-urban-dictionary:
  -word string
        a string (default "foo")
```
use the `-word` flag to pass in the word
```
➜  go-command-line-urban-dictionary git:(master) ✗ ./go-command-line-urban-dictionary -word=yolo
Word: YOLO
Defenition: An overused acronym for "[You only live once]." There is an [exception] for those who believe in [reincarnation] or are cats.
Example: Examples:
—I got up.
#[yolo]
—I inhaled.
#yolo
—I exhaled.
#yolo
—I [took a shit].
#yolo
—I [flushed] the toilet.
#yolo
—I stretched.
#yolo
```


text:
GreatFineCoin Core integration/staging tree
What is GreatFineCoin?
----------------

GreatFineCoin is an experimental digital currency that enables instant payments to
anyone, anywhere in the world. GreatFineCoin uses peer-to-peer technology to operate
with no central authority: managing transactions and issuing money are carried
out collectively by the network. GreatFineCoin Core is the name of open source
software which enables the use of this currency.


text:
### [CVE-2019-17520](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-17520)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

The Bluetooth Low Energy implementation on Texas Instruments SDK through <IP_ADDRESS> for CC2640R2 devices does not properly restrict the SM Public Key packet on reception, allowing attackers in radio range to cause a denial of service (crash) via crafted packets.

### POC

#### Reference
- https://www.youtube.com/watch?v=Iw8sIBLWE_w

#### Github
- https://github.com/JeffroMF/awesome-bluetooth-security321
- https://github.com/Matheus-Garbelini/sweyntooth_bluetooth_low_energy_attacks
- https://github.com/engn33r/awesome-bluetooth-security

repository: trickest/cve

branch_name: refs/heads/main

gha_language: HTML

repo_name: trickest/cve


text:
---
last_modified_on: "2021-10-21"
$schema: "/.meta/.schemas/guides.json"
title: The Complete Guide To AWS Load Balancers
description: AWS is a vast collection of services for deploying, maintaining, and running code. Load balancers are a way to manage high traffic by distributing it to different servers. This article will help readers understand everything there is to know about how load balancers work in AWS.
author_github: https://github.com/shingai_zivuku
tags: ["type: engineering", "cloud_provider: aws"]
hide_pagination: true
---

import Jump from '@site/src/components/Jump';

import Assumptions from '@site/src/components/Assumptions';

The AWS Elastic Load Balancing (ELB) automatically distributes your incoming application traffic across multiple targets, such as [EC2 instances](https://aws.amazon.com/ec2/instance-types/), containers, and IP addresses, in one or more [Availability Zones](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html#concepts-availability-zones), ultimately increasing the availability and fault tolerance of your applications. In other words, ELB, as its name implies, is responsible for distributing frontend traffic to backend servers in a balanced manner.

ELB monitors the health of its registered targets and routes traffic only to the healthy targets. For example, if a system has only one web server, for system applications with high traffic, long response times or no response will often occur. At this time, you will want to increase the specifications of the web server or increase the number of web servers. If there are two web servers, on which server should the traffic come in?

At this time, there must be something responsible for receiving and distributing traffic. That something is [ELB](https://aws.amazon.com/elasticloadbalancing).

<!--
     THIS FILE IS AUTOGENERATED!

     To make changes please edit the template located at:

     website/guides/engineering/the-complete-guide-to-aws-load-balancers.md.erb
-->

## Benefits of Using the AWS Elastic Load Balancing

The major use for an ELB is to ensure the elastic and high availability of your resources. There are four types of forwarding rules that you can assign to a load balancer: HTTP, HTTPS, TCP, and UDP.

Some of the benefits of ELB include the following:

- High availability and distribution of website traffic to multiple destinations or targets.
- High security through user authentication and SSL/TLS decryption functions.
- Handling drastic changes in website traffic without human intervention.
- Increased visibility of your applications through continuous monitoring and auditing.
- Hybrid load balancing, which can help with the migration of resources to the cloud.

## Types of AWS Load Balancers

As of today, AWS supports four types of load balancers: Classic Load Balancers, Network Load Balancers (NLBs), Application Load Balancers (ALBs), and Gateway Load Balancers (GWLBs). This article will focus on the first three, as their sole purpose is to distribute incoming traffic across multiple targets.

The Classic Load Balancer is a previous-generation load balancer and, currently, is only recommended for scenarios where you still have instances running on an EC2-Classic network; if you do not, then AWS recommends that you use an NLB or an ALB, as the features provided by the Classic Load Balancer can be replaced by either.

### Classic Load Balancer

This is the simplest form of load balancer that was originally used for classic EC2 instances. It operates both at the connection level and the request level. The main disadvantage of this type of load balancer is that it does not support some features, such as host-based routing or route-based routing. Once configured, the load balancer distributes the load among the servers regardless of what is on the server, which, in certain situations, can reduce efficiency and performance.

### Application Load Balancer

The Application Load Balancer (ALB) is a load balancer at the seventh layer of the OSI model, and it can route the network packet to different backend services based on the content of the network packet. Unlike running an elastic load balancer for each service, an ALB can balance network traffic for multiple backend services. For example, a URL containing `/api` and a URL containing `/signup` will be routed to different backend services.

This type of load balancer is a new generation of load balancer from AWS that provides native support for HTTP/2 and WebSocket protocols. By multiplexing requests over a single connection, HTTP/2 reduces network traffic. WebSocket allows developers to configure persistent TCP connections between client and server while minimizing power consumption.

Compared with the Classic Load Balancer, the ALB supports more features, such as the following:

- Support for [path-based/host-based](https://aws.amazon.com/about-aws/whats-new/2017/04/elastic-load-balancing-adds-support-for-host-based-routing-and-increased-rules-on-its-application-load-balancer/#:~:text=Host%2Dbased%20routing%20allows%20you,Application%20Load%20Balancers%20to%2075.) routing.
- Ability to register IP addresses as targets.
- Support for [calling Lambda functions](https://aws.amazon.com/about-aws/whats-new/2018/11/alb-can-now-invoke-lambda-functions-to-serve-https-requests/) to serve HTTP(S) requests.
- Support for [SNI](https://aws.amazon.com/blogs/aws/new-application-load-balancer-sni/).
- Support for load balancing between [multiple ports](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/register-multiple-targetgroups.html) of a single instance to provide enhanced container support.

### Network Load Balancer

If the application needs to achieve extreme performance and static IP, [AWS recommends](https://aws.amazon.com/elasticloadbalancing/faqs/) that you use a Network Load Balancer (NLB).

The NLB is optimized to handle bursty, unstable traffic patterns and rapidly fluctuating workloads. Providing high throughput, NLB can scale to handle millions of requests per second. So if your workload requirements are to handle bursty workflows at the transport layer or require extreme network performance, then you may consider using an NLB.

In addition, NLB automatically provides a static IP that can be used as the frontend IP of the balancer itself. It is also possible to assign a resilient IP address to each subnet enabled for the load balancer. This allows the NLB to be incorporated into your existing firewall security policy and avoid the problems associated with DNS caching.

## How to Configure Application Load Balancers

Next, learn how to create an ALB through the AWS Management Console, a web-based interface.

Decide which two Availability Zones you’ll utilize for your EC2 instances before you start. In each of these Availability Zones, configure your virtual private cloud (VPC) with at least one public subnet. The load balancer is configured using these public subnets. You can instead launch your EC2 instances in one of these Availability Zones’ other subnets.

In each Availability Zone, start at least one EC2 instance. Make each EC2 instance have a web server installed, such as Apache. Ensure that these instances’ security groups enable HTTP access on port 80.

Then complete the following steps.

### Select a Load Balancer Type

To create an ALB, complete the following steps:

1. Open the Amazon [EC2 console](https://console.aws.amazon.com/ec2/).
2. Choose a region on the navigation bar for your load balancer. Be sure to select the same region that you used for your EC2 instances.
3. Choose `Load balancers` on the navigation pane under `LOAD BALANCING`.
4. Choose `Create load balancer`.

![Create load balancer](https://i.imgur.com/0oYclYi.png)

5. Choose `Create` for ALB.

![ALB](https://i.imgur.com/EYVHT1z.png)

### Complete Basic Configuration

To configure your cloud load balancer, complete the following steps:

1. Enter a name for your load balancer in the `Load balancer name`.
2. Keep the default values for `Scheme` and `IP address type`.
3. Select the VPC that you used for your EC2 instances under `Network mapping`, for mappings. Select the Availability Zone for each one that you have used to launch your EC2 instances; then select the public subnet for that Availability Zone.
4. Keep the default for `Listeners`, which is a listener that accepts HTTP traffic on port 80.

### Configure a Security Group

To have ELB configure a security group for your load balancer on your behalf, complete the following steps:

1. Choose `Create new security group` under the `Security groups` section.
2. Type a name and description for the security group or keep the default name and description. This new security group contains a rule that allows traffic to the load balancer listener port that you have selected on the `Configure load balancer` page.

![Security group](https://i.imgur.com/3ZrhgIt.png)

### Configure Your Target Group

Create a target group to use in request routing. The default rule for your listener routes requests to targets registered in that group. The load balancer checks the health of the targets in this target group with the health check settings defined for the target group.

To configure your target group, complete the following steps in the `Configure Routing` section:

1. Keep the default `New target group` for the `Target group`.
2. Enter a name for the new target group under `Name`.
3. Keep the default target type (Instance), protocol (HTTP), and port (80).
4. Keep the default settings for `Health checks`.
5. Choose `Next`.
6. Choose `Create target group`.

![Create target group](https://i.imgur.com/7ynCrUG.png)

### Register Targets with Your Target Group

To register your instances with the target group, complete the following steps on the `Register Targets` page:

1. Select one or more instances under `Instances`.
2. Keep the default port (80) and choose `Include as pending below`.
3. Choose `Register pending targets` when you have finished selecting instances.

![Include pending targets](https://i.imgur.com/uZ4HHN4.png)

![Register pending targets](https://i.imgur.com/L0CR0IR.png)

### Create and Test Your Load Balancer

Review the summary of your settings before creating your load balancer. After creating the load balancer, verify that it’s sending traffic to your EC2 instances.

To create and test your load balancer, complete the following steps:

1. Choose `Create load balancer` after the summary section.
2.
3. Choose `Target groups` on the navigation pane, under `LOAD BALANCING`; and then select the newly created target group.
4. Check the `Targets` tab to verify that your instances are ready. If the status of an instance is `initial`, it’s probably because the instance is still in the process of being registered or it has not passed the minimum number of health checks to be considered healthy. After the status of at least one instance is healthy, you can test your load balancer.
5. Choose `Load balancers` on the navigation pane, under `LOAD BALANCING`.
6. Select the newly created load balancer.
7. Copy the DNS name of the load balancer from the `Description` tab. Paste the DNS name into the address field of an Internet-connected web browser. If everything is working, the browser will display the default page of your server.

![DNS name](https://i.imgur.com/W6OvDBs.png)

![Browser display](https://i.imgur.com/ON8WLZa.png)

## Conclusion

In this article, you learned basic information about the load balancers used in AWS (excluding GWLBs). You also learned to create an ALB with a single EC2 instance.

Some key points to remember are as follows:

- Load balancers are used for increasing the availability and fault tolerance of your application.
- Load balancers in AWS come in four flavors: the classic load balancer, ALB, NLB, and GWLB.
- You should ideally use ALB or NLB since the classic load balancer is now deprecated.
- NLB can handle bursty workloads and millions of requests per second.
- ALB has support for path-based or host-based routing and can balance traffic for multiple backend services.

The unique needs of your application use case—such as whether you need end-to-end SSL/TLS encryption or whether you want path-based or host-based routing—will determine the type of load balancer that is best for you.

<Jump to="/guides/tutorial/">Tutorial</Jump>

repository: lorismaz/documentation

repo_name: lorismaz/documentation


text:
# bad-reversed-sequence (E0111)

*The first reversed() argument is not a sequence* Used when the first
argument to reversed() builtin isn’t a sequence (does not implement
\_\_reversed\_\_, nor \_\_getitem\_\_ and \_\_len\_\_

repository: codacy/codacy-pylint

gha_language: Python

gha_license_id: NOASSERTION

repo_name: codacy/codacy-pylint


text:
# Gavin Andresen: Banks Will Securely Handle Your Bitcoins

> Why would bitcoin be a threat to banks?  They're really good at securely handling currency; that's a valuable service, whether the currency is dollars or euros or bitcoins.

https://bitcointalk.org/index.php?topic=6744.msg98696#msg98696

repository: eragmus/quotes

repo_name: eragmus/quotes


text:
# NPDsales-predictor

Use this R script to forecast sales for New Products using the Bass Diffusion Model.
This script was specifically written to predict territorial sales for a manufacturer in cosmetic industry. Complete and easy instructions provided in the script for customization.

This script provides limited functionality on graphs and can be customized/used further using simple plot functions.

Library packages used:
Propagate

Requirements:
R Statistical Platform


text:
# Command Timestamps

In iTerm, `cmd` + `shift` + `E` toggles the timestamp of commands. This, however does not work with tmux well.

[Here](https://redandblack.io/blog/2020/bash-prompt-with-updating-time/) is a nice way to achieve that in Bash.

repository: yunusrf/til

repo_name: yunusrf/til


text:
## Breadcrumbs for SugarView

Adds Module Icon and Breadcrumbs to the Module line.

**Warning!** This plugin is not upgrade safe. This plugin modifies the include/MVC/View/SugarView.php file on install, it's highly recommended to make backup before install.

The package is uninstallable and removes all the modifications from any core files it changed on install.

##License

Distributed under the MIT license.

repository: soulware-ltd/Breadcrumbs

repo_name: soulware-ltd/Breadcrumbs


text:
This WIP document was made to cover the expected code-style for this repository. Please follow this style as closely as possible to make pull requests as simple as possible. Note that the examples below are mostly non-sensical and written for the sake of being examples.

# Conditionals
### When writing a conditional, be explicit with the expected result.

✔ Do:
```csharp
bool a = true;
if (a == true) {
    //
} else if (a == false) {
    //
}
```

❌ Don't:
```csharp
bool a = true;
if (a) {
    //
} else if (!a) {
    //
}
```

# Referencing Class Members
### When writing code inside of a classes' method, refer to members using `this.`.

✔ Do:
```csharp
class MyClass {
    public int a = 10;
    public int b = 10;

    public int Add() {
        return this.a + this.b;
    }
}
```

❌ Don't:
```csharp
class MyClass {
    public int a = 10;
    public int b = 10;

    public int Add() {
        return a + b;
    }
}
```

# Local Variables
### When using local variables, prefix their names using an underscore. This *does not* need to be followed for variables used as iterators in loops.

✔ Do:
```csharp
string _myCharacterName = "John";
Console.WriteLine("My name is " + _myCharacterName);
```

❌ Don't:
```csharp
string myCharacterName = "John";
Console.WriteLine("My name is " + myCharacterName);
```

# Types
### Avoid using `var` for types whenever possible. This *does not* need to be followed for one-off variables.

✔ Do:
```csharp
LInstance _instGlobal = _game.Instances[(double)LVariableScope.Global];
double _instX = _instGlobal.Variables["x"];
Console.WriteLine("Instance X position is: {0}", _instX);
```

❌ Don't:
```csharp
var _instGlobal = _game.Instances[(double)LVariableScope.Global];
var _instX = _instGlobal.Variables["x"];
Console.WriteLine("Instance X position is: {0}", _instX);
```

# Brackets
### Brackets of all kinds should be put on the same line as the loop or conditional

✔ Do:
```csharp
int a = 0;
if (a > 0) {
    //
} else if (a  0) {

} else {

}

for(int i = 0; i < 100; i++) {
    //
}
```

❌ Don't:
```csharp
int a = 0;
if (a > 0)
{
    //
}
else if (a < 0)
{
    //
}
else
{
    //
}

for(int i = 0; i < 100; i++)
{
    //
}
```

repository: gm-archive/Luna

repo_name: gm-archive/Luna


text:
### Using Tests to Communicate

Teams should talk to each other using tests. Teams usually have real problems communicating efficiently with each other. You might find an email, a half-baked bug-tracking issue opened, a few paragraphs, a screen shot, and if you are lucky, a recorded screencast movie.

This is a horrible way to communicate. The information isn't reusable, the context isn't immediately clear, you can't scale, you can't expand on the topic, and you can't run it automatically to know if the problem is still there or not. This is a highly inefficient way to communicate.

The best way for teams to communicate is by using Tests.

Both within and across teams; top-down and bottom-up, from managers and testers to teams.

Tests should become the lingua franca of companies. Their main means of communication.

This has tremendous advantages, since in order for it to work, it requires really very good test APIs, and very good execution environments.

One must have an easy-to-develop, easy-to-install, and easy-to-access development environment in place, something that very rarely occurs.

By making tests the principal way teams communicate, you create an environment that not only rewards good APIs, it rewards good solutions for testing the application. Another advantage is that you can measure how many tests have been written across teams and you can review the quality of the tests.

Not only is this a major advantage to a company, it is also a spectacular way to review changes. If you send a test that says, _"Hey! I would like XYZ to occur"_, or _"Here is a problem"_, then the best way to review the quality of the change is to review the test that was modified in order to solve the problem.

In this scenario, you have a test that reflects the fixed state of a behaviour, and you have a test that communicates the changes you want to make. A review of both tests is often the best way to evaluate if the requested changes have been made and are working as desired.


text:
Currently working on [Datasette](https://datasette.io/) and associated projects. Read [my blog](https://simonwillison.net/) or [follow @simonw on Twitter](https://twitter.com/simonw).

### Recent releases

[datasette-publish-vercel 0.9.1](https://github.com/simonw/datasette-publish-vercel/releases/tag/0.9.1) - 2020-12-28

[dogsheep-beta 0.10.1](https://github.com/dogsheep/dogsheep-beta/releases/tag/0.10.1) - 2020-12-19

[github-to-sqlite 2.8.2](https://github.com/dogsheep/github-to-sqlite/releases/tag/2.8.2) - 2020-12-16

[sqlite-utils 3.1](https://github.com/simonw/sqlite-utils/releases/tag/3.1) - 2020-12-13

[datasette-publish-fly 1.0.1](https://github.com/simonw/datasette-publish-fly/releases/tag/1.0.1) - 2020-12-12

[datasette-auth-passwords 0.3.3](https://github.com/simonw/datasette-auth-passwords/releases/tag/0.3.3) - 2020-12-11

[datasette 0.53](https://github.com/simonw/datasette/releases/tag/0.53) - 2020-12-11

[datasette-column-inspect 0.2a](https://github.com/simonw/datasette-column-inspect/releases/tag/0.2a) - 2020-12-09

More [recent releases](https://github.com/simonw/simonw/blob/main/releases.md)

### On my blog

[Weeknotes: Datasette internals](http://simonwillison.net/2020/Dec/27/weeknotes-datasette-internals/) - 2020-12-27

[Building a search engine for datasette.io](http://simonwillison.net/2020/Dec/19/dogsheep-beta/) - 2020-12-19

[Build v.s. buy: how billing models affect your internal culture](http://simonwillison.net/2020/Dec/13/build-vs-buy/) - 2020-12-13

[datasette.io, an official project website for Datasette](http://simonwillison.net/2020/Dec/13/datasette-io/) - 2020-12-13

[Weeknotes: github-to-sqlite workflows, datasette-ripgrep enhancements, Datasette 0.52](http://simonwillison.net/2020/Dec/6/weeknotes/) - 2020-12-06

More on [simonwillison.net](https://simonwillison.net/)

### TIL

[Using Prettier to check JavaScript code style in GitHub Actions](https://til.simonwillison.net/github-actions/prettier-github-actions) - 2020-12-31

[Using Jest without a package.json](https://til.simonwillison.net/javascript/jest-without-package-json) - 2020-12-30

[Relinquishing control in Python asyncio](https://til.simonwillison.net/python/yielding-in-asyncio) - 2020-12-29

[Replicating SQLite with rqlite](https://til.simonwillison.net/sqlite/replicating-rqlite) - 2020-12-28

[Skipping CSV rows with odd numbers of quotes using ripgrep](https://til.simonwillison.net/bash/skip-csv-rows-with-odd-numbers) - 2020-12-12

More on [til.simonwillison.net](https://til.simonwillison.net/)

 How this works

repository: MainEpicenter/simonw

repo_name: MainEpicenter/simonw


text:
# Skin Detection
Skin detection is the process of finding skin-colored pixels and regions in an image or a video.
This process is typically used as a preprocessing step to find regions that potentially have human
faces and limbs in images. Several computer vision approaches have been developed for skin
detection. A skin detector typically transforms a given pixel into an appropriate color space and
then use a skin classifier to label the pixel whether it is a skin or a non-skin pixel. A skin classifier
defines a decision boundary of the skin color class in the color space based on a training database
of skin-colored pixels.

Skin color and textures are important cues that people use consciously or unconsciously to infer
variety of culture-related aspects about each other. Skin color and texture can be an indication of
race, health, age, wealth, beauty, etc. However, such interpretations vary across cultures and
across the history. In images and videos, skin color is an indication of the existence of humans in
such media. Therefore, in the last two decades extensive research have focused on skin detection
in images. Skin detection means detecting image pixels and regions that contain skin-tone color.
Most the research in this area have focused on detecting skin pixels and regions based on their
color. Very few approaches attempt to also use texture information to classify skin pixels.
As will be described shortly, detecting skin pixels are rather computationally easy task and
can be done very efficiently, a feature that encourages the use of skin detection in many video
analysis applications. For example, in one of the early applications, detecting anchors in TV news
videos for the sake of video automatic annotation, archival, and retrieval. In such an application,
it is typical that the face and the hands of the anchor person are the largest skin-tone colored region
in a given frame since, typically, news programs are shot in indoor controlled environments with man-made
background materials that hardly contain skin-colored objects. In many similar applications, where
the background is controlled or unlikely to contain skin-colored regions, detecting skin-colored
pixels can be a very efficient cue to find human faces and hands in images. An example in the
context of biometric is detecting faces for face recognition in an controlled environment.

Detecting skin-colored pixels, although seems a straightforward easy task, has proven quite
challenging for many reasons. The appearance of skin in an image depends on the illumination
conditions (illumination geometry and color) where the image was captured. We humans are very
good at identifying object colors in a wide range of illuminations, this is called color constancy.
Color constancy is a mystery of perception. Therefore, an important challenge in skin detection is
to represent the color in a way that is invariant or at least insensitive to changes in illumination. As
will be discussed shortly, the choice of the color space affects greatly the performance of any skin
detector and its sensitivity to change in illumination conditions. Another challenge comes from the
fact that many objects in the real world might have skin-tone colors. For example, wood, leather,
skin-colored clothing, hair, sand, etc. This causes any skin detector to have many false detections
in the background if the environment is not controlled.

# Framework for Skin Detection:

Skin detection process has two phases: a training phase and a detection phase. Training a skin
detector involves three basic steps:
1.  Collecting a database of skin patches from different images. Such a database typically contains
    skin-colored patches from a variety of people under different illumination conditions.
    (Data collected from random Google Search)
2.  Choosing a suitable color space.
3.  Learning the parameters of a skin classifier.

Given a trained skin detector, identifying skin pixels in a given image or video frame involves:
1.  Converting the image into the same color space that was used in the training phase.
2.  Classifying each pixel using the skin classifier to either a skin or non-skin.
3.  Typically post processing is needed using morphology to impose spatial homogeneity on the
    detected regions.

In any given color space, skin color occupies a part of such a space, which might be a compact
or large region in the space. Such region is usually called the skin color cluster. A skin classifier is
a one-class or two-class classification problem. A given pixel is classified and labeled whether it
is a skin or a non-skin given a model of the skin color cluster in a given color space. In the context
of skin classification, true positives are skin pixels that the classifier correctly labels as skin. True
negatives are non-skin pixels that the classifier correctly labels as non-skin. Any classifier makes
errors: it can wrongly label a non-skin pixel as skin or a skin pixel as a non-skin. The former type
of errors is referred to as false positives (false detections) while the later is false negatives. A good
classifier should have low false positive and false negative rates. As in any classification problem,
there is a tradeoff between false positives and false negatives. The more loose the class boundary,
the less the false negatives and the more the false positives. The tighter the class boundary, the
more the false negatives and the less the false positives. The same applies to skin detection. This
makes the choice of the color space extremely important in skin detection. The color needs to
be represented in a color space where the skin class is most compact in order to be able to tightly
model the skin class. The choice of the color space directly affects the kind of classifier that should
be used.

repository: daleyprabhakar/skin-Detection

repo_name: daleyprabhakar/skin-Detection


text:
## [0.1.3]

- Removed all flutter references because the package also works standalone for dart. Thanks [jld3103](https://github.com/jld3103)
- Added Wordpress Standard endpoints as requested in [issue #3](https://github.com/dhmgroup/dart-wp/issues/3). These include getPosts(), getCategories(), getTags(), getComments(), and getUsers() functions.

## [0.1.2+3]

- Minor fixes

## [0.1.2+2]

- Added endpoint query handler

## [0.1.2+1]

- Added getAsyc exception

## [0.1.2]

- Fixed the error in JSON endpoint retrieval

## [0.1.1+2]

- Changed getAsync return raw json body
- Changed example code url

## [0.1.1+1]

- Changed getAsync return data to a map.

## [0.1.1]

- Updated example and readme

## [0.1.0]

- Added an example

## [0.0.2]

- Updated documentation

## [0.0.1]

- Initial release.

repository: Flutter-ar/dart-wp

repo_name: Flutter-ar/dart-wp


text:
# Switch Connections between Apache Cassandra™ and Astra databases
This application shows how to use the [C# DataStax Driver](https://docs.datastax.com/en/developer/csharp-driver/latest) to connect to an on-prem Cassandra database or a Astra database in the cloud at runtime using environment variables.

Contributor(s): [Dave Bechberger](https://github.com/bechbd)

## Objectives
* Shows the differences between a Cassandra connection configuration and an Astra connection configuration in a single app.
* Provide a demonstration of how to configure the database connection at runtime.
* See the [documentation](https://docs.datastax.com/en/developer/csharp-driver/latest/features/cloud/) for more details about the Astra connection configuration for the C# Driver

## Project Layout
* [Program.cs](/Program.cs) - The main application file which contains the logic to switch between the configurations

## How this Sample Works
This sample uses environment variables to specify the configuration parameters and whether to use a Cassandra (DSE/DDAC/C*) configuration or an Astra configuration.
All the logic to switch between the configurations occurs in the [`GetClientConfiguration`](https://github.com/DataStax-Examples/switch-connection-csharp/blob/master/Program.cs#L33) method.
* If you specify the `USEASTRA` environment variable and it is `true`:
    * The environment variables are checked to see that `DBUSERNAME`, `DBPASSWORD`, `SECURECONNECTBUNDLEPATH`, and `KEYSPACE` exist
		* If they exist then the Astra connection is created
		* If they do not exist then an error is thrown
* If you so not specify the `USEASTRA` environment variable or it is `false`:
	* The environment variables are checked to see that `CONTACTPOINTS` and `DATACENTER` exist
		* If they exist then the standard connection is created
		* If they do not exist then an error is thrown
		* If `DBUSERNAME` and `DBPASSWORD` exist then credentials are added to the configuration
		* If `KEYSPACE` exists then it is added to the configuration

While these criteria added to the configuration are commonly used configuration parameters you are able to specify any additional ones in the code.

Additionally while this example uses environment variables to control which configuration is selected this could also be done via the use of configuration files or command line parameters.

For clarity this sample does not contain any of the normal error handling process you would want to wrap around connecting to a cluster to handle likely errors that would occur.

## Setup and Running

### Prerequisites
* .NET Core 2.1
* A Cassandra cluster or an Astra database to connect to with the appropriate connection information

### Running

To connect to an Astra database you first need to download the secure connect bundle following the instructions found [here](https://docs.datastax.com/en/astra/aws/doc/dscloud/astra/dscloudObtainingCredentials.html).
This first step in the process is to build the application.  This can be done using the following command:

`dotnet build`

Once you have compiled the connection information and built the application you can run this to connect to Astra by using the command below, with the appropriate configuration added:

`USEASTRA=true DBUSERNAME=XXX DBPASSWORD=XXX KEYSPACE=XXX SECURECONNECTBUNDLEPATH="/valid/path/to/secureconnectbundle.zip" dotnet run`

If you would like to connect to a Cassandra cluster use the command below, with the appropriate configuration added:

`CONTACTPOINTS=XX.XX.XX.XX dotnet run`

Once you run this against either option you will get output that specifies the number of hosts and their IP addresses printed to the console:

```Connected to cluster with 3 host(s) XX.XX.XX.XX:9042,XX.XX.XX.XX:9042,XX.XX.XX.XX:9042```


text:
# asdf-minishift

![CI](https://github.com/sqtran/asdf-minishift/workflows/CI/badge.svg?branch=master)

[Minishift](https://github.com/minishift/minishift) plugin for [asdf](https://github.com/asdf-vm/asdf) version manager.  This work is based off of the [minikube](https://github.com/alvarobp/asdf-minikube) plugin.

## Install

```bash
asdf plugin add minishift https://github.com/sqtran/asdf-minishift.git
asdf install minishift latest
```

## Use

Check the [asdf](https://github.com/asdf-vm/asdf) README for instructions on how to install and manage versions of Minishift.

repository: sqtran/asdf-minishift

gha_language: Shell

repo_name: sqtran/asdf-minishift


text:
# easyai
A framework to make even a common-man experiment with deeplearning.

# Installation
pip install git+https://github.com/IamVNIE/easyai/ --upgrade

# Requirements
Python Version : 3.5-3.7 (Doesn't Work on 3.8 Since Tensorflow does not support 3.8 yet.
Dependencies: Numpy, Tensorflow, Seaborn, Matplotlib, Pandas

    NOTE: Dependency libraries are automatically installed. No need for user to install them manually.

# Usage

import easyai.chief as easyai

repository: aibharata/easyai

repo_name: aibharata/easyai


text:
Appdynamics Collector
=====================

This project uses Spring Boot to package the collector as an executable JAR with dependencies.

Building and Deploying
--------------------------------------

Run
```
mvn install
```
to package the collector into an executable JAR file. Copy this file to your server and launch it using :
```
java -JAR appdynamics-perf-collector.jar --spring.config.name=appdynamics --spring.config.location=<appdynamics.properties location>
```
You will need to provide an **appdynamics.properties** file that contains information about how
to connect to the Dashboard MongoDB database instance, as well as properties the Appdynamics collector requires. See
the Spring Boot [documentation](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#boot-features-external-config-application-property-files)
for information about sourcing this properties file.

###Sample application.properties file
--------------------------------------

    #Database Name
    database=dashboard

    #Database HostName - default is localhost
    dbhost=localhost

    #Database Port - default is 27017
    dbport=27017

    #Database Username - default is blank
    dbusername=db

    #Database Password - default is blank
    dbpassword=dbpass

    #Logging File
    logging.file=./logs/appd-collector.log

    #Collector schedule (required)
    appdynamics.cron=1 * * * * *

    #Appdynamics server (required)
    appdynamics.instanceUrl=http://appdyn-hqa-c01.kdc.company.com

    #Appdynamics Username (required)
    appdynamics.username=APPD_USERNAME

    #Appdynamics Password (required)
    appdynamics.password=APPD_PASSWORD

    #Appdynamics Dashboard (required)
    appdynamics.dashboardUrl=http://appdyn-hqa-c01.kdc.company.com/controller/#/location=APP_DASHBOARD&timeRange=last_15_minutes.BEFORE_NOW.-1.-1.15&application=%s&dashboardMode=force

repository: CapitalOne-Hygieia/Hygieia

repo_name: CapitalOne-Hygieia/Hygieia


text:
# Colmar Academy

## Description

This is our assessment to put all our knowledge into practice! You will create the [Codecademy's Colmar Project](https://www.codecademy.com/paths/learn-how-to-build-websites/tracks/learn-how-to-build-websites-capstone-project/modules/colmar-academy/projects/colmar-academy).

## Resources

- [spec file](https://content.codecademy.com/courses/freelance-1/capstone-2/colmar-academy-spec.png)
- [bootstrap](https://getbootstrap.com/)

## Setup

As it is intended to be done all on your own environment, you may not want to follow along my steps. So feel free to do it any way you see fit.

- `fork` and `git clone` the repo to get the necessary files.
- `cd colmar-academy`
- `code .`
- `touch index.html`
- `open index.html`

## Recommendations

When you see measurements in pixels, consider using [bootstrap's built in spacing](https://getbootstrap.com/docs/5.0/utilities/spacing/). This will make the site more responsive.

repository: tino-msakwa/colmar-academy

repo_name: tino-msakwa/colmar-academy


text:
---
title: Enchilada Stuffed Peppers
ingredients:
  salsa: 3 cups
  ground beef: 1.5 pounds - optional
  ground bison: 1.5 pounds - optional
  sweet potatoes: 1 medium
  yellow onion: 1 small
  carrots: 2
  baby spinach: 3 cups
  sea salt: 2.5 teaspoons
  cumin: 2 teaspoons
  coriander: 1.5 teaspoons
  poblano peppers: 8 large
  avacado: sliced - optional
  Guacamole: optional
gluten-free: true
time: 1.5 hours
servings: 8
---

1. Peel and dice sweet potatoe and carrots. Dice onion. Chop spinach.
2. Leaving the stems on, cut a Y-shaped slit down the top and center of each
   pepper. Gently scrape out and discard the seeds.
3. Brown beef and drain.
4. Preheat oven to 375F
5. Add sweet potatoes, onion, carrots, spinach, salt, cumin, and coriander.
   Saute over medium heat for 10 minutes, until vegetables have softened
   slightly.
6. Stuff each pepper generously with the meat mixture, being careful not to
   tear the pepper.
7. Spread a thin layer of salsa on the bottom of the baking dish, then arrange
   the pppers on top. Spoon the remaining salsa over each pepper.
8. Bake, covered for 20 minutes. Uncover and bake for 15 more minutes, until
   the peppers are soft and the salsa is hot.
9. Serve with avacado slices or Guacamole.

repository: roxanneminerals/food

repo_name: roxanneminerals/food


text:
Native HTTP stack for Node.js on Windows
===

The httpsys module is a native, server side HTTP stack for Node.js applications on Windows. It is based on HTTP.SYS.

### Benefits

Compared to the built in HTTP[S] stack in Node.js, the httpsys module offers:

* **Better performance**. Check out [early performance benchmarks](http://tomasz.janczuk.org/2012/08/the-httpsys-stack-for-nodejs-apps-on.html).
* **Kernel mode output caching**. Applications suitable for output caching can realize additional, substantial increases in throughput. See [benchmarks](http://tomasz.janczuk.org/2012/08/the-httpsys-stack-for-nodejs-apps-on.html).
* **Port sharing**. Horizontally partitioned applications (e.g. web chat) can use very efficient kernel mode routing to achieve process level affinity for increased throughput and reduced latency. [Read more](http://tomasz.janczuk.org/2013/05/how-to-save-5-million-running-nodejs.html).
* **Kernel mode SSL configuration**. SSL credentials are securely configured using Windows tools rather than stored in files or provided through code.

### Compatibility

The httpsys module requires Windows. It works with any stable version of Node.js, both 32- and 64-bit. The module was developed and tested with Node.js 0.6.20, 0.8.22, 0.10.15, each in 32 and 64 bit flavors.

WebSockets functionality requires Windows 8 or Windows Server 2012 or later.

The module aspires to provide high level of API and behavioral compatibility with the built in server side HTTP stack in Node.js. While it is impossible to guarantee compatibility will all Node.js applications, the httpsys module was proved to work with the cluster module, the [einaros/ws](https://github.com/einaros/ws) module for WebSockets, as well as the [socket.io](http://socket.io/) module for WebSockets and HTTP long polling.

Any and all feedback is welcome [here](https://github.com/tjanczuk/httpsys/issues/new). Collaboration welcome - I do take contributions.

### Getting started

You must have Windows and a stable version of Node.js installed (0.6, 0.8, 0.10). Then:

```
npm install httpsys
```

Then in your code:

```javascript
// Replace the built-in HTTP[S] module with httpsys.
// This must be the first line of the app.
require('httpsys').slipstream();

var http = require('http');

http.createServer(function (req, res) {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello, world!');
}).listen(8080);
```

### Port sharing

To use port sharing, provide a full [URL prefix string](http://msdn.microsoft.com/en-us/library/windows/desktop/aa364698(v=vs.85\).aspx) in the call to `Server.listen`, e.g.:

```javascript
require('httpsys').slipstream();

var http = require('http');

http.createServer(function (req, res) {
  // ...
}).listen('http://*:8080/foo/');
```

At the same time, you can start another node.exe process that listens on a different URL prefix on the same port, e.g. `http://*:8080/bar/`. Each of the processes will only receive requests matching the URL prefix they registered for. The processes may belong to different users.

Port sharing is particularly relevant to horizontally partitioned applications (e.g. web chat). With it you can use very efficient kernel mode routing to achieve process level affinity for increased throughput and reduced latency. [Read more](http://tomasz.janczuk.org/2013/05/how-to-save-5-million-running-nodejs.html).

### HTTPS

Create a self-signed X.509 server certificate with associated private key and place it in the LocalMachine\My certificate store:

```
makecert -sr LocalMachine -ss My -pe -n "CN=mydomain.com" -a sha256 -len 1024 -r
```

List the certificates in the LocalMachine\My certificate store, locate the one you just created (CN=mydomain.com), and take note of its SHA1 Thumbprint:

```
certmgr -c -s -r LocalMachine My
```

Let's assume the SHA1 Thumprint of the certificate is `EC2F8BD2 360C6118 0C0DA68C 2DC911EB 6708B1E5`. Next, register this certificate to be used by HTTP.SYS for all connections made on the TCP port on which you intend to set up the HTTPS server, in this case port 8080:

```
netsh http add sslcert ipport=<IP_ADDRESS>:8080 certhash=EC2F8BD2360C61180C0DA68C2DC911EB6708B1E5
      appid={00112233-4455-6677-8899-AABBCCDDEEFE}
```

(line breaks added for readability only; note that you must remove spaces from the SHA1 Thumprint; the appid parameter is an arbitrary GUID).

Verify the certificate is properly installed:

```
netsh http show sslcert ipport=<IP_ADDRESS>:8080
```

Finally, author your HTTPS server:

```javascript
require('httpsys').slipstream();

var https = require('http');
var options = {};

https.createServer(options, function (req, res) {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello, world!');
}).listen(8080);
```

Note that the X.509 credentials had already been configured with HTTP.SYS, so there is no need to specify them through the `options` object passed to the `createServer`. If you do specify X.509 credentials there, they will be silently ignored. The `options` object is expected merely for API compatibility with the built-in Node.js HTTPS stack.

Now, visit your endpoint by going to `https://localhost:8080`. The browser will display a warning given that the certificate is self-signed and therefore not trusted, but otherwise your server is fully functional.

To inspect or modify HTTP.SYS configuration underlying your server use the `netsh http` command in Windows. This allows you to set various timeout values as well as configure SSL certificates.

### HTTPS mutual X.509 authentication

You can configure httpsys module to require and validate client X.509 certificate. Unlike with the built-in `https` module, trust verification checks of the client certificate are configured at the operating system level using the certificate store and the `netsh` tool rather than with the `options` object passed to the `https.createServer` method.

All SSL and cryptographic properties specified within the `options` object passed to `https.createServer` function are ignored. In partcular, none of the `options.ca`, `options.rejectUnauthorized`, and `options.requestCert` are effective.

To require the client to present an X.509 certificate during SSL handshake, you must configure the HTTP.SYS accordingly when registering the server certificate for a particlar TCP port, e.g.:

```text
netsh http add sslcert ipport=<IP_ADDRESS>:3501 certhash=EC2F8BD2360C61180C0DA68C2DC911EB6708B1E5
      appid={00112233-4455-6677-8899-AABBCCDDEEFE} clientcertnegotiation=enable
```

(Note the `clientcertnegotiation=enable` setting).

By default HTTP.SYS will validate client certificates by attempting to build a certificate chain up to a trusted root using the LocalMachine certificate store. You control your trust base by controlling the content of that certificate store using tools like `certmgr`, `certutil`, or the certificate plug-in for `mmc`. In addition, the `netsh http add sslcert` command allows you to fine tune the client certificate validation behavior for a particular TCP port.

The httpsys module never automatically rejects HTTPS request when the client presents an invalid or untrusted X.509 certificate. The application code must consult the `req.client.authorized`, `req.client.authorizationError`, and `req.client.getPeerCertificate()` values before deciding to accept or reject a request.

If the client certificate is trusted, `req.client.authorized` is *true*. Otherwise `req.client.authorizationError` contains one of the following error codes, or a hexadecimal number for more esoteric error conditions:

* CERT_E_EXPIRED
* CERT_E_UNTRUSTEDCA
* TRUST_E_CERT_SIGNATURE
* CRYPT_E_REVOKED
* CERT_E_UNTRUSTEDROOT
* CERT_E_WRONG_USAGE
* CRYPT_E_NO_REVOCATION_CHECK
* CRYPT_E_REVOCATION_OFFLINE
* CERT_E_CHAINING

Whenever the client presented an X.509 certificate (even one that failed validation), the `req.client.getPeerCertificate()` will return an object describing some key properties of the certificate, e.g.:

```text
{
	subject: 'CN=localhost',
	issuer: 'CN=localhost',
	valid_from: 'Mon, 12 Aug 2013 14:23:23 GMT',
	valid_to: 'Wed, 31 Dec 2098 22:00:00 GMT',
	fingerprint: 'C0:8E:29:A6:96:CC:C5:A2:5E:2F:3B:9A:94:34:EA:62:4B:83:7E:E8'
}
```

The httpsys module can optionally pass the entire, encoded X.509 certificate presented by the client to the application. To enable this feature, set the `HTTPSYS_EXPORT_CLIENT_CERT=1` environment variable. As a result the object returned from `req.client.getPeerCertificate()` will also contain an `encoded` property with a Buffer that holds the raw X.509 certificate. This may be useful for customized certificate validation, for example using the .NET's [X509Chain](http://msdn.microsoft.com/en-us/library/system.security.cryptography.x509certificates.x509chain.aspx) class accessed via [Edge.js](http://tjanczuk.github.io/edge).

### HTTP.SYS output caching

The HTTP.SYS output caching feature enables you to [dramatically improve](http://tomasz.janczuk.org/2012/08/the-httpsys-stack-for-nodejs-apps-on.html) the throughput of your Node.js HTTP[S] server if you are repeatedly serving responses that can be cached for even a short period (e.g. 1 second). The first time an HTTP request is made, HTTP.SYS caches the response generated by the Node.js application in an efficient, in-memory, kernel mode cache. For all similar requests that arrive within the specified cache duration, HTTP.SYS then serves the response directly from the cache without invoking the Node.js application.

By default HTTP.SYS output caching is disabled. To enable output caching for your application, set the `HTTPSYS_CACHE_DURATION` environment variable to the desired default cache duration in seconds, e.g.

```
set HTTPSYS_CACHE_DURATION=1
node server.js
```

There are no changes required in the code of your application, unless you want to override the default cache duration for a particular HTTP response:

```javascript
require('httpsys').slipstream();

var http = require('http');

http.createServer(function (req, res) {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.cacheDuration = 60; // cache this particular response for 60 seconds
  res.end('Hello, world!');
}).listen(8080);
```

Note that if you do not set the `HTTPSYS_CACHE_DURATION` environment variable at all, the `cacheDuration` property in code remains ineffective. If you want to enable output caching only for carefully chosen set of responses, set `HTTPSYS_CACHE_DURATION` to 0 (zero), and then use `cacheDuration` in code to change this default for selected responses.

You can inspect the state of the HTTP.SYS output cache using the `netsh http show cachestate` command.

### WebSockets

The httpsys module supports WebSockets on Windows 8 or Windows Server 2012 or later. The module was proved to work with the [einaros/ws](https://github.com/einaros/ws) module for WebSockets, as well as the [socket.io](http://socket.io/) module for WebSockets and HTTP long polling. Check out tests for code samples.

### Cluster

Cluster functionality is supported.

Note that when you use HTTP.SYS output caching, using cluster is typically not necessary to fully saturate server CPU. This is because HTTP.SYS is multi-threaded, and with adequate request load can fully utilize the server CPU serving responses from the cache.

### Other configuration options

There are a few other aspects of the `httpsys` module behavior that are controlled with environment variables:

* `HTTPSYS_CACHE_DURATION` - default lifetime of the HTTP response in the the HTTP.SYS output cache in seconds. If unset, the HTTP.SYS output caching feature is completely disabled.
* `HTTPSYS_BUFFER_SIZE` - the size of the memory buffer used for reading HTTP requests in bytes. The default is 4096. If you are expecting HTTP requests with headers that exceed this size (e.g. large cookies or authentication), you may need to increase this value to e.g. 16384.
* `HTTPSYS_REQUEST_QUEUE_LENGTH` - the maximum number of HTTP requests that HTTP.SYS will allow to be queued up before responding with a 503 to new requests. This is helpful in addressing short-lived spikes in traffic. The default is 5000.
* `HTTPSYS_PENDING_READ_COUNT` - the number of async read requests for new HTTP requests that `httpsys` will maintain at any given point in time. The default is 1.
* `HTTPSYS_NATIVE` - fully qualified file name of the native httpsys.node module to use; this is useful when working with custom builds of the `httpsys` module.
* `HTTPSYS_EXPORT_CLIENT_CERT` - if set to 1, raw client X.509 certificates negotiated during SSL handshake will be provided to the application as a `encoded` property of the object returned from `req.client.getPeerCertificate()`.

### APIs

The httpsys module exposes the following functions:

* *slipstream()*. Calling this function first in your application replaces Node.js'es built-in server side HTTP(S) stack with httpsys. This means that subsequent calls to `require('http')` or `require('https')` will return a version of the module based on HTTP.SYS.
* *http()*. If you don't want to globally replace the built-in HTTP(S) modules with httpsys by calling `slipstream()`, you can obtain an isolated reference to the httpsys version of the built-in *http* module with a call to `http()`.
* *https()*. Similar to `http()`, only for HTTPS.

### Building

To build httpsys, you must have Visual Studio 2012 or Visual Studio Express 2012 for Windows Desktop. There are a few ways to build depending on what you want to achieve.

To build httpsys for all supported versions and flavors of Node.js: (0.6.20, 0.8.22, 0.10.15) x (x32, x64), call

```text
tools\buildall.bat
```

The first time you call the command above, respective versions of Node.js and node-gyp will be dynamically downloaded from the web. Subsequent builds will use the downloaded versions and be faster. The build results in several flavors of *httpsys.node* module binplaced in directories under *lib\native\win32* and ready to use.

To build a debug version of httpsys for the version and flavor of Node.js currently installed on your machine, call:

```text
tools\builddev.bat
```

Once you set the `HTTPSYS_NATIVE` environment variable to point to the resulting *httpsys.node* binary, you can run your apps with that custom version of httpsys. Useful for debugging and development.

### Running tests

To run tests using the version and falvor of Node.js installed on your machine, call

```text
npm test
```

To run tests against all the versions and flavors against which httpsys was built, call:

```text
test\testall.bat
```

Note that prior to calling *testall.bat* you must have successfuly built the module using `tools\buildall.bat` to ensure the required versions of *node.exe* are present in expected locations.

### Feedback

Please provide feedback and ask questions [here](https://github.com/tjanczuk/httpsys/issues/new). Collaboration welcome - I do take contributions.

repository: sebgod/httpsys

repo_name: sebgod/httpsys


text:
# Jumga server demo live app

<https://jumga-demo.herokuapp.com/api-docs>

## Frontend repo

<https://github.com/okezieobi/jumga-client-demo>

## Features

- Users can signup, login and logout
- Authorized users can create a store with an unapproved status
- Authorized users can create items for to sell at a specific store
- Authorized users can find stores depending on supplied parameters
- Authorized users can find items for sale depending on supplied parameters
- Authorized users can purchase an item

## Stack

ExpressJS/NodeJS, MongoDB/Mongoose

repository: okezieobi/jumga-server-demo

gha_language: JavaScript

repo_name: okezieobi/jumga-server-demo


text:
csvtojson
==========

This tool is to convert a csv file into new line delimited json format.
A data type auto-detection is implemented so that the schema and/or data type of a column will be auto-detected.
The supported data types are string, numbers (float and integer), and boolean.

Install
----------
pip install csvtojson

Usage
----------

```python
# auto-detect schema
import csvtojson as c2j
data = c2j.load('./file.csv')

# print the rows in json format
for item in data:
    print item
```

repository: ImenJarroudi/csvtojson

repo_name: ImenJarroudi/csvtojson


text:
+++
title = "Imports and Exports as Documentation"
date = 2015-08-22

[taxonomies]
tags = ["Programming", "Haskell"]
categories = ["Posts"]
+++

Lately I've been reading huge haskell code bases quite a lot.
One thing that I have noted to be helpful when documentated
has been the imports section as well as the code having a list of the code it exports.

<!-- more -->

I don't know whether this is just a non-experienced programmer issue or it cuts across the board.

Documenting imports can happen:

- explicitly through:
    - comments

- implicity through:
    - uniquely qualified imports.
    ```haskell
        import A qualified as X
        import B qualified as Y
    ```
    over
    ```haskell
        import A qualified as X
        import B qualified as X
    ```
    - importing of specific instances (i.e using brackets to specify what one wants to import)

Basically anything that saves the programmer effort or time in:

- Understanding what you're importing
- Why you're importing it
- See the usage of a function and quickly know where it's from

I can't quantify or explain exactly how this helps me understand the code but it really does.
Especially when I can't hoogle a function name
(the internet connections aren't too fast in these parts).
It saves me the time of have to go through several modules trying to figure out where this import is from.

Most of time we are in just too much of a hurry to do this I understand.
I'm a victim of some terrible coding practices but I think it's a good habit to adopt.

Well, the user can use tools like the repl to query where these imports are from
but again when you can save the user time and effort of querying for meta information please do so.
I know it's not possible to do it all the time and everywhere but please do it when and where you can.

Let me illustrate this in some example code:

```haskell
{-|
Module      : Devel.Build
Description : Attempts to compile the WAI application.
Copyright   : (c)
License     : GPL-3
Maintainer<EMAIL_ADDRESS>Stability   : experimental
Portability : POSIX

compile compiles the app to give:
Either a list of source errors or an ide-backend session.
-}

{-# LANGUAGE PackageImports, OverloadedStrings #-}

module Devel.Compile (compile) where

-- Almost everything is dependent on ide-backend.
import IdeSession

-- From Cabal-ide-backend
-- for parsing the cabal file and extracting lang extensions used.
import Distribution.PackageDescription
import Distribution.PackageDescription.Parse
import Distribution.PackageDescription.Configuration
import Language.Haskell.Extension

-- Used internally for showing errors.
import Data.Text (unpack)

-- Utility functions
import Data.Monoid ((<>))
import System.Directory (createDirectoryIfMissing, getCurrentDirectory)

-- Local imports
import Devel.Paths
import Devel.Types
```

Compare with this which I wrote in a hurry.

```haskell
{-|
Module      : Devel.Paths
Description : For filepath related matters.
Copyright   : (c)
License     : GPL-3
Maintainer<EMAIL_ADDRESS>Stability   : experimental
Portability : POSIX

Uses the GHC package to parse .hi files.
Will hopefully be moved upstream to ide-backend.
-}

{-# LANGUAGE OverloadedStrings #-}

module Devel.Paths where

import System.Directory (getCurrentDirectory, doesDirectoryExist, getDirectoryContents)
import Control.Monad (forM)
import Control.Concurrent (forkIO)
import System.FilePath.Glob
import System.FilePath ((</>))
import Data.List
import IdeSession
import Devel.Modules
import System.FilePath.Posix (replaceExtension, dropExtension, takeExtensions)
import qualified Data.ByteString.Char8 as C8
import Control.Monad.IO.Class
import System.FilePath (pathSeparator)
import System.Directory (removeFile)
```

As you can see one can learn quite a bit just from looking at the imports and module documentation alone.

The issue is that it sometimes takes a while for one to clean up their code like this
so it's okay if your imports aren't legible before refactoring.

Another thing, I don't know if it's just an emacs thing but I
can just to my imports and jump between sections of imports with f12.
This is both advantageous to both the one writing the code and the one reading it.
The point of all of this is that well structured and well documented imports and exports are
a win for both the programmer and the one reading the code.


text:
# qTop_BG9x_AxC_ThingsBoard
qTop-BG9x-AxC Adafruit Feather Compatible / Arduino MKR Compatible Shield ThingsBoard Local Condition Monitoring Demo

Let us share our experience of setting up in a minute local condition DIY IOT monitoring demo project. IOT hardware, embedded firmware and Cloud Dashboard will be setup and configured. Local temperature, humidity and pressure, as well as device vital data, like a battery level and cellular RSSI, and, location info were obtained and published to ThingsBoard cloud.

More info :
- qTop BG96 AFC Adafruit Feather ThingsBoard Demo
https://www.iot-bots.com/blogs/news/get-your-nice-looking-iot-dashboard-in-a-minute-with-our-diy-iot-esp32-bg96-bme280-thingsboard-solution

- qTop BG95 AMC Arduino MKR ThingsBoard Demo
https://www.iot-bots.com/blogs/news/bg95-arduino-mkr-shield-and-thingsboard-dashboard-new-option-from-iot-bots-com


text:
# Warn about potentially complex selectors with too many nodes

This rule would warn if a CSS selector is too "deep" - has a significant number of nodes in the path.

For instance, this CSS selector would be considered fragile and complex, because of 6 nodes in the path:

```css
.content > table > tbody > tr:nth-child(2) > td.cell > input#email
```

A simpler version in this case could be (2 nodes):

```css
.content input#email
```

The idea behind this rule is that the more nodes you have in your CSS selector path - the more fragile, the more dependant on the HTML structure of the page it is.

Number of nodes is configurable, default value is `5`.

## Rule details

This rule is based on [`css-selector-parser`](https://github.com/mdevils/node-css-selector-parser) parsing abilities.

:thumbsdown: Any use of the following patterns are considered warnings (with the default depth value of `5`):

```js
element(by.css(".content > table > tbody > tr:nth-child(2) > td.cell > input#email"));
element.all(by.css(".content > table > tbody > tr:nth-child(2) > td.cell > input#email"));
$(".content > table > tbody > tr:nth-child(2) > td.cell > input#email");
$$(".content > table > tbody > tr:nth-child(2) > td.cell > input#email");
```

:thumbsup: The following patterns are not warnings:

```js
element(by.css(".myclass"));
element.all(by.css(".content input#email"));
$("#email");
$$("tr:nth-child(2)");
```

repository: alecxe/eslint-plugin-protractor

repo_name: alecxe/eslint-plugin-protractor


text:
---
layout: post
title: "Israel - Palestinia"
date: 2002-04-22 06:17
comments: true
categories: Life in General
author: Oliver Thylmann
---

I just read this on the TMF discussion boards:

*"Negotiations In Israel"

The Prime Minister of Israel sits down with Arafat
at the beginning of negotiations regarding the
resolution of the conflict. The Prime Minister
requests that he be allowed to begin with a story.
Arafat replies, "Of course."

The Prime Minister begins his story: "Years before
the Israelites came to the Promised Land and settled
here, Moses led them for 40 years through the desert.
The Israelites began complaining that they were thirsty
and, lo and behold, a miracle occurred and a stream
appeared before them. They drank their fill and then
decided to take advantage of the stream to do some
bathing -- including Moses. When Moses came out
of the water, he found that all his clothing was missing.

"Who took my clothes?" Moses asked those around him.

"It was the Palestinians," replied the Israelites--"

"Wait a minute," objected Arafat immediately, "there were
no Palestinians during the time of Moses!"

"All right," replies the Prime Minister, "Now that we've got
that settled, let's begin our negotiations."*


text:
# CallbackReference

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**CallbackData** | **string** | Data the application can register with the server when subscribing to notifications, and that are passed back unchanged in each of the related notifications. These data can be used by the application in the processing of the notification, e.g. for correlation purposes. | [optional] [default to null]
**NotificationFormat** | [***NotificationFormat**](NotificationFormat.md) |  | [optional] [default to null]
**NotifyURL** | **string** | Notify Callback URL | [default to null]

[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

repository: dilallkx/AdvantEDGE

repo_name: dilallkx/AdvantEDGE


text:
# d3-webpack-babel

simple d3 webpack boilerplate to test some simple code

### What's in it?
Just a simple [index.js](./index.jsx), [webpack.config.js](./webpack.config.js) and [index.html](./src/template.html) file.

### To run

You can simply run webpack build using this command:

```
> $ npm run build
```

If you want to run with webpack-dev-server simply run this command:

```
> $ npm run start
```
And go to:
```
http://http://<IP_ADDRESS>:8888/webpack-dev-server/bundle

```


text:
# Mathey

To run your code, go to the [MyMain.java](src/main/java/MyMain.java) and file and click on `Run` above the `main()` method.

## Run your tests with:
```shell script
make test
```


text:
# validatecc : Credit Card Number Validator

Currently only support for 16 digits credit card number and for bank in Indonesia.

## Background

When I was working in a telemarketing insurance company as a data analyst, I found some problems. One of it was "How to know the credit card number that will be used as payment channel is valid or not in a short time?". Because if the telemarketing officer hanging up the phone after closing and then check the validation of credit card number it will take more cost and time, and even the customer can cancel the insurance policy.

So I decided to create a fast enough way to solve this problem. Once, I use Microsoft Excel as user interface and use it formula.

Now I use shiny to create a more pleasing user interface.

https://aephiday25.shinyapps.io/validatecc


text:
Monaca CLI
==========

Command line version of Monaca. It can be used to download projects from the [Monaca](http://monaca.io) cloud service, livesyncing Cordova projects to a local device using the Monaca Debugger among a lot of other things.

Installation instructions
----

If you don't have have Node.js installed, please download it [from here](http://nodejs.org/) or install it with your favorite package manager.

When that's done you can install the Monaca CLI by using:

```bash
$ npm install -g monaca
```

On some systems you may have to prefix the command with `sudo` because of permissions:

```bash
$ sudo npm install -g monaca
```

Available commands
----

Just run

```bash
$ monaca
```

to see a list of available commands:

```
login  .........  sign in to Monaca Cloud
logout  ........  sign out from Monaca Cloud
signup  ........  register a new Monaca account
create  ........  create a new local Monaca project from a template
clone  .........  clone a project from Monaca Cloud
import  ........  import a project from Monaca Cloud
download  ......  download a project from Monaca Cloud
upload  ........  upload a project to Monaca Cloud
signing ........  manage signing configurations
remote build  ..  build a project on Monaca Cloud
remote config  ..  open the project configuration on Monaca Cloud
preview  .......  run a local web server for preview
debug  .........  run app on device using Monaca Debugger
transpile  .....  transpile project source code
update .........  update projects created with CLI 2.x to the latest Monaca project structure.
init ...........  initialize projects created using other CLI tools to be able to execute with Monaca.
config  ........  manage Monaca configuration
plugin  ........  manage Cordova Plugin
docs  ..........  display docs for Monaca CLI, Onsen UI and Tutorials
info  ..........  display project and environment info
```

You can run `monaca <command_name> --help` to get in-depth information about a single command:

```
$ monaca upload --help

Usage: monaca upload

Description:

  Uploads the current project to the Monaca Cloud.

  This command requires you to be logged in. The project
  files will be compared with the remote files so only
  changed and new files will be uploaded.

Examples:

  $ monaca upload
```

It also supports the command line options from Cordova CLI. The following options exactly follows the same behavior to Cordova, and Monaca Cloud is not used in this case.

```
platform  ......  add, update and remove platforms
prepare  .......  prepare project for build
compile  .......  build the project
run  ...........  deploy project on a device / emulator
build  .........  shortcut for compile, then prepare
emulate  .......  run project in emulator
serve  .........  run a local web server for assets
```

---

## Troubleshooting

### Problem after installation (Windows OS):

I successfully installed Monaca CLI, but after executing command `monaca login` and writing my credentials, nothing happens or I get UnhandledPromiseRejectionWarning:

```
$ monaca login
Use "monaca signup" command if you need to create a new account.

? Enter your email address<EMAIL_ADDRESS>? Enter your password: ********

(node:12344) UnhandledPromiseRejectionWarning: TypeError: Cannot read property of 'hasOwnProperty' of undefined
```

### Solution:

The problem might be in the installation of Node.js. If you installed Node.js through [.msi installer](https://nodejs.org/en/download/) on Node.js official website, we suggest you to use `NVM for Windows` to manage your Node.js versions instead.

1. Uninstall Node.js from your computer. Refer to this [manual](https://stackoverflow.com/questions/20711240/how-to-completely-remove-node-js-from-windows).
2. Install [NVM for Windows](https://github.com/coreybutler/nvm-windows#node-version-manager-nvm-for-windows).
3. After installation, download a Node.js version 14.19.0 and set this version to be used:
   ```bash
   $ nvm install 14.19.0
   $ nvm use 14.19.0
   ```
   For more information about managing multiple Node.js versions, refer to this [documentation](https://docs.microsoft.com/en-us/windows/dev-environment/javascript/nodejs-on-windows).
4. Install the Monaca CLI again.
5. The login should be working now.

repository: monaca/monaca-cli

repo_name: monaca/monaca-cli


text:
# TicTacToe_Trainable
A tictactoe playing bot that implements trial and error method wherein whenever it loses, it deletes the last (wrong) move it made from the list of possible moves. If only 1 move is possible for that particular board then the cpu deletes the previous move (i.e., it backtracks).

At the time of upload, 1 have trained the code in excess of 1200 games. But it would take round about 10,000 games
to learn all the moves.

T3_Final is the actual game which imports the T3_Core file.
T3_board contains all possible combinations of the board.
T3_do contains the corresponding possible moves for the current state of board.
T3_winratio contains win/loss details, 1 means the cpu won/tie and 0 means it lost.

<br>

## Getting Started
* Clone this repository
* ```cd TicTacToe_Trainable```
* Run ```T3_Final.py```